fix(app): retain draft while loading the first session

.github/workflows/publish.yml

@@ -91,7 +91,7 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
         with:
-          bun-version: 1.4.2
+          bun-version: 1.4.1
 
       - name: Setup git committer
         id: committer
@@ -113,7 +113,7 @@ jobs:
         id: build
         run: ./packages/cli/script/build.ts ${{ (github.ref_name == 'beta' && '--sourcemaps') || '' }}
         env:
-          BUN_COMPILE_RELEASE: bun-v1.4.2
+          BUN_COMPILE_RELEASE: bun-v1.4.1
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           OPENCODE_RELEASE: ${{ needs.version.outputs.release }}
           GH_REPO: ${{ needs.version.outputs.repo }}

bun.lock

@@ -695,8 +695,6 @@
         "effect": "catalog:",
       },
       "devDependencies": {
-        "@opencode-ai/client": "workspace:*",
-        "@opencode-ai/plugin": "workspace:*",
         "@tsconfig/bun": "catalog:",
         "@types/bun": "catalog:",
         "@typescript/native-preview": "catalog:",
@@ -1067,7 +1065,7 @@
     "@opentui/solid": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "bun-types": "1.4.2",
+    "bun-types": "1.4.1",
     "effect": "catalog:",
     "solid-js": "catalog:",
   },
@@ -3487,7 +3485,7 @@
 
     "bun-pty": ["bun-pty@0.4.8", "", {}, "sha512-rO70Mrbr13+jxHHHu2YBkk2pNqrJE5cJn29WE++PUr+GFA0hq/VgtQPZANJ8dJo6d7XImvBk37Innt8GM7O28w=="],
 
-    "bun-types": ["bun-types@1.4.2", "", { "dependencies": { "@types/node": "*" } }, "sha512-bxV1FgK7yBIzjRe5zBozIM4Bem11ZJcCXSrjWRG3YWLt8yFDePu4cLjpebO8OvPeIE9trbyPF4fuj3Cia4Fj3w=="],
+    "bun-types": ["bun-types@1.4.1", "", { "dependencies": { "@types/node": "*" } }, "sha512-loKuVrAFZKfEv+JvWkHRS9GW5IqLuLRjVXN9p+vZvBN86O5hf/pBZQ5hSoyipsrMmWObZBDvWnlmKvjKTM0PdA=="],
 
     "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],
 

infra/console.ts

@@ -235,7 +235,6 @@ const bucketNew = new sst.cloudflare.Bucket("ZenDataNew")
 const DISCORD_INCIDENT_WEBHOOK_URL = new sst.Secret("DISCORD_INCIDENT_WEBHOOK_URL")
 const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID")
 const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY")
-const ENTERPRISE_SALES_INBOX_EMAIL = new sst.Secret("ENTERPRISE_SALES_INBOX_EMAIL")
 
 const SALESFORCE_CLIENT_ID = new sst.Secret("SALESFORCE_CLIENT_ID")
 const SALESFORCE_CLIENT_SECRET = new sst.Secret("SALESFORCE_CLIENT_SECRET")
@@ -264,7 +263,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     EMAILOCTOPUS_API_KEY,
     AWS_SES_ACCESS_KEY_ID,
     AWS_SES_SECRET_ACCESS_KEY,
-    ENTERPRISE_SALES_INBOX_EMAIL,
     SALESFORCE_CLIENT_ID,
     SALESFORCE_CLIENT_SECRET,
     SALESFORCE_INSTANCE_URL,

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-6VoxH/BowtAOYdhGqD7ZkFJv+h+/onFmuNZhvBxoGAI=",
-    "aarch64-linux": "sha256-Va77URDCTAkvMQ0g7huFgp1iwb5C6+idSrlLOaFNVB0=",
-    "aarch64-darwin": "sha256-IqCsKuiuuAmK4Z3oOfJ9kX4b4CpCmj6GeTKhXOewc7E=",
-    "x86_64-darwin": "sha256-LXOxHzh6SS63WkfKvwBz+NylfvbcCi+rmXIRmpwu/oE="
+    "x86_64-linux": "sha256-J7xJ1+x+f13zso+UMP1YYzkjFM0LiHZURmf8HhO3X4M=",
+    "aarch64-linux": "sha256-CF7BiObbwjFT4BV5FUqB535fqoPuXuExKpERcev/Re0=",
+    "aarch64-darwin": "sha256-ts3zgHiPeQcrehST1ikr+BNwlF+3JDn0/IUeJSAOB3o=",
+    "x86_64-darwin": "sha256-awKiMBuDMrapw3Lrm39TbE+ILJZ1P8R8sqYJEWapSf8="
   }
 }

package.json

@@ -5,7 +5,7 @@
   "version": "0.0.0",
   "private": true,
   "type": "module",
-  "packageManager": "bun@1.4.2",
+  "packageManager": "bun@1.4.1",
   "scripts": {
     "dev": "bun run --cwd packages/cli --conditions=browser src/index.ts",
     "dev:live": "sh -c 'OPENCODE_TUI_CHANNEL=dev OPENCODE_PASSWORD=\"$(opencode2 service get password)\" exec bun run dev \"$@\" --server \"$(opencode2 service status)\"' --",
@@ -159,7 +159,7 @@
     "@effect/platform-node-shared": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
-    "bun-types": "1.4.2",
+    "bun-types": "1.4.1",
     "effect": "catalog:",
     "solid-js": "catalog:"
   },

packages/app/e2e/regression/cross-server-tab-close.spec.ts

@@ -86,12 +86,7 @@ async function mockServers(page: Page, requests: string[]) {
       }
       return json(route, url.pathname === "/api/project" ? [project] : { id: project.id, directory: current.directory })
     }
-    if (url.pathname === "/api/location")
-      return json(route, {
-        directory: current.directory,
-        project: { id: current.projectID, directory: current.directory, canonical: current.directory },
-      })
-    if (url.pathname === "/api/worktree") return json(route, [{ directory: current.directory }])
+    if (url.pathname === "/api/location") return json(route, { directory: current.directory })
     if (url.pathname === "/api/vcs")
       return json(route, {
         location: { directory: current.directory },

packages/app/e2e/regression/first-prompt-transition.spec.ts

@@ -0,0 +1,111 @@
+import { expect, test } from "@playwright/test"
+import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
+
+const directory = "/fixture/first-prompt"
+const projectID = "proj_first_prompt"
+const text = "Keep the composer visible while opening this session."
+
+test.use({ serviceWorkers: "block" })
+
+for (const input of ["keyboard", "pointer"] as const) {
+  test(`retains the draft during a cold first prompt from ${input}`, async ({ page }, testInfo) => {
+    const sessions: ReturnType<typeof currentSession>[] = []
+    const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
+    await mockOpenCodeServer(page, {
+      directory,
+      project: { id: projectID, worktree: directory, name: "first-prompt", vcs: "git", sandboxes: [] },
+      provider: {
+        all: [{ id: "opencode", name: "OpenCode", models: { fixture: { id: "fixture", name: "Fixture Model" } } }],
+        connected: ["opencode"],
+        default: { providerID: "opencode", modelID: "fixture" },
+      },
+      sessions,
+      pageMessages: () => ({ items: [] }),
+      onPrompt: (prompt) => prompts.push(prompt),
+    })
+    await page.route("**/api/session", (route) => {
+      if (route.request().method() !== "POST") return route.fallback()
+      const session = currentSession({ ...route.request().postDataJSON(), projectID, title: "First prompt" }, directory)
+      sessions.push(session)
+      return route.fulfill({ json: { data: session } })
+    })
+    await page.addInitScript((directory) => {
+      localStorage.setItem(
+        "opencode.global.dat:server",
+        JSON.stringify({
+          projects: { local: [{ worktree: directory, expanded: true }] },
+          lastProject: { local: directory },
+        }),
+      )
+    }, directory)
+
+    // The session route awaits the file viewer chunk. Keep that real import pending
+    // until the test has inspected the draft; do not add timing-dependent sleeps.
+    const requested = Promise.withResolvers<void>()
+    const loaded = Promise.withResolvers<void>()
+    await page.route(
+      /(?:\/_assets\/file-(?!icon-)[^/]+\.js|\/session-ui\/src\/components\/file\.tsx)(?:\?|$)/,
+      async (route) => {
+        requested.resolve()
+        await loaded.promise
+        await route.continue()
+      },
+    )
+
+    await page.goto("/")
+    await page.locator('[data-action="home-new-session"]').click()
+    const editor = page.getByRole("textbox", { name: "Prompt", exact: true })
+    await expect(editor).toBeEditable()
+    await expect(page.locator('[data-action="composer-model"]')).toHaveText("Fixture Model")
+    await editor.fill(text)
+    await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
+    const observation = await page.evaluateHandle(() => {
+      const frames: { visible: boolean; time: number }[] = []
+      const start = performance.now()
+      let frame = 0
+      const sample = () => {
+        const editor = document.querySelector<HTMLElement>('[data-component="composer-editor"]')
+        frames.push({
+          visible: !!editor?.checkVisibility({ checkVisibilityCSS: true, checkOpacity: true }),
+          time: performance.now() - start,
+        })
+        frame = requestAnimationFrame(sample)
+      }
+      sample()
+      return {
+        stop: () => {
+          cancelAnimationFrame(frame)
+          return frames
+        },
+      }
+    })
+
+    try {
+      if (input === "keyboard") await editor.press("Enter")
+      if (input === "pointer") await page.locator('[data-action="composer-submit"]').click()
+      await requested.promise
+      await expect(editor).toBeVisible()
+      await expect(editor).toHaveText(text)
+      await testInfo.attach("loading-session", { body: await page.screenshot(), contentType: "image/png" })
+    } finally {
+      loaded.resolve()
+    }
+
+    await expect(page).toHaveURL(/\/session\/ses_/)
+    await expect.poll(() => prompts).toEqual([{ sessionID: sessions[0]!.id, body: expect.objectContaining({ text }) }])
+    await expect(editor).toHaveText("")
+    await expect(editor).toBeEditable()
+    await expect(page.locator('[data-action="composer-model"]')).toHaveText("Fixture Model")
+    const frames = await observation.evaluate((observation) => observation.stop())
+    await observation.dispose()
+    await testInfo.attach("composer-frames", { body: JSON.stringify(frames), contentType: "application/json" })
+    expect(frames.length).toBeGreaterThan(0)
+    expect(
+      frames.filter((frame) => !frame.visible),
+      "composer must remain visible through the route handoff",
+    ).toEqual([])
+    await page.keyboard.type("Follow-up")
+    await expect(editor).toHaveText("Follow-up")
+    await expect(editor).toBeFocused()
+  })
+}

packages/app/e2e/regression/new-session-workspace-pending.spec.ts

@@ -490,24 +490,20 @@ async function openDraft(
   page.on("request", (request) => {
     if (request.method() !== "POST") return
     const path = new URL(request.url()).pathname
-    if (path === "/api/worktree") {
-      expect(new URL(request.url()).searchParams.get("location[directory]")).toBe(directory)
+    if (path === `/api/worktree/${projectID}`) {
       calls.push("worktree")
       worktreeRequests.push(request.postDataJSON())
     }
     if (path === "/api/session") calls.push("session")
     if (/^\/api\/session\/[^/]+\/prompt$/.test(path)) calls.push("prompt")
   })
-  await page.route(
-    (url) => url.pathname === "/api/worktree",
-    async (route) => {
-      if (route.request().method() !== "POST") return route.fallback()
-      // Keep the real HTTP response pending until the test has checked the preview.
-      const response = await worktree.promise
-      if (response.status === 200) project.sandboxes.push(workspace)
-      await route.fulfill({ ...response, headers })
-    },
-  )
+  await page.route(`**/api/worktree/${projectID}`, async (route) => {
+    if (route.request().method() !== "POST") return route.fallback()
+    // Keep the real HTTP response pending until the test has checked the preview.
+    const response = await worktree.promise
+    if (response.status === 200) project.sandboxes.push(workspace)
+    await route.fulfill({ ...response, headers })
+  })
   await page.route("**/api/session", async (route) => {
     if (route.request().method() !== "POST") return route.fallback()
     const body: Record<string, unknown> = route.request().postDataJSON()

packages/app/e2e/regression/remote-session-settings.spec.ts

@@ -396,12 +396,7 @@ async function mockServers(
       return json(route, { data: [], cursor: {} })
     if (sessions.some((session) => url.pathname === `/api/session/${session.id}/inbox`))
       return json(route, { data: [] })
-    if (url.pathname === "/api/location")
-      return json(route, {
-        directory,
-        project: { id: remote ? sessionB.projectID : "project-server-a", directory, canonical: directory },
-      })
-    if (url.pathname === "/api/worktree") return json(route, [{ directory }])
+    if (url.pathname === "/api/location") return json(route, { directory })
     if (url.pathname === "/api/vcs")
       return json(route, { location: { directory }, data: { branch: "main", defaultBranch: "main" } })
     if (url.pathname === "/api/pty/shells") return json(route, { location: { directory }, data: [] })

packages/app/e2e/regression/settings-loading.spec.ts

@@ -87,24 +87,16 @@ test("recording a new session shortcut stays in settings until recording finishe
 test("workspaces opens without waiting for inventory or sessions", async ({ page }) => {
   const inventory = Promise.withResolvers<void>()
   const sessions = Promise.withResolvers<void>()
-  await page.route(
-    (url) => url.pathname === "/api/worktree",
-    async (route) => {
-      await inventory.promise
-      await route.fallback()
-    },
-  )
+  await page.route("**/api/worktree/*", async (route) => {
+    await inventory.promise
+    await route.fallback()
+  })
   await page.route("**/api/session?*", async (route) => {
     if (new URL(route.request().url()).searchParams.has("directory")) await sessions.promise
     await route.fallback()
   })
   const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(
-    (request) =>
-      new URL(request.url()).pathname === "/api/worktree" &&
-      new URL(request.url()).searchParams.get("location[directory]") === directory &&
-      request.method() === "GET",
-  )
+  const requested = page.waitForRequest((request) => new URL(request.url()).pathname.startsWith("/api/worktree/"))
   await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()
   await requested
   await expect(settings.getByRole("heading", { name: "Worktrees", exact: true })).toBeVisible()
@@ -118,57 +110,16 @@ test("workspaces opens without waiting for inventory or sessions", async ({ page
   await expect(settings.getByText("Workspace 1 session", { exact: true })).toBeVisible()
 
   const refresh = Promise.withResolvers<void>()
-  await page.route(
-    (url) => url.pathname === "/api/worktree",
-    async (route) => {
-      await refresh.promise
-      await route.fallback()
-    },
-  )
+  await page.route("**/api/worktree/*", async (route) => {
+    await refresh.promise
+    await route.fallback()
+  })
   await settings.getByRole("tab", { name: "Preferences", exact: true }).click()
   await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()
   await expect(settings.getByText("Workspace 1 session", { exact: true })).toBeVisible()
   refresh.resolve()
 })
 
-test("worktree deletion sends the project location separately from the target", async ({ page }) => {
-  const removed = new Set<string>()
-  await page.route(
-    (url) => url.pathname === "/api/worktree",
-    async (route) => {
-      if (route.request().method() === "GET") {
-        return route.fulfill({
-          json: [
-            { directory },
-            ...sandboxes.filter((item) => !removed.has(item)).map((directory) => ({ directory, strategy: "git" })),
-          ],
-        })
-      }
-      if (route.request().method() === "DELETE") {
-        removed.add(route.request().postDataJSON().directory)
-        return route.fulfill({ status: 204 })
-      }
-      return route.fallback()
-    },
-  )
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()
-  await expect(settings.getByText(sandboxes[0], { exact: true })).toBeVisible()
-  await settings.getByRole("button", { name: 'Delete worktree "workspace-1"?', exact: true }).click()
-  const confirmation = page.getByRole("dialog", { name: "Delete worktree", exact: true })
-  const remove = confirmation.getByRole("button", { name: "Delete worktree", exact: true })
-  await expect(remove).toBeEnabled()
-  const deleting = page.waitForRequest(
-    (request) => new URL(request.url()).pathname === "/api/worktree" && request.method() === "DELETE",
-  )
-  await remove.click()
-  const request = await deleting
-  expect(new URL(request.url()).searchParams.get("location[directory]")).toBe(directory)
-  expect(request.postDataJSON()).toEqual({ directory: sandboxes[0], force: true })
-  await expect(settings.getByText(sandboxes[0], { exact: true })).toHaveCount(0)
-  await expect(settings.getByText("11 worktrees", { exact: true })).toBeVisible()
-})
-
 test("extensions opens without waiting for MCPs", async ({ page }) => {
   const mcps = Promise.withResolvers<void>()
   await page.route("**/api/mcp", async (route) => {

packages/app/e2e/regression/tab-navigate-mousedown.spec.ts

@@ -225,81 +225,13 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
   await page.mouse.down()
   await page.mouse.move(resized.x - 200, resized.y + resized.height / 2)
   await page.mouse.up()
-  await expect(sidebar).toHaveCSS("width", "140px")
+  await expect(sidebar).toHaveCSS("width", "130px")
 
   await tabB.click()
   await expect(page).toHaveURL(new RegExp(`${hrefB.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`))
   await expect(tabB).toBeVisible()
 })
 
-for (const count of [0, 26]) {
-  test(`vertical navigation labels and icons use the available width with ${count} tabs`, async ({
-    page,
-  }, testInfo) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, directory, count }) => {
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({
-            appearance: { tabLayout: "vertical" },
-            keybinds: { "home.toggle": "alt+home", "tab.new": "ctrl+shift+n" },
-          }),
-        )
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify(
-            Array.from({ length: count }, (_, index) => ({
-              type: "draft",
-              server,
-              directory,
-              draftID: `draft_navigation_${index}`,
-            })),
-          ),
-        )
-      },
-      { server, directory: sessionA.directory, count },
-    )
-    await page.goto("/")
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    await expect(sidebar).toHaveCSS("width", "260px")
-    await expect(sidebar.locator("[data-titlebar-tab-slot]")).toHaveCount(count)
-    for (const width of [260, 180, 140]) {
-      if (width !== 260) {
-        const handle = await sidebar.locator('[data-component="resize-handle"]').boundingBox()
-        const bounds = await sidebar.boundingBox()
-        if (!handle || !bounds) throw new Error("vertical tab sidebar has no bounding box")
-        await page.mouse.move(handle.x + handle.width / 2, handle.y + handle.height / 2)
-        await page.mouse.down()
-        await page.mouse.move(handle.x + handle.width / 2 + width - bounds.width, handle.y + handle.height / 2)
-        await page.mouse.up()
-      }
-      await expect(sidebar).toHaveCSS("width", `${width}px`)
-      await testInfo.attach(`navigation-${count}-${width}`, {
-        body: await sidebar.screenshot(),
-        contentType: "image/png",
-      })
-      for (const name of ["Home", "New session"]) {
-        const button = sidebar.getByRole("button", { name, exact: true })
-        const label = button.getByText(name, { exact: true })
-        await expect(label).toBeVisible()
-        await expect
-          .poll(() => label.evaluate((element) => element.scrollWidth - element.clientWidth), { message: name })
-          .toBeLessThanOrEqual(1)
-        await expect(button.locator('[data-slot="icon-svg"]')).toHaveCSS("width", "16px")
-        await button.hover()
-        await expect(button.locator('span[aria-hidden="true"]')).toBeVisible()
-        await expect(button.locator('[data-slot="icon-svg"]')).toHaveCSS("width", "16px")
-        await expect
-          .poll(() => button.evaluate((element) => element.scrollWidth - element.clientWidth))
-          .toBeLessThanOrEqual(1)
-        await page.getByRole("main").hover()
-      }
-    }
-  })
-}
-
 for (const direction of ["ltr", "rtl"]) {
   test(`vertical tabs keep Settings pinned while scrolling in ${direction}`, async ({ page }, testInfo) => {
     await mockServer(page)
@@ -427,9 +359,9 @@ for (const profile of [
       const hint = button.locator('span[aria-hidden="true"]')
       await expect(hint).toHaveText(row.shortcut)
       await expect(hint.getByText(row.shortcut, { exact: true })).toHaveCSS("direction", "ltr")
-      await expect(hint).toBeHidden()
+      await expect(hint).toHaveCSS("opacity", "0")
       await button.hover()
-      await expect(hint).toBeVisible()
+      await expect(hint).toHaveCSS("opacity", "1")
       await expect
         .poll(() =>
           hint.evaluate((element) => {
@@ -441,7 +373,7 @@ for (const profile of [
         )
         .toBeCloseTo(8, 1)
       await page.getByRole("main").hover()
-      await expect(hint).toBeHidden()
+      await expect(hint).toHaveCSS("opacity", "0")
     }
 
     const home = sidebar.locator('[data-action="vertical-tabs-home"]')
@@ -449,10 +381,10 @@ for (const profile of [
     await home.focus()
     await page.keyboard.press("Tab")
     await expect(newSession).toBeFocused()
-    await expect(newSession.locator('span[aria-hidden="true"]')).toBeVisible()
+    await expect(newSession.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
     await page.keyboard.press("Shift+Tab")
     await expect(home).toBeFocused()
-    await expect(home.locator('span[aria-hidden="true"]')).toBeVisible()
+    await expect(home.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
   })
 }
 
@@ -628,12 +560,7 @@ async function mockServer(page: Page) {
         url.pathname === "/api/project" ? [project] : { id: project.id, directory: sessionA.directory },
       )
     }
-    if (url.pathname === "/api/location")
-      return json(route, {
-        directory: sessionA.directory,
-        project: { id: sessionA.projectID, directory: sessionA.directory, canonical: sessionA.directory },
-      })
-    if (url.pathname === "/api/worktree") return json(route, [{ directory: sessionA.directory }])
+    if (url.pathname === "/api/location") return json(route, { directory: sessionA.directory })
     if (url.pathname === "/api/vcs")
       return json(route, {
         location: { directory: sessionA.directory },

packages/app/e2e/regression/workspace-accent.spec.ts

@@ -97,9 +97,7 @@ for (const theme of ["light", "dark"] as const) {
 
       const refreshed = page.waitForResponse(
         (response) =>
-          new URL(response.url()).pathname === "/api/worktree" &&
-          new URL(response.url()).searchParams.get("location[directory]") === root &&
-          response.request().method() === "GET",
+          new URL(response.url()).pathname === `/api/worktree/${projectID}` && response.request().method() === "GET",
       )
       view.worktrees.push({ directory: workspace, strategy: "git" })
       view.events.push({
@@ -201,13 +199,10 @@ async function openSession(page: Page, directory: string, worktrees = [...invent
     events: () => events.splice(0),
   })
   // Keep authoritative inventory independent of the raw project's empty sandboxes.
-  await page.route(
-    (url) => url.pathname === "/api/worktree",
-    (route) => {
-      if (route.request().method() !== "GET") return route.fallback()
-      return route.fulfill({ json: worktrees, headers: { "access-control-allow-origin": "*" } })
-    },
-  )
+  await page.route(`**/api/worktree/${projectID}`, (route) => {
+    if (route.request().method() !== "GET") return route.fallback()
+    return route.fulfill({ json: worktrees, headers: { "access-control-allow-origin": "*" } })
+  })
   if (draft)
     await page.addInitScript(
       ({ root, server }) => {
@@ -227,9 +222,7 @@ async function openSession(page: Page, directory: string, worktrees = [...invent
     )
   const loaded = page.waitForResponse(
     (response) =>
-      new URL(response.url()).pathname === "/api/worktree" &&
-      new URL(response.url()).searchParams.get("location[directory]") === root &&
-      response.request().method() === "GET",
+      new URL(response.url()).pathname === `/api/worktree/${projectID}` && response.request().method() === "GET",
   )
   await page.goto(
     draft ? "/new-session?draftId=draft_workspace_accent" : `/server/${base64Encode(server)}/session/${sessionID}`,

packages/app/e2e/utils/mock-api.ts

@@ -71,23 +71,27 @@ const Group = HttpApiGroup.make("mock")
   .add(HttpApiEndpoint.get("projectList", "/api/project", { success: Json }))
   .add(HttpApiEndpoint.get("projectCurrent", "/api/project/current", { success: Json }))
   .add(
-    HttpApiEndpoint.get("worktreeList", "/api/worktree", {
+    HttpApiEndpoint.get("worktreeList", "/api/worktree/:projectID", {
+      params: { projectID: Schema.String },
       success: Json,
     }),
   )
   .add(
-    HttpApiEndpoint.post("worktreeCreate", "/api/worktree", {
+    HttpApiEndpoint.post("worktreeCreate", "/api/worktree/:projectID", {
+      params: { projectID: Schema.String },
       payload: JsonPayload,
       success: Json,
     }),
   )
   .add(
-    HttpApiEndpoint.delete("worktreeRemove", "/api/worktree", {
+    HttpApiEndpoint.delete("worktreeRemove", "/api/worktree/:projectID", {
+      params: { projectID: Schema.String },
       success: NoContent,
     }),
   )
   .add(
-    HttpApiEndpoint.post("worktreeRefresh", "/api/worktree/refresh", {
+    HttpApiEndpoint.post("worktreeRefresh", "/api/worktree/:projectID/refresh", {
+      params: { projectID: Schema.String },
       success: NoContent,
     }),
   )

packages/app/src/composer/editor/editor.css

@@ -8,7 +8,6 @@
 }
 
 [data-color-scheme="dark"] [data-component="composer"][data-dock-border-underlay="true"],
-[data-color-scheme="dark"] [data-component="session-composer-dock"] [data-component="composer"],
 [data-color-scheme="dark"] [data-component="new-session"] [data-component="composer"] {
   background: var(--v2-background-bg-layer-01);
 }

packages/app/src/home/model.ts

@@ -34,14 +34,6 @@ export function createHomeController() {
     const conn = list[0]
     if (conn) setSelection({ server: ServerConnection.key(conn) })
   })
-  createEffect(() => {
-    const ctx = focusedServerCtx()
-    const id = selectedProject()?.id
-    if (!ctx || !id || ctx.sdk.connection.status() !== "connected") return
-    // Selecting a project is the demand for its worktree inventory: the session filter spans its worktrees.
-    const root = ctx.sync.data.project.find((project) => project.id === id)?.worktree
-    if (root) void ctx.sync.worktrees.load(root)
-  })
 
   function setSelection(next: HomeProjectSelection) {
     layout.home.setSelection(next)

packages/app/src/home/sessions/controller.tsx

@@ -27,7 +27,7 @@ import { sessionLabel, sessionTitle } from "@/session/title"
 import { showToast } from "@/shell/notifications/toast"
 import { archiveHomeSession } from "./archive"
 import type { HomeController } from "../model"
-import { buildHomeSessionRecords, homeProjectForSession, type HomeSessionRecord } from "./records"
+import { buildHomeSessionRecords, type HomeSessionRecord } from "./records"
 
 export type { HomeSessionRecord } from "./records"
 
@@ -270,7 +270,14 @@ export function createHomeSessionsController(home: HomeController) {
       },
       create: home.project.openNewSession,
       open: (session: SessionInfo, options?: OpenSessionOptions) => {
-        const project = homeProjectForSession(session, home.project.list())
+        const directoryKey = pathKey(session.location.directory)
+        const project = home.project
+          .list()
+          .find(
+            (item) =>
+              pathKey(item.worktree) === directoryKey ||
+              item.sandboxes?.some((sandbox) => pathKey(sandbox) === directoryKey),
+          )
         const conn = home.server.focused()
         if (!conn) return
         const connKey = ServerConnection.key(conn)

packages/app/src/home/sessions/records.test.ts

@@ -36,26 +36,4 @@ describe("buildHomeSessionRecords", () => {
 
     expect(records.map((record) => record.session.id)).toEqual(["a"])
   })
-
-  test("labels a worktree session with its project before that project's inventory has loaded", () => {
-    const records = buildHomeSessionRecords({
-      sessions: () => [session("w", "/repo/a/.worktrees/feature", "project-a")],
-      projectDirectories: () => undefined,
-      projects: () => [{ ...opened, name: "Project A" }],
-    })
-
-    expect(records[0]?.project).toMatchObject({ id: "project-a", worktree: "/repo/a" })
-    expect(records[0]?.projectName).toBe("Project A")
-  })
-
-  test("prefers the added project whose directory matches over a sibling entry with the same ID", () => {
-    const nested = { id: "project-a", worktree: "/repo/a/packages/app", expanded: true } as LocalProject
-    const records = buildHomeSessionRecords({
-      sessions: () => [session("n", "/repo/a/packages/app", "project-a")],
-      projectDirectories: () => undefined,
-      projects: () => [opened, nested],
-    })
-
-    expect(records[0]?.project.worktree).toBe("/repo/a/packages/app")
-  })
 })

packages/app/src/home/sessions/records.ts

@@ -22,7 +22,13 @@ export function buildHomeSessionRecords(input: {
   return [...new Map(sessions.map((session) => [session.id, session] as const)).values()]
     .sort(compareSessionTime)
     .map((session) => {
-      const project = homeProjectForSession(session, input.projects()) ?? {
+      const directory = pathKey(session.location.directory)
+      const project = input
+        .projects()
+        .find(
+          (item) =>
+            pathKey(item.worktree) === directory || item.sandboxes?.some((sandbox) => pathKey(sandbox) === directory),
+        ) ?? {
         id: session.projectID,
         worktree: session.location.directory,
         expanded: false,
@@ -30,18 +36,3 @@ export function buildHomeSessionRecords(input: {
       return { session, project, projectName: displayName(project) }
     })
 }
-
-// Worktree inventories load on demand, so a worktree session may not match any directory yet;
-// the session's project ID still identifies its added project.
-export function homeProjectForSession<T extends { id?: string; worktree: string; sandboxes?: readonly string[] }>(
-  session: SessionInfo,
-  projects: readonly T[],
-) {
-  const directory = pathKey(session.location.directory)
-  return (
-    projects.find(
-      (item) =>
-        pathKey(item.worktree) === directory || item.sandboxes?.some((sandbox) => pathKey(sandbox) === directory),
-    ) ?? projects.find((item) => item.id === session.projectID)
-  )
-}

packages/app/src/providers/catalog/order.test.ts

@@ -1,6 +0,0 @@
-import { expect, test } from "bun:test"
-import { popularProviders } from "./order"
-
-test("lists OpenCode Go before Zen and other popular providers", () => {
-  expect(popularProviders.slice(0, 2)).toEqual(["opencode-go", "opencode"])
-})

packages/app/src/providers/catalog/order.ts

@@ -1,6 +1,6 @@
 export const popularProviders = [
-  "opencode-go",
   "opencode",
+  "opencode-go",
   "anthropic",
   "github-copilot",
   "openai",

packages/app/src/providers/connect/dialog.tsx

@@ -110,7 +110,7 @@ function ProviderPicker(props: { directory?: string; onSelect: (provider: string
     active: undefined as string | undefined,
     connecting: undefined as string | undefined,
   })
-  const featured = ["opencode-go", "opencode", "anthropic", "openai", "google", "openrouter", "vercel"]
+  const featured = ["opencode", "opencode-go", "anthropic", "openai", "google", "openrouter", "vercel"]
   const custom = () => ({ id: CUSTOM_ID, name: language.t("dialog.provider.custom.label") })
   const all = createMemo(() => {
     language.locale()

packages/app/src/providers/models/unpaid.tsx

@@ -13,7 +13,7 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { ModelTooltip } from "./tooltip"
 
 type ModelState = ReturnType<typeof useLocal>["model"]
-const featuredProviders = ["opencode-go", "opencode", "openai", "anthropic", "google", "github-copilot"]
+const featuredProviders = ["opencode", "opencode-go", "openai", "anthropic", "google", "github-copilot"]
 const displayModelName = (name: string) => name.replace(/\s+(?:\(free\)|free)$/i, "")
 
 export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props) => {

packages/app/src/runtime/server/client.tsx

@@ -6,7 +6,6 @@ import { createApiForServer, type ServerApi } from "@/runtime/server/api"
 import { usePlatform } from "@/runtime/platform/platform"
 import { ServerConnection } from "./registry"
 import { createRefCountMap } from "@/runtime/server/refcount"
-import { createRequestQueue } from "@/runtime/server/request-queue"
 import { ServerScope } from "@/runtime/server/scope"
 import { useServer } from "./current"
 
@@ -115,9 +114,8 @@ export function createServerTransport(input: { http: ServerConnection.HttpBase;
   readonly api: ServerApi
   readonly pty: ReturnType<typeof createPtyClient>
 } {
-  const queue = createRequestQueue({ fetch: input.fetch ?? globalThis.fetch })
   const build = (http: ServerConnection.HttpBase) => {
-    const api = createApiForServer({ server: http, fetch: queue.fetch })
+    const api = createApiForServer({ server: http, fetch: input.fetch })
     return { http, api, pty: createPtyClient(api, { url: http.url }) }
   }
   const state = { current: build(input.http) }

packages/app/src/runtime/server/global-sync/bootstrap.test.ts

@@ -6,7 +6,9 @@ import { bootstrapGlobal, loadPathQuery, loadProjectsQuery } from "./bootstrap"
 import { ServerScope } from "@/runtime/server/scope"
 import type { ServerApi } from "@/runtime/server/api"
 import type { ServerSync } from "@/runtime/server/sync"
-import { worktreeInventoryKey } from "@/workspaces/inventory"
+
+type ProjectApi = ServerApi["project"]
+type WorktreeApi = ServerApi["worktree"]
 
 test("bootstraps projects through the native store setter and preserves subsequent updates", async () => {
   const api = OpenCode.make({
@@ -21,6 +23,7 @@ test("bootstraps projects through the native store setter and preserves subseque
           })
         if (url.pathname === "/api/project")
           return Response.json([{ id: "project", canonical: "/repo", time: { created: 1, updated: 1 }, sandboxes: [] }])
+        if (url.pathname === "/api/worktree") return Response.json([{ directory: "/repo" }])
         throw new Error(`Unexpected request: ${url.pathname}`)
       },
       { preconnect() {} },
@@ -47,18 +50,6 @@ test("bootstraps projects through the native store setter and preserves subseque
     await bootstrapGlobal({ serverAPI: api, scope: ServerScope.local, setGlobalStore: setStore, queryClient })
     expect(store.project.map((project) => [project.id, project.worktree])).toEqual([["project", "/repo"]])
     expect(store.config).toEqual({})
-
-    // A refetch keeps the inventory a view already loaded for this project.
-    queryClient.setQueryData(worktreeInventoryKey(ServerScope.local, "/repo/"), [
-      { directory: "/repo" },
-      { directory: "/repo/feature", strategy: "git" },
-    ])
-    await bootstrapGlobal({ serverAPI: api, scope: ServerScope.local, setGlobalStore: setStore, queryClient })
-    expect(store.project[0]?.sandboxes).toEqual(["/repo/feature"])
-    expect(store.project[0]?.worktrees).toEqual([
-      { directory: "/repo" },
-      { directory: "/repo/feature", strategy: "git" },
-    ])
   } finally {
     queryClient.clear()
   }
@@ -88,39 +79,58 @@ describe("query keys", () => {
     expect(result).toMatchObject({ directory: "/repo/subpath", worktree: "/repo" })
   })
 
-  test("loads project metadata without enumerating any project's worktrees", async () => {
-    const requests: string[] = []
-    const api = OpenCode.make({
-      baseUrl: "http://localhost:3000",
-      fetch: Object.assign(
-        async (input: RequestInfo | URL, init?: RequestInit) => {
-          const url = new URL(new Request(input, init).url)
-          requests.push(url.pathname)
-          if (url.pathname !== "/api/project") throw new Error(`Unexpected request: ${url}`)
-          return Response.json([
-            ...Array.from({ length: 300 }, (_, index) => ({
-              id: `historical-${index.toString().padStart(3, "0")}`,
-              canonical: `/history/${index}`,
-              time: { created: 1, updated: 1 },
-              sandboxes: [],
-            })),
-            { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
-            { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: ["/a/legacy"] },
-            { id: "test", canonical: "/tmp/opencode-test-1", time: { created: 1, updated: 1 }, sandboxes: [] },
-          ])
-        },
-        { preconnect() {} },
-      ),
-    })
+  test("loads projects from the current endpoint", async () => {
+    const calls: string[] = []
+    const projects = {
+      list: async () => [
+        { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
+        { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
+      ],
+    } as unknown as ProjectApi
+    const worktrees = {
+      list: async ({ projectID }: { projectID: string }) => {
+        calls.push(projectID)
+        return [
+          { directory: `/${projectID}` },
+          { directory: `/${projectID}/clone` },
+          { directory: `/${projectID}/copy`, strategy: "git" },
+        ]
+      },
+    } as unknown as WorktreeApi
 
-    const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, api.project))
+    const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, projects, worktrees))
 
-    expect(requests).toEqual(["/api/project"])
-    expect(result).toHaveLength(302)
-    expect(result.slice(0, 2)).toMatchObject([
-      { id: "a", worktree: "/a", sandboxes: ["/a/legacy"], worktrees: [{ directory: "/a" }] },
-      { id: "b", worktree: "/b", sandboxes: [], worktrees: [{ directory: "/b" }] },
+    expect(result.map((project) => project.id)).toEqual(["a", "b"])
+    expect(result.map((project) => project.sandboxes)).toEqual([
+      ["/a/clone", "/a/copy"],
+      ["/b/clone", "/b/copy"],
+    ])
+    expect(result.map((project) => project.worktrees)).toEqual([
+      [{ directory: "/a" }, { directory: "/a/clone" }, { directory: "/a/copy", strategy: "git" }],
+      [{ directory: "/b" }, { directory: "/b/clone" }, { directory: "/b/copy", strategy: "git" }],
+    ])
+    expect(calls.toSorted()).toEqual(["a", "b"])
+  })
+
+  test("keeps projects whose directory inventory cannot load", async () => {
+    const projects = {
+      list: async () => [
+        { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
+        { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
+      ],
+    } as unknown as ProjectApi
+    const worktrees = {
+      list: async ({ projectID }: { projectID: string }) => {
+        if (projectID === "b") throw new Error("unavailable")
+        return [{ directory: "/a/copy", strategy: "git" as const }]
+      },
+    } as unknown as WorktreeApi
+
+    const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, projects, worktrees))
+
+    expect(result.map((project) => ({ id: project.id, sandboxes: project.sandboxes }))).toEqual([
+      { id: "a", sandboxes: ["/a/copy"] },
+      { id: "b", sandboxes: [] },
     ])
-    expect(result.some((project) => project.id === "test")).toBe(false)
   })
 })

packages/app/src/runtime/server/global-sync/bootstrap.ts

@@ -15,7 +15,8 @@ import { cmp, normalizeProjectInfo } from "./utils"
 import { formatServerError } from "@/runtime/server/errors"
 import { QueryClient, queryOptions } from "@tanstack/solid-query"
 import type { ServerScope } from "@/runtime/server/scope"
-import { withWorktreeInventory, worktreeInventoryKey } from "@/workspaces/inventory"
+import type { ServerApi } from "@/runtime/server/api"
+import { sameDirectory } from "@/workspaces/paths"
 
 type GlobalStore = {
   path: Path
@@ -63,21 +64,42 @@ type ProjectApi = {
   readonly list: () => Promise<ProjectListOutput>
   readonly current: (input?: ProjectCurrentInput) => Promise<ProjectCurrentOutput>
 }
+type WorktreeApi = Pick<ServerApi["worktree"], "list">
 type LocationApi = { readonly get: (input?: LocationGetInput) => Promise<LocationGetOutput> }
 
-// Metadata only. Worktree inventories load per project when a view shows it (see workspaces/inventory).
-export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi) =>
+export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi, worktrees: WorktreeApi) =>
   queryOptions({
     queryKey: [scope, "project"],
     queryFn: () =>
       retry(() =>
-        projects.list().then((items) =>
-          items
-            .filter((project) => !!project?.id)
-            .map(normalizeProjectInfo)
+        projects.list().then(async (items) => {
+          return (
+            await Promise.all(
+              items
+                .filter((project) => !!project?.id)
+                .map(async (project) => {
+                  const directories = await worktrees
+                    .list({ projectID: project.id })
+                    .catch(() => [
+                      { directory: project.canonical },
+                      ...(project.sandboxes ?? [])
+                        .filter((directory) => !sameDirectory(project.canonical, directory))
+                        .map((directory) => ({ directory })),
+                    ])
+                  return normalizeProjectInfo({
+                    ...project,
+                    sandboxes: directories
+                      .map((item) => item.directory)
+                      .filter((directory) => !sameDirectory(project.canonical, directory)),
+                    worktrees: directories,
+                  })
+                }),
+            )
+          )
             .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
-            .sort((a, b) => cmp(a.id, b.id)),
-        ),
+            .slice()
+            .sort((a, b) => cmp(a.id, b.id))
+        }),
       ),
   })
 
@@ -85,6 +107,7 @@ export async function bootstrapGlobal(input: {
   serverAPI: {
     readonly location: LocationApi
     readonly project: ProjectApi
+    readonly worktree: WorktreeApi
   }
   scope: ServerScope
   setGlobalStore: SetStoreFunction<GlobalStore>
@@ -94,17 +117,9 @@ export async function bootstrapGlobal(input: {
     () => input.queryClient.fetchQuery(loadGlobalConfigQuery(input.scope)),
     () => input.queryClient.fetchQuery(loadPathQuery(input.scope, null, input.serverAPI.location)),
     () =>
-      input.queryClient.fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project)).then((data) =>
-        input.setGlobalStore(
-          "project",
-          data.map((project) =>
-            withWorktreeInventory(
-              project,
-              input.queryClient.getQueryData(worktreeInventoryKey(input.scope, project.worktree)),
-            ),
-          ),
-        ),
-      ),
+      input.queryClient
+        .fetchQuery(loadProjectsQuery(input.scope, input.serverAPI.project, input.serverAPI.worktree))
+        .then((data) => input.setGlobalStore("project", data)),
   ]
   await runAll(slow)
 }

packages/app/src/runtime/server/request-queue.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createRequestQueue } from "./request-queue"
-
-function setup(input?: { limit?: number; stallMs?: number }) {
-  const pending: Array<{ url: string; resolve: () => void }> = []
-  const logs: Array<{ message: string; data: Record<string, unknown> }> = []
-  let clock = 0
-  const queue = createRequestQueue({
-    limit: input?.limit ?? 2,
-    stallMs: input?.stallMs,
-    now: () => clock,
-    log: (message, data) => logs.push({ message, data }),
-    fetch: Object.assign(
-      (resource: RequestInfo | URL) =>
-        new Promise<Response>((resolve) => {
-          pending.push({ url: new Request(resource).url, resolve: () => resolve(new Response("ok")) })
-        }),
-      { preconnect() {} },
-    ),
-  })
-  const settle = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
-  return { queue, pending, logs, settle, tick: (ms: number) => (clock += ms) }
-}
-
-describe("createRequestQueue", () => {
-  test("caps concurrent requests and starts queued ones as slots free up", async () => {
-    const input = setup()
-    const responses = ["/api/a", "/api/b", "/api/c"].map((path) => input.queue.fetch(`http://server${path}`))
-    await input.settle()
-    expect(input.pending.map((item) => new URL(item.url).pathname)).toEqual(["/api/a", "/api/b"])
-    expect(input.queue.queued()).toBe(1)
-    input.pending[0]!.resolve()
-    await input.settle()
-    expect(input.pending.map((item) => new URL(item.url).pathname)).toEqual(["/api/a", "/api/b", "/api/c"])
-    input.pending.forEach((item) => item.resolve())
-    await Promise.all(responses)
-    expect(input.queue.inflight()).toBe(0)
-  })
-
-  test("never counts the event stream against the budget", async () => {
-    const input = setup({ limit: 1 })
-    void input.queue.fetch("http://server/api/session")
-    void input.queue.fetch("http://server/api/event")
-    await input.settle()
-    expect(input.pending.map((item) => new URL(item.url).pathname).toSorted()).toEqual(["/api/event", "/api/session"])
-    expect(input.queue.inflight()).toBe(1)
-  })
-
-  test("aborted requests leave the queue without being sent", async () => {
-    const input = setup({ limit: 1 })
-    const controller = new AbortController()
-    void input.queue.fetch("http://server/api/first")
-    const aborted = input.queue.fetch("http://server/api/second", { signal: controller.signal })
-    controller.abort()
-    await input.settle()
-    input.pending[0]!.resolve()
-    await expect(aborted).rejects.toBeInstanceOf(DOMException)
-    expect(input.pending.map((item) => new URL(item.url).pathname)).toEqual(["/api/first"])
-    expect(input.queue.inflight()).toBe(0)
-  })
-
-  test("a burst that drains promptly is not thrashing", async () => {
-    const input = setup({ stallMs: 5 })
-    const responses = Array.from({ length: 12 }, (_, index) => input.queue.fetch(`http://server/api/${index}`))
-    await input.settle()
-    expect(input.queue.queued()).toBe(10)
-    // Drain two at a time before the stall threshold elapses.
-    for (let round = 0; round < 6; round++) {
-      input.pending.splice(0).forEach((item) => item.resolve())
-      await input.settle()
-    }
-    await Promise.all(responses)
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    expect(input.logs).toEqual([])
-  })
-
-  test("logs what is in flight and queued once per burst after requests stall", async () => {
-    const input = setup({ stallMs: 5 })
-    input.queue.fetch("http://server/api/worktree?location[directory]=%2Fa").catch(() => undefined)
-    input.tick(50)
-    input.queue.fetch("http://server/api/worktree?location[directory]=%2Fb").catch(() => undefined)
-    input.tick(50)
-    input.queue.fetch("http://server/api/worktree?location[directory]=%2Fc").catch(() => undefined)
-    input.tick(100)
-    input.queue.fetch("http://server/api/health").catch(() => undefined)
-    expect(input.logs).toEqual([])
-    input.tick(2_000)
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    expect(input.logs).toEqual([
-      {
-        message: "server thrashing detected",
-        data: {
-          limit: 2,
-          inflight: [
-            { method: "GET", url: "http://server/api/worktree?location[directory]=%2Fa", ms: 2_200 },
-            { method: "GET", url: "http://server/api/worktree?location[directory]=%2Fb", ms: 2_150 },
-          ],
-          queued: [
-            { method: "GET", url: "http://server/api/worktree?location[directory]=%2Fc", ms: 2_100 },
-            { method: "GET", url: "http://server/api/health", ms: 2_000 },
-          ],
-        },
-      },
-    ])
-    // Still stalled within the rate limit: no repeat.
-    input.tick(2_000)
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    expect(input.logs).toHaveLength(1)
-    input.tick(10_000)
-    await new Promise((resolve) => setTimeout(resolve, 20))
-    expect(input.logs).toHaveLength(2)
-  })
-})

packages/app/src/runtime/server/request-queue.ts

@@ -1,84 +0,0 @@
-type Entry = { method: string; url: string; at: number }
-
-// Chromium allows six connections per origin. The event stream holds one for the life of the
-// connection and health probes use their own fetch, so the app's API calls stay below that or
-// a burst stalls probes and user actions inside the browser where nothing can observe it.
-export const requestQueueLimit = 4
-
-// A mount legitimately fires a dozen requests at once; only a request that has waited this long
-// for a slot indicates the server is not keeping up.
-export const requestStallMs = 2_000
-
-export function createRequestQueue(input: {
-  fetch: typeof globalThis.fetch
-  limit?: number
-  stallMs?: number
-  log?: (message: string, data: Record<string, unknown>) => void
-  now?: () => number
-}) {
-  const limit = input.limit ?? requestQueueLimit
-  const stallMs = input.stallMs ?? requestStallMs
-  // Call the browser fetch unbound; `input.fetch(...)` would make `this` the options object.
-  const base = input.fetch
-  const now = input.now ?? Date.now
-  const log = input.log ?? ((message, data) => console.warn(`[server-request-queue] ${message}`, data))
-  const inflight = new Set<Entry>()
-  const waiting: Array<{ entry: Entry; start: () => void }> = []
-  let warned = -Infinity
-  let watcher: ReturnType<typeof setTimeout> | undefined
-
-  const describe = (entry: Entry) => ({ method: entry.method, url: entry.url, ms: now() - entry.at })
-  // Debug exports include the console, so list what the server is busy with while requests wait.
-  const watch = () => {
-    watcher = undefined
-    const oldest = waiting[0]?.entry
-    if (!oldest) return
-    if (now() - oldest.at >= stallMs && now() - warned >= 10_000) {
-      warned = now()
-      log("server thrashing detected", {
-        limit,
-        inflight: [...inflight].map(describe),
-        queued: waiting.map((item) => describe(item.entry)),
-      })
-    }
-    watcher = setTimeout(watch, stallMs)
-  }
-  const release = (entry: Entry) => {
-    inflight.delete(entry)
-    waiting.shift()?.start()
-  }
-  const acquire = (entry: Entry) =>
-    new Promise<void>((resolve) => {
-      const start = () => {
-        entry.at = now()
-        inflight.add(entry)
-        resolve()
-      }
-      if (inflight.size < limit) return start()
-      waiting.push({ entry, start })
-      watcher ??= setTimeout(watch, stallMs)
-    })
-
-  const fetch: typeof globalThis.fetch = Object.assign(
-    async (resource: RequestInfo | URL, init?: RequestInit) => {
-      const request = new Request(resource, init)
-      // The event stream is long-lived; never count it against the request budget.
-      if (new URL(request.url).pathname === "/api/event") return base(request)
-      const entry = { method: request.method, url: request.url, at: now() }
-      await acquire(entry)
-      if (request.signal.aborted) {
-        release(entry)
-        throw request.signal.reason ?? new DOMException("The operation was aborted.", "AbortError")
-      }
-      return base(request).finally(() => release(entry))
-    },
-    // Bun's fetch type carries preconnect; the browser never calls it.
-    { preconnect: () => {} },
-  )
-
-  return {
-    fetch,
-    inflight: () => inflight.size,
-    queued: () => waiting.length,
-  }
-}

packages/app/src/runtime/server/sync.tsx

@@ -20,8 +20,6 @@ import { toggleMcp } from "./global-sync/mcp"
 import { createConnectionSync } from "./server-sync/connection"
 import { usePlatform } from "@/runtime/platform/platform"
 import type { Data } from "@opencode-ai/client/solid"
-import { createWorktreeInventory, withWorktreeInventory } from "@/workspaces/inventory"
-import { sameDirectory } from "@/workspaces/paths"
 
 type GlobalStore = {
   path: Path
@@ -81,17 +79,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
   })
 
   const queryClient = useQueryClient()
-  const worktrees = createWorktreeInventory({
-    scope: serverSDK.scope,
-    queryClient,
-    api: () => serverSDK.api.worktree,
-    updated: (directory, items) =>
-      setGlobalStore("project", (projects) =>
-        projects.map((project) =>
-          sameDirectory(project.worktree, directory) ? withWorktreeInventory(project, items) : project,
-        ),
-      ),
-  })
   const bootstrap = useQuery(() => ({
     queryKey: [serverSDK.scope, "bootstrap"],
     queryFn: async () => {
@@ -210,27 +197,17 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
 
   function applyProjectUpdate(update: Parameters<typeof updateProjectInfo>[1]) {
     setGlobalStore("project", (projects) =>
-      projects.map((project) =>
-        project.id === update.id
-          ? // The wire payload carries no worktrees; keep the inventory this project already loaded.
-            withWorktreeInventory(updateProjectInfo(project, update), worktrees.cached(update.canonical))
-          : project,
-      ),
+      projects.map((project) => (project.id === update.id ? updateProjectInfo(project, update) : project)),
     )
   }
 
   const unsub = serverSDK.event.listen((event) => {
     connection.handleEvent({ type: event.type })
     if (event.type === "project.updated") applyProjectUpdate(event.data)
-    if (event.type === "worktree.updated") {
-      const root = globalStore.project.find((project) => project.id === event.data.projectID)?.worktree
-      if (root) void worktrees.refresh(root)
-      void bootstrap.refetch()
-      return
-    }
 
     if (!event.location) {
-      if (event.type === "config.updated" || event.type === "agent.updated") bootstrap.refetch()
+      if (event.type === "config.updated" || event.type === "agent.updated" || event.type === "worktree.updated")
+        bootstrap.refetch()
       return
     }
 
@@ -239,6 +216,7 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
     if (!children.children[key]) return
     children.mark(key)
     if (event.type === "config.updated" || event.type === "agent.updated") queue.push(key)
+    if (event.type === "worktree.updated") void bootstrap.refetch()
   })
 
   onCleanup(unsub)
@@ -283,7 +261,6 @@ export function createServerSyncContextInner(serverSDK: ServerSDK, data: Data) {
     // bootstrap,
     updateConfig: updateConfigMutation.mutateAsync,
     project: projectApi,
-    worktrees,
     mcp: {
       toggle: async (directory: string, name: string) => {
         const key = directoryKey(directory)

packages/app/src/session/preparing-composer.tsx

@@ -3,9 +3,11 @@ import { useLocation } from "@solidjs/router"
 import { ComposerEditor } from "@/composer/editor/editor"
 import { setCursorPosition } from "@/composer/editor/dom"
 import { createComposerEditor } from "@/composer/editor/interaction"
+import { useLanguage } from "@/runtime/i18n/language"
 import type { PendingSession } from "@/shell/tabs/tabs"
 
 export function PreparingComposer(props: { pending: PendingSession }) {
+  const language = useLanguage()
   const location = useLocation()
   let element: HTMLElement | undefined
   const editor = createComposerEditor({
@@ -18,6 +20,7 @@ export function PreparingComposer(props: { pending: PendingSession }) {
     },
     view: {
       draftOnly: true,
+      placeholder: () => language.t("session.new.worktree.draftPlaceholder"),
       submit: { stopping: () => false, onSubmit() {}, onStop() {} },
     },
   })

packages/app/src/session/route.tsx

@@ -64,7 +64,7 @@ function PreparingSession(props: { sessionID: string; pending: PendingSession })
           provider: { all: providers.all(), default: providers.default(), connected: [] },
         }}
       >
-        <div data-component="session-preparing" data-workspace-session class="min-h-0 flex-1 overflow-y-auto">
+        <div data-component="session-preparing" class="min-h-0 flex-1 overflow-y-auto">
           <SessionIdentityHeader sessionID={props.sessionID} />
           <div class="mx-auto w-full min-w-0 max-w-[1000px] px-4 pb-5 md:px-5">
             <SessionUserMessage

packages/app/src/session/timeline/session-workspace-menu.tsx

@@ -40,7 +40,8 @@ export function SessionWorkspaceMenu(props: {
     if (!open) return
     const sdk = serverSDK
     void sdk.api.worktree
-      .list({ location: { directory: props.directory } })
+      .refresh({ projectID: props.project.id })
+      .then(() => sdk.api.worktree.list({ projectID: props.project.id }))
       .then((items) =>
         setDirectories(
           items.map((item) => item.directory).filter((directory) => !sameDirectory(props.project.worktree, directory)),

packages/app/src/settings/providers/providers.tsx

@@ -58,7 +58,6 @@ export const SettingsProviders: Component<{
         (provider) =>
           provider.id !== "opencode" || Object.values(provider.models).some((model) => model.cost.input > 0),
       )
-      .toSorted((a, b) => Number(b.id === "opencode-go") - Number(a.id === "opencode-go"))
   })
 
   const popular = createMemo(() => {

packages/app/src/settings/workspaces/workspaces.tsx

@@ -65,7 +65,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
       Promise.all(
         (await serverSDK.api.project.list()).map(async (project) => {
           const worktrees = await serverSDK.api.worktree
-            .list({ location: { directory: project.canonical } })
+            .list({ projectID: project.id })
             .catch(() => [{ directory: project.canonical }, ...project.sandboxes.map((directory) => ({ directory }))])
           return normalizeProjectInfo({ ...project, worktrees })
         }),
@@ -180,7 +180,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     }
     const removed = await context.sdk.api.worktree
       .remove({
-        location: { directory: workspace.project.worktree },
+        projectID: workspace.project.id,
         directory: workspace.directory,
         force,
       })

packages/app/src/shell/routes/routes.tsx

@@ -1,10 +1,10 @@
 import { Route, useParams } from "@solidjs/router"
-import { createMemo, lazy, Show, Suspense, type ParentProps } from "solid-js"
+import { createMemo, lazy, Show, type ParentProps } from "solid-js"
 import { Home } from "@/home/route"
 import { ServerProvider } from "@/runtime/server/current"
 import { useGlobal } from "@/runtime/server/runtime"
 import { ServerConnection } from "@/runtime/server/registry"
-import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
+import { SessionRouteFrame } from "@/session/session-frame"
 import { LayoutProvider } from "@/shell/state/layout"
 import { SettingsSurfaceProvider } from "@/settings/surface"
 import Shell from "@/shell/shell"
@@ -36,17 +36,9 @@ export function AppRoutes() {
         path="/server/:serverKey/session/:id"
         component={() => (
           <SessionRouteFrame>
-            <Suspense
-              fallback={
-                <div class="flex min-h-0 flex-1 px-2 pb-[var(--shell-bottom-inset,8px)] pt-[var(--shell-top-inset,8px)]">
-                  <SessionPanelFrame raised />
-                </div>
-              }
-            >
-              <TargetServerRoute>
-                <TargetSessionRouteContent />
-              </TargetServerRoute>
-            </Suspense>
+            <TargetServerRoute>
+              <TargetSessionRouteContent />
+            </TargetServerRoute>
           </SessionRouteFrame>
         )}
       />

packages/app/src/shell/shell.tsx

@@ -8,6 +8,8 @@ import { ToastRegion } from "@/shell/notifications/toast"
 import { TitlebarRightProvider } from "@/shell/titlebar/right-slot"
 import { useSettingsSurface } from "@/settings/surface"
 import { useSettings } from "@/settings/model"
+import { useCurrentRoute } from "@/shell/state/layout"
+import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
 
 const DebugBar = lazy(() => import("@/shell/debug/debug-bar").then((module) => ({ default: module.DebugBar })))
 
@@ -15,6 +17,7 @@ export default function Layout(props: ParentProps) {
   const platform = usePlatform()
   const settings = useSettingsSurface()
   const preferences = useSettings()
+  const route = useCurrentRoute()
   const mobile = createMediaQuery("(max-width: 767px)")
   const [state, setState] = createStore({
     debugTools: false,
@@ -74,7 +77,7 @@ export default function Layout(props: ParentProps) {
                 class="-end-2"
                 direction="horizontal"
                 size={state.tabsWidth}
-                min={140}
+                min={130}
                 max={520}
                 onResize={(width) => setState("tabsWidth", width)}
               />
@@ -91,7 +94,18 @@ export default function Layout(props: ParentProps) {
             }}
           >
             <div class="flex size-full min-h-0 min-w-0 flex-col">
-              <Suspense>{props.children}</Suspense>
+              {/* Retain the previous page during navigation; only show the empty shell on initial load. */}
+              <Suspense
+                fallback={
+                  <Show when={route().type === "session"}>
+                    <SessionRouteFrame padded>
+                      <SessionPanelFrame raised />
+                    </SessionRouteFrame>
+                  </Show>
+                }
+              >
+                {props.children}
+              </Suspense>
             </div>
           </main>
         </div>

packages/app/src/shell/titlebar/titlebar.tsx

@@ -356,10 +356,10 @@ export function Titlebar(props: {
                   aria-label={language.t("home.title")}
                   aria-pressed={layout.route().type === "home"}
                 >
-                  <Icon name="grid-plus" class="shrink-0" />
+                  <Icon name="grid-plus" />
                   <span class="min-w-0 truncate">{language.t("home.title")}</span>
                   <span
-                    class="ms-auto hidden min-w-0 truncate text-v2-text-text-faint group-hover:block group-focus-visible:block"
+                    class="ms-auto shrink-0 whitespace-nowrap text-v2-text-text-faint opacity-0 group-hover:opacity-100 group-focus-visible:opacity-100"
                     aria-hidden="true"
                   >
                     <bdi dir="ltr">{command.keybind("home.toggle")}</bdi>
@@ -654,10 +654,10 @@ export function Titlebar(props: {
                               onClick={openNewTab}
                               aria-label={language.t("command.session.new")}
                             >
-                              <Icon name="edit" class="shrink-0" />
+                              <Icon name="edit" />
                               <span class="min-w-0 truncate">{language.t("command.session.new")}</span>
                               <span
-                                class="ms-auto hidden min-w-0 truncate text-v2-text-text-faint group-hover:block group-focus-visible:block"
+                                class="ms-auto shrink-0 whitespace-nowrap text-v2-text-text-faint opacity-0 group-hover:opacity-100 group-focus-visible:opacity-100"
                                 aria-hidden="true"
                               >
                                 <bdi dir="ltr">{command.keybind("tab.new")}</bdi>

packages/app/src/workspaces/create.test.ts

@@ -7,27 +7,30 @@ import { createWorktree } from "./create"
 describe("worktree creation", () => {
   test.each(
     [
-      { name: "clone", directory: "/copies/repo", root: "/copies/repo", canonical: "/copies/repo" },
+      { name: "clone", directory: "/copies/repo", root: "/copies/repo", canonical: "/copies/repo", parent: "/copies/" },
       {
         name: "clone subdirectory",
         directory: "/copies/repo/packages/app",
         root: "/copies/repo",
         canonical: "/copies/repo",
+        parent: "/copies/",
       },
       {
         name: "linked worktree subdirectory",
         directory: "/linked/task/packages/app",
         root: "/linked/task",
         canonical: "/copies/repo",
+        parent: "/copies/",
       },
       {
         name: "Windows clone",
         directory: "C:\\copies\\repo\\packages\\app",
         root: "C:\\copies\\repo",
         canonical: "C:\\copies\\repo",
+        parent: "C:/copies/",
       },
     ].flatMap((input) => [true, false].map((cached) => ({ ...input, cached }))),
-  )("uses the server destination and clone-local main for $name (cached: $cached)", async (input) => {
+  )("uses the clone-local main for $name (cached: $cached)", async (input) => {
     const project = { id: "proj_clone", directory: input.root, canonical: input.canonical }
     const requests: Request[] = []
     const api = OpenCode.make({
@@ -63,9 +66,10 @@ describe("worktree creation", () => {
           strategy: "git",
           from: input.canonical,
           branch: "clone-only",
+          directory: input.parent,
         })
         expect(requests.find((request) => request.method === "POST")?.url).toBe(
-          `http://localhost:3000/api/worktree?location%5Bdirectory%5D=${encodeURIComponent(input.directory)}`,
+          "http://localhost:3000/api/worktree/proj_clone",
         )
         expect(
           requests

packages/app/src/workspaces/create.ts

@@ -1,5 +1,6 @@
 import type { LocationGetOutput, OpenCodeClient } from "@opencode-ai/client/promise"
 import type { Data } from "@opencode-ai/client/solid"
+import { getDirectory } from "@opencode-ai/util/path"
 
 export async function createWorktree(input: {
   api: Pick<OpenCodeClient, "location" | "worktree">
@@ -10,10 +11,11 @@ export async function createWorktree(input: {
 }) {
   const project = input.project ?? (await input.api.location.get({ location: { directory: input.directory } })).project
   const created = await input.api.worktree.create({
-    location: { directory: input.directory },
+    projectID: project.id,
     strategy: "git",
     from: project.canonical,
     branch: input.branch,
+    directory: getDirectory(project.canonical),
   })
   // Populate the client cache before the destination session mounts.
   await input.data.location.syncInfo({ directory: created.directory })

packages/app/src/workspaces/inventory.test.ts

@@ -1,111 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { QueryClient } from "@tanstack/solid-query"
-import type { WorktreeDirectory } from "@opencode-ai/client/promise"
-import { createWorktreeInventory, withWorktreeInventory, worktreeInventoryKey } from "./inventory"
-import { ServerScope } from "@/runtime/server/scope"
-import { normalizeProjectInfo, updateProjectInfo } from "@/runtime/server/global-sync/utils"
-
-function setup(list: (directory: string) => Promise<WorktreeDirectory[]>) {
-  const client = new QueryClient()
-  const calls: string[] = []
-  const updates: Array<[string, WorktreeDirectory[]]> = []
-  const inventory = createWorktreeInventory({
-    scope: ServerScope.local,
-    queryClient: client,
-    api: () => ({
-      list: (input) => {
-        const directory = input!.location!.directory!
-        calls.push(directory)
-        return list(directory)
-      },
-    }),
-    updated: (directory, items) => updates.push([directory, items]),
-  })
-  return { client, calls, updates, inventory }
-}
-
-describe("createWorktreeInventory", () => {
-  test("loads once per project, shares in-flight work, and publishes the result", async () => {
-    const gate = Promise.withResolvers<void>()
-    const setupResult = setup(async (directory) => {
-      await gate.promise
-      return [{ directory }, { directory: `${directory}/feature`, strategy: "git" }]
-    })
-    const first = setupResult.inventory.load("/repo")
-    const second = setupResult.inventory.load("/repo/")
-    expect(setupResult.calls).toEqual(["/repo"])
-    gate.resolve()
-    expect(await first).toHaveLength(2)
-    expect(await second).toHaveLength(2)
-    await setupResult.inventory.load("/repo")
-    expect(setupResult.calls).toEqual(["/repo"])
-    expect(setupResult.updates).toEqual([
-      ["/repo", [{ directory: "/repo" }, { directory: "/repo/feature", strategy: "git" }]],
-    ])
-    expect(setupResult.inventory.cached("/repo/")).toHaveLength(2)
-    setupResult.client.clear()
-  })
-
-  test("refreshes only inventories a view already loaded", async () => {
-    const setupResult = setup(async (directory) => [{ directory }])
-    await setupResult.inventory.refresh("/never-opened")
-    expect(setupResult.calls).toEqual([])
-    await setupResult.inventory.load("/opened")
-    await setupResult.inventory.refresh("/opened")
-    expect(setupResult.calls).toEqual(["/opened", "/opened"])
-    setupResult.client.clear()
-  })
-
-  test("a failed load is not cached and never rejects the caller", async () => {
-    let fail = true
-    const setupResult = setup(async (directory) => {
-      if (fail) throw new Error("Location unavailable")
-      return [{ directory }]
-    })
-    expect(await setupResult.inventory.load("/repo")).toBeUndefined()
-    expect(setupResult.inventory.cached("/repo")).toBeUndefined()
-    fail = false
-    expect(await setupResult.inventory.load("/repo")).toEqual([{ directory: "/repo" }])
-    expect(setupResult.calls).toEqual(["/repo", "/repo"])
-    setupResult.client.clear()
-  })
-
-  test("keys are partitioned by server and normalized by path", () => {
-    const remote = "https://remote.example" as typeof ServerScope.local
-    expect(worktreeInventoryKey(ServerScope.local, "C:\\Repo\\")).toEqual(
-      worktreeInventoryKey(ServerScope.local, "C:/Repo"),
-    )
-    expect(worktreeInventoryKey(ServerScope.local, "/repo")).not.toEqual(worktreeInventoryKey(remote, "/repo"))
-  })
-})
-
-describe("withWorktreeInventory", () => {
-  const metadata = {
-    id: "project",
-    canonical: "/repo",
-    name: "Before",
-    time: { created: 1, updated: 1 },
-    sandboxes: [],
-  }
-
-  test("derives the workspace list from the inventory, excluding the project root", () => {
-    const worktrees = [
-      { directory: "/repo/" },
-      { directory: "/repo/feature", strategy: "git" },
-      { directory: "/elsewhere" },
-    ]
-    expect(withWorktreeInventory(normalizeProjectInfo(metadata), worktrees)).toMatchObject({
-      worktree: "/repo",
-      sandboxes: ["/repo/feature", "/elsewhere"],
-      worktrees,
-    })
-  })
-
-  test("leaves metadata untouched without an inventory and survives metadata updates", () => {
-    const project = normalizeProjectInfo(metadata)
-    expect(withWorktreeInventory(project, undefined)).toBe(project)
-    const cached = [{ directory: "/repo" }, { directory: "/repo/feature", strategy: "git" }]
-    const updated = updateProjectInfo(withWorktreeInventory(project, cached), { ...metadata, name: "After" })
-    expect(withWorktreeInventory(updated, cached)).toMatchObject({ name: "After", sandboxes: ["/repo/feature"] })
-  })
-})

packages/app/src/workspaces/inventory.ts

@@ -1,58 +0,0 @@
-import type { QueryClient } from "@tanstack/solid-query"
-import type { WorktreeDirectory } from "@opencode-ai/client/promise"
-import type { ServerApi } from "@/runtime/server/api"
-import type { ServerScope } from "@/runtime/server/scope"
-import type { Project } from "@/runtime/server/types"
-import { pathKey } from "./path-key"
-import { sameDirectory } from "./paths"
-
-export function worktreeInventoryKey(scope: ServerScope, directory: string) {
-  return [scope, "worktree", pathKey(directory)] as const
-}
-
-// Project metadata arrives without worktrees; a loaded inventory supplies the workspace list.
-export function withWorktreeInventory(project: Project, worktrees: readonly WorktreeDirectory[] | undefined): Project {
-  if (!worktrees) return project
-  return {
-    ...project,
-    worktrees: [...worktrees],
-    sandboxes: worktrees
-      .map((item) => item.directory)
-      .filter((directory) => !sameDirectory(project.worktree, directory)),
-  }
-}
-
-// Listing a project's worktrees boots its Location on the server and runs discovery, so only
-// projects the user is looking at are loaded. Historical projects stay metadata-only.
-export function createWorktreeInventory(input: {
-  scope: ServerScope
-  queryClient: QueryClient
-  api: () => Pick<ServerApi["worktree"], "list">
-  updated: (directory: string, worktrees: WorktreeDirectory[]) => void
-}) {
-  const options = (directory: string) => ({
-    queryKey: worktreeInventoryKey(input.scope, directory),
-    queryFn: () =>
-      input
-        .api()
-        .list({ location: { directory } })
-        .then((items) => {
-          input.updated(directory, items)
-          return items
-        }),
-    // `worktree.updated` and reconnect invalidation drive refreshes; time alone does not re-list.
-    staleTime: Infinity,
-    gcTime: Infinity,
-    retry: false,
-  })
-  return {
-    cached: (directory: string) =>
-      input.queryClient.getQueryData<WorktreeDirectory[]>(worktreeInventoryKey(input.scope, directory)),
-    load: (directory: string) => input.queryClient.fetchQuery(options(directory)).catch(() => undefined),
-    // Only inventories some view already demanded are refreshed.
-    refresh: (directory: string) => {
-      if (!input.queryClient.getQueryState(worktreeInventoryKey(input.scope, directory))) return Promise.resolve()
-      return input.queryClient.fetchQuery({ ...options(directory), staleTime: 0 }).catch(() => undefined)
-    },
-  }
-}

packages/app/src/workspaces/location.tsx

@@ -3,7 +3,7 @@ import type { LocationGetOutput, LocationRef } from "@opencode-ai/client/promise
 import { retry } from "@opencode-ai/util/retry"
 import { type Accessor, createEffect, createMemo, onCleanup } from "solid-js"
 import { type LocationContext, useServerSDK } from "@/runtime/server/client"
-import { useData, useServer } from "@/runtime/server/current"
+import { useData } from "@/runtime/server/current"
 export type { LocationContext } from "@/runtime/server/client"
 
 export type WorkspaceLocation = LocationContext & {
@@ -15,7 +15,6 @@ const context = createSimpleContext({
   name: "Location",
   init: (props: { directory: string | Accessor<string>; workspaceID?: string | Accessor<string | undefined> }) => {
     const serverSDK = useServerSDK()
-    const server = useServer()
     const data = useData()
     const ref = createMemo(
       () => ({
@@ -41,14 +40,6 @@ const context = createSimpleContext({
         retryIf: () => !stale,
       }).catch(() => undefined)
     })
-    createEffect(() => {
-      const id = current()?.project.id
-      if (!id || serverSDK.connection.status() !== "connected") return
-      // Showing a Location is the demand for its project's worktree inventory (workspace styling, picker).
-      // Key it by the metadata root so the result merges into the same global project record.
-      const root = server.ctx.sync.data.project.find((project) => project.id === id)?.worktree
-      if (root) void server.ctx.sync.worktrees.load(root)
-    })
 
     const location = createMemo(() => serverSDK.ensureDirSdkContext(current()?.directory ?? ref().directory))
     return createMemo<WorkspaceLocation>(() => ({

packages/cli/src/services/updater.ts

@@ -75,7 +75,7 @@ const make = Effect.gen(function* () {
         Effect.orElseSucceed(() => undefined),
       ),
     )
-    return values.findLast((value) => value !== undefined) ?? "notify"
+    return values.findLast((value) => value !== undefined) ?? "auto"
   })
 
   const exec = Effect.fnUntraced(function* (command: string[], timeout: Duration.Input = "10 seconds") {

packages/client/src/effect/api/api.ts

@@ -1931,37 +1931,33 @@ export interface ReferenceApi<E = never> {
   readonly list: ReferenceListOperation<E>
 }
 
-export type WorktreeListInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
+export type WorktreeListInput = { readonly projectID: Project.ID }
 export type WorktreeListOutput = Worktree.List
-export type WorktreeListOperation<E = never> = (input?: WorktreeListInput) => Effect.Effect<WorktreeListOutput, E>
+export type WorktreeListOperation<E = never> = (input: WorktreeListInput) => Effect.Effect<WorktreeListOutput, E>
 
 export type WorktreeCreateInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  readonly strategy?: Worktree.StrategyID | undefined
+  readonly projectID: Project.ID
+  readonly strategy: Worktree.StrategyID
   readonly from?: AbsolutePath | undefined
   readonly branch?: string | undefined
-  readonly directory?: AbsolutePath | undefined
+  readonly directory: AbsolutePath
   readonly name?: string | undefined
 }
 export type WorktreeCreateOutput = Worktree.Info
-export type WorktreeCreateOperation<E = never> = (input?: WorktreeCreateInput) => Effect.Effect<WorktreeCreateOutput, E>
+export type WorktreeCreateOperation<E = never> = (input: WorktreeCreateInput) => Effect.Effect<WorktreeCreateOutput, E>
 
 export type WorktreeRemoveInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+  readonly projectID: Project.ID
   readonly directory: AbsolutePath
   readonly force: boolean
 }
 export type WorktreeRemoveOutput = void
 export type WorktreeRemoveOperation<E = never> = (input: WorktreeRemoveInput) => Effect.Effect<WorktreeRemoveOutput, E>
 
-export type WorktreeRefreshInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
+export type WorktreeRefreshInput = { readonly projectID: Project.ID }
 export type WorktreeRefreshOutput = void
 export type WorktreeRefreshOperation<E = never> = (
-  input?: WorktreeRefreshInput,
+  input: WorktreeRefreshInput,
 ) => Effect.Effect<WorktreeRefreshOutput, E>
 
 export interface WorktreeApi<E = never> {

packages/client/src/effect/generated/client.ts

@@ -1451,21 +1451,21 @@ const EndpointReferenceList = (raw: RawClient["server.reference"]) => (input?: R
 
 const adaptGroupReference = (raw: RawClient["server.reference"]) => ({ list: EndpointReferenceList(raw) })
 
-const EndpointWorktreeList = (raw: RawClient["server.worktree"]) => (input?: WorktreeListInput) =>
+const EndpointWorktreeList = (raw: RawClient["server.worktree"]) => (input: WorktreeListInput) =>
   preserveEffect<WorktreeListOutput>()(
-    raw["worktree.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["worktree.list"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const EndpointWorktreeCreate = (raw: RawClient["server.worktree"]) => (input?: WorktreeCreateInput) =>
+const EndpointWorktreeCreate = (raw: RawClient["server.worktree"]) => (input: WorktreeCreateInput) =>
   preserveEffect<WorktreeCreateOutput>()(
     raw["worktree.create"]({
-      query: { location: input?.["location"] },
+      params: { projectID: input["projectID"] },
       payload: {
-        strategy: input?.["strategy"],
-        from: input?.["from"],
-        branch: input?.["branch"],
-        directory: input?.["directory"],
-        name: input?.["name"],
+        strategy: input["strategy"],
+        from: input["from"],
+        branch: input["branch"],
+        directory: input["directory"],
+        name: input["name"],
       },
     }).pipe(Effect.mapError(mapClientError)),
   )
@@ -1473,14 +1473,14 @@ const EndpointWorktreeCreate = (raw: RawClient["server.worktree"]) => (input?: W
 const EndpointWorktreeRemove = (raw: RawClient["server.worktree"]) => (input: WorktreeRemoveInput) =>
   preserveEffect<WorktreeRemoveOutput>()(
     raw["worktree.remove"]({
-      query: { location: input["location"] },
+      params: { projectID: input["projectID"] },
       payload: { directory: input["directory"], force: input["force"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const EndpointWorktreeRefresh = (raw: RawClient["server.worktree"]) => (input?: WorktreeRefreshInput) =>
+const EndpointWorktreeRefresh = (raw: RawClient["server.worktree"]) => (input: WorktreeRefreshInput) =>
   preserveEffect<WorktreeRefreshOutput>()(
-    raw["worktree.refresh"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
+    raw["worktree.refresh"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
 const adaptGroupWorktree = (raw: RawClient["server.worktree"]) => ({

packages/client/src/promise/api.ts

@@ -20,7 +20,6 @@ export type WebSearchApi = Client["websearch"]
 export type SessionApi = Client["session"]
 export type SkillApi = Client["skill"]
 export type VcsApi = Client["vcs"]
-export type WorktreeApi = Client["worktree"]
 
 export interface CatalogApi {
   readonly provider: ProviderApi

packages/client/src/promise/generated/client.ts

@@ -1968,30 +1968,28 @@ export function make(options: ClientOptions) {
         ),
     },
     worktree: {
-      list: (input?: WorktreeListInput, requestOptions?: RequestOptions) =>
+      list: (input: WorktreeListInput, requestOptions?: RequestOptions) =>
         request<WorktreeListOutput>(
           {
             method: "GET",
-            path: `/api/worktree`,
-            query: { location: input?.["location"] },
+            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
             successStatus: 200,
             declaredStatuses: [400, 401],
             empty: false,
           },
           requestOptions,
         ),
-      create: (input?: WorktreeCreateInput, requestOptions?: RequestOptions) =>
+      create: (input: WorktreeCreateInput, requestOptions?: RequestOptions) =>
         request<WorktreeCreateOutput>(
           {
             method: "POST",
-            path: `/api/worktree`,
-            query: { location: input?.["location"] },
+            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
             body: {
-              strategy: input?.["strategy"],
-              from: input?.["from"],
-              branch: input?.["branch"],
-              directory: input?.["directory"],
-              name: input?.["name"],
+              strategy: input["strategy"],
+              from: input["from"],
+              branch: input["branch"],
+              directory: input["directory"],
+              name: input["name"],
             },
             successStatus: 200,
             declaredStatuses: [400, 401],
@@ -2003,8 +2001,7 @@ export function make(options: ClientOptions) {
         request<WorktreeRemoveOutput>(
           {
             method: "DELETE",
-            path: `/api/worktree`,
-            query: { location: input["location"] },
+            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
             body: { directory: input["directory"], force: input["force"] },
             successStatus: 204,
             declaredStatuses: [400, 401],
@@ -2012,12 +2009,11 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      refresh: (input?: WorktreeRefreshInput, requestOptions?: RequestOptions) =>
+      refresh: (input: WorktreeRefreshInput, requestOptions?: RequestOptions) =>
         request<WorktreeRefreshOutput>(
           {
             method: "POST",
-            path: `/api/worktree/refresh`,
-            query: { location: input?.["location"] },
+            path: `/api/worktree/${encodeURIComponent(input.projectID)}/refresh`,
             successStatus: 204,
             declaredStatuses: [400, 401],
             empty: true,

packages/client/src/promise/generated/types.ts

@@ -430,8 +430,6 @@ export type WebSearchProvider = { id: string; name: string }
 
 export type WebSearchResult = { url: string; title?: string; content?: string; time: { published?: number } }
 
-export type ConfigWorktree = { directory: string }
-
 export type ProviderRequest = {
   settings: ProviderSettings
   headers: { [x: string]: string }
@@ -1995,7 +1993,6 @@ export type ConfigEntry =
         }
         websearch?: false | { provider: "random" | (string & {}) }
         plugins?: Array<string | { package: string; options?: { [x: string]: JsonValue } }>
-        worktree?: ConfigWorktree
         warming?: boolean | { prompt?: string; interval?: string; duration?: string }
         providers?: {
           [x: string]: {
@@ -6080,51 +6077,45 @@ export type ReferenceListOutput = {
   data: Array<ReferenceInfo>
 }
 
-export type WorktreeListInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
+export type WorktreeListInput = { readonly projectID: { readonly projectID: string }["projectID"] }
 
 export type WorktreeListOutput = WorktreeList
 
 export type WorktreeCreateInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-  readonly strategy?: {
-    readonly strategy?: string
+  readonly projectID: { readonly projectID: string }["projectID"]
+  readonly strategy: {
+    readonly strategy: string
     readonly from?: string
     readonly branch?: string
-    readonly directory?: string
+    readonly directory: string
     readonly name?: string
   }["strategy"]
   readonly from?: {
-    readonly strategy?: string
+    readonly strategy: string
     readonly from?: string
     readonly branch?: string
-    readonly directory?: string
+    readonly directory: string
     readonly name?: string
   }["from"]
   readonly branch?: {
-    readonly strategy?: string
+    readonly strategy: string
     readonly from?: string
     readonly branch?: string
-    readonly directory?: string
+    readonly directory: string
     readonly name?: string
   }["branch"]
-  readonly directory?: {
-    readonly strategy?: string
+  readonly directory: {
+    readonly strategy: string
     readonly from?: string
     readonly branch?: string
-    readonly directory?: string
+    readonly directory: string
     readonly name?: string
   }["directory"]
   readonly name?: {
-    readonly strategy?: string
+    readonly strategy: string
     readonly from?: string
     readonly branch?: string
-    readonly directory?: string
+    readonly directory: string
     readonly name?: string
   }["name"]
 }
@@ -6132,20 +6123,14 @@ export type WorktreeCreateInput = {
 export type WorktreeCreateOutput = WorktreeInfo
 
 export type WorktreeRemoveInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
+  readonly projectID: { readonly projectID: string }["projectID"]
   readonly directory: { readonly directory: string; readonly force: boolean }["directory"]
   readonly force: { readonly directory: string; readonly force: boolean }["force"]
 }
 
 export type WorktreeRemoveOutput = void
 
-export type WorktreeRefreshInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-}
+export type WorktreeRefreshInput = { readonly projectID: { readonly projectID: string }["projectID"] }
 
 export type WorktreeRefreshOutput = void
 

packages/client/test/promise.test.ts

@@ -336,7 +336,7 @@ test("file.read returns binary content from the public HTTP contract", async ()
   )
 })
 
-test("all worktree operations use location-based routes without a project parameter", async () => {
+test("worktree methods use the global project contract", async () => {
   const requests: Request[] = []
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
@@ -350,25 +350,27 @@ test("all worktree operations use location-based routes without a project parame
     },
   })
 
-  expect(await client.worktree.list()).toEqual([{ directory: "/tmp/project" }])
+  expect(await client.worktree.list({ projectID: "proj_test" })).toEqual([{ directory: "/tmp/project" }])
   expect(
     await client.worktree.create({
+      projectID: "proj_test",
       strategy: "git",
       directory: "/tmp/worktrees",
       name: "api",
     }),
   ).toEqual({ directory: "/tmp/worktrees/api" })
   await client.worktree.remove({
+    projectID: "proj_test",
     directory: "/tmp/worktrees/api",
     force: false,
   })
-  await client.worktree.refresh()
+  await client.worktree.refresh({ projectID: "proj_test" })
 
   expect(requests.map((request) => [request.method, request.url])).toEqual([
-    ["GET", "http://localhost:3000/api/worktree"],
-    ["POST", "http://localhost:3000/api/worktree"],
-    ["DELETE", "http://localhost:3000/api/worktree"],
-    ["POST", "http://localhost:3000/api/worktree/refresh"],
+    ["GET", "http://localhost:3000/api/worktree/proj_test"],
+    ["POST", "http://localhost:3000/api/worktree/proj_test"],
+    ["DELETE", "http://localhost:3000/api/worktree/proj_test"],
+    ["POST", "http://localhost:3000/api/worktree/proj_test/refresh"],
   ])
   expect(await requests[1]?.json()).toEqual({
     strategy: "git",
@@ -378,39 +380,6 @@ test("all worktree operations use location-based routes without a project parame
   expect(await requests[2]?.json()).toEqual({ directory: "/tmp/worktrees/api", force: false })
 })
 
-test("worktree operations send the configuration location separately from their payload", async () => {
-  const requests: Request[] = []
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = new Request(input, init)
-      requests.push(request)
-      if (request.method === "GET") return Response.json([{ directory: "/configured/task", strategy: "git" }])
-      if (request.method === "DELETE" || new URL(request.url).pathname.endsWith("/refresh"))
-        return new Response(null, { status: 204 })
-      return Response.json({ directory: "/configured/task" })
-    },
-  })
-  expect(await client.worktree.create({ location: { directory: "/repo/nested" }, name: "task" })).toEqual({
-    directory: "/configured/task",
-  })
-  expect(requests[0]?.url).toBe("http://localhost:3000/api/worktree?location%5Bdirectory%5D=%2Frepo%2Fnested")
-  expect(await requests[0]?.json()).toEqual({ name: "task" })
-  await client.worktree.remove({
-    location: { directory: "/repo/nested" },
-    directory: "/configured/task",
-    force: true,
-  })
-  await client.worktree.refresh({ location: { directory: "/repo/nested" } })
-  expect(requests[1]?.url).toBe("http://localhost:3000/api/worktree?location%5Bdirectory%5D=%2Frepo%2Fnested")
-  expect(await requests[1]?.json()).toEqual({ directory: "/configured/task", force: true })
-  expect(requests[2]?.url).toBe("http://localhost:3000/api/worktree/refresh?location%5Bdirectory%5D=%2Frepo%2Fnested")
-  expect(await client.worktree.list({ location: { directory: "/repo/nested" } })).toEqual([
-    { directory: "/configured/task", strategy: "git" },
-  ])
-  expect(requests[3]?.url).toBe("http://localhost:3000/api/worktree?location%5Bdirectory%5D=%2Frepo%2Fnested")
-})
-
 test("workspace.destroy returns the transition result", async () => {
   let request: Request | undefined
   const client = OpenCode.make({

packages/console/app/src/routes/api/enterprise.ts

@@ -98,7 +98,7 @@ ${body.phone ? `${body.phone}<br>` : ""}`.trim()
         return false
       }),
       AWS.sendEmail({
-        to: Resource.ENTERPRISE_SALES_INBOX_EMAIL.value,
+        to: "contact@anoma.ly",
         subject: `Enterprise Inquiry from ${body.name}`,
         body: emailContent,
         replyTo: body.email,

packages/containers/bun-node/Dockerfile

@@ -4,7 +4,7 @@ FROM ${REGISTRY}/build/base:24.04
 SHELL ["/bin/bash", "-lc"]
 
 ARG NODE_VERSION=24.4.0
-ARG BUN_VERSION=1.4.2
+ARG BUN_VERSION=1.4.1
 
 ENV BUN_INSTALL=/opt/bun
 ENV PATH=/opt/bun/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

packages/core/src/codemode/instructions.ts

@@ -12,7 +12,7 @@ ${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalo
 
 ## Search
 
-Call \`search(...)\` to discover exact paths and signatures for additional tools:
+Use \`search\` to discover exact paths and signatures for additional tools:
 
 - ${searchSignature}` : ""}
 

packages/core/src/codemode/tool.ts

@@ -61,7 +61,7 @@ export type Inventory = {
 const description = [
   "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
   "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
-  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+  "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
   'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
   "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
   "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`.",

packages/core/src/config/normalize.ts

@@ -209,7 +209,6 @@ export function normalize(input: unknown): Result {
     media: Info.fields.media,
     tool_output: Info.fields.tool_output,
     websearch: Info.fields.websearch,
-    worktree: Info.fields.worktree,
     warming: Info.fields.warming,
   }
   Object.entries(nativeAtomic).forEach(([key, schema]) => {

packages/core/src/config/plugin/worktree.ts

@@ -1,35 +0,0 @@
-export * as ConfigWorktreePlugin from "./worktree.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Effect } from "effect"
-import path from "path"
-import { Config } from "../../config.js"
-import { Global } from "@opencode-ai/util/global"
-import { Location } from "../../location.js"
-import { AbsolutePath } from "../../schema.js"
-import { Worktree } from "../../worktree.js"
-import { ConfigEntryObserver } from "./entry-observer.js"
-
-export const Plugin = define({
-  id: "opencode.config.worktree",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const location = yield* Location.Service
-    const global = yield* Global.Service
-    const worktrees = yield* Worktree.Service
-    const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, worktrees.reload())
-    yield* worktrees.transform((editor) => {
-      for (const entry of loaded.entries) {
-        if (entry.type !== "document" || !entry.info.worktree) continue
-        const directory = entry.info.worktree.directory
-        editor.configure({
-          directory: AbsolutePath.make(
-            directory.startsWith("~/")
-              ? path.join(global.home, directory.slice(2))
-              : path.resolve(entry.path ? path.dirname(entry.path) : location.directory, directory),
-          ),
-        })
-      }
-    })
-  }),
-})

packages/core/src/instance.ts

@@ -25,7 +25,6 @@ import { Plugin } from "./plugin.js"
 import { PluginHooks } from "./plugin/hooks.js"
 import { InstancePlugins } from "./plugin/instance.js"
 import { PluginSupervisor } from "./plugin/supervisor.js"
-import { WorktreeRefresh } from "./worktree/refresh.js"
 import { Worktree } from "./worktree.js"
 import { Pty } from "./pty.js"
 import { Shell } from "./shell.js"
@@ -72,8 +71,7 @@ const nodes = [
   PluginHooks.node,
   InstancePlugins.node,
   PluginSupervisor.node,
-  WorktreeRefresh.node,
-  Worktree.node,
+  Worktree.refreshNode,
   FileSystemSearch.node,
   FileSystem.node,
   ShellSelect.node,

packages/core/src/plugin/host.ts

@@ -30,7 +30,6 @@ import { Tool } from "../tool.js"
 import { Workspace } from "../workspace.js"
 import { Vcs } from "../vcs.js"
 import { WebSearch } from "../websearch.js"
-import { Worktree } from "../worktree.js"
 import { Generate } from "../generate.js"
 import { Permission } from "../permission.js"
 import { PluginHooks } from "./hooks.js"
@@ -70,7 +69,6 @@ export const make = Effect.fn("PluginHost.make")(function* (
   const sessions = yield* Session.Service
   const persistentPty = yield* PersistentPty.Service
   const locations = yield* LocationServiceMap.Service
-  const worktrees = yield* Worktree.Service
   const locationInfo = () =>
     new Location.Info({
       directory: location.directory,
@@ -90,24 +88,6 @@ export const make = Effect.fn("PluginHost.make")(function* (
   const response = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
     effect.pipe(Effect.map((data) => ({ location: locationInfo(), data })))
 
-  const atWorktree = <A, E>(
-    ref: Location.Ref | undefined,
-    run: (service: Worktree.Interface) => Effect.Effect<A, E>,
-  ) => {
-    if (ref?.workspaceID) return Effect.fail(new Worktree.UnsupportedLocationError({ directory: ref.directory }))
-    if (!ref || isCurrentLocation(ref)) return run(worktrees)
-    return Effect.gen(function* () {
-      // Defer this import: Plugin's construction depends on this host. Same-location setup calls never wait on themselves.
-      const { Plugin } = yield* Effect.promise(() => import("../plugin.js"))
-      const plugins = yield* Plugin.Service
-      const target = yield* Worktree.Service
-      yield* plugins.awaitActivation
-      return yield* run(target)
-    }).pipe(Effect.provide(locations.get(ref)))
-  }
-  const decodeWorktree = Schema.decodeUnknownEffect(Worktree.Info)
-  const decodeWorktrees = Schema.decodeUnknownEffect(Schema.Array(Worktree.ListEntry))
-
   const listAgents = Effect.fn("PluginHost.listAgents")((ref: Location.Ref) =>
     Effect.gen(function* () {
       const location = yield* Location.Service
@@ -482,25 +462,6 @@ export const make = Effect.fn("PluginHost.make")(function* (
           })
         }),
     },
-    worktree: {
-      list: (input) => atWorktree(locationRef(input), (service) => service.list()),
-      create: (input) => atWorktree(locationRef(input), (service) => service.create(input)),
-      refresh: (input) => atWorktree(locationRef(input), (service) => service.refresh()).pipe(Effect.asVoid),
-      remove: (input) => atWorktree(locationRef(input), (service) => service.remove(input)),
-      reload: worktrees.reload,
-      transform: (callback) =>
-        worktrees.transform((editor) =>
-          callback({
-            add: (definition) =>
-              editor.add({
-                id: Worktree.StrategyID.make(definition.id),
-                create: (input) => definition.create(input).pipe(Effect.flatMap(decodeWorktree)),
-                remove: (input) => definition.remove(input),
-                list: (directory) => definition.list(directory).pipe(Effect.flatMap(decodeWorktrees)),
-              }),
-          }),
-        ),
-    },
     session: {
       hook: (name, callback, options) => hooks.register("session", name, callback, options),
       create: (input) =>
@@ -549,7 +510,6 @@ export const requirements = LayerNode.group([
   Tool.node,
   Vcs.node,
   WebSearch.node,
-  Worktree.node,
   Generate.node,
   Permission.node,
   PluginHooks.node,

packages/core/src/plugin/internal.ts

@@ -27,8 +27,6 @@ import { ConfigSnapshotPlugin } from "../config/plugin/snapshot.js"
 import { ConfigSkillPlugin } from "../config/plugin/skill.js"
 import { ConfigToolOutputPlugin } from "../config/plugin/tool-output.js"
 import { ConfigWebSearchPlugin } from "../config/plugin/websearch.js"
-import { ConfigWorktreePlugin } from "../config/plugin/worktree.js"
-import { Worktree } from "../worktree.js"
 import { Bus } from "../bus.js"
 import { Environment } from "../environment/index.js"
 import { FileMutation } from "../file-mutation.js"
@@ -137,7 +135,6 @@ const services = [
   ToolOutput.Service,
   Watcher.Service,
   WellKnown.Service,
-  Worktree.Service,
 ] as const
 
 export type Requirements = Context.Service.Identifier<(typeof services)[number]>
@@ -186,7 +183,6 @@ export const requirements = LayerNode.group([
   ToolOutput.node,
   Watcher.node,
   WellKnown.node,
-  Worktree.node,
 ])
 
 export type InternalPlugin = Plugin<Requirements | Scope.Scope>
@@ -236,7 +232,6 @@ const post = [
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,
-  ConfigWorktreePlugin.Plugin,
   VariantPlugin.Plugin,
   ConfigPolicyPlugin.Plugin,
 ] as const satisfies readonly InternalPlugin[]

packages/core/src/plugin/provider/openai.ts

@@ -274,12 +274,10 @@ export const OpenAIPlugin = define({
             return
           }
           const apiID = draft.modelID ?? draft.id
-          const match = apiID.match(/^gpt-(\d+)(?:\.(\d+))?/)
-          const major = Number(match?.[1])
-          const minor = Number(match?.[2] ?? 0)
+          const match = apiID.match(/^gpt-(\d+\.\d+)/)
           if (
             !codexAllowed.has(apiID) &&
-            (codexDisallowed.has(apiID) || !match || !(major > 5 || (major === 5 && minor > 4)))
+            (codexDisallowed.has(apiID) || !match || Number.parseFloat(match[1]) <= 5.4)
           ) {
             draft.enabled = false
             return

packages/core/src/plugin/system-prompt.ts

@@ -2,50 +2,42 @@ export * as SystemPromptPlugin from "./system-prompt.js"
 
 import { SystemPart } from "@opencode-ai/ai"
 import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Model } from "@opencode-ai/schema/model"
 import { Effect } from "effect"
-import { SessionSystemPrompt } from "../session/system-prompt.js"
 
-import PROMPT_GPT from "./system-prompt/gpt.txt"
-import PROMPT_ASTRA from "./system-prompt/gpt-astra.txt"
+import PROMPT_ANTHROPIC from "./system-prompt/anthropic.txt"
+import PROMPT_GPT from "./system-prompt/gpt-extension.txt"
 import PROMPT_KIMI from "./system-prompt/kimi.txt"
 import PROMPT_META from "./system-prompt/meta.txt"
 import PROMPT_TRINITY from "./system-prompt/trinity.txt"
 
-export const OpenAIPlugin = make(
-  "openai",
-  (model) => {
-    if (!model.id.toLowerCase().includes("gpt")) return
+export const OpenAIPlugin = make("openai", (id) => (id.includes("gpt") ? PROMPT_GPT : undefined), {
+  operation: "append",
+})
 
-    if (model.id.toLowerCase().includes("gpt-6")) return PROMPT_ASTRA
-
-    return PROMPT_GPT
-  },
-  { operation: "replace" },
-)
-
-export const KimiPlugin = make("kimi", (model) => (model.id.toLowerCase().includes("kimi") ? PROMPT_KIMI : undefined), {
+export const AnthropicPlugin = make("anthropic", (id) => (id.includes("claude") ? PROMPT_ANTHROPIC : undefined), {
+  operation: "replace",
+})
+export const KimiPlugin = make("kimi", (id) => (id.includes("kimi") ? PROMPT_KIMI : undefined), {
+  operation: "replace",
+})
+export const ArceePlugin = make("arcee", (id) => (id.includes("trinity") ? PROMPT_TRINITY : undefined), {
   operation: "replace",
 })
-export const ArceePlugin = make(
-  "arcee",
-  (model) => (model.id.toLowerCase().includes("trinity") ? PROMPT_TRINITY : undefined),
-  { operation: "replace" },
-)
 export const MetaPlugin = make(
   "meta",
-  (model) => {
-    if (!model.id.toLowerCase().includes("muse")) return
-    return PROMPT_META.replaceAll("{{MODEL_NAME}}", model.name)
+  (id) => {
+    if (!id.includes("muse")) return
+    const name = id.includes("muse-glimmer") ? "Muse Glimmer" : "Muse Spark"
+    return PROMPT_META.replaceAll("{{MODEL_NAME}}", name)
   },
   { operation: "replace" },
 )
 
-export const Plugins = [OpenAIPlugin, KimiPlugin, ArceePlugin, MetaPlugin] as const
+export const Plugins = [OpenAIPlugin, AnthropicPlugin, KimiPlugin, ArceePlugin, MetaPlugin] as const
 
 function make(
   id: string,
-  getPrompt: (model: Model.Info) => string | undefined,
+  getPrompt: (modelID: string) => string | undefined,
   options: { operation: "replace" | "append" },
 ) {
   return define({
@@ -59,9 +51,8 @@ function make(
           const model = (yield* ctx.catalog.model.list()).data.find(
             (model) => model.providerID === event.model.providerID && model.id === event.model.id,
           )
-          const template = getPrompt(model ?? Model.Info.default(event.model.providerID, event.model.id))
-          if (!template) return
-          const prompt = SessionSystemPrompt.render(template, Object.keys(event.tools))
+          const prompt = getPrompt(`${model?.modelID ?? event.model.id} ${model?.family ?? ""}`.toLowerCase())
+          if (!prompt) return
           if (options.operation === "append") {
             event.system.splice(1, 0, SystemPart.make(prompt))
             return

packages/core/src/plugin/system-prompt/anthropic.txt

@@ -0,0 +1,53 @@
+You are OpenCode, the best coding agent on the planet.
+
+You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+If the user asks for help or wants to give feedback inform them of the following:
+- ctrl+p to list available actions
+- To give feedback, users should report the issue at
+  https://github.com/anomalyco/opencode
+
+When the user directly asks about OpenCode (eg. "can OpenCode do...", "does OpenCode have..."), or asks in second person (eg. "are you able...", "can you do..."), or asks how to use a specific OpenCode feature (eg. implement a hook, write a slash command, or install an MCP server), use the webfetch tool to gather information to answer the question from OpenCode docs. The list of available docs is available at https://opencode.ai/v2/docs/
+
+# Tone and style
+- Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+- Your output will be displayed on a command line interface. Your responses should be short and concise. You can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+- Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like the shell tool or code comments as means to communicate with the user during the session.
+- NEVER create files unless they're absolutely necessary for achieving your goal. ALWAYS prefer editing an existing file to creating a new one. This includes markdown files.
+
+# Professional objectivity
+Prioritize technical accuracy and truthfulness over validating the user's beliefs. Focus on facts and problem-solving, providing direct, objective technical info without any unnecessary superlatives, praise, or emotional validation. It is best for the user if OpenCode honestly applies the same rigorous standards to all ideas and disagrees when necessary, even if it may not be what the user wants to hear. Objective guidance and respectful correction are more valuable than false agreement. Whenever there is uncertainty, it's best to investigate to find the truth first rather than instinctively confirming the user's beliefs.
+
+# Doing tasks
+The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are automatically added by the system, and bear no direct relation to the specific tool results or user messages in which they appear.
+
+
+# Tool usage policy
+- When doing file search, prefer to use the subagent tool in order to reduce context usage.
+- You should proactively use the subagent tool with specialized agents when the task at hand matches the agent's description.
+
+- When webfetch returns a message about a redirect to a different host, you should immediately make a new webfetch request with the redirect URL provided in the response.
+- You can call multiple tools in a single response. If you intend to call multiple tools and there are no dependencies between them, make all independent tool calls in parallel. Maximize use of parallel tool calls where possible to increase efficiency. However, if some tool calls depend on previous calls to inform dependent values, do NOT call these tools in parallel and instead call them sequentially. For instance, if one operation must complete before another starts, run these operations sequentially instead. Never use placeholders or guess missing parameters in tool calls.
+- If the user specifies that they want you to run tools "in parallel", you MUST send a single message with multiple tool use content blocks. For example, if you need to launch multiple agents in parallel, send a single message with multiple subagent tool calls.
+- Use specialized tools instead of shell commands when possible, as this provides a better user experience. For file operations, use dedicated tools: read for reading files instead of cat/head/tail, edit for editing instead of sed/awk, and write for creating files instead of cat with heredoc or echo redirection. Reserve the shell tool exclusively for actual system commands and terminal operations that require shell execution. NEVER use shell echo or other command-line tools to communicate thoughts, explanations, or instructions to the user. Output all communication directly in your response text instead.
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the subagent tool instead of running search commands directly.
+<example>
+user: Where are errors from the client handled?
+assistant: [Uses the subagent tool to find the files that handle client errors instead of using glob or grep directly]
+</example>
+<example>
+user: What is the codebase structure?
+assistant: [Uses the subagent tool]
+</example>
+
+# Code References
+
+When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
+
+<example>
+user: Where are errors from the client handled?
+assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
+</example>

packages/core/src/plugin/system-prompt/gpt-astra.txt

@@ -1,45 +0,0 @@
-You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.
-
-# Harness
-- Responses are rendered as GitHub-flavored Markdown.
-- `<system-reminder>` blocks are harness instructions, not user-authored content. Read and follow them.
-- Prefer parallelizing independent tool calls.
-- Do not use a skill based solely on keywords, superficial relevance, or its availability. Avoid re-reading skills already available in the conversation unless needed.
-${OPENCODE_TOOL_GUIDANCE}
-
-# Communication
-
-State the main point clearly and early. Keep responses clear and concise, and avoid unnecessary technical jargon. Use only as much structure as needed, and include technical detail only when it helps the conversation. Use clear file paths when referring to files.
-
-When describing your work, avoid adding what you won't do, what will remain unchanged, or how you'll separate or categorize results. Do not introduce unprompted alternatives through framing such as "X, not Y" or "This isn't about X. It's about Y."
-
-## Autonomy
-
-Infer the user's intent and your task scope from their instructions and the prior conversation context. You should bias towards action and carry out the user's intended task until it is completed. If the intent is unclear, progress towards the goal using the available information and ask for clarification while continuing independent work when possible.
-
-When the user's prompt indicates a request for action, such as "can you...", "I want to...", "help me..." and similar expressions, treat these as instructions to take action. Do not stop at acknowledging capability (e.g. "Yes…"), proposing a plan, or offering to continue. Do not settle for a partial or "helpful enough" solution to save time, effort, or tokens. Continue until the user's intended goal is fulfilled, even when it requires sustained work.
-
-## Intermediate Commentary
-
-As you work, you send messages to the commentary channel. These are how you collaborate with the user while you work: stating assumptions and providing updates. Keep them concise and quickly scannable, and send them only when they add real information, such as a discovery, a tradeoff, or a blocker. Do not narrate routine reads, searches, or edits.
-
-By default, treat new messages received during ongoing work as steering the active task rather than replacing it. Incorporate corrections and constraints, and answer questions briefly in commentary before continuing. Replace the task only when the user clearly cancels it or requests an incompatible objective.
-
-Do not put a final response, such as a blocking or clarifying question, in the commentary channel. The final answer must always be fully self-contained.
-
-## Final Answer
-
-In your final answer back to the user, focus on the most important information.
-
-# Working in codebases
-
-- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.
-- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.
-- Do not introduce unsolicited warnings, disclaimers, approval flows, or safety/compliance checklists due to hypothetical risk.
-- Do not write tests for reversible, low-impact changes or that mirror the implementation. If you do choose to verify your work with tests, make sure that the tests are meaningful and necessary to verify implementation.
-- Run tests appropriate to the change and complete required checks. Once those pass, broaden or repeat testing only when new changes, failures, or unresolved concerns justify it; otherwise, continue toward completing the task.
-
-
-# Delegation
-
-Do not spawn subagents unless the user or applicable AGENTS.md/skill instructions explicitly ask for subagents, delegation, or parallel agent work.

packages/core/src/plugin/system-prompt/gpt-extension.txt

@@ -1,30 +1,10 @@
-You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.
-
-# Harness
-- Responses are rendered as GitHub-flavored Markdown.
-- `<system-reminder>` blocks are harness instructions, not user-authored content. Read and follow them.
-- Prefer parallelizing independent tool calls.
-${OPENCODE_TOOL_GUIDANCE}
-
-# Communication
-
-Use clear file paths when referring to files. Keep responses clear and concise, and avoid unnecessary technical jargon.
-
-## Intermediate Commentary
+# Response channels
 
 As you work, you send messages to the commentary channel. These are how you collaborate with the user while you work: stating assumptions and providing updates. Keep them concise and quickly scannable, and send them only when they add real information, such as a discovery, a tradeoff, or a blocker. Do not narrate routine reads, searches, or edits.
 
-By default, treat new messages received during ongoing work as steering the active task rather than replacing it. Incorporate corrections and constraints, and answer questions briefly in commentary before continuing. Replace the task only when the user clearly cancels it or requests an incompatible objective.
-
 Do not put a final response, such as a blocking or clarifying question, in the commentary channel. The final answer must always be fully self-contained.
 
-## Final Answer
-
-In the final answer, lead with the outcome, not the steps you took to reach it. Cover the most important information, use only as much structure as the answer needs, and avoid long-winded explanations unless necessary. Include technical detail only where it helps.
-
-# Working in codebases
-- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.
-- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.
+In the final answer, lead with the outcome, not the steps you took to reach it. Cover the most important information, use only as much structure as the answer needs, and skip explanation the user did not ask for. Include technical detail only where it helps.
 
 # Delegation
 

packages/core/src/session/system-prompt.ts

@@ -3,15 +3,10 @@ export * as SessionSystemPrompt from "./system-prompt.js"
 import PROMPT from "./runner/prompt/system.txt"
 
 export function make(tools: string[]) {
-  return render(PROMPT, tools)
-}
-
-export function render(prompt: string, tools: string[]) {
   const instructions: string[] = []
   if (tools.includes("shell")) {
     instructions.push(
       "- Prefer dedicated tools over shell commands; fall back to the shell when a tool cannot do what you need.",
-      "- Do not chain shell commands with separators like `echo \"====\";` or `printf '---'`; the output becomes noisy in a way that makes the user's side of the conversation worse.",
     )
   }
   if (tools.includes("write")) {
@@ -24,5 +19,5 @@ export function render(prompt: string, tools: string[]) {
       "- Use the edit tool for targeted changes to existing text files. It replaces the exact text in `oldString` with `newString`, and the values must differ. By default, `oldString` must occur exactly once. If it occurs multiple times, include more surrounding context to make it unique or set `replaceAll` to true to replace every occurrence.",
     )
   }
-  return prompt.replace("${OPENCODE_TOOL_GUIDANCE}", instructions.join("\n"))
+  return PROMPT.replace("${OPENCODE_TOOL_GUIDANCE}", instructions.join("\n"))
 }

packages/core/src/worktree.ts

@@ -1,13 +1,12 @@
 export * as Worktree from "./worktree.js"
 
 import { Context, Effect, Layer, Schema } from "effect"
-import { and, asc, desc, eq, isNull, sql } from "drizzle-orm"
+import { and, asc, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm"
 import path from "path"
 import { AbsolutePath } from "./schema.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Git } from "./git.js"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Global } from "@opencode-ai/util/global"
+import { makeGlobalNode, makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { ProjectSchema } from "./project/schema.js"
 import { Slug } from "./util/slug.js"
 import { Bus } from "./bus.js"
@@ -21,10 +20,8 @@ import type { EffectDrizzleSqlite } from "./database/drizzle.js"
 import { ProjectTable } from "./project/sql.js"
 import { AppProcess } from "@opencode-ai/util/process"
 import { ChildProcess } from "effect/unstable/process"
-import { State } from "./state.js"
 
 export { DirectoryUnavailableError } from "./worktree/directory.js"
-export { OperationError } from "@opencode-ai/schema/worktree"
 
 export const StrategyID = Worktree.StrategyID
 export type StrategyID = typeof StrategyID.Type
@@ -35,6 +32,11 @@ export type CreateInput = typeof CreateInput.Type
 export const RemoveInput = Worktree.RemoveInput
 export type RemoveInput = typeof RemoveInput.Type
 
+export const RefreshInput = Schema.Struct({
+  projectID: ProjectSchema.ID,
+}).annotate({ identifier: "Worktree.RefreshInput" })
+export type RefreshInput = typeof RefreshInput.Type
+
 export const RefreshResult = Schema.Struct({
   updated: Schema.Array(AbsolutePath),
   removed: Schema.Array(AbsolutePath),
@@ -44,10 +46,16 @@ export type RefreshResult = typeof RefreshResult.Type
 export const Info = Worktree.Info
 export type Info = typeof Info.Type
 
+export const ListInput = Worktree.ListInput
+export type ListInput = typeof ListInput.Type
+
 export const List = Worktree.List
 export type List = typeof List.Type
 
-export const ListEntry = Worktree.ListEntry
+export const ListEntry = Schema.Struct({
+  directory: AbsolutePath,
+  type: Schema.Literals(["root", "worktree"]),
+}).annotate({ identifier: "Worktree.ListEntry" })
 export type ListEntry = typeof ListEntry.Type
 
 export class SourceDirectoryNotFoundError extends Schema.TaggedError<SourceDirectoryNotFoundError>()(
@@ -70,9 +78,9 @@ export class StrategyUnavailableError extends Schema.TaggedError<StrategyUnavail
   { strategy: StrategyID },
 ) {}
 
-export class UnsupportedLocationError extends Schema.TaggedError<UnsupportedLocationError>()(
-  "Worktree.UnsupportedLocationError",
-  { directory: AbsolutePath },
+export class DuplicateStrategyError extends Schema.TaggedError<DuplicateStrategyError>()(
+  "Worktree.DuplicateStrategyError",
+  { strategy: StrategyID },
 ) {}
 
 export type Error =
@@ -81,8 +89,6 @@ export type Error =
   | DirectoryUnavailableError
   | InvalidDirectoryError
   | StrategyUnavailableError
-  | UnsupportedLocationError
-  | Worktree.OperationError
   | AppProcess.AppProcessError
   | Git.WorktreeError
 
@@ -92,78 +98,67 @@ export interface Strategy {
     sourceDirectory: AbsolutePath
     directory: AbsolutePath
     branch?: string
-  }) => Effect.Effect<Info, unknown>
-  readonly remove: (input: { directory: AbsolutePath; force: boolean }) => Effect.Effect<void, unknown>
-  readonly list: (directory: AbsolutePath) => Effect.Effect<readonly ListEntry[], unknown>
+  }) => Effect.Effect<Info, Git.WorktreeError | DirectoryUnavailableError>
+  readonly remove: (input: {
+    directory: AbsolutePath
+    force: boolean
+  }) => Effect.Effect<void, Git.WorktreeError | DirectoryUnavailableError>
+  readonly list: (directory: AbsolutePath) => Effect.Effect<ListEntry[], Git.WorktreeError | DirectoryUnavailableError>
 }
 
 export const Event = Worktree.Event
 
 interface StoredInput {
+  readonly projectID: ProjectSchema.ID
   readonly directory: AbsolutePath
   readonly strategy?: string
-  readonly replace?: boolean
 }
 
 type DatabaseClient = EffectDrizzleSqlite.EffectSQLiteDatabase
 type Transaction = Parameters<Parameters<DatabaseClient["transaction"]>[0]>[0]
 
-export interface Editor {
-  readonly add: (strategy: Strategy) => void
-  readonly configure: (settings: { readonly directory: AbsolutePath }) => void
-}
-
-export interface Interface extends State.Transformable<Editor> {
-  readonly list: () => Effect.Effect<List, Error>
-  readonly create: (input?: CreateInput) => Effect.Effect<Info, Error>
+export interface Interface {
+  readonly register: (strategy: Strategy) => Effect.Effect<void, DuplicateStrategyError>
+  readonly list: (projectID: ProjectSchema.ID) => Effect.Effect<List>
+  readonly create: (input: CreateInput) => Effect.Effect<Info, Error>
   readonly remove: (input: RemoveInput) => Effect.Effect<void, Error>
-  readonly refresh: () => Effect.Effect<RefreshResult, Error>
+  readonly refresh: (input: RefreshInput) => Effect.Effect<RefreshResult, Error>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Worktree") {}
 
+export const refreshAfterBoot = Effect.gen(function* () {
+  const location = yield* Location.Service
+  const worktrees = yield* Service
+  yield* Effect.gen(function* () {
+    yield* Effect.logInfo("worktree refresh started", { projectID: location.project.id })
+    const result = yield* worktrees.refresh({ projectID: location.project.id })
+    yield* Effect.logInfo("worktree refresh done", {
+      projectID: location.project.id,
+      updated: result.updated,
+      removed: result.removed,
+    })
+  }).pipe(
+    Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })),
+    Effect.forkScoped,
+    Effect.asVoid,
+  )
+})
+
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const fs = yield* FSUtil.Service
-    const database = yield* Database.Service
-    const db = database.db
+    const db = (yield* Database.Service).db
     const bus = yield* Bus.Service
     const processService = yield* AppProcess.Service
-    const location = yield* Location.Service
-    const global = yield* Global.Service
-    const projectID = location.project.id
 
-    const local = location.workspaceID
-      ? Effect.fail(new UnsupportedLocationError({ directory: location.directory }))
-      : Effect.void
-
-    const gitStrategy = yield* WorktreeGit.make
-    const state = State.create({
-      name: "worktree",
-      initial: () => ({
-        directory: AbsolutePath.make(path.join(global.data, "worktree", projectID.slice(0, 6))),
-        strategies: new Map<StrategyID, Strategy>([[gitStrategy.id, gitStrategy]]),
-        selected: gitStrategy.id,
-      }),
-      editor: (value): Editor => ({
-        configure: (settings) => {
-          value.directory = settings.directory
-        },
-        add: (strategy) => {
-          value.strategies.delete(strategy.id)
-          value.strategies.set(strategy.id, strategy)
-          value.selected = strategy.id
-        },
-      }),
-    })
-
-    const changed = Effect.fnUntraced(function* (update: boolean) {
+    const changed = Effect.fnUntraced(function* (projectID: ProjectSchema.ID, update: boolean) {
       if (update) yield* bus.publish(Event.Updated, { projectID })
     })
 
     const ops = {
-      list: Effect.fnUntraced(function* () {
+      list: Effect.fn("Worktree.list")(function* (projectID: ProjectSchema.ID) {
         const rows = yield* db
           .select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy })
           .from(WorktreeTable)
@@ -173,7 +168,7 @@ const layer = Layer.effect(
           .pipe(Effect.orDie)
         return rows.map((row) => ({ directory: row.directory, strategy: row.strategy ?? undefined }))
       }),
-      find: Effect.fnUntraced(function* (directory: AbsolutePath) {
+      find: Effect.fnUntraced(function* (projectID: ProjectSchema.ID, directory: AbsolutePath) {
         const row = yield* db
           .select({ directory: WorktreeTable.directory, strategy: WorktreeTable.strategy })
           .from(WorktreeTable)
@@ -182,21 +177,24 @@ const layer = Layer.effect(
           .pipe(Effect.orDie)
         return row ? { directory: row.directory, strategy: row.strategy ?? undefined } : undefined
       }),
+      primary: Effect.fnUntraced(function* (projectID: ProjectSchema.ID) {
+        return yield* db
+          .select({ directory: ProjectTable.worktree })
+          .from(ProjectTable)
+          .where(eq(ProjectTable.id, projectID))
+          .get()
+          .pipe(Effect.orDie)
+      }),
       create: (input: StoredInput, tx?: Transaction) =>
         (tx ?? db)
           .insert(WorktreeTable)
-          .values({
-            project_id: projectID,
-            directory: input.directory,
-            strategy: input.strategy,
-          })
+          .values({ project_id: input.projectID, directory: input.directory, strategy: input.strategy })
           .onConflictDoUpdate({
             target: [WorktreeTable.project_id, WorktreeTable.directory],
-            set: {
-              strategy: input.strategy ?? null,
-            },
-            // Discovery may claim an unowned row, but never replace another strategy's ownership.
-            setWhere: input.replace ? undefined : input.strategy ? isNull(WorktreeTable.strategy) : sql`false`,
+            set: { strategy: input.strategy ?? null },
+            setWhere: input.strategy
+              ? or(isNull(WorktreeTable.strategy), ne(WorktreeTable.strategy, input.strategy))
+              : isNotNull(WorktreeTable.strategy),
           })
           .returning({ directory: WorktreeTable.directory })
           .get()
@@ -204,7 +202,7 @@ const layer = Layer.effect(
             Effect.orDie,
             Effect.map((row) => row !== undefined),
           ),
-      remove: (directory: AbsolutePath, tx?: Transaction) =>
+      remove: (projectID: ProjectSchema.ID, directory: AbsolutePath, tx?: Transaction) =>
         (tx ?? db)
           .delete(WorktreeTable)
           .where(and(eq(WorktreeTable.project_id, projectID), eq(WorktreeTable.directory, directory)))
@@ -216,57 +214,62 @@ const layer = Layer.effect(
           ),
     }
 
-    const source = Effect.fnUntraced(function* (input: AbsolutePath | undefined) {
-      const sourceDirectory = input ?? location.project.directory
+    const registry = new Map<StrategyID, Strategy>()
+
+    const register = Effect.fn("Worktree.register")(function* (strategy: Strategy) {
+      if (registry.has(strategy.id)) return yield* new DuplicateStrategyError({ strategy: strategy.id })
+      registry.set(strategy.id, strategy)
+    })
+
+    // Register default strategies
+    const gitStrategy = yield* WorktreeGit.make
+    yield* register(gitStrategy).pipe(Effect.orDie)
+
+    const source = Effect.fnUntraced(function* (input: AbsolutePath | undefined, projectID: ProjectSchema.ID) {
+      const sourceDirectory = input ?? (yield* ops.primary(projectID))?.directory
+      if (!sourceDirectory) return yield* new SourceDirectoryNotFoundError({ projectID })
       const resolved = yield* canonical(fs, sourceDirectory)
-      if ((yield* ops.find(resolved)) === undefined)
+      if ((yield* ops.find(projectID, resolved)) === undefined)
         return yield* new SourceDirectoryNotFoundError({ projectID, directory: resolved })
       return resolved
     })
 
-    const getStrategy = Effect.fnUntraced(function* (id: StrategyID, strategies: ReadonlyMap<StrategyID, Strategy>) {
-      const found = strategies.get(id)
+    const getStrategy = Effect.fnUntraced(function* (id: StrategyID) {
+      const found = registry.get(id)
       if (!found) return yield* new StrategyUnavailableError({ strategy: id })
       return found
     })
 
-    const create = Effect.fn("Worktree.create")(function* (input: CreateInput = {}) {
-      yield* local
-      const current = state.get()
-      const selected = yield* getStrategy(input.strategy ?? current.selected, current.strategies)
-      const directory = input.directory ?? current.directory
-      const sourceDirectory = yield* source(input.from)
-      yield* fs.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie)
+    const create = Effect.fn("Worktree.create")(function* (input: CreateInput) {
+      const selected = yield* getStrategy(input.strategy)
+      const sourceDirectory = yield* source(input.from, input.projectID)
+      yield* fs.makeDirectory(input.directory, { recursive: true }).pipe(Effect.orDie)
       const name = input.name ?? Slug.create()
       let suffix = 1
-      let worktreeDirectory = AbsolutePath.make(path.join(directory, name))
+      let worktreeDirectory = AbsolutePath.make(path.join(input.directory, name))
       while (yield* fs.existsSafe(worktreeDirectory)) {
         suffix++
         if (suffix > 10) return yield* new DestinationExistsError({ directory: worktreeDirectory })
-        worktreeDirectory = AbsolutePath.make(path.join(directory, `${name}-${suffix}`))
+        worktreeDirectory = AbsolutePath.make(path.join(input.directory, `${name}-${suffix}`))
       }
 
-      const created = yield* selected
-        .create({
-          directory: worktreeDirectory,
-          sourceDirectory,
-          branch: input.branch,
-        })
-        .pipe(Effect.mapError((error) => operationError(selected.id, "create", error)))
-      const result = { directory: yield* canonical(fs, created.directory) }
-      if (result.directory !== (yield* canonical(fs, worktreeDirectory)))
-        return yield* new InvalidDirectoryError({ directory: result.directory })
+      const result = yield* selected.create({
+        directory: worktreeDirectory,
+        sourceDirectory,
+        branch: input.branch,
+      })
       yield* changed(
+        input.projectID,
         yield* ops.create({
+          projectID: input.projectID,
           directory: result.directory,
-          strategy: selected.id,
-          replace: true,
+          strategy: input.strategy,
         }),
       )
       const project = yield* db
         .select({ commands: ProjectTable.commands })
         .from(ProjectTable)
-        .where(eq(ProjectTable.id, projectID))
+        .where(eq(ProjectTable.id, input.projectID))
         .get()
         .pipe(Effect.orDie)
       const command = project?.commands?.start?.trim()
@@ -291,71 +294,70 @@ const layer = Layer.effect(
     })
 
     const remove = Effect.fn("Worktree.remove")(function* (input: RemoveInput) {
-      yield* local
       const worktreeDirectory = yield* canonical(fs, input.directory)
-      const stored = yield* ops.find(worktreeDirectory)
+      const stored = yield* ops.find(input.projectID, worktreeDirectory)
       if (!stored?.strategy) return yield* new InvalidDirectoryError({ directory: worktreeDirectory })
-      const strategy = yield* getStrategy(StrategyID.make(stored.strategy), state.get().strategies)
-      yield* strategy
-        .remove({
-          directory: worktreeDirectory,
-          force: input.force,
-        })
-        .pipe(Effect.mapError((error) => operationError(strategy.id, "remove", error)))
-      yield* changed(yield* ops.remove(worktreeDirectory))
+      const strategy = yield* getStrategy(StrategyID.make(stored.strategy))
+      yield* strategy.remove({
+        directory: worktreeDirectory,
+        force: input.force,
+      })
+      yield* changed(input.projectID, yield* ops.remove(input.projectID, worktreeDirectory))
     })
 
-    const refresh = Effect.fn("Worktree.refresh")(function* () {
-      yield* local
-      const stored = yield* ops.list()
+    const refresh = Effect.fn("Worktree.refresh")(function* (input: RefreshInput) {
+      const stored = yield* ops.list(input.projectID)
       const checked = yield* Effect.forEach(
         stored,
         (item) => fs.isDir(item.directory).pipe(Effect.map((exists) => ({ ...item, exists }))),
         { concurrency: "unbounded" },
       )
-      const strategies = Array.from(state.get().strategies.values()).toReversed()
-      const discovered = new Map<AbsolutePath, StoredInput>()
-      // A location's plugin instances only discover its own checkout, not sibling clones.
-      if (checked.some((item) => item.directory === location.project.directory && item.exists)) {
-        for (const strategy of strategies) {
-          const entries = yield* strategy.list(location.project.directory).pipe(
-            Effect.mapError((error) => operationError(strategy.id, "list", error)),
-            Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])),
-          )
-          for (const entry of entries) {
-            const directory = yield* canonical(fs, entry.directory).pipe(
-              Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.undefined),
-            )
-            if (!directory || discovered.has(directory)) continue
-            discovered.set(directory, {
-              directory,
-              strategy: entry.type === "worktree" ? strategy.id : undefined,
-            })
-          }
-        }
-      }
+      const sourceDirectories = checked
+        .filter((item) => item.strategy === undefined && item.exists)
+        .map((item) => item.directory)
+      const discovered = yield* Effect.forEach(
+        sourceDirectories,
+        (sourceDirectory) =>
+          Effect.forEach(Array.from(registry.values()), (strategy) =>
+            strategy.list(sourceDirectory).pipe(
+              Effect.catchTag("Worktree.DirectoryUnavailableError", () => Effect.succeed([])),
+              Effect.map((items) =>
+                items.map((item) => ({
+                  directory: item.directory,
+                  strategy: item.type === "worktree" ? strategy.id : undefined,
+                })),
+              ),
+            ),
+          ),
+        { concurrency: "unbounded" },
+      ).pipe(
+        Effect.map((sets) => new Map(sets.flat(2).map((item) => [item.directory, item] as const)).values().toArray()),
+      )
       const removed = checked.filter((item) => !item.exists).map((item) => item.directory)
       const changes = yield* db
         .transaction((tx) =>
           Effect.all({
-            updated: Effect.filter(Array.from(discovered.values()), (item) => ops.create(item, tx)).pipe(
-              Effect.map((items) => items.map((item) => item.directory)),
-            ),
-            removed: Effect.filter(removed, (directory) => ops.remove(directory, tx)),
+            updated: Effect.filter(discovered, (item) =>
+              ops.create(
+                {
+                  projectID: input.projectID,
+                  directory: item.directory,
+                  strategy: item.strategy,
+                },
+                tx,
+              ),
+            ).pipe(Effect.map((items) => items.map((item) => item.directory))),
+            removed: Effect.filter(removed, (directory) => ops.remove(input.projectID, directory, tx)),
           }),
         )
         .pipe(Effect.orDie)
-      yield* changed(changes.updated.length > 0 || changes.removed.length > 0)
+      yield* changed(input.projectID, changes.updated.length > 0 || changes.removed.length > 0)
       return changes
     })
 
     return Service.of({
-      transform: state.transform,
-      reload: state.reload,
-      list: Effect.fn("Worktree.list")(function* () {
-        yield* refresh()
-        return yield* ops.list()
-      }),
+      register,
+      list: ops.list,
       create,
       remove,
       refresh,
@@ -363,20 +365,14 @@ const layer = Layer.effect(
   }),
 )
 
-export const node = makeLocationNode({
+export const node = makeGlobalNode({
   service: Service,
   layer: layer,
-  deps: [FSUtil.node, Git.node, Bus.node, Database.node, AppProcess.node, Location.node, Global.node],
+  deps: [FSUtil.node, Git.node, Bus.node, Database.node, AppProcess.node],
 })
 
-function operationError(strategy: StrategyID, operation: string, error: unknown) {
-  if (
-    error instanceof Git.WorktreeError ||
-    error instanceof DirectoryUnavailableError ||
-    error instanceof Worktree.OperationError
-  )
-    return error
-  return new Worktree.OperationError({
-    message: `Worktree strategy ${strategy} failed to ${operation}: ${error instanceof globalThis.Error ? error.message : String(error)}`,
-  })
-}
+export const refreshNode = makeLocationNode({
+  name: "worktree-refresh",
+  layer: Layer.effectDiscard(refreshAfterBoot),
+  deps: [node, Location.node],
+})

packages/core/src/worktree/refresh.ts

@@ -1,28 +0,0 @@
-export * as WorktreeRefresh from "./refresh.js"
-
-import { Effect, Layer } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import { Location } from "../location.js"
-import { Plugin } from "../plugin.js"
-import { PluginSupervisor } from "../plugin/supervisor.js"
-import { Worktree } from "../worktree.js"
-
-const layer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    const location = yield* Location.Service
-    const plugins = yield* Plugin.Service
-    const worktrees = yield* Worktree.Service
-    if (location.workspaceID) return
-    yield* plugins.awaitActivation.pipe(
-      Effect.andThen(worktrees.refresh()),
-      Effect.catchCause((cause) => Effect.logWarning("worktree refresh failed", { cause })),
-      Effect.forkScoped,
-    )
-  }),
-)
-
-export const node = makeLocationNode({
-  name: "worktree-refresh",
-  layer,
-  deps: [Worktree.node, Location.node, Plugin.node, PluginSupervisor.node],
-})

packages/core/test/codemode/catalog.test.ts

@@ -131,7 +131,6 @@ describe("CodeModeInstructions.render", () => {
     expect(partial).toContain("## Available tools")
     expect(partial).toContain("- orders (1 tool, none shown)")
     expect(partial).toContain("## Search")
-    expect(partial).toContain("Call `search(...)` to discover exact paths and signatures for additional tools:")
     expect(partial).toContain("The Code Mode tool catalog below is partial.")
     expect(partial).toContain(
       "The Code Mode catalog and `search` results are the complete set of tools callable inside `execute`.",

packages/core/test/fixtures/recordings/session-runner/openai-chat-streams-text.json

@@ -13,7 +13,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"gpt-4o-mini\",\"messages\":[{\"role\":\"system\",\"content\":\"You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.\\n\\n# Harness\\n- Responses are rendered as GitHub-flavored Markdown.\\n- `<system-reminder>` blocks are harness instructions, not user-authored content. Read and follow them.\\n- Prefer parallelizing independent tool calls.\\n\\n\\n# Communication\\n\\nUse clear file paths when referring to files. Keep responses clear and concise, and avoid unnecessary technical jargon.\\n\\n## Intermediate Commentary\\n\\nAs you work, you send messages to the commentary channel. These are how you collaborate with the user while you work: stating assumptions and providing updates. Keep them concise and quickly scannable, and send them only when they add real information, such as a discovery, a tradeoff, or a blocker. Do not narrate routine reads, searches, or edits.\\n\\nBy default, treat new messages received during ongoing work as steering the active task rather than replacing it. Incorporate corrections and constraints, and answer questions briefly in commentary before continuing. Replace the task only when the user clearly cancels it or requests an incompatible objective.\\n\\nDo not put a final response, such as a blocking or clarifying question, in the commentary channel. The final answer must always be fully self-contained.\\n\\n## Final Answer\\n\\nIn the final answer, lead with the outcome, not the steps you took to reach it. Cover the most important information, use only as much structure as the answer needs, and avoid long-winded explanations unless necessary. Include technical detail only where it helps.\\n\\n# Working in codebases\\n- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.\\n- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.\\n\\n# Delegation\\n\\nDo not spawn subagents unless the user or applicable AGENTS.md/skill instructions explicitly ask for subagents, delegation, or parallel agent work.\\n\\n# Destructive actions\\n\\nDo not revert, reset, or discard changes you did not make. Never run destructive commands such as `git reset --hard`, `git checkout --`, or recursive deletes on broad paths unless the user clearly asked for that operation; if the target or scope is unclear, ask first. Prefer non-interactive git commands.\\n\\n# Autonomy\\n\\nDo not infer authorization for work beyond the user's request. Assumptions that help you make progress are fine as long as they stay within the user's intent and the scope of the task.\\n\"},{\"role\":\"user\",\"content\":\"Say hello in one short sentence.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"store\":false,\"prompt_cache_key\":\"ses_runner_recorded\",\"max_completion_tokens\":20,\"temperature\":0}"
+        "body": "{\"model\":\"gpt-4o-mini\",\"messages\":[{\"role\":\"system\",\"content\":\"You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.\\n\\n# Harness\\n- Responses are rendered as GitHub-flavored Markdown.\\n- `<system-reminder>` blocks are harness instructions, not user-authored content. Read and follow them.\\n- Prefer parallelizing independent tool calls.\\n\\n\\n# Communication\\n- Use clear file paths when referring to files.\\n- Keep responses clear and concise, and avoid unnecessary technical jargon.\\n\\n# Working in codebases\\n- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.\\n- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.\\n\\n# Response channels\\n\\nAs you work, you send messages to the commentary channel. These are how you collaborate with the user while you work: stating assumptions and providing updates. Keep them concise and quickly scannable, and send them only when they add real information, such as a discovery, a tradeoff, or a blocker. Do not narrate routine reads, searches, or edits.\\n\\nDo not put a final response, such as a blocking or clarifying question, in the commentary channel. The final answer must always be fully self-contained.\\n\\nIn the final answer, lead with the outcome, not the steps you took to reach it. Cover the most important information, use only as much structure as the answer needs, and skip explanation the user did not ask for. Include technical detail only where it helps.\\n\\n# Delegation\\n\\nDo not spawn subagents unless the user or applicable AGENTS.md/skill instructions explicitly ask for subagents, delegation, or parallel agent work.\\n\\n# Destructive actions\\n\\nDo not revert, reset, or discard changes you did not make. Never run destructive commands such as `git reset --hard`, `git checkout --`, or recursive deletes on broad paths unless the user clearly asked for that operation; if the target or scope is unclear, ask first. Prefer non-interactive git commands.\\n\\n# Autonomy\\n\\nDo not infer authorization for work beyond the user's request. Assumptions that help you make progress are fine as long as they stay within the user's intent and the scope of the task.\\n\"},{\"role\":\"user\",\"content\":\"Say hello in one short sentence.\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"store\":false,\"prompt_cache_key\":\"ses_runner_recorded\",\"max_completion_tokens\":20,\"temperature\":0}"
       },
       "response": {
         "status": 200,

packages/core/test/plugin/fixture.ts

@@ -32,7 +32,6 @@ import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { Tool } from "@opencode-ai/core/tool"
 import { Vcs } from "@opencode-ai/core/vcs"
 import { WebSearch } from "@opencode-ai/core/websearch"
-import { Worktree } from "@opencode-ai/core/worktree"
 import { Effect, Layer } from "effect"
 import { tempLocationLayer } from "../fixture/location"
 import { emptyMcpLayer } from "../fixture/mcp"
@@ -95,7 +94,6 @@ export const PluginTestLayer = AppNodeBuilder.build(
     Vcs.node,
     Watcher.node,
     WebSearch.node,
-    Worktree.node,
   ]),
   [
     Location.node.replace(tempLocationLayer),

packages/core/test/plugin/host.ts

@@ -145,14 +145,6 @@ export function host(overrides: Overrides = {}): Plugin.Context {
       transform: () => Effect.die("unused vcs.transform"),
       reload: () => Effect.die("unused vcs.reload"),
     },
-    worktree: overrides.worktree ?? {
-      list: () => Effect.die("unused worktree.list"),
-      create: () => Effect.die("unused worktree.create"),
-      remove: () => Effect.die("unused worktree.remove"),
-      refresh: () => Effect.die("unused worktree.refresh"),
-      transform: () => Effect.die("unused worktree.transform"),
-      reload: () => Effect.die("unused worktree.reload"),
-    },
     websearch: overrides.websearch ?? {
       providers: () => Effect.die("unused websearch.providers"),
       query: () => Effect.die("unused websearch.query"),

packages/core/test/plugin/provider-openai.test.ts

@@ -115,15 +115,6 @@ describe("OpenAIPlugin", () => {
           model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
         })
         catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-4.1"), () => {})
-        catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-6-astra"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
-        })
-        catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-5.10"), (model) => {
-          model.limit = { context: 1_050_000, input: 922_000, output: 128_000 }
-        })
-        catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-5"), () => {})
-        catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-5.04-astra"), () => {})
-        catalog.model.update(Provider.ID.openai, Model.ID.make("gpt-4.99"), () => {})
       })
       yield* credentials.create({
         integrationID: Integration.ID.make("openai"),
@@ -170,11 +161,6 @@ describe("OpenAIPlugin", () => {
       expect(gpt56.enabled).toBe(true)
       expect(gpt56.limit).toEqual({ context: 400_000, input: 272_000, output: 128_000 })
       expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.1"))).enabled).toBe(false)
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-6-astra"))).enabled).toBe(true)
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.10"))).enabled).toBe(true)
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5"))).enabled).toBe(false)
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-5.04-astra"))).enabled).toBe(false)
-      expect(required(yield* catalog.model.get(Provider.ID.openai, Model.ID.make("gpt-4.99"))).enabled).toBe(false)
     }),
   )
 

packages/core/test/plugin/system-prompt.test.ts

@@ -54,6 +54,7 @@ describe("SystemPromptPlugin", () => {
   test("uses granular IDs with a common prefix", () => {
     expect(SystemPromptPlugin.Plugins.map((plugin) => plugin.id)).toEqual([
       "opencode.prompt.openai",
+      "opencode.prompt.anthropic",
       "opencode.prompt.kimi",
       "opencode.prompt.arcee",
       "opencode.prompt.meta",
@@ -66,23 +67,19 @@ describe("SystemPromptPlugin", () => {
       const hooks = yield* PluginHooks.Service
       const pluginHost = yield* makeHost
       yield* catalog.transform((editor) => {
-        for (const id of ["gpt-5", "gpt-4.1", "gpt-5-codex", "gpt-6-astra"])
+        for (const id of ["gpt-5", "gpt-4.1", "gpt-5-codex"])
           editor.model.update(Provider.ID.make("test"), Model.ID.make(id), () => {})
-        editor.model.update(Provider.ID.make("test"), Model.ID.make("meta/muse-spark-1.1"), (model) => {
-          model.name = "Muse Spark"
-        })
       })
       yield* Effect.forEach(SystemPromptPlugin.Plugins, (plugin) => plugin.effect(pluginHost), {
         discard: true,
       })
       const cases = [
-        ["gpt-5", "# Delegation"],
-        ["gpt-4.1", "# Delegation"],
+        ["gpt-5", "# Response channels"],
+        ["gpt-4.1", "# Response channels"],
         ["o3", fallback],
-        ["gpt-5-codex", "# Delegation"],
-        ["gpt-6-astra", "Do not settle for a partial"],
+        ["gpt-5-codex", "# Response channels"],
         ["gemini-2.5-pro", fallback],
-        ["claude-sonnet-4", fallback],
+        ["claude-sonnet-4", "# Professional objectivity"],
         ["kimi-k2", "# Prompt and Tool Use"],
         ["trinity", "what command should I run to list files"],
         ["meta/muse-spark-1.1", "powered by Muse Spark"],
@@ -106,7 +103,7 @@ describe("SystemPromptPlugin", () => {
     }),
   )
 
-  it.effect("renders the OpenAI prompt and preserves project instructions", () =>
+  it.effect("appends the OpenAI extension after the baseline", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const hooks = yield* PluginHooks.Service
@@ -116,42 +113,26 @@ describe("SystemPromptPlugin", () => {
       )
       yield* SystemPromptPlugin.OpenAIPlugin.effect(pluginHost)
       const event = context("gpt-5")
-      event.system.push(SystemPart.make("Project instructions"))
-      event.tools.shell = { description: "Run a command", input: { type: "object" } }
 
       yield* hooks.trigger("session", "context", event)
 
-      expect(event.system.map((part) => part.text)).toEqual([
-        expect.stringContaining("# Delegation"),
-        "Project instructions",
-      ])
-      expect(event.system[0]?.text).toStartWith("You are an AI agent powered by OpenCode")
-      expect(event.system[0]?.text).toContain("Prefer dedicated tools over shell commands")
-      expect(event.system[0]?.text).not.toContain("${OPENCODE_TOOL_GUIDANCE}")
+      expect(event.system.map((part) => part.text)).toEqual([fallback, expect.stringContaining("# Delegation")])
     }),
   )
 
-  it.effect("uses catalog names in Meta prompts for Muse model IDs", () =>
+  it.effect("selects the Meta prompt for Muse family model IDs", () =>
     Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
       const hooks = yield* PluginHooks.Service
       const pluginHost = yield* makeHost
-      const cases = [
-        ["meta/muse-spark-preview", "Muse Spark Preview"],
-        ["muse-spark-1.2", "Muse Spark 1.2"],
-        ["meta/muse-glimmer-30b", "Muse Glimmer 30B"],
-        ["muse-glimmer-30b", "Muse Glimmer"],
-      ] as const
-      yield* catalog.transform((editor) => {
-        for (const [id, name] of cases)
-          editor.model.update(Provider.ID.make("test"), Model.ID.make(id), (model) => {
-            model.name = name
-          })
-      })
       yield* SystemPromptPlugin.MetaPlugin.effect(pluginHost)
 
       yield* Effect.forEach(
-        cases,
+        [
+          ["meta/muse-spark-preview", "Muse Spark"],
+          ["muse-spark-1.2", "Muse Spark"],
+          ["meta/muse-glimmer-30b", "Muse Glimmer"],
+          ["muse-glimmer-30b", "Muse Glimmer"],
+        ] as const,
         ([id, name]) => {
           const event = context(id)
           return hooks.trigger("session", "context", event).pipe(
@@ -209,19 +190,19 @@ describe("SystemPromptPlugin", () => {
     Effect.gen(function* () {
       const hooks = yield* PluginHooks.Service
       const pluginHost = yield* makeHost
-      yield* SystemPromptPlugin.KimiPlugin.effect(pluginHost)
+      yield* SystemPromptPlugin.AnthropicPlugin.effect(pluginHost)
       const gemini = context("gemini-2.5-pro")
-      const kimi = context("kimi-k2")
+      const claude = context("claude-sonnet-4")
 
       yield* hooks.trigger("session", "context", gemini)
-      yield* hooks.trigger("session", "context", kimi)
+      yield* hooks.trigger("session", "context", claude)
 
       expect(gemini.system[0]?.text).toBe(fallback)
-      expect(kimi.system[0]?.text).toContain("# Prompt and Tool Use")
+      expect(claude.system[0]?.text).toContain("# Professional objectivity")
     }),
   )
 
-  it.effect("selects against the catalog ID rather than the physical model ID or family", () =>
+  it.effect("selects against the catalog model ID instead of its alias", () =>
     Effect.gen(function* () {
       const catalog = yield* Catalog.Service
       const hooks = yield* PluginHooks.Service
@@ -247,9 +228,12 @@ describe("SystemPromptPlugin", () => {
       yield* hooks.trigger("session", "context", physicalCustom)
       yield* hooks.trigger("session", "context", familyOpenAI)
 
-      expect(physicalOpenAI.system.map((part) => part.text)).toEqual([fallback])
-      expect(physicalCustom.system.map((part) => part.text)).toEqual([expect.stringContaining("# Delegation")])
-      expect(familyOpenAI.system.map((part) => part.text)).toEqual([fallback])
+      expect(physicalOpenAI.system.map((part) => part.text)).toEqual([
+        fallback,
+        expect.stringContaining("# Delegation"),
+      ])
+      expect(physicalCustom.system.map((part) => part.text)).toEqual([fallback])
+      expect(familyOpenAI.system.map((part) => part.text)).toEqual([fallback, expect.stringContaining("# Delegation")])
     }),
   )
 })

packages/core/test/plugin/worktree.test.ts

@@ -1,52 +0,0 @@
-import { expect } from "bun:test"
-import { Cause, Deferred, Effect, Exit, Fiber } from "effect"
-import { Plugin } from "@opencode-ai/plugin"
-import type { WorktreeDefinition } from "@opencode-ai/plugin/effect/worktree"
-import { PluginPromise } from "@opencode-ai/core/plugin/promise"
-import { State } from "@opencode-ai/core/state"
-import { it } from "../lib/effect"
-import { host } from "./host"
-
-it.live("Promise worktree callbacks receive interruption through their AbortSignal", () =>
-  Effect.gen(function* () {
-    const started = yield* Deferred.make<AbortSignal>()
-    const state = State.create({
-      initial: () => new Map<string, WorktreeDefinition>(),
-      editor: (value) => ({
-        add: (definition: WorktreeDefinition) => {
-          value.set(definition.id, definition)
-        },
-      }),
-    })
-    const context = host()
-    const plugin = PluginPromise.fromPromise(
-      Plugin.define({
-        id: "cancel-worktree",
-        async setup(ctx) {
-          await ctx.worktree.transform((editor) =>
-            editor.add({
-              id: "cancel",
-              create: (_input, { signal }) =>
-                new Promise<never>((_resolve, reject) => {
-                  signal.addEventListener("abort", () => reject(new Error("cancelled")), { once: true })
-                  Effect.runSync(Deferred.succeed(started, signal))
-                }),
-              remove: async () => {},
-              list: async () => [],
-            }),
-          )
-        },
-      }),
-    )
-    yield* plugin.effect(host({ worktree: { ...context.worktree, transform: state.transform, reload: state.reload } }))
-    const strategy = state.get().get("cancel")
-    if (!strategy) return yield* Effect.die("Strategy was not registered")
-    const fiber = yield* strategy.create({ sourceDirectory: "/source", directory: "/target" }).pipe(Effect.forkScoped)
-    const signal = yield* Deferred.await(started)
-    expect(signal.aborted).toBe(false)
-    yield* Fiber.interrupt(fiber)
-    const exit = yield* Fiber.await(fiber)
-    expect(signal.aborted).toBe(true)
-    expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true)
-  }),
-)

packages/core/test/session-runner.test.ts

@@ -1590,6 +1590,7 @@ describe("SessionRunnerLLM", () => {
     yield* s.resume
 
     expect(s.requests.at(-1)?.system.map((part) => part.text)).toEqual([
+      defaultSystem,
       expect.stringContaining("# Delegation"),
       "Initial context",
     ])
@@ -1610,6 +1611,7 @@ describe("SessionRunnerLLM", () => {
     yield* s.resume
 
     expect(s.requests.at(-1)?.system.map((part) => part.text)).toEqual([
+      defaultSystem,
       expect.stringContaining("# Delegation"),
       "Initial context",
     ])

packages/core/test/shared-schema.test.ts

@@ -114,6 +114,7 @@ test("Core reuses the canonical shared schemas", async () => {
     [coreWorktree.CreateInput, Worktree.CreateInput],
     [coreWorktree.RemoveInput, Worktree.RemoveInput],
     [coreWorktree.Info, Worktree.Info],
+    [coreWorktree.ListInput, Worktree.ListInput],
     [coreWorktree.List, Worktree.List],
     [coreWorktree.Event, Worktree.Event],
     [corePty.Info, Pty.Info],

packages/core/test/tool-execute.test.ts

@@ -24,7 +24,7 @@ test("execute describes invariant Code Mode behavior", () => {
     [
       "Run JavaScript in a confined Code Mode runtime to orchestrate tool calls and compose their results.",
       "Imports, direct filesystem access, and timers are unavailable. Do not use `fetch`; all external access goes through `tools`.",
-      "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by the `search` function. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
+      "Within `{ code }`, the only callable tools are those explicitly listed in the Code Mode catalog instructions or returned by `search`. Inside `{ code }`, ignore tools shown outside the Code Mode catalog. They are not available in the Code Mode runtime.",
       'Call tools through `tools` using only exact paths and signatures from the catalog. Do not infer or normalize tool names; preserve bracket notation such as `tools.<namespace>["tool-name"](input)`.',
       "Prefer an explicit `return`; if omitted, the final top-level expression becomes the result.",
       "Await every call whose completion matters; pending calls are interrupted when execution ends. Run independent calls concurrently with `Promise.all`.",

packages/core/test/worktree.test.ts

@@ -3,7 +3,7 @@ import { $ } from "bun"
 import fs from "fs/promises"
 import path from "path"
 import { and, eq, isNull } from "drizzle-orm"
-import { Context, Effect, Exit, Fiber, Layer, Queue, Scope, Stream } from "effect"
+import { Effect, Fiber, Stream } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -15,64 +15,14 @@ import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { Worktree } from "@opencode-ai/core/worktree"
 import { WorktreeDirectory } from "@opencode-ai/core/worktree/directory"
 import { WorktreeTable } from "@opencode-ai/core/worktree/sql"
-import { WorktreeGit } from "@opencode-ai/core/worktree/git"
-import { Location } from "@opencode-ai/core/location"
-import { Global } from "@opencode-ai/util/global"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Config } from "@opencode-ai/core/config"
-import { ConfigWorktreePlugin } from "@opencode-ai/core/config/plugin/worktree"
-import { ConfigNormalize } from "@opencode-ai/core/config/normalize"
-import { Document, Event, Info } from "@opencode-ai/schema/config"
-import { EventManifest } from "@opencode-ai/schema/event-manifest"
-import { Workspace } from "@opencode-ai/schema/workspace"
-import { host } from "./plugin/host"
 import { initRepo } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
-class Fixture extends Context.Service<Fixture, Effect.Success<ReturnType<typeof makeFixture>>>()("WorktreeFixture") {}
-
-const infrastructure = AppNodeBuilder.build(LayerNode.group([Project.node, Database.node, Bus.node]))
-const it = testEffect(
-  Layer.unwrap(
-    Effect.gen(function* () {
-      const input = yield* makeFixture()
-      const database = yield* Database.Service
-      const bus = yield* Bus.Service
-      return Layer.mergeAll(
-        Layer.succeed(Fixture, input),
-        Config.testLayer(),
-        worktreeLayer(input.sourceDirectory, input.projectID, database, bus, input.root.path),
-      )
-    }),
-  ).pipe(Layer.provideMerge(infrastructure)),
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Worktree.node, Database.node, Bus.node])))
+const projectIt = testEffect(
+  AppNodeBuilder.build(LayerNode.group([Project.node, Worktree.node, Database.node, Bus.node])),
 )
-const projectIt = it
-
-function worktreeLayer(
-  directory: AbsolutePath,
-  projectID: Project.ID,
-  database: Database.Interface,
-  bus: Bus.Interface,
-  data: string,
-  workspaceID?: Workspace.ID,
-) {
-  return AppNodeBuilder.build(LayerNode.group([Worktree.node, Git.node, FSUtil.node, Location.node, Global.node]), [
-    Database.node.replace(Layer.succeed(Database.Service, database)),
-    Bus.node.replace(Layer.succeed(Bus.Service, bus)),
-    Global.node.replace(Global.layerWith({ data })),
-    Location.node.replace(
-      Layer.succeed(
-        Location.Service,
-        Location.Service.of({
-          directory,
-          workspaceID,
-          project: { id: projectID, directory, canonical: directory },
-        }),
-      ),
-    ),
-  ]).pipe(Layer.fresh)
-}
 
 function abs(input: string) {
   return AbsolutePath.make(input)
@@ -80,11 +30,7 @@ function abs(input: string) {
 
 const gitWorktree = Worktree.StrategyID.make("git")
 
-const setup = Effect.fnUntraced(function* () {
-  return yield* Fixture
-})
-
-function makeFixture() {
+function setup() {
   return Effect.gen(function* () {
     const root = yield* Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -161,6 +107,7 @@ describe("Worktree", () => {
       const unavailable = Worktree.StrategyID.make("acme/missing")
       const error = yield* worktree
         .create({
+          projectID: input.projectID,
           strategy: unavailable,
           from: input.sourceDirectory,
           directory: abs(`${input.root.path}-missing-strategy`),
@@ -184,6 +131,7 @@ describe("Worktree", () => {
 
       const error = yield* worktree
         .create({
+          projectID: input.projectID,
           strategy: gitWorktree,
           from: input.sourceDirectory,
           directory: abs(`${input.root.path}-missing-source`),
@@ -211,6 +159,7 @@ describe("Worktree", () => {
       yield* Effect.yieldNow
 
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         directory: parent,
         name: "worktree",
@@ -224,39 +173,13 @@ describe("Worktree", () => {
       )
       expect((yield* Fiber.join(fiber))[0]?.data).toEqual({ projectID: input.projectID })
 
-      yield* worktree.remove({ directory: created.directory, force: false })
+      yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: false })
 
       expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
       expect(yield* Effect.promise(() => Bun.file(target).exists())).toBe(false)
     }),
   )
 
-  it.live("defaults to the TUI worktree directory and suffixes duplicate names", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktree = yield* Worktree.Service
-      const global = yield* Global.Service
-      const parent = path.join(global.data, "worktree", "worktr")
-
-      const created = yield* worktree.create({
-        strategy: gitWorktree,
-        from: input.sourceDirectory,
-        name: "task",
-      })
-      const duplicate = yield* worktree.create({
-        strategy: gitWorktree,
-        from: input.sourceDirectory,
-        name: "task",
-      })
-
-      expect(created.directory).toBe(abs(path.join(parent, "task")))
-      expect(duplicate.directory).toBe(abs(path.join(parent, "task-2")))
-      expect(yield* Effect.promise(() => Bun.file(path.join(created.directory, ".git")).exists())).toBe(true)
-      yield* worktree.remove({ directory: created.directory, force: false })
-      yield* worktree.remove({ directory: duplicate.directory, force: false })
-    }),
-  )
-
   it.live("runs the project setup script with worktree paths", () =>
     Effect.gen(function* () {
       const input = yield* setup()
@@ -276,6 +199,7 @@ describe("Worktree", () => {
         .run()
         .pipe(Effect.orDie)
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         directory: parent,
         name: "worktree",
@@ -286,7 +210,7 @@ describe("Worktree", () => {
         created.directory,
         created.directory,
       ])
-      yield* worktree.remove({ directory: created.directory, force: true })
+      yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: true })
     }),
   )
 
@@ -309,12 +233,9 @@ describe("Worktree", () => {
           .quiet()
       })
       const projects = yield* Project.Service
+      const worktrees = yield* Worktree.Service
       const initial = yield* projects.resolve(main)
       const selected = yield* projects.resolve(clone)
-      const database = yield* Database.Service
-      const bus = yield* Bus.Service
-      const context = yield* Layer.build(worktreeLayer(selected.directory, selected.id, database, bus, root.path))
-      const worktrees = Context.get(context, Worktree.Service)
       yield* projects.update({
         projectID: initial.id,
         commands: {
@@ -324,6 +245,7 @@ describe("Worktree", () => {
       })
 
       const created = yield* worktrees.create({
+        projectID: selected.id,
         strategy: gitWorktree,
         from: selected.canonical,
         directory: abs(path.join(root.path, "worktrees")),
@@ -354,6 +276,7 @@ describe("Worktree", () => {
       })
 
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         branch: "feature-base",
         directory: parent,
@@ -377,6 +300,7 @@ describe("Worktree", () => {
 
       const error = yield* worktree
         .create({
+          projectID: input.projectID,
           strategy: gitWorktree,
           branch: "--no-checkout",
           directory: parent,
@@ -397,6 +321,7 @@ describe("Worktree", () => {
 
       const error = yield* worktree
         .create({
+          projectID: input.projectID,
           strategy: gitWorktree,
           from: abs(path.join(temp, "does-not-exist")),
           directory: abs(`${input.root.path}-missing-directory`),
@@ -422,6 +347,7 @@ describe("Worktree", () => {
         ]).pipe(Effect.asVoid),
       )
       const source = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         from: input.sourceDirectory,
         directory: sourceParent,
@@ -434,6 +360,7 @@ describe("Worktree", () => {
         .pipe(Effect.orDie)
 
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         from: source.directory,
         directory: targetParent,
@@ -441,8 +368,8 @@ describe("Worktree", () => {
       })
 
       expect(created.directory).toBe(abs(path.join(targetParent, "target")))
-      yield* worktree.remove({ directory: created.directory, force: false })
-      yield* worktree.remove({ directory: source.directory, force: false })
+      yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: false })
+      yield* worktree.remove({ projectID: input.projectID, directory: source.directory, force: false })
     }),
   )
 
@@ -454,6 +381,7 @@ describe("Worktree", () => {
       const parent = abs(path.join(temp, path.basename(input.root.path) + "-worktree-dirty"))
       yield* Effect.addFinalizer(() => Effect.promise(() => fs.rm(parent, { recursive: true, force: true })))
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         from: input.sourceDirectory,
         directory: parent,
@@ -461,7 +389,9 @@ describe("Worktree", () => {
       })
       yield* Effect.promise(() => Bun.write(path.join(created.directory, "dirty.txt"), "dirty"))
 
-      const error = yield* worktree.remove({ directory: created.directory, force: false }).pipe(Effect.flip)
+      const error = yield* worktree
+        .remove({ projectID: input.projectID, directory: created.directory, force: false })
+        .pipe(Effect.flip)
 
       expect(error).toBeInstanceOf(Git.WorktreeError)
       if (error instanceof Git.WorktreeError) {
@@ -471,7 +401,7 @@ describe("Worktree", () => {
       expect(yield* stored(input.projectID)).toContainEqual({ directory: created.directory, strategy: "git" })
       expect(yield* Effect.promise(() => Bun.file(path.join(created.directory, "dirty.txt")).exists())).toBe(true)
 
-      yield* worktree.remove({ directory: created.directory, force: true })
+      yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: true })
       expect(yield* Effect.promise(() => Bun.file(created.directory).exists())).toBe(false)
     }),
   )
@@ -489,7 +419,9 @@ describe("Worktree", () => {
         .run()
         .pipe(Effect.orDie)
 
-      const error = yield* worktree.remove({ directory: unavailable, force: false }).pipe(Effect.flip)
+      const error = yield* worktree
+        .remove({ projectID: input.projectID, directory: unavailable, force: false })
+        .pipe(Effect.flip)
 
       expect(error).toBeInstanceOf(Worktree.StrategyUnavailableError)
       expect(yield* stored(input.projectID)).toContainEqual({ directory: unavailable, strategy: "acme/missing" })
@@ -508,6 +440,7 @@ describe("Worktree", () => {
       yield* Effect.promise(() => fs.mkdir(path.join(parent, "worktree-2")))
 
       const created = yield* worktree.create({
+        projectID: input.projectID,
         strategy: gitWorktree,
         from: input.sourceDirectory,
         directory: parent,
@@ -522,7 +455,7 @@ describe("Worktree", () => {
         yield* Effect.promise(() => fs.stat(path.join(parent, "worktree-2")).then((item) => item.isDirectory())),
       ).toBe(true)
 
-      yield* worktree.remove({ directory: created.directory, force: false })
+      yield* worktree.remove({ projectID: input.projectID, directory: created.directory, force: false })
     }),
   )
 
@@ -543,6 +476,7 @@ describe("Worktree", () => {
 
       const error = yield* worktree
         .create({
+          projectID: input.projectID,
           strategy: gitWorktree,
           from: input.sourceDirectory,
           directory: parent,
@@ -558,6 +492,7 @@ describe("Worktree", () => {
 
   it.live("does not publish an event when refresh finds no directory changes", () =>
     Effect.gen(function* () {
+      const input = yield* setup()
       const worktree = yield* Worktree.Service
       const bus = yield* Bus.Service
       const event = yield* bus.subscribe(Worktree.Event.Updated).pipe(
@@ -567,7 +502,7 @@ describe("Worktree", () => {
         Effect.flatMap((fiber) =>
           Effect.gen(function* () {
             yield* Effect.yieldNow
-            yield* worktree.refresh()
+            yield* worktree.refresh({ projectID: input.projectID })
             return yield* Fiber.join(fiber).pipe(Effect.timeoutOption("50 millis"))
           }),
         ),
@@ -606,7 +541,7 @@ describe("Worktree", () => {
 
       const discovered = abs(yield* Effect.promise(() => fs.realpath(target)))
       const existing = abs(yield* Effect.promise(() => fs.realpath(unchanged)))
-      expect(yield* worktree.refresh()).toEqual({ updated: [discovered], removed: [] })
+      expect(yield* worktree.refresh({ projectID: input.projectID })).toEqual({ updated: [discovered], removed: [] })
 
       expect(yield* stored(input.projectID)).toEqual(
         [
@@ -619,7 +554,7 @@ describe("Worktree", () => {
 
       yield* Effect.promise(() => $`git worktree remove --force ${target}`.cwd(input.root.path).quiet())
       yield* Effect.promise(() => $`git worktree remove --force ${unchanged}`.cwd(input.root.path).quiet())
-      expect(yield* worktree.refresh()).toEqual({
+      expect(yield* worktree.refresh({ projectID: input.projectID })).toEqual({
         updated: [],
         removed: [discovered, existing].toSorted(),
       })
@@ -640,7 +575,7 @@ describe("Worktree", () => {
         yield* Effect.promise(() => fs.rm(stale, { recursive: true, force: true }))
         yield* Effect.promise(() => $`git worktree add --detach ${target} HEAD`.cwd(input.root.path).quiet())
 
-        yield* worktree.refresh()
+        yield* worktree.refresh({ projectID: input.projectID })
 
         const discovered = abs(yield* Effect.promise(() => fs.realpath(target)))
         expect(yield* stored(input.projectID)).toEqual(
@@ -659,7 +594,7 @@ describe("Worktree", () => {
       yield* Effect.promise(() => fs.rm(path.join(input.sourceDirectory, ".git"), { recursive: true }))
       const worktree = yield* Worktree.Service
 
-      yield* worktree.refresh()
+      yield* worktree.refresh({ projectID: input.projectID })
 
       expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
     }),
@@ -667,15 +602,9 @@ describe("Worktree", () => {
 
   it.live("refresh with no roots is a no-op", () =>
     Effect.gen(function* () {
-      const input = yield* setup()
-      yield* input.db
-        .delete(WorktreeTable)
-        .where(eq(WorktreeTable.project_id, input.projectID))
-        .run()
-        .pipe(Effect.orDie)
       const worktree = yield* Worktree.Service
 
-      expect(yield* worktree.refresh()).toEqual({
+      expect(yield* worktree.refresh({ projectID: Project.ID.make("missing-project") })).toEqual({
         updated: [],
         removed: [],
       })
@@ -693,251 +622,9 @@ describe("Worktree", () => {
         .pipe(Effect.orDie)
       const worktree = yield* Worktree.Service
 
-      expect(yield* worktree.refresh()).toEqual({ updated: [], removed: [missing] })
+      expect(yield* worktree.refresh({ projectID: input.projectID })).toEqual({ updated: [], removed: [missing] })
 
       expect(yield* stored(input.projectID)).not.toContainEqual({ directory: missing, strategy: null })
     }),
   )
-
-  it.live("defaults to Git and configured directory without depending on Config", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktrees = yield* Worktree.Service
-      const parent = abs(path.join(input.root.path, "configured"))
-      const registration = yield* worktrees.transform((editor) => editor.configure({ directory: parent }))
-      const created = yield* worktrees.create({ name: "configured" })
-      expect(created.directory).toBe(abs(path.join(parent, "configured")))
-      expect(yield* worktrees.list()).toContainEqual({
-        directory: created.directory,
-        strategy: "git",
-      })
-      yield* registration.dispose
-      const fallback = yield* worktrees.create({ name: "default" })
-      expect(fallback.directory).toBe(
-        abs(path.join(input.root.path, "worktree", input.projectID.slice(0, 6), "default")),
-      )
-    }),
-  )
-
-  it.live("selects the last active registration and restores earlier strategies on disposal", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktrees = yield* Worktree.Service
-      const git = yield* WorktreeGit.make
-      const parent = abs(path.join(input.root.path, "strategies"))
-      const first = yield* worktrees.transform((editor) =>
-        editor.add({ ...git, id: Worktree.StrategyID.make("first") }),
-      )
-      const scope = yield* Effect.acquireRelease(Scope.make(), (scope) => Scope.close(scope, Exit.void))
-      const second = yield* worktrees
-        .transform((editor) => editor.add({ ...git, id: Worktree.StrategyID.make("second") }))
-        .pipe(Effect.provideService(Scope.Scope, scope))
-      yield* worktrees.transform((editor) => editor.configure({ directory: parent }))
-      const created = yield* worktrees.create({ name: "second" })
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: created.directory, strategy: "second" })
-      yield* Scope.close(scope, Exit.void)
-      yield* second.dispose
-      const earlier = yield* worktrees.create({ name: "first" })
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: earlier.directory, strategy: "first" })
-      yield* first.dispose
-      const fallback = yield* worktrees.create({ name: "git" })
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: fallback.directory, strategy: "git" })
-      const error = yield* worktrees.remove({ directory: created.directory, force: false }).pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Worktree.StrategyUnavailableError)
-      yield* worktrees.refresh()
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: created.directory, strategy: "second" })
-    }),
-  )
-
-  it.live("does not fall back to Git when a registered strategy fails", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktrees = yield* Worktree.Service
-      const git = yield* WorktreeGit.make
-      yield* worktrees.transform((editor) =>
-        editor.add({
-          ...git,
-          id: Worktree.StrategyID.make("broken"),
-          create: () => Effect.fail(new Error("backend failed")),
-        }),
-      )
-      const parent = abs(path.join(input.root.path, "failures"))
-      const error = yield* worktrees.create({ directory: parent, name: "failure" }).pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Worktree.OperationError)
-      expect(yield* stored(input.projectID)).toEqual([{ directory: input.sourceDirectory, strategy: null }])
-      const explicit = yield* worktrees.create({
-        directory: parent,
-        name: "explicit",
-        strategy: gitWorktree,
-      })
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: explicit.directory, strategy: "git" })
-    }),
-  )
-
-  it.live("rejects a source override belonging to another project", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktrees = yield* Worktree.Service
-      const projects = yield* Project.Service
-      const other = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir()))
-      yield* Effect.promise(() => initRepo(other.path))
-      const resolved = yield* projects.resolve(abs(other.path))
-      expect(resolved.id).not.toBe(input.projectID)
-      const error = yield* worktrees.create({ from: abs(other.path), name: "nope" }).pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Worktree.SourceDirectoryNotFoundError)
-      if (error instanceof Worktree.SourceDirectoryNotFoundError) expect(error.projectID).toBe(input.projectID)
-    }),
-  )
-
-  it.live("cannot remove a worktree from another project through the current location", () =>
-    Effect.gen(function* () {
-      const worktrees = yield* Worktree.Service
-      const projects = yield* Project.Service
-      const other = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir()))
-      yield* Effect.promise(() => initRepo(other.path))
-      const linked = abs(path.join(other.path, "linked"))
-      yield* Effect.promise(() => $`git worktree add --detach ${linked} HEAD`.cwd(other.path).quiet())
-      const resolved = yield* projects.resolve(linked)
-      const error = yield* worktrees.remove({ directory: linked, force: true }).pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Worktree.InvalidDirectoryError)
-      expect(yield* stored(resolved.id)).toContainEqual({ directory: linked, strategy: "git" })
-      expect(yield* Effect.promise(() => fs.stat(linked).then((item) => item.isDirectory()))).toBe(true)
-    }),
-  )
-
-  it.live("rejects workspace-qualified locations before running worktree operations", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const database = yield* Database.Service
-      const bus = yield* Bus.Service
-      const fs = yield* FSUtil.Service
-      const context = yield* Layer.build(
-        worktreeLayer(
-          input.sourceDirectory,
-          input.projectID,
-          database,
-          bus,
-          input.root.path,
-          Workspace.ID.make("wrk_remote"),
-        ),
-      )
-      const worktrees = Context.get(context, Worktree.Service)
-      const directory = abs(path.join(input.root.path, "not-created"))
-      const errors = yield* Effect.all([
-        worktrees.list().pipe(Effect.flip),
-        worktrees.create({ directory, name: "task" }).pipe(Effect.flip),
-        worktrees.remove({ directory: input.sourceDirectory, force: true }).pipe(Effect.flip),
-        worktrees.refresh().pipe(Effect.flip),
-      ])
-      for (const error of errors) expect(error).toBeInstanceOf(Worktree.UnsupportedLocationError)
-      expect(yield* fs.existsSafe(directory)).toBe(false)
-      expect(yield* fs.isDir(input.sourceDirectory)).toBe(true)
-    }),
-  )
-
-  it.live("list invokes the location's strategies before returning inventory", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const worktrees = yield* Worktree.Service
-      const git = yield* WorktreeGit.make
-      const directory = abs(path.join(input.root.path, "discovered"))
-      yield* Effect.promise(() => fs.mkdir(directory))
-      const sources: AbsolutePath[] = []
-      yield* worktrees.transform((editor) =>
-        editor.add({
-          ...git,
-          id: Worktree.StrategyID.make("discovered-copy"),
-          list: (sourceDirectory) =>
-            Effect.sync(() => {
-              sources.push(sourceDirectory)
-              return [{ directory, type: "worktree" as const }]
-            }),
-        }),
-      )
-      expect(yield* worktrees.list()).toContainEqual({ directory, strategy: "discovered-copy" })
-      expect(sources).toEqual([input.sourceDirectory])
-      expect(yield* stored(input.projectID)).toContainEqual({ directory, strategy: "discovered-copy" })
-      yield* Effect.promise(() => fs.rmdir(directory))
-      expect(yield* worktrees.list()).not.toContainEqual({ directory, strategy: "discovered-copy" })
-      expect(sources).toEqual([input.sourceDirectory, input.sourceDirectory])
-    }),
-  )
-
-  it.live("list surfaces strategy discovery failures", () =>
-    Effect.gen(function* () {
-      const worktrees = yield* Worktree.Service
-      const git = yield* WorktreeGit.make
-      yield* worktrees.transform((editor) =>
-        editor.add({
-          ...git,
-          id: Worktree.StrategyID.make("broken-discovery"),
-          list: () => Effect.fail(new Error("Cannot enumerate worktrees")),
-        }),
-      )
-      const error = yield* worktrees.list().pipe(Effect.flip)
-      expect(error).toBeInstanceOf(Worktree.OperationError)
-      if (error instanceof Worktree.OperationError) expect(error.message).toContain("Cannot enumerate worktrees")
-    }),
-  )
-
-  it.live("applies directory config through the adapter and restores defaults after config removal", () =>
-    Effect.gen(function* () {
-      const input = yield* setup()
-      const config = yield* Config.Test
-      const worktrees = yield* Worktree.Service
-      const bus = yield* Bus.Service
-      const reloaded = yield* Queue.unbounded<void>()
-      const documents = [
-        new Document({
-          type: "document",
-          path: abs(path.join(input.root.path, "opencode.json")),
-          info: new Info({ worktree: { directory: "outer" } }),
-        }),
-        new Document({
-          type: "document",
-          path: abs(path.join(input.root.path, "nested/opencode.json")),
-          info: new Info({ worktree: { directory: "copies" } }),
-        }),
-      ]
-      yield* config.setEntries(documents)
-      const git = yield* WorktreeGit.make
-      yield* worktrees.transform((editor) => editor.add({ ...git, id: Worktree.StrategyID.make("custom") }))
-      yield* ConfigWorktreePlugin.Plugin.effect(
-        host({ event: { subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer)) } }),
-      ).pipe(
-        Effect.provideService(Worktree.Service, {
-          ...worktrees,
-          reload: () => worktrees.reload().pipe(Effect.tap(() => Queue.offer(reloaded, undefined))),
-        }),
-      )
-      const first = yield* worktrees.create({ name: "one" })
-      expect(first.directory).toBe(abs(path.join(input.root.path, "nested/copies/one")))
-      expect(yield* stored(input.projectID)).toContainEqual({ directory: first.directory, strategy: "custom" })
-      yield* config.setEntries(documents.slice(0, 1))
-      yield* bus.publish(Event.Updated, {})
-      yield* Queue.take(reloaded)
-      const second = yield* worktrees.create({ name: "two" })
-      expect(second.directory).toBe(abs(path.join(input.root.path, "outer/two")))
-      yield* config.setEntries([])
-      yield* bus.publish(Event.Updated, {})
-      yield* Queue.take(reloaded)
-      const third = yield* worktrees.create({ name: "three" })
-      expect(third.directory).toBe(abs(path.join(input.root.path, "worktree", input.projectID.slice(0, 6), "three")))
-    }),
-  )
-
-  it.effect("normalization retains worktree directory and rejects invalid configuration", () =>
-    Effect.sync(() => {
-      expect(ConfigNormalize.normalize({ worktree: { directory: "./copies" } })).toMatchObject({
-        type: "normalized",
-        encoded: { worktree: { directory: "./copies" } },
-        diagnostics: [],
-      })
-      for (const worktree of [{ directory: " " }, { directory: 12 }, {}]) {
-        const result = ConfigNormalize.normalize({ worktree })
-        expect(result.diagnostics.length).toBeGreaterThan(0)
-        if (result.type === "normalized") expect(result.encoded).not.toHaveProperty("worktree")
-      }
-    }),
-  )
 })

packages/plugin/src/effect/index.ts

@@ -16,4 +16,3 @@ export { Rpc } from "@opencode-ai/schema/rpc"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Vcs } from "@opencode-ai/schema/vcs"
 export { WebSearch } from "@opencode-ai/schema/websearch"
-export { Worktree } from "@opencode-ai/schema/worktree"

packages/plugin/src/effect/plugin.ts

@@ -20,7 +20,6 @@ import type { StorageDomain } from "./storage.js"
 import type { ToolDomain } from "./tool.js"
 import type { VcsDomain } from "./vcs.js"
 import type { WebSearchDomain } from "./websearch.js"
-import type { WorktreeDomain } from "./worktree.js"
 
 export interface Context {
   readonly app: App
@@ -48,7 +47,6 @@ export interface Context {
   readonly tool: ToolDomain
   readonly vcs: VcsDomain
   readonly websearch: WebSearchDomain
-  readonly worktree: WorktreeDomain
 }
 
 export interface Plugin<R = Scope.Scope> {

packages/plugin/src/effect/worktree.ts

@@ -1,21 +0,0 @@
-import type { WorktreeApi } from "@opencode-ai/client/effect/api"
-import type { Effect } from "effect"
-import type { WorktreeCreateInput, WorktreeEntry, WorktreeRemoveInput, WorktreeResult } from "../worktree.js"
-import type { Transform } from "./registration.js"
-
-export interface WorktreeDefinition {
-  readonly id: string
-  readonly create: (input: WorktreeCreateInput) => Effect.Effect<WorktreeResult, unknown>
-  readonly remove: (input: WorktreeRemoveInput) => Effect.Effect<void, unknown>
-  readonly list: (sourceDirectory: string) => Effect.Effect<readonly WorktreeEntry[], unknown>
-}
-
-export interface WorktreeEditor {
-  /** Registers an implementation and selects it as the default. Later active registrations win. */
-  add(definition: WorktreeDefinition): void
-}
-
-export interface WorktreeDomain extends WorktreeApi<unknown> {
-  readonly transform: Transform<WorktreeEditor>
-  readonly reload: () => Effect.Effect<void>
-}

packages/plugin/src/promise/adapter.ts

@@ -234,7 +234,6 @@ export function fromPromise(plugin: Plugin) {
         const SkillEndpoints = ClientApi.groups["server.skill"].endpoints
         const VcsEndpoints = ClientApi.groups["server.vcs"].endpoints
         const WebSearchEndpoints = ClientApi.groups["server.websearch"].endpoints
-        const WorktreeEndpoints = ClientApi.groups["server.worktree"].endpoints
         const context = yield* Effect.context<Scope.Scope>()
         const streams = yield* makeStreams()
 
@@ -539,27 +538,6 @@ export function fromPromise(plugin: Plugin) {
                 }),
               ),
           },
-          worktree: {
-            list: adaptApiMethod(WorktreeEndpoints["worktree.list"], host.worktree.list),
-            create: adaptApiMethod(WorktreeEndpoints["worktree.create"], host.worktree.create),
-            remove: adaptApiMethod(WorktreeEndpoints["worktree.remove"], host.worktree.remove),
-            refresh: adaptApiMethod(WorktreeEndpoints["worktree.refresh"], host.worktree.refresh),
-            reload: () => run(host.worktree.reload()),
-            transform: (callback) =>
-              register(
-                host.worktree.transform((editor) =>
-                  callback({
-                    add: (definition) =>
-                      editor.add({
-                        id: definition.id,
-                        create: (input) => attempt((signal) => definition.create(input, { signal })),
-                        remove: (input) => attempt((signal) => definition.remove(input, { signal })),
-                        list: (directory) => attempt((signal) => definition.list(directory, { signal })),
-                      }),
-                  }),
-                ),
-              ),
-          },
           session: {
             hook: (name, callback, options) =>
               register(

packages/plugin/src/promise/index.ts

@@ -17,4 +17,3 @@ export { Rpc } from "@opencode-ai/schema/rpc"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Vcs } from "@opencode-ai/schema/vcs"
 export { WebSearch } from "@opencode-ai/schema/websearch"
-export { Worktree } from "@opencode-ai/schema/worktree"

packages/plugin/src/promise/plugin.ts

@@ -20,7 +20,6 @@ import type { StorageDomain } from "./storage.js"
 import type { ToolDomain } from "./tool.js"
 import type { VcsDomain } from "./vcs.js"
 import type { WebSearchDomain } from "./websearch.js"
-import type { WorktreeDomain } from "./worktree.js"
 
 export interface Context {
   readonly app: App
@@ -48,7 +47,6 @@ export interface Context {
   readonly tool: ToolDomain
   readonly vcs: VcsDomain
   readonly websearch: WebSearchDomain
-  readonly worktree: WorktreeDomain
 }
 
 export type Cleanup = () => Promise<void> | void

packages/plugin/src/promise/worktree.ts

@@ -1,23 +0,0 @@
-import type { WorktreeApi } from "@opencode-ai/client/promise/api"
-import type { WorktreeCreateInput, WorktreeEntry, WorktreeRemoveInput, WorktreeResult } from "../worktree.js"
-import type { Transform } from "./registration.js"
-
-export interface WorktreeDefinition {
-  readonly id: string
-  readonly create: (input: WorktreeCreateInput, context: { readonly signal: AbortSignal }) => Promise<WorktreeResult>
-  readonly remove: (input: WorktreeRemoveInput, context: { readonly signal: AbortSignal }) => Promise<void>
-  readonly list: (
-    sourceDirectory: string,
-    context: { readonly signal: AbortSignal },
-  ) => Promise<readonly WorktreeEntry[]>
-}
-
-export interface WorktreeEditor {
-  /** Registers an implementation and selects it as the default. Later active registrations win. */
-  add(definition: WorktreeDefinition): void
-}
-
-export interface WorktreeDomain extends WorktreeApi {
-  readonly transform: Transform<WorktreeEditor>
-  readonly reload: () => Promise<void>
-}

packages/plugin/src/worktree.ts

@@ -1,19 +0,0 @@
-export interface WorktreeCreateInput {
-  readonly sourceDirectory: string
-  readonly directory: string
-  /** Starting ref, not the name of a new branch. Reject unsupported refs rather than ignoring them. */
-  readonly branch?: string
-}
-
-export interface WorktreeRemoveInput {
-  readonly directory: string
-  readonly force: boolean
-}
-
-export interface WorktreeResult {
-  readonly directory: string
-}
-
-export interface WorktreeEntry extends WorktreeResult {
-  readonly type: "root" | "worktree"
-}

packages/protocol/openapi.json

@@ -11997,50 +11997,18 @@
         "summary": "List references"
       }
     },
-    "/api/worktree": {
+    "/api/worktree/{projectID}": {
       "get": {
         "tags": ["worktree"],
         "operationId": "v2.worktree.list",
         "parameters": [
           {
-            "name": "location",
-            "in": "query",
+            "name": "projectID",
+            "in": "path",
             "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
+              "type": "string"
             },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
+            "required": true
           }
         ],
         "security": [],
@@ -12056,18 +12024,11 @@
             }
           },
           "400": {
-            "description": "WorktreeError | InvalidRequestError",
+            "description": "InvalidRequestError",
             "content": {
               "application/json": {
                 "schema": {
-                  "anyOf": [
-                    {
-                      "$ref": "#/components/schemas/WorktreeErrorEncoded"
-                    },
-                    {
-                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
-                    }
-                  ]
+                  "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
                 }
               }
             }
@@ -12083,7 +12044,7 @@
             }
           }
         },
-        "description": "Discover worktrees through the requested location's strategies and return its project's inventory.",
+        "description": "List known local worktrees for a project.",
         "summary": "List worktrees"
       },
       "post": {
@@ -12091,44 +12052,12 @@
         "operationId": "v2.worktree.create",
         "parameters": [
           {
-            "name": "location",
-            "in": "query",
+            "name": "projectID",
+            "in": "path",
             "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
+              "type": "string"
             },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
+            "required": true
           }
         ],
         "security": [],
@@ -12171,13 +12100,32 @@
             }
           }
         },
-        "description": "Create a local worktree using the location's registered strategy and directory defaults, then run the project's setup script.",
+        "description": "Create a worktree for a project and run its configured setup script.",
         "summary": "Create worktree",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/Worktree.CreateInput"
+                "type": "object",
+                "properties": {
+                  "strategy": {
+                    "type": "string"
+                  },
+                  "from": {
+                    "type": "string"
+                  },
+                  "branch": {
+                    "type": "string"
+                  },
+                  "directory": {
+                    "type": "string"
+                  },
+                  "name": {
+                    "type": "string"
+                  }
+                },
+                "required": ["strategy", "directory"],
+                "additionalProperties": false
               }
             }
           },
@@ -12189,44 +12137,12 @@
         "operationId": "v2.worktree.remove",
         "parameters": [
           {
-            "name": "location",
-            "in": "query",
+            "name": "projectID",
+            "in": "path",
             "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
+              "type": "string"
             },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
+            "required": true
           }
         ],
         "security": [],
@@ -12262,13 +12178,23 @@
             }
           }
         },
-        "description": "Remove a managed worktree from the requested location's project using its recorded strategy.",
+        "description": "Remove a managed worktree from a project.",
         "summary": "Remove worktree",
         "requestBody": {
           "content": {
             "application/json": {
               "schema": {
-                "$ref": "#/components/schemas/Worktree.RemoveInput"
+                "type": "object",
+                "properties": {
+                  "directory": {
+                    "type": "string"
+                  },
+                  "force": {
+                    "type": "boolean"
+                  }
+                },
+                "required": ["directory", "force"],
+                "additionalProperties": false
               }
             }
           },
@@ -12276,50 +12202,18 @@
         }
       }
     },
-    "/api/worktree/refresh": {
+    "/api/worktree/{projectID}/refresh": {
       "post": {
         "tags": ["worktree"],
         "operationId": "v2.worktree.refresh",
         "parameters": [
           {
-            "name": "location",
-            "in": "query",
+            "name": "projectID",
+            "in": "path",
             "schema": {
-              "anyOf": [
-                {
-                  "type": "object",
-                  "properties": {
-                    "directory": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    },
-                    "workspace": {
-                      "anyOf": [
-                        {
-                          "type": "string"
-                        },
-                        {
-                          "type": "null"
-                        }
-                      ]
-                    }
-                  },
-                  "additionalProperties": false
-                },
-                {
-                  "type": "null"
-                }
-              ]
+              "type": "string"
             },
-            "required": false,
-            "style": "deepObject",
-            "explode": true
+            "required": true
           }
         ],
         "security": [],
@@ -12355,7 +12249,7 @@
             }
           }
         },
-        "description": "Discover worktrees from the requested location and reconcile the shared project inventory.",
+        "description": "Reconcile stored worktrees with the project repositories.",
         "summary": "Refresh worktrees"
       }
     },
@@ -14252,9 +14146,6 @@
               ]
             }
           },
-          "worktree": {
-            "$ref": "#/components/schemas/Config.Worktree"
-          },
           "warming": {
             "anyOf": [
               {
@@ -14572,16 +14463,6 @@
         },
         "additionalProperties": false
       },
-      "Config.Worktree": {
-        "type": "object",
-        "properties": {
-          "directory": {
-            "type": "string"
-          }
-        },
-        "required": ["directory"],
-        "additionalProperties": false
-      },
       "ConfigWebSearch.InfoEncoded": {
         "type": "object",
         "properties": {
@@ -19695,27 +19576,6 @@
         "additionalProperties": false,
         "description": "Reports whether this request destroyed an existing workspace."
       },
-      "Worktree.CreateInput": {
-        "type": "object",
-        "properties": {
-          "strategy": {
-            "type": "string"
-          },
-          "from": {
-            "type": "string"
-          },
-          "branch": {
-            "type": "string"
-          },
-          "directory": {
-            "type": "string"
-          },
-          "name": {
-            "type": "string"
-          }
-        },
-        "additionalProperties": false
-      },
       "Worktree.Directory": {
         "type": "object",
         "properties": {
@@ -19745,19 +19605,6 @@
           "$ref": "#/components/schemas/Worktree.Directory"
         }
       },
-      "Worktree.RemoveInput": {
-        "type": "object",
-        "properties": {
-          "directory": {
-            "type": "string"
-          },
-          "force": {
-            "type": "boolean"
-          }
-        },
-        "required": ["directory", "force"],
-        "additionalProperties": false
-      },
       "WorktreeErrorEncoded": {
         "type": "object",
         "properties": {
@@ -19891,7 +19738,7 @@
     },
     {
       "name": "worktree",
-      "description": "Location-scoped worktree management routes."
+      "description": "Project worktree management routes."
     },
     {
       "name": "workspace",

packages/protocol/src/api.ts

@@ -54,7 +54,6 @@ type LocationGroups<LocationId extends HttpApiMiddleware.AnyId> =
   | HttpApiGroup.AddMiddleware<typeof PtyGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ShellGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ReferenceGroup, LocationId>
-  | HttpApiGroup.AddMiddleware<typeof WorktreeGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof VcsGroup, LocationId>
   | HttpApiGroup.AddMiddleware<typeof ConfigGroup, LocationId>
 
@@ -89,6 +88,7 @@ type ApiGroups<
   | typeof ServerGroup
   | typeof DebugGroup
   | typeof MigrationGroup
+  | typeof WorktreeGroup
   | typeof WorkspaceGroup
   | typeof GenerateGroup
   | typeof PersistentPtyGroup
@@ -176,7 +176,7 @@ const makeApiFromGroup = <
     .add(PersistentPtyGroup)
     .add(ShellGroup.middleware(locationMiddleware))
     .add(ReferenceGroup.middleware(locationMiddleware))
-    .add(WorktreeGroup.middleware(locationMiddleware))
+    .add(WorktreeGroup)
     .add(WorkspaceGroup)
     .add(VcsGroup.middleware(locationMiddleware))
     .add(DebugGroup)

packages/protocol/src/groups/worktree.ts

@@ -1,9 +1,9 @@
+import { Project } from "@opencode-ai/schema/project"
 import { Worktree } from "@opencode-ai/schema/worktree"
-import { Schema } from "effect"
+import { Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
-import { LocationQuery, locationQueryOpenApi } from "./location.js"
 
-const root = "/api/worktree"
+const root = "/api/worktree/:projectID"
 
 export class WorktreeError extends Schema.Error<WorktreeError>("WorktreeError")(
   {
@@ -16,69 +16,61 @@ export class WorktreeError extends Schema.Error<WorktreeError>("WorktreeError")(
   { httpApiStatus: 400 },
 ) {}
 
+const CreatePayload = Schema.Struct(Struct.omit(Worktree.CreateInput.fields, ["projectID"]))
+const RemovePayload = Schema.Struct(Struct.omit(Worktree.RemoveInput.fields, ["projectID"]))
+
 export const WorktreeGroup = HttpApiGroup.make("server.worktree")
   .add(
     HttpApiEndpoint.get("worktree.list", root, {
-      query: LocationQuery,
+      params: { projectID: Project.ID },
       success: Worktree.List,
-      error: WorktreeError,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.worktree.list",
-          summary: "List worktrees",
-          description:
-            "Discover worktrees through the requested location's strategies and return its project's inventory.",
-        }),
-      ),
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.worktree.list",
+        summary: "List worktrees",
+        description: "List known local worktrees for a project.",
+      }),
+    ),
   )
   .add(
     HttpApiEndpoint.post("worktree.create", root, {
-      query: LocationQuery,
-      payload: Worktree.CreateInput,
+      params: { projectID: Project.ID },
+      payload: CreatePayload,
       success: Worktree.Info,
       error: WorktreeError,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.worktree.create",
-          summary: "Create worktree",
-          description:
-            "Create a local worktree using the location's registered strategy and directory defaults, then run the project's setup script.",
-        }),
-      ),
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.worktree.create",
+        summary: "Create worktree",
+        description: "Create a worktree for a project and run its configured setup script.",
+      }),
+    ),
   )
   .add(
     HttpApiEndpoint.delete("worktree.remove", root, {
-      query: LocationQuery,
-      payload: Worktree.RemoveInput,
+      params: { projectID: Project.ID },
+      payload: RemovePayload,
       success: HttpApiSchema.NoContent,
       error: WorktreeError,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.worktree.remove",
-          summary: "Remove worktree",
-          description: "Remove a managed worktree from the requested location's project using its recorded strategy.",
-        }),
-      ),
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.worktree.remove",
+        summary: "Remove worktree",
+        description: "Remove a managed worktree from a project.",
+      }),
+    ),
   )
   .add(
     HttpApiEndpoint.post("worktree.refresh", `${root}/refresh`, {
-      query: LocationQuery,
+      params: { projectID: Project.ID },
       success: HttpApiSchema.NoContent,
       error: WorktreeError,
-    })
-      .annotateMerge(locationQueryOpenApi)
-      .annotateMerge(
-        OpenApi.annotations({
-          identifier: "v2.worktree.refresh",
-          summary: "Refresh worktrees",
-          description: "Discover worktrees from the requested location and reconcile the shared project inventory.",
-        }),
-      ),
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.worktree.refresh",
+        summary: "Refresh worktrees",
+        description: "Reconcile stored worktrees with the project repositories.",
+      }),
+    ),
   )
-  .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Location-scoped worktree management routes." }))
+  .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Project worktree management routes." }))

packages/schema/src/config.ts

@@ -20,7 +20,6 @@ import { ConfigWebSearch } from "./config/websearch.js"
 import { ConfigToolOutput } from "./config/tool-output.js"
 import { ConfigWatcher } from "./config/watcher.js"
 import { ConfigWarming } from "./config/warming.js"
-import { ConfigWorktree } from "./config/worktree.js"
 
 export class Info extends Schema.Class<Info>("Config.Info")({
   $schema: optional(Schema.String).annotate({
@@ -99,9 +98,6 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
     description: "Ordered plugin enablement directives and external package declarations",
   }),
-  worktree: ConfigWorktree.Info.pipe(optional).annotate({
-    description: "Directory defaults for local worktree creation",
-  }),
   warming: ConfigWarming.Warming.pipe(optional).annotate({
     description: "Keep recently active sessions warm with transient model requests (default: false)",
   }),

packages/schema/src/config/worktree.ts

@@ -1,10 +0,0 @@
-export * as ConfigWorktree from "./worktree.js"
-
-import { Schema } from "effect"
-
-export const Info = Schema.Struct({
-  directory: Schema.Trim.pipe(Schema.check(Schema.isNonEmpty())).annotate({
-    description: "Parent directory for new worktrees, relative to the declaring config file when not absolute",
-  }),
-}).annotate({ identifier: "Config.Worktree" })
-export interface Info extends Schema.Schema.Type<typeof Info> {}

packages/schema/src/worktree.ts

@@ -2,6 +2,7 @@ export * as Worktree from "./worktree.js"
 
 import { Schema } from "effect"
 import { durable, ephemeral, inventory } from "./event.js"
+import { ProjectID } from "./project-id.js"
 import { AbsolutePath, optional } from "./schema.js"
 import { Project } from "./project.js"
 
@@ -9,18 +10,17 @@ export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Sc
 export type StrategyID = typeof StrategyID.Type
 
 export const CreateInput = Schema.Struct({
-  strategy: optional(StrategyID),
+  projectID: ProjectID,
+  strategy: StrategyID,
   from: optional(AbsolutePath),
   branch: optional(Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()))),
-  directory: optional(AbsolutePath).annotate({
-    description:
-      "Parent directory for the new worktree. Uses the location's configuration, then defaults to the server's data directory under worktree/<first six project ID characters>.",
-  }),
+  directory: AbsolutePath,
   name: optional(Schema.String),
 }).annotate({ identifier: "Worktree.CreateInput" })
 export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {}
 
 export const RemoveInput = Schema.Struct({
+  projectID: ProjectID,
   directory: AbsolutePath,
   force: Schema.Boolean,
 }).annotate({ identifier: "Worktree.RemoveInput" })
@@ -37,16 +37,10 @@ export const Directory = Schema.Struct({
 }).annotate({ identifier: "Worktree.Directory" })
 export interface Directory extends Schema.Schema.Type<typeof Directory> {}
 
-export const ListEntry = Schema.Struct({
-  directory: AbsolutePath,
-  type: Schema.Literals(["root", "worktree"]),
-}).annotate({ identifier: "Worktree.ListEntry" })
-export interface ListEntry extends Schema.Schema.Type<typeof ListEntry> {}
-
-export class OperationError extends Schema.TaggedError<OperationError>()("Worktree.OperationError", {
-  message: Schema.String,
-  forceRequired: optional(Schema.Boolean),
-}) {}
+export const ListInput = Schema.Struct({
+  projectID: ProjectID,
+}).annotate({ identifier: "Worktree.ListInput" })
+export interface ListInput extends Schema.Schema.Type<typeof ListInput> {}
 
 export const List = Schema.Array(Directory).annotate({ identifier: "Worktree.List" })
 export type List = typeof List.Type

packages/schema/test/config.test.ts

@@ -10,15 +10,6 @@ import { AbsolutePath } from "../src/schema.js"
 import { WebSearch } from "../src/websearch.js"
 
 describe("Config.Entry", () => {
-  test("accepts directory-only worktree config and omits it when absent", () => {
-    const decode = Schema.decodeUnknownSync(Config.Info)
-    const input = { worktree: { directory: "../worktrees" } }
-    expect(Schema.encodeSync(Config.Info)(decode(input))).toEqual(input)
-    expect(Schema.encodeSync(Config.Info)(new Config.Info({ worktree: undefined }))).not.toHaveProperty("worktree")
-    expect(() => decode({ worktree: {} })).toThrow()
-    expect(() => decode({ worktree: { directory: " " } })).toThrow()
-    expect(() => decode({ worktree: { directory: false } })).toThrow()
-  })
   test("round-trips canonical provider IDs without changing config keys", () => {
     const input = { providers: { "console-anthropic": { canonical: "anthropic" } } }
     const decoded = Schema.decodeUnknownSync(Config.Info)(input)

packages/schema/test/contract-hygiene.test.ts

@@ -184,6 +184,7 @@ describe("contract hygiene", () => {
       Model.Variant,
       Project.Current,
       Worktree.Directory,
+      Worktree.ListInput,
       Worktree.List,
       Project.Icon,
       Project.Commands,

packages/schema/test/worktree.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Schema } from "effect"
-import { Worktree } from "../src/worktree.js"
-
-describe("Worktree.CreateInput", () => {
-  test("allows the server to choose the destination", () => {
-    const input = Schema.decodeUnknownSync(Worktree.CreateInput)({
-      strategy: "git",
-    })
-    expect(input.directory).toBeUndefined()
-    expect(Schema.encodeSync(Worktree.CreateInput)({ ...input, directory: undefined })).toEqual({
-      strategy: "git",
-    })
-  })
-
-  test("preserves an explicit destination", () => {
-    const input = { strategy: "git", directory: "/custom/worktrees" }
-    expect(Schema.encodeSync(Worktree.CreateInput)(Schema.decodeUnknownSync(Worktree.CreateInput)(input))).toEqual(
-      input,
-    )
-  })
-})
-
-test("worktree mutation inputs do not require a project or explicit creation defaults", () => {
-  const value = Schema.decodeUnknownSync(Worktree.CreateInput)({ name: "task" })
-  expect(Schema.encodeSync(Worktree.CreateInput)(value)).toEqual({ name: "task" })
-  expect(Schema.encodeSync(Worktree.CreateInput)(Schema.decodeUnknownSync(Worktree.CreateInput)({}))).toEqual({})
-  expect(Worktree.CreateInput.fields).not.toHaveProperty("projectID")
-  expect(Worktree.RemoveInput.fields).not.toHaveProperty("projectID")
-})
-
-test("inventory contains only the directory and its owning strategy", () => {
-  const value = Schema.decodeUnknownSync(Worktree.Directory)({ directory: "/repo/task", strategy: "git" })
-  expect(Schema.encodeSync(Worktree.Directory)(value)).toEqual({ directory: "/repo/task", strategy: "git" })
-})
-
-test("strategy failures can request force confirmation without Core or Git dependencies", () => {
-  const value = new Worktree.OperationError({ message: "Dirty worktree", forceRequired: true })
-  expect(value.forceRequired).toBe(true)
-  expect(
-    Schema.encodeSync(Worktree.OperationError)(new Worktree.OperationError({ message: "Failed" })),
-  ).not.toHaveProperty("forceRequired")
-})

packages/server/package.json

@@ -36,8 +36,6 @@
     "effect": "catalog:"
   },
   "devDependencies": {
-    "@opencode-ai/client": "workspace:*",
-    "@opencode-ai/plugin": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:"

packages/server/src/handlers/worktree.ts

@@ -1,31 +1,31 @@
 import { Git } from "@opencode-ai/core/git"
 import { Worktree } from "@opencode-ai/core/worktree"
-import { Plugin } from "@opencode-ai/core/plugin"
 import { WorktreeError } from "@opencode-ai/protocol/groups/worktree"
 import { Effect } from "effect"
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
 import { Api } from "../api"
 
 export const WorktreeHandler = HttpApiBuilder.group(Api, "server.worktree", (handlers) =>
-  handlers
-    .handle("worktree.list", () => run((worktrees) => worktrees.list()))
-    .handle("worktree.create", (ctx) => run((worktrees) => worktrees.create(ctx.payload)))
-    .handle("worktree.remove", (ctx) =>
-      run((worktrees) => worktrees.remove(ctx.payload)).pipe(Effect.as(HttpApiSchema.NoContent.make())),
-    )
-    .handle("worktree.refresh", () =>
-      run((worktrees) => worktrees.refresh()).pipe(Effect.as(HttpApiSchema.NoContent.make())),
-    ),
-)
-
-function run<A>(action: (service: Worktree.Interface) => Effect.Effect<A, Worktree.Error>) {
-  return Effect.gen(function* () {
-    const plugins = yield* Plugin.Service
+  Effect.gen(function* () {
     const worktrees = yield* Worktree.Service
-    yield* plugins.awaitActivation
-    return yield* action(worktrees)
-  }).pipe(badRequest)
-}
+
+    return handlers
+      .handle("worktree.list", (ctx) => worktrees.list(ctx.params.projectID))
+      .handle("worktree.create", (ctx) =>
+        badRequest(worktrees.create({ ...ctx.payload, projectID: ctx.params.projectID })),
+      )
+      .handle("worktree.remove", (ctx) =>
+        badRequest(worktrees.remove({ ...ctx.payload, projectID: ctx.params.projectID })).pipe(
+          Effect.as(HttpApiSchema.NoContent.make()),
+        ),
+      )
+      .handle("worktree.refresh", (ctx) =>
+        badRequest(worktrees.refresh({ projectID: ctx.params.projectID })).pipe(
+          Effect.as(HttpApiSchema.NoContent.make()),
+        ),
+      )
+  }),
+)
 
 function badRequest<A, R>(effect: Effect.Effect<A, Worktree.Error, R>) {
   return effect.pipe(
@@ -35,10 +35,7 @@ function badRequest<A, R>(effect: Effect.Effect<A, Worktree.Error, R>) {
           name: "WorktreeError",
           data: {
             message: message(error),
-            forceRequired:
-              error instanceof Git.WorktreeError || error instanceof Worktree.OperationError
-                ? error.forceRequired
-                : undefined,
+            forceRequired: error instanceof Git.WorktreeError ? error.forceRequired : undefined,
           },
         }),
     ),
@@ -54,6 +51,5 @@ function message(error: Worktree.Error) {
   if (error instanceof Worktree.DirectoryUnavailableError) return `Worktree directory unavailable: ${error.directory}`
   if (error instanceof Worktree.InvalidDirectoryError) return `Invalid worktree directory: ${error.directory}`
   if (error instanceof Worktree.StrategyUnavailableError) return `Worktree strategy unavailable: ${error.strategy}`
-  if (error instanceof Worktree.UnsupportedLocationError) return "Worktree operations only support local locations"
   return error.message
 }

packages/server/src/routes.ts

@@ -30,6 +30,7 @@ import { PluginUpdate } from "@opencode-ai/core/plugin/update"
 import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { WellKnown } from "@opencode-ai/core/wellknown"
 import { Workspace } from "@opencode-ai/core/workspace"
+import { Worktree } from "@opencode-ai/core/worktree"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { HttpRouter } from "effect/unstable/http"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
@@ -55,6 +56,7 @@ const applicationServiceNodes = [
   httpClient,
   Job.node,
   Project.node,
+  Worktree.node,
   Session.node,
   Instance.node,
   SessionTransfer.node,

packages/server/test/fixture/worktree-delegate/index.ts

@@ -1,13 +0,0 @@
-import { Plugin } from "@opencode-ai/plugin"
-
-export default Plugin.define({
-  id: "test.worktree-delegate",
-  async setup(ctx) {
-    const directory = ctx.options.directory
-    if (typeof directory !== "string") throw new Error("Missing target location")
-    await ctx.worktree.create({
-      location: { directory },
-      name: "delegated",
-    })
-  },
-})

packages/server/test/fixture/worktree-plugin/index.ts

@@ -1,47 +0,0 @@
-import { Plugin, Worktree } from "@opencode-ai/plugin"
-
-export default Plugin.define({
-  id: "test.worktree",
-  async setup(ctx) {
-    const id = typeof ctx.options.strategy === "string" ? ctx.options.strategy : "test-copy"
-    await ctx.worktree.transform((editor) =>
-      editor.add({
-        id,
-        async create(input, { signal }) {
-          await git(
-            input.sourceDirectory,
-            ["worktree", "add", "--detach", "--", input.directory, input.branch ?? "HEAD"],
-            signal,
-          )
-          await ctx.storage.set(`tree:${input.directory}`, input.sourceDirectory)
-          return { directory: input.directory }
-        },
-        async remove(input, { signal }) {
-          const source = await ctx.storage.get(`tree:${input.directory}`)
-          if (typeof source !== "string") throw new Worktree.OperationError({ message: "Worktree source not found" })
-          // Windows cannot remove the working directory of the Git process itself.
-          await git(
-            source,
-            ["worktree", "remove", ...(input.force ? ["--force"] : []), input.directory],
-            signal,
-            !input.force,
-          )
-          await ctx.storage.remove(`tree:${input.directory}`)
-        },
-        async list(sourceDirectory, { signal }) {
-          signal.throwIfAborted()
-          const rows = await ctx.storage.scan({ prefix: "tree:" })
-          return rows.entries
-            .filter((row) => row.value === sourceDirectory)
-            .map((row) => ({ directory: row.key.slice(5), type: "worktree" as const }))
-        },
-      }),
-    )
-  },
-})
-
-async function git(directory: string, args: string[], signal: AbortSignal, forceRequired = false) {
-  const child = Bun.spawn(["git", "-C", directory, ...args], { stdout: "pipe", stderr: "pipe", signal })
-  const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()])
-  if (code !== 0) throw new Worktree.OperationError({ message: stderr, forceRequired })
-}

packages/server/test/worktree.test.ts

@@ -6,223 +6,57 @@ import { Effect } from "effect"
 import { tmpdir } from "../../core/test/fixture/tmpdir"
 import { it } from "../../core/test/lib/effect"
 import { startServer } from "./fixture/server"
-import { OpenCode } from "@opencode-ai/client"
-import { initRepo } from "../../core/test/fixture/git"
 
-it.live(
-  "lists, creates, and removes worktrees through the same location",
-  () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-worktree-endpoint-")))
-      const project = path.join(tmp.path, "project")
-      const destination = path.join(tmp.path, "worktrees")
-      yield* Effect.promise(() => fs.mkdir(project, { recursive: true }))
-      yield* Effect.promise(() => $`git init`.cwd(project).quiet())
-      yield* Effect.promise(() => $`git config user.email test@opencode.test`.cwd(project).quiet())
-      yield* Effect.promise(() => $`git config user.name Test`.cwd(project).quiet())
-      yield* Effect.promise(() => $`git commit --allow-empty -m root`.cwd(project).quiet())
-      const server = yield* startServer(path.join(tmp.path, "config"))
-      const url = new URL("/api/worktree", server.base)
-      url.searchParams.set("location[directory]", project)
+it.live("lists, creates, and removes worktrees by project ID", () =>
+  Effect.gen(function* () {
+    const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-worktree-endpoint-")))
+    const project = path.join(tmp.path, "project")
+    const destination = path.join(tmp.path, "worktrees")
+    yield* Effect.promise(() => fs.mkdir(project, { recursive: true }))
+    yield* Effect.promise(() => $`git init`.cwd(project).quiet())
+    yield* Effect.promise(() => $`git config user.email test@opencode.test`.cwd(project).quiet())
+    yield* Effect.promise(() => $`git config user.name Test`.cwd(project).quiet())
+    yield* Effect.promise(() => $`git commit --allow-empty -m root`.cwd(project).quiet())
+    const server = yield* startServer(path.join(tmp.path, "config"))
+    const location = new URL("/api/location", server.base)
+    location.searchParams.set("location[directory]", project)
+    const resolved = yield* Effect.promise(() =>
+      fetch(location, { headers: server.headers }).then((response) => response.json()),
+    )
+    if (!isRecord(resolved) || !isRecord(resolved.project) || typeof resolved.project.id !== "string")
+      throw new Error("Expected resolved project")
+    const url = new URL(`/api/worktree/${resolved.project.id}`, server.base)
 
-      const initial = yield* Effect.promise(() =>
-        fetch(url, { headers: server.headers }).then((response) => response.json()),
-      )
-      expect(initial).toEqual([{ directory: project }])
+    const initial = yield* Effect.promise(() =>
+      fetch(url, { headers: server.headers }).then((response) => response.json()),
+    )
+    expect(initial).toEqual([{ directory: project }])
 
-      const created = yield* Effect.promise(() =>
-        fetch(url, {
-          method: "POST",
-          headers: { ...server.headers, "content-type": "application/json" },
-          body: JSON.stringify({ strategy: "git", directory: destination, name: "api" }),
-        }).then((response) => response.json()),
-      )
-      expect(created).toEqual({ directory: path.join(destination, "api") })
+    const created = yield* Effect.promise(() =>
+      fetch(url, {
+        method: "POST",
+        headers: { ...server.headers, "content-type": "application/json" },
+        body: JSON.stringify({ strategy: "git", directory: destination, name: "api" }),
+      }).then((response) => response.json()),
+    )
+    expect(created).toEqual({ directory: path.join(destination, "api") })
 
-      const listed = yield* Effect.promise(() =>
-        fetch(url, { headers: server.headers }).then((response) => response.json()),
-      )
-      expect(listed).toContainEqual({
-        directory: path.join(destination, "api"),
-        strategy: "git",
-      })
+    const listed = yield* Effect.promise(() =>
+      fetch(url, { headers: server.headers }).then((response) => response.json()),
+    )
+    expect(listed).toContainEqual({ directory: path.join(destination, "api"), strategy: "git" })
 
-      const removed = yield* Effect.promise(() =>
-        fetch(url, {
-          method: "DELETE",
-          headers: { ...server.headers, "content-type": "application/json" },
-          body: JSON.stringify({ directory: path.join(destination, "api"), force: false }),
-        }),
-      )
-      expect(removed.status).toBe(204)
-    }),
-  30_000,
+    const removed = yield* Effect.promise(() =>
+      fetch(url, {
+        method: "DELETE",
+        headers: { ...server.headers, "content-type": "application/json" },
+        body: JSON.stringify({ directory: path.join(destination, "api"), force: false }),
+      }),
+    )
+    expect(removed.status).toBe(204)
+  }),
 )
 
-it.live(
-  "derives the project and creation defaults when the SDK omits its input",
-  () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-worktree-default-location-")))
-      const project = path.join(tmp.path, "project")
-      const config = path.join(tmp.path, "config")
-      const destination = path.join(tmp.path, "copies")
-      yield* Effect.promise(async () => {
-        await fs.mkdir(project)
-        await initRepo(project)
-        await fs.mkdir(config)
-        await Bun.write(path.join(config, "opencode.json"), JSON.stringify({ worktree: { directory: destination } }))
-      })
-      const server = yield* startServer(config)
-      const api = OpenCode.make({
-        baseUrl: server.base,
-        headers: { ...server.headers, "x-opencode-directory": encodeURIComponent(project) },
-      })
-      yield* Effect.promise(async () => {
-        const created = await api.worktree.create()
-        expect(path.dirname(created.directory)).toBe(destination)
-        await api.worktree.refresh()
-        expect(await api.worktree.list()).toContainEqual({
-          directory: created.directory,
-          strategy: "git",
-        })
-        await api.worktree.remove({ directory: created.directory, force: false })
-        expect(await api.worktree.list()).toEqual([{ directory: project }])
-      })
-    }),
-  30_000,
-)
-
-it.live(
-  "uses checkout-local plugins and configuration for clones sharing a project",
-  () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-worktree-plugins-")))
-      const first = path.join(tmp.path, "first")
-      const second = path.join(tmp.path, "second")
-      const nested = path.join(first, "nested")
-      const config = path.join(tmp.path, "config")
-      const destination = path.join(tmp.path, "worktrees")
-      yield* Effect.promise(async () => {
-        await fs.mkdir(first)
-        await initRepo(first)
-        await $`git remote add origin git@github.com:example/worktree-fixture.git`.cwd(first).quiet()
-        await $`git clone --no-hardlinks ${first} ${second}`.quiet()
-        await $`git remote set-url origin https://github.com/example/worktree-fixture.git`.cwd(second).quiet()
-        await fs.mkdir(nested)
-        await fs.mkdir(config)
-        await Bun.write(path.join(config, "opencode.json"), JSON.stringify({ worktree: { directory: destination } }))
-        await Bun.write(
-          path.join(nested, "opencode.json"),
-          JSON.stringify({
-            plugins: [
-              { package: path.join(import.meta.dir, "fixture/worktree-plugin"), options: { strategy: "test-copy" } },
-            ],
-          }),
-        )
-      })
-      const server = yield* startServer(config)
-      const api = OpenCode.make({ baseUrl: server.base, headers: server.headers })
-      yield* Effect.promise(async () => {
-        const a = await api.location.get({ location: { directory: nested } })
-        const b = await api.location.get({ location: { directory: second } })
-        expect(a.project.id).toBe(b.project.id)
-        const custom = await api.worktree.create({ location: { directory: nested }, name: "custom" })
-        const builtin = await api.worktree.create({ location: { directory: second }, name: "builtin" })
-        expect(custom.directory).toBe(path.join(destination, "custom"))
-        expect(builtin.directory).toBe(path.join(destination, "builtin"))
-        const otherRows = await api.worktree.list({ location: { directory: second } })
-        expect(otherRows).toContainEqual({ directory: custom.directory, strategy: "test-copy" })
-        const rows = await api.worktree.list({ location: { directory: nested } })
-        expect(rows).toContainEqual({
-          directory: custom.directory,
-          strategy: "test-copy",
-        })
-        expect(rows).toContainEqual({ directory: builtin.directory, strategy: "git" })
-
-        await Bun.write(path.join(custom.directory, "dirty.txt"), "keep me")
-        const remove = new URL("/api/worktree", server.base)
-        remove.searchParams.set("location[directory]", second)
-        const unavailable = await fetch(remove, {
-          method: "DELETE",
-          headers: { ...server.headers, "content-type": "application/json" },
-          body: JSON.stringify({ directory: custom.directory, force: true }),
-        })
-        expect(unavailable.status).toBe(400)
-        expect(await unavailable.json()).toMatchObject({
-          data: { message: "Worktree strategy unavailable: test-copy" },
-        })
-        expect(await Bun.file(path.join(custom.directory, "dirty.txt")).text()).toBe("keep me")
-        remove.searchParams.set("location[directory]", nested)
-        const failure = await fetch(remove, {
-          method: "DELETE",
-          headers: { ...server.headers, "content-type": "application/json" },
-          body: JSON.stringify({ directory: custom.directory, force: false }),
-        })
-        expect(failure.status).toBe(400)
-        expect(await failure.json()).toMatchObject({ data: { forceRequired: true } })
-        expect(await Bun.file(path.join(custom.directory, "dirty.txt")).text()).toBe("keep me")
-
-        await api.worktree.remove({
-          location: { directory: nested },
-          directory: custom.directory,
-          force: true,
-        })
-        await api.worktree.remove({
-          location: { directory: second },
-          directory: builtin.directory,
-          force: false,
-        })
-        expect((await api.worktree.list({ location: { directory: nested } })).filter((row) => row.strategy)).toEqual([])
-      })
-    }),
-  30_000,
-)
-
-it.live(
-  "plugin calls await a different location's strategy and directory configuration",
-  () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-worktree-delegate-")))
-      const source = path.join(tmp.path, "source")
-      const target = path.join(tmp.path, "target")
-      const destination = path.join(tmp.path, "copies")
-      yield* Effect.promise(async () => {
-        for (const directory of [source, target]) {
-          await fs.mkdir(directory)
-          await initRepo(directory)
-          await $`git remote add origin git@github.com:example/delegate-fixture.git`.cwd(directory).quiet()
-        }
-        await Bun.write(
-          path.join(source, "opencode.json"),
-          JSON.stringify({
-            plugins: [
-              { package: path.join(import.meta.dir, "fixture/worktree-delegate"), options: { directory: target } },
-            ],
-          }),
-        )
-        await Bun.write(
-          path.join(target, "opencode.json"),
-          JSON.stringify({
-            worktree: { directory: destination },
-            plugins: [
-              { package: path.join(import.meta.dir, "fixture/worktree-plugin"), options: { strategy: "target-copy" } },
-            ],
-          }),
-        )
-      })
-      const server = yield* startServer(path.join(tmp.path, "config"))
-      const api = OpenCode.make({ baseUrl: server.base, headers: server.headers })
-      yield* Effect.promise(async () => {
-        await api.location.get({ location: { directory: source } })
-        const url = new URL("/api/plugin/await-activation", server.base)
-        url.searchParams.set("location[directory]", source)
-        expect((await fetch(url, { method: "POST", headers: server.headers })).status).toBe(204)
-        expect(await api.worktree.list({ location: { directory: target } })).toContainEqual({
-          directory: path.join(destination, "delegated"),
-          strategy: "target-copy",
-        })
-      })
-    }),
-  30_000,
-)
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}

packages/stats/server/Dockerfile

@@ -1,4 +1,4 @@
-FROM oven/bun:1.4.2-alpine AS base
+FROM oven/bun:1.4.1-alpine AS base
 
 WORKDIR /app