Merge branch 'v2' into worktree-ui

AGENTS.md

@@ -183,7 +183,7 @@ const table = sqliteTable("session", {
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
 - Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
-- Keep delivery vocabulary explicit. Prompts steer by default. At safe step boundaries, steered compaction takes priority up to the first steered move control; other steers retain enqueue order. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
+- Keep delivery vocabulary explicit. Prompts steer by default. Steers deliver in enqueue order at safe step boundaries, stopping before compaction or move control items. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
 - One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
 - Keep event replay ownership separate from clustered Session execution ownership.
 - Keep the Instructions algebra and built-ins in `src/instructions`; keep instruction producers with their observed domains, and keep Session History selection plus `InstructionState` and `InstructionEntry` persistence Session-owned. `InstructionDiscovery` observes ambient global and upward-project instructions. The runner composes built-ins, discovery, guidance, and entries explicitly in `loadInstructions`; there is no instruction registry.

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:",

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-IDORw4Nup1Yj+RZSLGo0pDnwrkveYA8GvYQVNTJUnMM=",
-    "aarch64-linux": "sha256-jxjyAI2imF7csdZNUqvs9mFj8SnYqGg1CapEEk15rxA=",
-    "aarch64-darwin": "sha256-Hbh+cw2DPOJpYCDjasK6m0SLqznyAw1ODKSb7w87GG8=",
-    "x86_64-darwin": "sha256-Aj0/MtMPoeccrN36mu2wUM6gyRKaTF2AbjZ0/wZtKnA="
+    "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="
   }
 }

packages/ai/src/protocols/open-responses-channel.ts

@@ -113,8 +113,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
           responseID = created
           return { type: "frame", frame }
         }
-        // Keepalives and provider notifications carry no response state and may precede response.created.
-        if (!event.type.startsWith("response.")) return { type: "frame", frame }
+        // Keepalives carry no response state and may arrive before response.created.
+        if (event.type === "keepalive") return { type: "frame", frame }
         if (!responseID)
           return yield* ProviderShared.eventError(
             options.id,

packages/ai/test/provider/openai-responses.test.ts

@@ -526,7 +526,7 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
-  it.effect("tolerates keepalive and provider notifications before response.created", () =>
+  it.effect("tolerates keepalive frames before response.created", () =>
     Effect.gen(function* () {
       const webSocket = WebSocketTransport.makeDirect({
         open: () =>
@@ -534,7 +534,6 @@ describe("OpenAI Responses route", () => {
             sendText: () => Effect.void,
             messages: Stream.fromArray([
               ProviderShared.encodeJson({ type: "keepalive", sequence_number: 0 }),
-              ProviderShared.encodeJson({ type: "codex.rate_limits" }),
               ProviderShared.encodeJson({ type: "response.created", response: { id: "resp_alive" } }),
               ProviderShared.encodeJson({
                 type: "response.completed",

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/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/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/new-session/view.tsx

@@ -34,6 +34,8 @@ export const ProviderTipSchema = Persistence.struct({
   dismissedAt: Schema.Finite,
 })
 
+export const WorkspaceTipSchema = ProviderTipSchema
+
 export function NewSessionView(props: {
   composer: ComposerModel
   project: PromptProjectController
@@ -99,7 +101,15 @@ export function NewSessionView(props: {
             </div>
           </div>
         </div>
-        <ProviderTip />
+        <NewSessionTips
+          workspaceEligible={
+            !!props.project.selected() &&
+            props.workspace.bar.visible() &&
+            props.workspace.selection.value() !== "create" &&
+            props.workspace.project.managed() === 0
+          }
+          onWorkspace={() => select("create")}
+        />
       </div>
     </div>
   )
@@ -118,56 +128,90 @@ export function NewSessionStatus(props: { visible: boolean }) {
   )
 }
 
-function ProviderTip() {
+function NewSessionTips(props: { workspaceEligible: boolean; onWorkspace: () => void }) {
   const language = useLanguage()
   const dialog = useDialog()
   const sdk = useWorkspaceLocation()
   const providers = useProviders(() => sdk().directory)
-  const [persistedState, setPersistedState, , persistedReady] = persisted(
+  const [providerState, setProviderState, , providerReady] = persisted(
     Persist.global("new-session.provider-tip"),
     ProviderTipSchema,
     { dismissedAt: 0 },
   )
-  const visible = createMemo(
+  const [workspaceState, setWorkspaceState, , workspaceReady] = persisted(
+    Persist.global("new-session.workspace-tip"),
+    WorkspaceTipSchema,
+    { dismissedAt: 0 },
+  )
+  const workspaceVisible = createMemo(
+    () =>
+      props.workspaceEligible &&
+      workspaceReady() &&
+      Date.now() - workspaceState.dismissedAt >= providerTipDismissalDuration,
+  )
+  const providerVisible = createMemo(
     () =>
       providers.ready() &&
-      persistedReady() &&
+      providerReady() &&
       providers.paid().length === 0 &&
-      Date.now() - persistedState.dismissedAt >= providerTipDismissalDuration,
+      Date.now() - providerState.dismissedAt >= providerTipDismissalDuration,
   )
+  const tip = createMemo<"workspace" | "provider" | undefined>(() => {
+    if (providerVisible()) return "provider"
+    if (workspaceVisible()) return "workspace"
+  })
+  const displayed = createMemo<"workspace" | "provider" | undefined>((previous) => tip() ?? previous)
   const [ref, setRef] = createSignal<HTMLDivElement>()
   const presence = createPresence({
-    show: visible,
+    show: () => tip() !== undefined,
     element: () => ref() ?? null,
   })
-  const openProviders = () => {
+  const open = () => {
+    const current = tip()
+    if (!current) return
+    if (current === "workspace") {
+      setWorkspaceState("dismissedAt", Date.now())
+      props.onWorkspace()
+      return
+    }
     void import("@/providers/connect/dialog").then(({ DialogConnectProvider }) => {
       void dialog.show(() => <DialogConnectProvider directory={sdk().directory} />)
     })
   }
+  const dismiss = () => {
+    const current = tip()
+    if (!current) return
+    if (current === "workspace") {
+      setWorkspaceState("dismissedAt", Date.now())
+      return
+    }
+    setProviderState("dismissedAt", Date.now())
+  }
 
   return (
     <Show when={presence.present()}>
       <div class="pointer-events-none absolute inset-x-0 bottom-4 flex justify-center px-10">
         <div
           ref={setRef}
-          data-component="provider-tip"
-          data-visible={visible()}
-          class="group/provider-tip pointer-events-auto relative flex h-6 max-w-full items-center transition-[opacity,transform] duration-[250ms] ease-[cubic-bezier(0.215,0.61,0.355,1)] motion-reduce:transition-none"
+          data-component="new-session-tip"
+          data-visible={tip() !== undefined}
+          class="group/new-session-tip pointer-events-auto relative flex h-6 max-w-full items-center transition-[opacity,transform] duration-[250ms] ease-[cubic-bezier(0.215,0.61,0.355,1)] motion-reduce:transition-none"
           classList={{ "data-[visible=false]:animate-out fade-out slide-out-to-bottom-4": true }}
         >
           <button
             type="button"
             class="flex h-6 min-w-0 items-center rounded-[4px] pl-1.5 text-[13px] leading-text-compact tracking-[-0.04px] text-v2-text-text-faint transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-text-text-muted focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-text-text-muted focus-visible:outline-none"
-            onClick={openProviders}
+            onClick={open}
           >
-            <span class="truncate">{language.t("home.providerTip")}</span>
+            <span class="truncate">
+              {language.t(displayed() === "workspace" ? "home.workspaceTip" : "home.providerTip")}
+            </span>
             <span class="flex size-6 shrink-0 items-center justify-center" aria-hidden="true">
               <Icon name="chevron-down" size="small" class="-rotate-90" />
             </span>
           </button>
           <Tooltip
-            class="hover-reveal absolute left-full top-0 flex h-6 w-7 items-center justify-end delay-0 duration-0 group-hover/provider-tip:delay-[250ms] group-hover/provider-tip:duration-150 group-hover/provider-tip:opacity-100 focus-within:delay-0 focus-within:duration-0 focus-within:opacity-100"
+            class="hover-reveal absolute left-full top-0 flex h-6 w-7 items-center justify-end delay-0 duration-0 group-hover/new-session-tip:delay-[250ms] group-hover/new-session-tip:duration-150 group-hover/new-session-tip:opacity-100 focus-within:delay-0 focus-within:duration-0 focus-within:opacity-100"
             placement="top"
             openDelay={1000}
             value={language.t("common.dismiss")}
@@ -176,7 +220,7 @@ function ProviderTip() {
               type="button"
               class="flex size-6 items-center justify-center rounded-[4px] text-v2-icon-icon-muted transition-[background-color,color] duration-150 ease-in-out hover:bg-v2-overlay-simple-overlay-hover hover:text-v2-icon-icon-base focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:text-v2-icon-icon-base focus-visible:outline-none"
               aria-label={language.t("common.dismiss")}
-              onClick={() => setPersistedState("dismissedAt", Date.now())}
+              onClick={dismiss}
             >
               <Icon name="xmark-small" />
             </button>

packages/app/src/new-session/workspace/controller.ts

@@ -1,5 +1,5 @@
 import { debounce } from "@solid-primitives/scheduled"
-import { createEffect, createMemo, createResource } from "solid-js"
+import { createEffect, createMemo, createResource, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { useServerSDK } from "@/runtime/server/client"
@@ -11,8 +11,8 @@ import { normalizeProjectInfo } from "@/runtime/server/global-sync/utils"
 import {
   isWorkspaceDirectory,
   isWorkspaceSelection,
+  sameDirectory,
   workspaceDefaultSelection,
-  workspaceDirectories,
   workspaceSelectionDestination,
 } from "@/workspaces/paths"
 
@@ -56,6 +56,45 @@ export function createNewSessionWorkspaceController(input: {
     const current = projectID ? data.project.get(projectID) : undefined
     return current ? normalizeProjectInfo(current) : undefined
   })
+  const [worktrees, worktreeActions] = createResource(
+    () => currentProject()?.id,
+    async (projectID) => ({
+      projectID,
+      items: await serverSDK.api.worktree
+        .list({ projectID })
+        .catch(() => (currentProject()?.id === projectID ? currentProject()?.worktrees : undefined) ?? []),
+    }),
+  )
+  onCleanup(
+    serverSDK.event.listen((event) => {
+      if (event.type === "worktree.updated") void worktreeActions.refetch()
+    }),
+  )
+  const worktreeItems = createMemo(() => {
+    const project = currentProject()
+    if (!project) return []
+    const loaded = worktrees.latest
+    return loaded?.projectID === project.id ? loaded.items : project.worktrees
+  })
+  const worktreeDirectories = createMemo(() => {
+    const project = currentProject()
+    if (!project) return []
+    const directories = [
+      ...worktreeItems().map((item) => item.directory),
+      ...project.worktrees.map((item) => item.directory),
+      ...(project.sandboxes ?? []),
+    ]
+    return directories
+      .filter((directory) => !sameDirectory(project.worktree, directory))
+      .filter((directory, index, items) => items.findIndex((item) => sameDirectory(item, directory)) === index)
+  })
+  const managedWorktrees = createMemo(() => {
+    const project = currentProject()
+    if (!project) return 0
+    return worktreeItems().filter(
+      (item) => item.strategy !== undefined && !sameDirectory(project.worktree, item.directory),
+    ).length
+  })
   const visible = createMemo(() =>
     resolveNewSessionGit({
       projectVcs: currentProject()?.vcs,
@@ -66,7 +105,9 @@ export function createNewSessionWorkspaceController(input: {
     const project = currentProject()
     const worktree = input.selectedWorktree()
     if (!project || !worktree) return
-    return isWorkspaceSelection(project, worktree) ? worktree : undefined
+    return isWorkspaceSelection(project, worktree) || worktreeDirectories().some((item) => sameDirectory(item, worktree))
+      ? worktree
+      : undefined
   })
   const fallback = createMemo(() => {
     const project = currentProject()
@@ -97,7 +138,7 @@ export function createNewSessionWorkspaceController(input: {
       () => undefined,
     )
     const project = currentProject()
-    const directories = project ? [project.worktree, ...workspaceDirectories(project)] : [sdk().directory]
+    const directories = project ? [project.worktree, ...worktreeDirectories()] : [sdk().directory]
     directories.forEach((directory) => void data.location.vcs.sync({ directory }).catch(() => undefined))
   })
   const branch = createMemo(() =>
@@ -122,7 +163,11 @@ export function createNewSessionWorkspaceController(input: {
       workspace: createMemo(() => {
         const project = currentProject()
         const current = value()
-        return current === "create" || (!!project && isWorkspaceDirectory(project, current))
+        return (
+          current === "create" ||
+          (!!project &&
+            (isWorkspaceDirectory(project, current) || worktreeDirectories().some((item) => sameDirectory(item, current))))
+        )
       }),
       reset: () => {
         input.setSelectedWorktree(undefined)
@@ -142,10 +187,8 @@ export function createNewSessionWorkspaceController(input: {
     },
     project: {
       root: projectRoot,
-      workspaces: () => {
-        const project = currentProject()
-        return project ? workspaceDirectories(project) : []
-      },
+      workspaces: worktreeDirectories,
+      managed: managedWorktrees,
       git: visible,
       branches: () => {
         const current = data.location.vcs.info({ directory: sdk().directory })?.branch.current

packages/app/src/new-session/workspace/selector.tsx

@@ -1,5 +1,6 @@
-import { createMemo, For, Show } from "solid-js"
+import { createMemo, createSignal, For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { Menu } from "@opencode-ai/ui/menu"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { Icon } from "@opencode-ai/ui/icon"
@@ -25,6 +26,9 @@ export function PromptWorkspaceSelector(props: {
   let searchInput: HTMLInputElement | undefined
   let branchSearchInput: HTMLInputElement | undefined
   let focusSearch = false
+  const branchTruncation = createTruncatedText()
+  const focusWorktreeSearch = () =>
+    requestAnimationFrame(() => requestAnimationFrame(() => searchInput?.focus({ preventScroll: true })))
   let pending: { type: "select"; value: string } | { type: "create"; branch: string } | { type: "viewAll" } | undefined
   const selected = () => (sameDirectory(props.value, props.projectRoot) ? "main" : props.value)
   const workspaces = createMemo(() => {
@@ -34,8 +38,8 @@ export function PromptWorkspaceSelector(props: {
   })
   const icon = () => {
     if (selected() === "main") return "monitor"
-    if (selected() === "create") return "workspace-new"
-    return "workspace-isolated"
+    if (selected() === "create") return "plus"
+    return "outline-worktree"
   }
   const select = (value: string) => {
     pending = { type: "select", value }
@@ -66,13 +70,14 @@ export function PromptWorkspaceSelector(props: {
     <>
       <span class="hidden select-none opacity-50 sm:inline mx-1">/</span>
       <Tooltip
+        appearance={props.onboarding ? "large" : undefined}
         placement="top"
         openDelay={800}
         value={
           props.onboarding ? (
             <div class="flex flex-col gap-1 text-start">
               <div class="flex items-center gap-1.5 font-[530] text-v2-text-text-base">
-                <Icon name="workspace-isolated" size="small" class="shrink-0 text-v2-text-text-accent" />
+                <Icon name="outline-worktree" size="small" class="shrink-0 text-v2-text-text-accent" />
                 <span>{language.t("workspace.onboarding.title")}</span>
               </div>
               <span class="font-[440] text-v2-text-text-muted">{language.t("workspace.onboarding.description")}</span>
@@ -89,7 +94,10 @@ export function PromptWorkspaceSelector(props: {
             aria-description={language.t("session.new.workspace.trigger.tooltip")}
             class="flex h-6 min-w-0 max-w-[203px] items-center gap-1.5 rounded-sm px-1.5 hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed data-[expanded]:text-v2-text-text-muted"
           >
-            <Icon name={icon()} class="shrink-0 text-v2-icon-icon-muted" />
+            <Icon
+              name={icon()}
+              class={`shrink-0 ${selected() === "main" || selected() === "create" ? "text-v2-icon-icon-muted" : "text-v2-icon-icon-accent"}`}
+            />
             <span class="min-w-0 truncate">{label()}</span>
             <Show when={props.onboarding}>
               <span
@@ -109,14 +117,8 @@ export function PromptWorkspaceSelector(props: {
                   <Tooltip
                     placement="right"
                     openDelay={800}
-                    value={
-                      <span class="flex flex-col gap-0.5">
-                        <span>{language.t("session.new.workspace.local")}</span>
-                        <span class="font-[440] text-v2-text-text-muted">
-                          {language.t("session.new.workspace.local.tooltip")}
-                        </span>
-                      </span>
-                    }
+                    value={language.t("session.new.workspace.local.tooltip")}
+                    contentClass="max-w-[140px]"
                     class="min-w-0 flex-1"
                   >
                     <span class="min-w-0 truncate">{language.t("session.new.workspace.local")}</span>
@@ -126,24 +128,22 @@ export function PromptWorkspaceSelector(props: {
                   </Show>
                 </Menu.Item>
                 <Menu.Item onSelect={() => select("create")}>
-                  <Icon name="workspace-new" />
-                  <span class="min-w-0 flex-1 truncate">{language.t("workspace.new")}</span>
+                  <Icon name="plus" />
+                  <Tooltip
+                    placement="right"
+                    openDelay={800}
+                    value={language.t("session.new.workspace.new.tooltip")}
+                    contentClass="max-w-[140px]"
+                    class="min-w-0 flex-1"
+                  >
+                    <span class="min-w-0 truncate">{language.t("workspace.new")}</span>
+                  </Tooltip>
                   <Show when={selected() === "create"}>
                     <Icon name="check" size="small" class="shrink-0" />
                   </Show>
                 </Menu.Item>
               </Menu.Group>
-              <Show
-                when={props.workspaces.length > 0}
-                fallback={
-                  <>
-                    <Menu.Separator class="h-[0.5px]" />
-                    <Menu.Item onSelect={() => (pending = { type: "viewAll" })}>
-                      <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-                    </Menu.Item>
-                  </>
-                }
-              >
+              <Show when={props.workspaces.length > 0}>
                 <Menu.Separator class="h-[0.5px]" />
                 <Menu.Sub
                   gutter={0}
@@ -156,10 +156,11 @@ export function PromptWorkspaceSelector(props: {
                     }
                     if (!focusSearch || props.workspaces.length < 10) return
                     focusSearch = false
-                    requestAnimationFrame(() => searchInput?.focus())
+                    focusWorktreeSearch()
                   }}
                 >
                   <Menu.SubTrigger
+                    onClick={focusWorktreeSearch}
                     onKeyDown={(event) => {
                       if (
                         event.key === "ArrowRight" ||
@@ -170,7 +171,7 @@ export function PromptWorkspaceSelector(props: {
                         focusSearch = true
                     }}
                   >
-                    <Icon name="workspace-isolated" />
+                    <Icon name="outline-worktree" />
                     <span class="min-w-0 flex-1 truncate">
                       {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
                     </span>
@@ -205,7 +206,7 @@ export function PromptWorkspaceSelector(props: {
                       <For each={workspaces()}>
                         {(workspace) => (
                           <Menu.Item onSelect={() => select(workspace)}>
-                            <Icon name="workspace-isolated" />
+                            <Icon name="outline-worktree" />
                             <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
                             <Show when={selected() === workspace}>
                               <Icon name="check" size="small" class="shrink-0" />
@@ -213,6 +214,11 @@ export function PromptWorkspaceSelector(props: {
                           </Menu.Item>
                         )}
                       </For>
+                      <Show when={search.workspaces.trim() && workspaces().length === 0}>
+                        <div class="px-3 py-4 text-center text-[13px] font-[440] leading-5 text-v2-text-text-muted">
+                          {language.t("session.new.workspace.search.empty")}
+                        </div>
+                      </Show>
                       <Menu.Separator class="h-[0.5px]" />
                       <Menu.Item onSelect={() => (pending = { type: "viewAll" })}>
                         <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
@@ -232,6 +238,7 @@ export function PromptWorkspaceSelector(props: {
         <Tooltip
           placement="top"
           value={language.t("session.new.workspace.fromBranch", { branch: props.branch! })}
+          disabled={!branchTruncation.truncated()}
           class="ms-1 min-w-0 max-w-[220px]"
           contentClass="max-w-[calc(100vw-32px)] break-all"
         >
@@ -245,7 +252,7 @@ export function PromptWorkspaceSelector(props: {
           >
             <Menu.Trigger class="flex h-6 min-w-0 max-w-[220px] items-center gap-1.5 rounded-full bg-v2-background-bg-layer-02 px-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint transition-colors hover:bg-v2-background-bg-layer-03 hover:text-v2-text-text-muted focus-visible:bg-v2-background-bg-layer-03 focus-visible:text-v2-text-text-muted focus-visible:outline-none data-[expanded]:bg-v2-background-bg-layer-03 data-[expanded]:text-v2-text-text-muted">
               <Icon name="branch-out" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-              <span class="min-w-0 truncate">
+              <span ref={branchTruncation.observe} class="min-w-0 truncate">
                 {language.t("session.new.workspace.fromBranch", { branch: props.branch! })}
               </span>
               <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
@@ -319,6 +326,7 @@ export function PromptWorkspaceSelector(props: {
 
 export function PromptGitStatus(props: { branch?: string; noGit?: boolean; from?: boolean; class?: string }) {
   const language = useLanguage()
+  const truncation = createTruncatedText()
   const label = () => {
     if (props.noGit) return language.t("session.new.git.none")
     if (!props.branch) return undefined
@@ -338,15 +346,27 @@ export function PromptGitStatus(props: { branch?: string; noGit?: boolean; from?
         <Tooltip
           placement="top"
           value={value()}
+          disabled={!truncation.truncated()}
           class={`min-w-0 max-w-[220px] ${props.class ?? ""}`}
           contentClass="max-w-[calc(100vw-32px)] break-all"
         >
           <div class="flex h-6 min-w-0 max-w-[220px] items-center gap-1.5 rounded-full bg-v2-background-bg-layer-02 px-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-faint">
             <Icon name={icon()} size="small" class="shrink-0 text-v2-icon-icon-muted" />
-            <span class="min-w-0 truncate">{value()}</span>
+            <span ref={truncation.observe} class="min-w-0 truncate">
+              {value()}
+            </span>
           </div>
         </Tooltip>
       )}
     </Show>
   )
 }
+
+function createTruncatedText() {
+  const [truncated, setTruncated] = createSignal(false)
+  return {
+    truncated,
+    observe: (element: HTMLSpanElement) =>
+      createResizeObserver(element, () => setTruncated(element.scrollWidth > element.clientWidth)),
+  }
+}

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/i18n/en.ts

@@ -659,6 +659,7 @@ export const dict = {
   "home.sessions.group.yesterday": "Yesterday",
   "home.sessions.group.older": "Older",
   "home.providerTip": "Connect to 75+ providers to use other models, including Claude, GPT, Gemini, etc",
+  "home.workspaceTip": "Start next session in a new workspace to keep changes isolated",
 
   "session.tab.session": "Session",
   "session.tab.files": "Files",
@@ -1238,30 +1239,43 @@ export const dict = {
 
   "workspace.new": "New worktree",
   "common.viewAll": "View all",
-  "session.new.workspace.local.tooltip": "Use current checkout",
-  "session.new.workspace.new.tooltip": "Create isolated checkout",
+  "session.new.workspace.local.tooltip": "Uses project’s current checkout",
+  "session.new.workspace.new.tooltip": "Creates isolated copy from current checkout",
   "session.new.workspace.fromBranch": "from {{branch}}",
   "session.new.workspace.createFrom": "Create from branch",
   "session.new.workspace.branch.search.placeholder": "Search branches",
   "session.new.workspace.trigger.tooltip": "Select where to run session",
   "session.new.workspace.search.placeholder": "Search worktrees",
+  "session.new.workspace.search.empty": "No matching worktrees",
   "settings.tab.workspaces": "Worktrees",
+  "settings.workspaces.description": "Review worktrees and manage disk usage",
   "settings.workspaces.filter.all": "All projects",
-  "settings.workspaces.empty": "No worktrees",
+  "settings.workspaces.empty": "No worktrees yet",
+  "settings.workspaces.empty.description": "Worktrees created in OpenCode will appear here",
   "settings.workspaces.count.one": "{{count}} worktree",
   "settings.workspaces.count.other": "{{count}} worktrees",
   "settings.workspaces.sessions.one": "{{count}} session in {{project}}",
   "settings.workspaces.sessions.other": "{{count}} sessions in {{project}}",
+  "settings.workspaces.sessions.filtered.one": "{{count}} session",
+  "settings.workspaces.sessions.filtered.other": "{{count}} sessions",
   "settings.workspaces.lastActiveSession": "Last active session",
   "settings.workspaces.deleteAll": "Delete all worktrees",
-  "settings.workspaces.deleteAll.confirm": "Delete all {{count}} worktrees?",
-  "settings.workspaces.delete.warning":
-    "The worktree directory and branch will be permanently removed, including any unmerged changes shown below.",
+  "settings.workspaces.deleteAll.confirm.one": "This will permanently delete {{count}} selected worktree.",
+  "settings.workspaces.deleteAll.confirm.other": "This will permanently delete {{count}} selected worktrees.",
+  "settings.workspaces.deleteWithoutSessions": "Delete worktrees without sessions",
+  "settings.workspaces.deleteWithoutSessions.confirm.one":
+    "This will permanently delete {{count}} worktree without linked sessions.",
+  "settings.workspaces.deleteWithoutSessions.confirm.other":
+    "This will permanently delete {{count}} worktrees without linked sessions.",
+  "settings.workspaces.deleteWithoutSessions.warning":
+    "Worktrees with unmerged changes or active locations will be kept.",
+  "settings.workspaces.delete.button": "Delete worktrees",
+  "settings.workspaces.delete.warning": "This permanently deletes the worktree and its branch.",
   "settings.workspaces.deleteAll.warning":
-    "The {{count}} selected worktrees in {{project}} will be permanently removed only if each is clean, inactive, and has no linked sessions.",
+    "Worktrees with unmerged changes, linked sessions, or active locations will be kept.",
   "settings.workspaces.delete.blocked.active": "The active worktree cannot be deleted.",
   "settings.workspaces.delete.blocked.linked":
-    "Linked sessions will remain, but their working directory will be permanently removed.",
+    "Linked sessions will remain, but their working directory will no longer exist.",
   "settings.workspaces.default.title": "Default environment",
   "settings.workspaces.default.description": "Choose where new sessions start",
   "settings.workspaces.default.lastUsed": "Last used per project",
@@ -1272,9 +1286,10 @@ export const dict = {
   "workspace.move.failed": "Failed to move session",
   "workspace.lifecycle.creating": "Creating worktree",
   "workspace.lifecycle.created": "Worktree created",
+  "workspace.lifecycle.deleting": "Deleting…",
   "workspace.lifecycle.starting": "Starting session",
   "workspace.onboarding.title": "Isolate sessions with worktrees",
-  "workspace.onboarding.description": "Each gets its own checkout, so nothing interferes with your local repository",
+  "workspace.onboarding.description": "Each gets its own checkout",
   "workspace.lifecycle.moving": "Moving to worktree",
   "workspace.lifecycle.set": "Worktree set",
   "session.summary.title": "Session details",
@@ -1293,9 +1308,10 @@ export const dict = {
   "workspace.status.checking": "Checking for unmerged changes…",
   "workspace.status.error": "Unable to verify git status.",
   "workspace.status.clean": "No unmerged changes detected.",
-  "workspace.status.dirty": "Unmerged changes detected in this worktree.",
+  "workspace.status.dirty": "Unmerged changes will be lost.",
   "workspace.delete.title": "Delete worktree",
-  "workspace.delete.confirm": 'Delete worktree "{{name}}"?',
+  "workspace.delete.confirm": "Delete “{{name}}”?",
+  "workspace.delete.location": "Location",
   "workspace.delete.button": "Delete worktree",
   "workspace.reset.title": "Reset worktree",
   "workspace.reset.confirm": 'Reset worktree "{{name}}"?',

packages/app/src/runtime/persistence/consumers.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Schema } from "effect"
-import { WorkspaceOnboardingSchema, ProviderTipSchema } from "@/new-session/view"
+import { WorkspaceOnboardingSchema, ProviderTipSchema, WorkspaceTipSchema } from "@/new-session/view"
 import { ModelSelectionSchema } from "@/providers/models/selection"
 import { Persistence } from "@/runtime/persistence/schema"
 import { FileViewsSchema } from "@/workspaces/files/view-cache"
@@ -12,6 +12,7 @@ describe("persisted consumer schemas", () => {
   test("onboarding and provider tip retain defaults and validate stored values", () => {
     const onboarding = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceOnboardingSchema, { used: false }))
     const tip = Schema.decodeUnknownSync(Persistence.withInitial(ProviderTipSchema, { dismissedAt: 0 }))
+    const workspaceTip = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }))
     expect(onboarding({})).toEqual({ used: false })
     expect(onboarding({ used: "true" })).toEqual({ used: false })
     expect(onboarding({ used: true })).toEqual({ used: true })
@@ -19,6 +20,7 @@ describe("persisted consumer schemas", () => {
     expect(tip({ dismissedAt: "yesterday" })).toEqual({ dismissedAt: 0 })
     expect(tip({ dismissedAt: Infinity })).toEqual({ dismissedAt: 0 })
     expect(tip({ dismissedAt: 123 })).toEqual({ dismissedAt: 123 })
+    expect(workspaceTip({ dismissedAt: 123 })).toEqual({ dismissedAt: 123 })
   })
 
   test("collapse records recover malformed entries without losing valid siblings", () => {

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

@@ -7,6 +7,9 @@ import { ServerScope } from "@/runtime/server/scope"
 import type { ServerApi } from "@/runtime/server/api"
 import type { ServerSync } from "@/runtime/server/sync"
 
+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({
     baseUrl: "http://opencode.local",
@@ -76,32 +79,26 @@ describe("query keys", () => {
     expect(result).toMatchObject({ directory: "/repo/subpath", worktree: "/repo" })
   })
 
-  test("loads each project's inventory through its own location using the real client", async () => {
+  test("loads projects from the current endpoint", async () => {
     const calls: 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)
-          if (url.pathname === "/api/project")
-            return Response.json([
-              { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
-              { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
-            ])
-          const directory = url.searchParams.get("location[directory]")
-          if (url.pathname !== "/api/worktree" || !directory) throw new Error(`Unexpected request: ${url}`)
-          calls.push(directory)
-          return Response.json([
-            { directory },
-            { directory: `${directory}/clone` },
-            { directory: `${directory}/copy`, strategy: "git" },
-          ])
-        },
-        { preconnect() {} },
-      ),
-    })
+    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, api.worktree))
+    const result = await new QueryClient().fetchQuery(loadProjectsQuery(ServerScope.local, projects, worktrees))
 
     expect(result.map((project) => project.id)).toEqual(["a", "b"])
     expect(result.map((project) => project.sandboxes)).toEqual([
@@ -112,30 +109,24 @@ describe("query keys", () => {
       [{ 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"])
+    expect(calls.toSorted()).toEqual(["a", "b"])
   })
 
   test("keeps projects whose directory inventory cannot load", async () => {
-    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)
-          if (url.pathname === "/api/project")
-            return Response.json([
-              { id: "a", canonical: "/a", time: { created: 1, updated: 1 }, sandboxes: [] },
-              { id: "b", canonical: "/b", time: { created: 1, updated: 1 }, sandboxes: [] },
-            ])
-          const directory = url.searchParams.get("location[directory]")
-          if (url.pathname !== "/api/worktree" || !directory) throw new Error(`Unexpected request: ${url}`)
-          if (directory === "/b") return Response.json({ message: "unavailable" }, { status: 503 })
-          return Response.json([{ directory: "/a/copy", strategy: "git" }])
-        },
-        { preconnect() {} },
-      ),
-    })
+    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, api.project, api.worktree))
+    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"] },

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

@@ -79,7 +79,7 @@ export const loadProjectsQuery = (scope: ServerScope, projects: ProjectApi, work
                 .filter((project) => !!project?.id)
                 .map(async (project) => {
                   const directories = await worktrees
-                    .list({ location: { directory: project.canonical } })
+                    .list({ projectID: project.id })
                     .catch(() => [
                       { directory: project.canonical },
                       ...(project.sandboxes ?? [])

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/session-identity-header.tsx

@@ -91,7 +91,7 @@ export function SessionProjectMenu(props: {
               when={props.showProjectIcon}
               fallback={
                 <span class={props.workspace ? "text-v2-icon-icon-accent" : "text-v2-icon-icon-muted"}>
-                  <Icon name={props.workspace ? "workspace-isolated" : "monitor"} />
+                  <Icon name={props.workspace ? "outline-worktree" : "monitor"} />
                 </span>
               }
             >

packages/app/src/session/timeline/message-timeline.tsx

@@ -185,7 +185,7 @@ function WorkspaceMoveAction(props: {
             : "flex h-[46px] w-full items-center gap-2 rounded-b-[6px] px-3 pe-9 pt-2.5 text-[13px] font-[440] leading-5 tracking-[-0.04px] text-v2-text-text-muted focus-visible:outline-none"
         }
       >
-        <Icon name="workspace-new" class="shrink-0 text-v2-icon-icon-muted" />
+        <Icon name="outline-worktree" class="shrink-0 text-v2-icon-icon-muted" />
         <span class="min-w-0 truncate">{language.t("workspace.move.title")}</span>
       </SessionWorkspaceMenu>
       <button
@@ -257,7 +257,10 @@ export function SessionSummaryPanel(props: {
           gutter={props.mobile ? 4 : -22}
           class={`${row} hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed`}
         >
-          <Icon name={props.local ? "monitor" : "workspace-isolated"} class="shrink-0 text-v2-icon-icon-muted" />
+          <Icon
+            name={props.local ? "monitor" : "outline-worktree"}
+            class={`shrink-0 ${props.local ? "text-v2-icon-icon-muted" : "text-v2-icon-icon-accent"}`}
+          />
           <span dir="auto" class="min-w-0 flex-1 truncate text-start">
             {location()}
           </span>

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

@@ -7,7 +7,6 @@ import type { Project } from "@/runtime/server/types"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useServerSDK } from "@/runtime/server/client"
 import { useData } from "@/runtime/server/current"
-import { useSettingsDialog } from "@/settings/command"
 import { pathKey } from "@/workspaces/path-key"
 import { showToast } from "@/shell/notifications/toast"
 import { containsDirectory, sameDirectory, workspaceDirectories } from "@/workspaces/paths"
@@ -28,7 +27,6 @@ export function SessionWorkspaceMenu(props: {
   const language = useLanguage()
   const serverSDK = useServerSDK()
   const data = useData()
-  const openWorkspaces = useSettingsDialog("workspaces")
   const [store, setStore] = createStore({ selected: undefined as string | undefined })
   const [directories, setDirectories] = createSignal(workspaceDirectories(props.project))
   const blocked = () => props.eligible === false || data.session.status(props.sessionID) === "running"
@@ -40,7 +38,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)),
@@ -99,13 +98,13 @@ export function SessionWorkspaceMenu(props: {
               </Menu.Item>
             </Show>
             <Menu.Item disabled={!!store.selected || blocked()} onSelect={() => void move("create")}>
-              <Icon name="workspace-new" />
+              <Icon name="plus" />
               {language.t("workspace.new")}
             </Menu.Item>
             <Show when={workspaces().length > 0}>
               <Menu.Sub gutter={0} overlap overflowPadding={8}>
                 <Menu.SubTrigger>
-                  <Icon name="workspace-isolated" />
+                  <Icon name="outline-worktree" />
                   {language.t("session.new.workspace.existing").replace(/(…|\.{3})$/, "")}
                 </Menu.SubTrigger>
                 <Menu.Portal>
@@ -113,7 +112,7 @@ export function SessionWorkspaceMenu(props: {
                     <For each={workspaces()}>
                       {(workspace) => (
                         <Menu.Item disabled={!!store.selected || blocked()} onSelect={() => void move(workspace)}>
-                          <Icon name="workspace-isolated" />
+                          <Icon name="outline-worktree" />
                           <span class="min-w-0 flex-1 truncate">{getFilename(workspace)}</span>
                         </Menu.Item>
                       )}
@@ -123,10 +122,6 @@ export function SessionWorkspaceMenu(props: {
               </Menu.Sub>
             </Show>
           </Menu.Group>
-          <Menu.Separator class="h-[0.5px] bg-v2-border-border-base" />
-          <Menu.Item onSelect={() => openWorkspaces()}>
-            <span class="min-w-0 flex-1 truncate">{language.t("common.viewAll")}</span>
-          </Menu.Item>
         </Menu.Content>
       </Menu.Portal>
     </Menu>

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/settings.css

@@ -1029,25 +1029,92 @@
   display: flex;
   flex-direction: column;
   gap: 0;
-  padding: 20px;
-  border-radius: 6px;
-  background-color: var(--v2-background-bg-base);
+  padding: 16px;
+  border-radius: 8px;
+  background-color: var(--v2-background-bg-layer-01);
   box-shadow: inset 0 0 0 0.5px var(--v2-border-border-base);
 }
 
+.settings-workspaces-inventory[data-empty="true"] [data-component="settings-list"] {
+  padding: 0;
+  background-color: transparent;
+  box-shadow: none;
+}
+
+.settings-workspaces-row-motion {
+  display: grid;
+  grid-template-rows: minmax(0, 1fr);
+  opacity: 1;
+  transition:
+    grid-template-rows 150ms ease-out,
+    opacity 120ms ease-out;
+}
+
+.settings-workspaces-row-motion[data-removing="true"] {
+  grid-template-rows: minmax(0, 0fr);
+  opacity: 0;
+}
+
 .settings-workspaces-row {
   display: flex;
   min-width: 0;
+  min-height: 0;
   flex-direction: column;
   gap: 12px;
+  overflow: hidden;
+  transition:
+    padding-bottom 150ms ease-out,
+    margin-bottom 150ms ease-out,
+    border-color 120ms ease-out;
 }
 
-.settings-workspaces-row:not(:last-child) {
+.settings-workspaces-row-motion:not(:last-child) > .settings-workspaces-row {
   padding-bottom: 20px;
   margin-bottom: 20px;
   border-bottom: 0.5px solid var(--v2-border-border-base);
 }
 
+.settings-workspaces-row-motion:has(+ .settings-workspaces-row-motion[data-removing="true"]:last-child)
+  > .settings-workspaces-row {
+  padding-bottom: 0;
+  margin-bottom: 0;
+  border-color: transparent;
+}
+
+.settings-workspaces-empty-motion {
+  display: grid;
+  min-height: 0;
+  grid-template-rows: minmax(0, 0fr);
+  opacity: 0;
+  overflow: hidden;
+  pointer-events: none;
+  transition:
+    grid-template-rows 150ms ease-out,
+    opacity 120ms ease-out;
+}
+
+.settings-workspaces-empty-motion[data-visible="true"] {
+  grid-template-rows: minmax(0, 1fr);
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.settings-workspaces-empty-motion > .settings-workspaces-empty {
+  min-height: 0;
+  overflow: hidden;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .settings-workspaces-row-motion {
+    transition: none;
+  }
+
+  .settings-workspaces-row,
+  .settings-workspaces-empty-motion {
+    transition: none;
+  }
+}
+
 .settings-workspaces-row-header {
   display: flex;
   min-width: 0;
@@ -1088,7 +1155,7 @@
   color: var(--v2-text-text-base);
   font-family: inherit;
   font-size: 13px;
-  font-weight: 530;
+  font-weight: 440;
   line-height: var(--line-height-compact);
   letter-spacing: -0.04px;
   text-overflow: ellipsis;
@@ -1098,6 +1165,11 @@
   cursor: default;
 }
 
+.settings-workspaces-path-name {
+  color: var(--v2-text-text-base);
+  font-weight: 530;
+}
+
 .settings-workspaces-meta {
   font-size: 13px;
   font-weight: 440;
@@ -1105,6 +1177,10 @@
   color: var(--v2-text-text-faint);
 }
 
+.settings-workspaces-meta-project {
+  color: var(--v2-text-text-muted);
+}
+
 .settings-workspaces-active,
 .settings-workspaces-more {
   flex-shrink: 0;
@@ -1114,11 +1190,16 @@
   color: var(--v2-text-text-faint);
 }
 
+.settings-workspaces-active {
+  font-size: 13px;
+  line-height: var(--line-height-compact);
+}
+
 .settings-workspaces-sessions {
   display: flex;
   flex-direction: column;
   border: 0.5px solid var(--v2-border-border-base);
-  border-radius: 4px;
+  border-radius: 6px;
   background-color: var(--v2-background-bg-base);
   overflow: hidden;
 }
@@ -1129,7 +1210,8 @@
   align-items: center;
   justify-content: space-between;
   gap: 12px;
-  padding: 10px 12px;
+  padding-block: 10px;
+  padding-inline: 12px 16px;
   font-size: 13px;
   font-weight: 440;
   line-height: 16px;
@@ -1149,22 +1231,28 @@
 
 .settings-workspaces-session-time {
   flex-shrink: 0;
-  font-size: 11px;
-  line-height: 1;
-  color: var(--v2-text-text-muted);
+  font-size: 13px;
+  line-height: var(--line-height-compact);
+  color: var(--v2-text-text-faint);
 }
 
 .settings-workspaces-empty {
   display: flex;
-  align-items: center;
-  justify-content: center;
-  padding-block: 48px;
+  min-width: 0;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 4px;
   font-size: 13px;
   font-weight: 440;
   line-height: var(--line-height-compact);
   color: var(--v2-text-text-muted);
 }
 
+.settings-workspaces-empty-title {
+  color: var(--v2-text-text-base);
+  font-weight: 530;
+}
+
 @media (max-width: 639px) {
   .settings-workspaces-header {
     padding: 24px 20px 20px;

packages/app/src/settings/shell.tsx

@@ -1,4 +1,5 @@
 import { Component, createEffect, createMemo, For, Show, onMount, startTransition } from "solid-js"
+import { createStore } from "solid-js/store"
 import { Tabs } from "@opencode-ai/ui/tabs"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Menu } from "@opencode-ai/ui/menu"
@@ -35,7 +36,7 @@ const sections = [
   [
     { value: "servers", icon: "server", label: "status.popover.tab.servers" },
     { value: "projects", icon: "folder", label: "settings.tab.projects" },
-    { value: "workspaces", icon: "workspace-isolated", label: "settings.tab.workspaces" },
+    { value: "workspaces", icon: "outline-worktree", label: "settings.tab.workspaces" },
   ],
   [
     { value: "providers", icon: "providers", label: "settings.providers.title" },
@@ -54,6 +55,7 @@ export const SettingsScreen: Component = () => {
   const servers = useServers()
   const tabs = useTabs()
   const global = useGlobal()
+  const [state, setState] = createStore({ worktreeFilterReset: 0 })
   let root: HTMLDivElement | undefined
 
   onMount(() => {
@@ -146,7 +148,14 @@ export const SettingsScreen: Component = () => {
                         </Show>
                         <For each={group}>
                           {(section) => (
-                            <Menu.RadioItem value={section.value} closeOnSelect>
+                            <Menu.RadioItem
+                              value={section.value}
+                              closeOnSelect
+                              onSelect={() => {
+                                if (section.value === "workspaces")
+                                  setState("worktreeFilterReset", (value) => value + 1)
+                              }}
+                            >
                               <Icon name={section.icon} />
                               {language.t(section.label)}
                             </Menu.RadioItem>
@@ -172,7 +181,12 @@ export const SettingsScreen: Component = () => {
                   <div class="flex flex-col gap-1 w-full">
                     <For each={group}>
                       {(section) => (
-                        <Tabs.Trigger value={section.value}>
+                        <Tabs.Trigger
+                          value={section.value}
+                          onClick={() => {
+                            if (section.value === "workspaces") setState("worktreeFilterReset", (value) => value + 1)
+                          }}
+                        >
                           <Icon name={section.icon} />
                           {language.t(section.label)}
                         </Tabs.Trigger>
@@ -208,7 +222,10 @@ export const SettingsScreen: Component = () => {
         </Tabs.Content>
         <SettingsServerScope directory={directory()}>
           <Tabs.Content value="workspaces" class="settings-panel">
-            <SettingsWorkspaces activeDirectory={directory()} />
+            <SettingsWorkspaces
+              activeDirectory={directory()}
+              resetProjectFilter={() => state.worktreeFilterReset}
+            />
           </Tabs.Content>
           <Tabs.Content value="providers" class="settings-panel">
             <SettingsProviders directory={directory()} onBack={showProviders} />

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

@@ -1,6 +1,8 @@
 import type { Component } from "solid-js"
-import { For, Show, createMemo } from "solid-js"
+import { For, Show, createEffect, createMemo, createSignal } from "solid-js"
 import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { Key } from "@solid-primitives/keyed"
 import type { SessionInfo } from "@opencode-ai/client/promise"
 import { useQuery } from "@tanstack/solid-query"
 import { Button } from "@opencode-ai/ui/button"
@@ -46,7 +48,7 @@ type Workspace = {
   project: Project
 }
 
-export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (props) => {
+export const SettingsWorkspaces: Component<{ activeDirectory?: string; resetProjectFilter: () => number }> = (props) => {
   const dialog = useDialog()
   const language = useLanguage()
   const serverSDK = useServerSDK()
@@ -56,6 +58,12 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
   const [store, setStore] = createStore({
     project: "all",
     transaction: undefined as "confirm" | "running" | undefined,
+    deleting: [] as string[],
+    removing: [] as string[],
+  })
+  createEffect(() => {
+    props.resetProjectFilter()
+    setStore("project", "all")
   })
 
   const projectQuery = useQuery(() => ({
@@ -65,7 +73,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 })
         }),
@@ -111,6 +119,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     ] as const,
     queryFn: () => loadSessions(workspaceDirectories()),
     enabled: serverSDK.connection.status() === "connected" && workspaceDirectories().length > 0,
+    placeholderData: (previous) => previous,
     refetchOnMount: "always",
   }))
   const sessionsByWorkspace = createMemo(() => {
@@ -123,14 +132,29 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     )
   })
   const workspaceSessions = (workspace: Workspace) => sessionsByWorkspace().get(pathKey(workspace.directory)) ?? []
+  const workspacesWithoutSessions = createMemo(() => {
+    if (sessionQuery.isPending || sessionQuery.isError) return []
+    return filtered().filter((workspace) => workspaceSessions(workspace).length === 0)
+  })
   const sessionCount = (workspace: Workspace) => {
     if (sessionQuery.isPending) return language.t("session.messages.loading")
     if (sessionQuery.isError) return language.t("common.requestFailed")
     const count = workspaceSessions(workspace).length
-    return language.plural("settings.workspaces.sessions", count, {
+    if (selectedProject() !== "all") return language.plural("settings.workspaces.sessions.filtered", count, { count })
+    const project = projectName(workspace.project)
+    const label = language.plural("settings.workspaces.sessions", count, {
       count,
-      project: projectName(workspace.project),
+      project,
     })
+    const start = label.lastIndexOf(project)
+    if (start < 0) return label
+    return (
+      <>
+        {label.slice(0, start)}
+        <span class="settings-workspaces-meta-project">{project}</span>
+        {label.slice(start + project.length)}
+      </>
+    )
   }
   const lastActive = (workspace: Workspace) => {
     const updated = workspaceSessions(workspace)[0]?.time.updated
@@ -158,54 +182,64 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
   }
   const inspectionMessages = (result: WorkspaceDeleteInspection) => {
     const messages = [
-      result.active ? language.t("settings.workspaces.delete.blocked.active") : undefined,
       result.linked ? language.t("settings.workspaces.delete.blocked.linked") : undefined,
       result.dirty ? language.t("workspace.status.dirty") : undefined,
     ].filter((message): message is string => message !== undefined)
-    return messages.length > 0 ? messages : [language.t("workspace.status.clean")]
+    return messages
   }
   const blocked = (result: WorkspaceDeleteInspection) => {
     showToast({
       variant: "error",
       title: language.t("workspace.delete.failed.title"),
-      description: inspectionMessages(result)[0],
+      description: result.active
+        ? language.t("settings.workspaces.delete.blocked.active")
+        : inspectionMessages(result)[0],
     })
   }
 
   const remove = async (workspace: Workspace, force = false, context = captureDeleteContext()) => {
-    const preflight = await inspect(workspace, context)
-    if (preflight.result.active || (!force && (preflight.result.linked || preflight.result.dirty))) {
-      blocked(preflight.result)
-      return
-    }
-    const removed = await context.sdk.api.worktree
-      .remove({
-        location: { directory: workspace.project.worktree },
-        directory: workspace.directory,
-        force,
-      })
-      .then(() => true)
-      .catch((error) => {
-        showToast({
-          variant: "error",
-          title: language.t("workspace.delete.failed.title"),
-          description: error instanceof Error ? error.message : language.t("common.requestFailed"),
+    const key = String(pathKey(workspace.directory))
+    setStore("deleting", (items) => [...items, key])
+    try {
+      const preflight = await inspect(workspace, context)
+      if (!force && (preflight.result.active || preflight.result.linked || preflight.result.dirty)) {
+        blocked(preflight.result)
+        return
+      }
+      const removed = await context.sdk.api.worktree
+        .remove({
+          projectID: workspace.project.id,
+          directory: workspace.directory,
+          force,
+        })
+        .then(() => true)
+        .catch((error) => {
+          showToast({
+            variant: "error",
+            title: language.t("workspace.delete.failed.title"),
+            description: error instanceof Error ? error.message : language.t("common.requestFailed"),
+          })
+          return false
+        })
+      if (!removed) return
+      setStore("removing", (items) => [...items, key])
+      await new Promise((resolve) => setTimeout(resolve, 150))
+      tabs.store.forEach((tab) => {
+        if (tab.type !== "draft" || tab.server !== context.server) return
+        const directoryMatches = containsDirectory(workspace.directory, tab.directory)
+        const worktreeMatches = tab.worktree && containsDirectory(workspace.directory, tab.worktree)
+        if (!directoryMatches && !worktreeMatches) return
+        tabs.updateDraft(tab.draftID, {
+          directory: directoryMatches ? workspace.project.worktree : tab.directory,
+          worktree: undefined,
         })
-        return false
       })
-    if (!removed) return
-    tabs.store.forEach((tab) => {
-      if (tab.type !== "draft" || tab.server !== context.server) return
-      const directoryMatches = containsDirectory(workspace.directory, tab.directory)
-      const worktreeMatches = tab.worktree && containsDirectory(workspace.directory, tab.worktree)
-      if (!directoryMatches && !worktreeMatches) return
-      tabs.updateDraft(tab.draftID, {
-        directory: directoryMatches ? workspace.project.worktree : tab.directory,
-        worktree: undefined,
-      })
-    })
-    clearWorkspaceTerminals(workspace.directory, platform, context.sdk.scope)
-    await projectQuery.refetch()
+      clearWorkspaceTerminals(workspace.directory, platform, context.sdk.scope)
+      await projectQuery.refetch()
+    } finally {
+      setStore("deleting", (items) => items.filter((item) => item !== key))
+      setStore("removing", (items) => items.filter((item) => item !== key))
+    }
   }
 
   let inspectionID = 0
@@ -253,13 +287,30 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     if (store.transaction) return
     const context = captureDeleteContext()
     const inventory = [...filtered()]
-    const project = projectOptions().find((option) => option.id === selectedProject())?.label ?? selectedProject()
     setStore("transaction", "confirm")
     void dialog.push(
       () => (
-        <DialogDeleteAllWorkspaces
-          count={inventory.length}
-          project={project}
+        <DialogDeleteWorkspaces
+          title={language.t("settings.workspaces.deleteAll")}
+          confirmation={language.plural("settings.workspaces.deleteAll.confirm", inventory.length)}
+          warning={language.t("settings.workspaces.deleteAll.warning")}
+          onDelete={() => transact(() => removeAll(inventory, context))}
+        />
+      ),
+      releaseConfirmation,
+    )
+  }
+  const confirmDeleteWithoutSessions = () => {
+    if (store.transaction || workspacesWithoutSessions().length === 0) return
+    const context = captureDeleteContext()
+    const inventory = [...workspacesWithoutSessions()]
+    setStore("transaction", "confirm")
+    void dialog.push(
+      () => (
+        <DialogDeleteWorkspaces
+          title={language.t("settings.workspaces.deleteWithoutSessions")}
+          confirmation={language.plural("settings.workspaces.deleteWithoutSessions.confirm", inventory.length)}
+          warning={language.t("settings.workspaces.deleteWithoutSessions.warning")}
           onDelete={() => transact(() => removeAll(inventory, context))}
         />
       ),
@@ -271,44 +322,47 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
     <>
       <div class="settings-tab-header settings-workspaces-header">
         <div class="settings-tab-header-row">
-          <h2 class="settings-tab-title">{language.t("settings.tab.workspaces")}</h2>
+          <div class="flex flex-col gap-1">
+            <h2 class="settings-tab-title">{language.t("settings.tab.workspaces")}</h2>
+            <span class="text-11-regular text-v2-text-text-muted">
+              {language.t("settings.workspaces.description")}
+            </span>
+          </div>
           <InlineServerSelect />
         </div>
       </div>
 
       <div class="settings-tab-body settings-workspaces">
-        <div class="settings-workspaces-toolbar">
-          <span class="settings-workspaces-count">
-            <Show when={!projectQuery.isPending && !projectQuery.isError}>
+        <Show when={filtered().length > 0}>
+          <div class="settings-workspaces-toolbar">
+            <span class="settings-workspaces-count">
               {language.plural("settings.workspaces.count", filtered().length)}
-            </Show>
-          </span>
-          <div class="settings-workspaces-toolbar-actions">
-            <Show when={projects().length > 1}>
-              <Menu placement="bottom-end" gutter={6}>
-                <Menu.Trigger class="flex h-6 max-w-48 items-center gap-1 rounded-sm px-2 text-13-medium hover:bg-v2-overlay-simple-overlay-hover focus-visible:bg-v2-overlay-simple-overlay-hover focus-visible:outline-none data-[expanded]:bg-v2-overlay-simple-overlay-pressed">
-                  <span class="min-w-0 truncate">
-                    {projectOptions().find((option) => option.id === selectedProject())?.label}
-                  </span>
-                  <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
-                </Menu.Trigger>
-                <Menu.Portal>
-                  <Menu.Content>
-                    <For each={projectOptions()}>
-                      {(option) => (
-                        <Menu.Item onSelect={() => setStore("project", option.id)}>
-                          <span class="min-w-0 flex-1 truncate">{option.label}</span>
-                          <Show when={selectedProject() === option.id}>
-                            <Icon name="check" size="small" class="shrink-0" />
-                          </Show>
-                        </Menu.Item>
-                      )}
-                    </For>
-                  </Menu.Content>
-                </Menu.Portal>
-              </Menu>
-            </Show>
-            <Show when={filtered().length > 0}>
+            </span>
+            <div class="settings-workspaces-toolbar-actions">
+              <Show when={projects().length > 1}>
+                <Menu placement="bottom-end" gutter={6}>
+                  <Menu.Trigger as={Button} size="small" variant="ghost-muted" class="max-w-48">
+                    <span class="min-w-0 truncate">
+                      {projectOptions().find((option) => option.id === selectedProject())?.label}
+                    </span>
+                    <Icon name="chevron-down" size="small" class="shrink-0 text-v2-icon-icon-muted" />
+                  </Menu.Trigger>
+                  <Menu.Portal>
+                    <Menu.Content>
+                      <For each={projectOptions()}>
+                        {(option) => (
+                          <Menu.Item onSelect={() => setStore("project", option.id)}>
+                            <span class="min-w-0 flex-1 truncate">{option.label}</span>
+                            <Show when={selectedProject() === option.id}>
+                              <Icon name="check" size="small" class="shrink-0" />
+                            </Show>
+                          </Menu.Item>
+                        )}
+                      </For>
+                    </Menu.Content>
+                  </Menu.Portal>
+                </Menu>
+              </Show>
               <Menu placement="bottom-end" gutter={4}>
                 <Menu.Trigger
                   as={IconButton}
@@ -321,78 +375,85 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                 />
                 <Menu.Portal>
                   <Menu.Content>
+                    <Show when={workspacesWithoutSessions().length > 0}>
+                      <Menu.Item onSelect={confirmDeleteWithoutSessions}>
+                        {language.t("settings.workspaces.deleteWithoutSessions")}
+                      </Menu.Item>
+                      <Menu.Separator />
+                    </Show>
                     <Menu.Item onSelect={confirmDeleteAll}>
                       <span class="settings-workspaces-delete-all">{language.t("settings.workspaces.deleteAll")}</span>
                     </Menu.Item>
                   </Menu.Content>
                 </Menu.Portal>
               </Menu>
-            </Show>
+            </div>
           </div>
-        </div>
+        </Show>
 
-        <div class="settings-workspaces-inventory">
-          <Show
-            when={filtered().length > 0}
-            fallback={
+        <div class="settings-workspaces-inventory" data-empty={filtered().length === 0}>
+          <SettingsList>
+            <div class="settings-workspaces-empty-motion" data-visible={filtered().length === 0}>
               <div class="settings-workspaces-empty">
-                {language.t(
-                  projectQuery.isPending
-                    ? "common.loading"
-                    : projectQuery.isError
-                      ? "common.requestFailed"
-                      : "settings.workspaces.empty",
-                )}
+                <Show
+                  when={!projectQuery.isPending && !projectQuery.isError}
+                  fallback={language.t(projectQuery.isPending ? "common.loading" : "common.requestFailed")}
+                >
+                  <span class="settings-workspaces-empty-title">{language.t("settings.workspaces.empty")}</span>
+                  <span>{language.t("settings.workspaces.empty.description")}</span>
+                </Show>
               </div>
-            }
-          >
-            <SettingsList>
-              <For each={filtered()}>
-                {(workspace) => {
-                  const linked = () => workspaceSessions(workspace)
-                  return (
+            </div>
+            <Key each={filtered()} by={(workspace) => `${workspace.project.id}:${pathKey(workspace.directory)}`}>
+              {(workspace) => {
+                const linked = () => workspaceSessions(workspace())
+                const key = () => String(pathKey(workspace().directory))
+                const deleting = () => store.deleting.includes(key())
+                return (
+                  <div class="settings-workspaces-row-motion" data-removing={store.removing.includes(key())}>
                     <div class="settings-workspaces-row">
                       <div class="settings-workspaces-row-header">
                         <div class="settings-workspaces-copy">
                           <div class="settings-workspaces-main">
-                            <Tooltip
-                              value={workspace.directory}
-                              placement="top-start"
-                              contentClass="max-w-[calc(100vw-32px)] break-all"
-                            >
-                              <span
-                                tabIndex={0}
-                                dir="ltr"
-                                aria-label={workspace.directory}
-                                class="settings-workspaces-path"
-                              >
-                                {workspace.directory}
-                              </span>
-                            </Tooltip>
+                            <WorkspacePath directory={workspace().directory} />
                           </div>
-                          <span class="settings-workspaces-meta">{sessionCount(workspace)}</span>
+                          <span class="settings-workspaces-meta">{sessionCount(workspace())}</span>
                         </div>
                         <div class="settings-workspaces-row-actions">
-                          <Show when={lastActive(workspace)}>
-                            {(value) => (
-                              <Tooltip value={language.t("settings.workspaces.lastActiveSession")} placement="top-end">
-                                <span tabIndex={0} class="settings-workspaces-active">
-                                  {value()}
-                                </span>
-                              </Tooltip>
-                            )}
+                          <Show
+                            when={deleting()}
+                            fallback={
+                              <>
+                                <Show when={lastActive(workspace())}>
+                                  {(value) => (
+                                    <Tooltip
+                                      value={language.t("settings.workspaces.lastActiveSession")}
+                                      placement="top-end"
+                                    >
+                                      <span tabIndex={0} class="settings-workspaces-active">
+                                        {value()}
+                                      </span>
+                                    </Tooltip>
+                                  )}
+                                </Show>
+                                <IconButton
+                                  type="button"
+                                  variant="ghost-muted"
+                                  size="small"
+                                  aria-label={language.t("workspace.delete.confirm", {
+                                    name: getFilename(workspace().directory),
+                                  })}
+                                  disabled={!!store.transaction}
+                                  icon={<Icon name="outline-trash" size="small" />}
+                                  onClick={() => confirmDelete(workspace())}
+                                />
+                              </>
+                            }
+                          >
+                            <span class="settings-workspaces-active">
+                              {language.t("workspace.lifecycle.deleting")}
+                            </span>
                           </Show>
-                          <IconButton
-                            type="button"
-                            variant="ghost-muted"
-                            size="small"
-                            aria-label={language.t("workspace.delete.confirm", {
-                              name: getFilename(workspace.directory),
-                            })}
-                            disabled={!!store.transaction}
-                            icon={<Icon name="trash" size="small" />}
-                            onClick={() => confirmDelete(workspace)}
-                          />
                         </div>
                       </div>
                       <Show when={linked().length > 0}>
@@ -401,7 +462,7 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                             {(session) => (
                               <div class="settings-workspaces-session">
                                 <span>{sessionLabel(session)}</span>
-                                <Show when={sessionTime(session)}>
+                                <Show when={linked().length > 1 ? sessionTime(session) : undefined}>
                                   {(time) => <span class="settings-workspaces-session-time">{time()}</span>}
                                 </Show>
                               </div>
@@ -410,18 +471,48 @@ export const SettingsWorkspaces: Component<{ activeDirectory?: string }> = (prop
                         </div>
                       </Show>
                     </div>
-                  )
-                }}
-              </For>
-            </SettingsList>
-          </Show>
+                  </div>
+                )
+              }}
+            </Key>
+          </SettingsList>
         </div>
       </div>
     </>
   )
 }
 
-function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDelete: () => Promise<void> }) {
+function WorkspacePath(props: { directory: string }) {
+  const [truncated, setTruncated] = createSignal(false)
+  const name = () => getFilename(props.directory)
+
+  return (
+    <Tooltip
+      value={props.directory}
+      placement="top-start"
+      disabled={!truncated()}
+      contentClass="max-w-[calc(100vw-32px)] break-all"
+    >
+      <span
+        ref={(element) => createResizeObserver(element, () => setTruncated(element.scrollWidth > element.clientWidth))}
+        tabIndex={truncated() ? 0 : undefined}
+        dir="ltr"
+        aria-label={props.directory}
+        class="settings-workspaces-path"
+      >
+        <span>{props.directory.slice(0, -name().length)}</span>
+        <span class="settings-workspaces-path-name">{name()}</span>
+      </span>
+    </Tooltip>
+  )
+}
+
+function DialogDeleteWorkspaces(props: {
+  title: string
+  confirmation: string
+  warning: string
+  onDelete: () => Promise<void>
+}) {
   const dialog = useDialog()
   const language = useLanguage()
   const remove = () => {
@@ -434,13 +525,12 @@ function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDe
     <Dialog fit>
       <DialogHeader>
         <DialogTitleGroup
-          title={language.t("settings.workspaces.deleteAll")}
+          title={props.title}
           description={
-            <>
-              {language.t("settings.workspaces.deleteAll.confirm", { count: props.count })}
-              <br />
-              {language.t("settings.workspaces.deleteAll.warning", { count: props.count, project: props.project })}
-            </>
+            <div class="flex flex-col gap-2">
+              <div>{props.confirmation}</div>
+              <div>{props.warning}</div>
+            </div>
           }
         />
       </DialogHeader>
@@ -449,7 +539,7 @@ function DialogDeleteAllWorkspaces(props: { count: number; project: string; onDe
           {language.t("common.cancel")}
         </Button>
         <Button type="button" variant="danger" onClick={remove}>
-          {language.t("settings.workspaces.deleteAll")}
+          {language.t("settings.workspaces.delete.button")}
         </Button>
       </DialogFooter>
     </Dialog>
@@ -472,7 +562,7 @@ function DialogDeleteWorkspace(props: {
     staleTime: 0,
   }))
   const descriptions = () => {
-    if (status.isPending) return [language.t("workspace.status.checking")]
+    if (status.isPending) return []
     if (status.isError) return [language.t("workspace.status.error")]
     if (!status.data) return []
     return props.inspectionMessages(status.data.result)
@@ -487,18 +577,20 @@ function DialogDeleteWorkspace(props: {
     <Dialog fit>
       <DialogHeader>
         <DialogTitleGroup
-          title={language.t("workspace.delete.title")}
+          title={language.t("workspace.delete.confirm", { name: getFilename(props.workspace.directory) })}
           description={
-            <>
-              {language.t("workspace.delete.confirm", { name: getFilename(props.workspace.directory) })}
-              <br />
-              <code class="max-w-full rounded-[4px] bg-[color-mix(in_oklch,var(--v2-text-text-base)_8%,transparent)] px-1 py-0.5 font-mono text-xs font-medium leading-4 text-v2-text-text-base break-all">
-                {props.workspace.directory}
-              </code>
-              <br />
-              {language.t("settings.workspaces.delete.warning")}
+            <div class="flex flex-col gap-2">
+              <div class="flex flex-col gap-1">
+                <span class="text-11-regular text-v2-text-text-faint">
+                  {language.t(status.isPending ? "workspace.status.checking" : "workspace.delete.location")}
+                </span>
+                <code class="block w-fit max-w-full rounded-[4px] bg-[color-mix(in_oklch,var(--v2-text-text-base)_8%,transparent)] px-1 py-0.5 font-mono text-xs font-medium leading-4 text-v2-text-text-base break-all">
+                  {props.workspace.directory}
+                </code>
+              </div>
+              <div>{language.t("settings.workspaces.delete.warning")}</div>
               <For each={descriptions()}>{(description) => <div>{description}</div>}</For>
-            </>
+            </div>
           }
         />
       </DialogHeader>
@@ -509,7 +601,7 @@ function DialogDeleteWorkspace(props: {
         <Button
           type="button"
           variant="danger"
-          disabled={status.isPending || status.isError || status.data?.result.active}
+          disabled={status.isPending || status.isError}
           onClick={remove}
         >
           {language.t("workspace.delete.button")}

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/cli/src/commands/handlers/default.ts

@@ -4,7 +4,7 @@ import { run } from "@opencode-ai/tui"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 import { Config } from "../../config"
-import { Context, Effect, Fiber, FileSystem, Option, Queue } from "effect"
+import { Context, Effect, FileSystem, Option, Queue } from "effect"
 import { ServerConnection } from "../../services/server-connection"
 import { Updater } from "../../services/updater"
 import { UpdatePreflight } from "../../services/update-preflight"
@@ -47,7 +47,6 @@ export default Runtime.handler(Commands, (input) =>
       ),
     )
     const updater = yield* Updater.Service
-    const update = yield* updater.run().pipe(Effect.forkScoped)
     preflight.loading()
     const config = yield* Config.Service
     const npm = yield* Npm.Service
@@ -84,15 +83,11 @@ export default Runtime.handler(Commands, (input) =>
         update: (update) => runPromise(config.update(update)),
       },
       updater: {
-        remote: requestedServer !== undefined,
-        subscribe: (notify, signal) =>
+        monitor: (notify, signal) =>
           runPromise(
-            Fiber.join(update).pipe(
-              Effect.flatMap((result) => (result === undefined ? Effect.void : Effect.sync(() => notify(result)))),
-            ),
+            updater.monitor((version) => Effect.sync(() => notify(version))),
             { signal },
           ),
-        check: (signal) => runPromise(Fiber.join(update).pipe(Effect.flatMap(() => updater.check())), { signal }),
         apply: (version) => runPromise(updater.apply(version)),
       },
       packages: {

packages/cli/src/server-process.ts

@@ -13,7 +13,6 @@ import { HttpServer } from "effect/unstable/http"
 import { Env } from "./env"
 import { ServiceConfig } from "./services/service-config"
 import { ServiceRegistration } from "./services/service-registration"
-import { Updater } from "./services/updater"
 import { WebUi } from "./services/web-ui"
 
 export type Mode = "default" | "service" | "stdio"
@@ -164,21 +163,6 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
       const url = HttpServer.formatAddress(server.address)
       console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
       if (foreground && !environmentPassword) console.log(`server password ${password}`)
-      yield* Updater.Service.pipe(
-        Effect.flatMap((updater) =>
-          Updater.pollUpdates({
-            check: updater.run().pipe(
-              Effect.flatMap((result) => {
-                if (!result) return Effect.void
-                if (result.type === "available") return server.updateAvailable(result.version)
-                return server.updated(result.version)
-              }),
-            ),
-          }),
-        ),
-        Effect.provide(Updater.layer),
-        Effect.forkScoped,
-      )
       return yield* options.mode === "service"
         ? server.shutdown
         : options.mode === "stdio"

packages/cli/src/services/updater-action.ts

@@ -1,5 +1,5 @@
-export type Policy = "disable" | "notify" | "auto"
-export type Action = "none" | "notify" | "auto"
+export type Policy = "disable" | "notify"
+export type Action = "none" | "notify"
 
 const maximumComponent = "9007199254740991"
 const versionPattern =
@@ -10,7 +10,7 @@ export function action(current: string, latest: string, policy: Policy): Action
   const currentVersion = parseReleaseVersion(current)
   const latestVersion = parseReleaseVersion(latest)
   if (!currentVersion || !latestVersion || sameRelease(currentVersion, latestVersion)) return "none"
-  return policy
+  return "notify"
 }
 
 export function parseReleaseVersion(input: string) {

packages/cli/src/services/updater.test.ts

@@ -6,14 +6,14 @@ describe("updater", () => {
   test("reads update policy from JSONC", () => {
     expect(decodePolicy('{ // preference\n "update": "notify",\n}')).toBe("notify")
     expect(decodePolicy('{ "update": "disable" }')).toBe("disable")
-    expect(decodePolicy('{ "update": "auto" }')).toBe("auto")
+    expect(decodePolicy('{ "update": "auto" }')).toBe("notify")
     expect(decodePolicy('{ "update": "invalid" }')).toBeUndefined()
   })
 
   test("maps the v1 update policy", () => {
     expect(decodePolicy('{ "autoupdate": false }')).toBe("disable")
     expect(decodePolicy('{ "autoupdate": "notify" }')).toBe("notify")
-    expect(decodePolicy('{ "autoupdate": true }')).toBe("auto")
+    expect(decodePolicy('{ "autoupdate": true }')).toBe("notify")
   })
 
   test("reports every available release", () => {
@@ -23,11 +23,6 @@ describe("updater", () => {
     expect(action("1.2.3", "1.2.3", "notify")).toBe("none")
   })
 
-  test("automatically installs every available release when enabled", () => {
-    expect(action("1.2.3", "1.2.4", "auto")).toBe("auto")
-    expect(action("1.2.3", "1.2.3", "auto")).toBe("none")
-  })
-
   test("skips when updates are disabled", () => {
     expect(action("1.2.3", "1.2.4", "disable")).toBe("none")
   })

packages/cli/src/services/updater.ts

@@ -1,7 +1,7 @@
 import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
 import { OPENCODE_ARTIFACT, OPENCODE_CHANNEL, OPENCODE_LOCAL, OPENCODE_VERSION } from "../version"
-import { Context, Duration, Effect, FileSystem, Layer, Ref, Schedule } from "effect"
+import { Context, Duration, Effect, FileSystem, Layer, Schedule } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
@@ -9,28 +9,28 @@ import { action, parseReleaseVersion, type Policy } from "./updater-action"
 
 export const methods = ["curl", "npm", "pnpm", "bun", "yarn"] as const
 export type Method = (typeof methods)[number]
-export type RunResult = { readonly type: "available" | "installed"; readonly version: string }
-export type CheckResult = RunResult | { readonly type: "unavailable"; readonly message: string }
 
 export interface Interface {
-  readonly run: () => Effect.Effect<RunResult | undefined>
-  readonly check: () => Effect.Effect<CheckResult | undefined, Error>
+  readonly monitor: (notify: (version: string) => Effect.Effect<void>) => Effect.Effect<void>
   readonly apply: (version: string) => Effect.Effect<void, Error>
   readonly method: () => Effect.Effect<Method | undefined>
   readonly latest: () => Effect.Effect<string, Error>
   readonly upgrade: (method: Method, version: string) => Effect.Effect<void, Error>
 }
 
-export const pollUpdates = Effect.fnUntraced(function* (input: {
-  readonly check: Effect.Effect<unknown>
+export const monitorUpdates = Effect.fnUntraced(function* (input: {
+  readonly inspect: () => Effect.Effect<string | undefined, Error>
+  readonly notify: (version: string) => Effect.Effect<void>
   readonly initialDelay?: Duration.Input
   readonly interval?: Duration.Input
 }) {
   const interval = input.interval ?? "10 minutes"
-  return yield* input.check.pipe(
-    Effect.repeat(Schedule.spaced(interval)),
-    Effect.delay(input.initialDelay ?? "1 minute"),
-  )
+  const initialDelay = input.initialDelay ?? "90 seconds"
+  const check = Effect.gen(function* () {
+    const version = yield* input.inspect()
+    if (version !== undefined) yield* input.notify(version)
+  }).pipe(Effect.catch((error) => Effect.logWarning("update check failed", { error })))
+  return yield* check.pipe(Effect.repeat(Schedule.spaced(interval)), Effect.delay(initialDelay))
 })
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Updater") {}
@@ -43,20 +43,20 @@ export function decodePolicy(text: string): Policy | undefined {
   if (errors.length || typeof input !== "object" || input === null) return
   if ("update" in input) {
     const value = input.update
-    if (value === "disable" || value === "notify" || value === "auto") return value
+    if (value === "disable" || value === "notify") return value
+    if (value === "auto") return "notify"
     return
   }
   if (!("autoupdate" in input)) return
   if (input.autoupdate === false) return "disable"
   if (input.autoupdate === "notify") return "notify"
-  if (input.autoupdate === true) return "auto"
+  if (input.autoupdate === true) return "notify"
 }
 
 const make = Effect.gen(function* () {
   const fs = yield* FileSystem.FileSystem
   const global = yield* Global.Service
   const appProcess = yield* AppProcess.Service
-  const installedVersion = yield* Ref.make(OPENCODE_VERSION)
   const channel = OPENCODE_CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-")
   const installedPackage = yield* Effect.gen(function* () {
     const executable = yield* fs.realPath(process.execPath)
@@ -78,7 +78,7 @@ const make = Effect.gen(function* () {
     return values.findLast((value) => value !== undefined) ?? "notify"
   })
 
-  const exec = Effect.fnUntraced(function* (command: string[], timeout: Duration.Input = "10 seconds") {
+  const run = Effect.fnUntraced(function* (command: string[], timeout: Duration.Input = "10 seconds") {
     return yield* appProcess
       .run(ChildProcess.make(command[0], command.slice(1)), {
         timeout,
@@ -113,7 +113,7 @@ const make = Effect.gen(function* () {
     ]
     const results = yield* Effect.forEach(
       checks,
-      (check) => exec(check.command).pipe(Effect.map((result) => ({ check, result }))),
+      (check) => run(check.command).pipe(Effect.map((result) => ({ check, result }))),
       { concurrency: "unbounded" },
     )
     return results.find((result) => result.result.stdout.includes(installedPackage))?.check.method
@@ -121,12 +121,12 @@ const make = Effect.gen(function* () {
 
   const release = Effect.fnUntraced(function* () {
     const response = yield* Effect.tryPromise({
-      try: (signal) =>
+      try: () =>
         fetch(
           `https://update.opencode.ai/api/${encodeURIComponent(channel)}/${encodeURIComponent(OPENCODE_ARTIFACT)}/npm`,
           {
             headers: { "User-Agent": `opencode/${OPENCODE_VERSION}` },
-            signal: AbortSignal.any([signal, AbortSignal.timeout(10_000)]),
+            signal: AbortSignal.timeout(10_000),
           },
         ),
       catch: (cause) => new Error("Failed to check for updates", { cause }),
@@ -168,20 +168,17 @@ const make = Effect.gen(function* () {
           // Bun does not prune old versions from its shared package cache.
           yield* fs.makeDirectory(global.cache, { recursive: true })
           const cache = yield* fs.makeTempDirectoryScoped({ directory: global.cache, prefix: "update-" })
-          return yield* exec(["bun", "install", "--global", "--trust", "--cache-dir", cache, target], "5 minutes")
+          return yield* run(["bun", "install", "--global", "--trust", "--cache-dir", cache, target], "5 minutes")
         }
         if (method === "curl") {
           yield* fs.makeDirectory(global.cache, { recursive: true })
           const directory = yield* fs.makeTempDirectoryScoped({ directory: global.cache, prefix: "update-" })
           const installer = path.join(directory, "install")
-          const download = yield* exec(
-            ["curl", "-fsSL", "-o", installer, "https://opencode.ai/v2/install"],
-            "5 minutes",
-          )
+          const download = yield* run(["curl", "-fsSL", "-o", installer, "https://opencode.ai/v2/install"], "5 minutes")
           if (download.code !== 0) return download
-          return yield* exec(["bash", installer, "--version", version, "--no-modify-path"], "5 minutes")
+          return yield* run(["bash", installer, "--version", version, "--no-modify-path"], "5 minutes")
         }
-        return yield* exec(commands[method], "5 minutes")
+        return yield* run(commands[method], "5 minutes")
       }),
     ).pipe(Effect.mapError((cause) => new Error(`Failed to update with ${method}`, { cause })))
     if (result.code === 0) return
@@ -203,19 +200,18 @@ const make = Effect.gen(function* () {
       return undefined
     }
 
-    const current = yield* Ref.get(installedVersion)
     const version = yield* latest()
     yield* Effect.logInfo("update check", {
-      current,
+      current: OPENCODE_VERSION,
       latest: version,
     })
-    const next = action(current, version, policy)
+    const next = action(OPENCODE_VERSION, version, policy)
     if (next === "none") {
       yield* Effect.logInfo("update check done", { action: "up-to-date" })
       return undefined
     }
-    yield* Effect.logInfo("OpenCode update available", { current, latest: version, action: next })
-    return { policy, version }
+    yield* Effect.logInfo("OpenCode update available", { current: OPENCODE_VERSION, latest: version })
+    return version
   })
 
   const install = Effect.fnUntraced(function* (version: string) {
@@ -224,10 +220,8 @@ const make = Effect.gen(function* () {
       yield* Effect.logWarning("update skipped: installation method not found")
       return false
     }
-    const current = yield* Ref.get(installedVersion)
     yield* upgrade(detected, version)
-    yield* Ref.set(installedVersion, version)
-    yield* Effect.logInfo("updated OpenCode", { from: current, to: version, method: detected })
+    yield* Effect.logInfo("updated OpenCode", { from: OPENCODE_VERSION, to: version, method: detected })
     return true
   })
 
@@ -235,36 +229,9 @@ const make = Effect.gen(function* () {
     if (!(yield* install(version))) return yield* Effect.fail(new Error("Installation method not found"))
   })
 
-  const check = Effect.fn("cli.updater.check")(function* () {
-    if (OPENCODE_LOCAL)
-      return {
-        type: "unavailable" as const,
-        message: "This build runs from a source checkout. Use an installed OpenCode release to check for updates.",
-      }
-    const version = yield* latest()
-    if (!parseReleaseVersion(version)) return yield* Effect.fail(new Error(`Invalid version: ${version}`))
-    const current = yield* Ref.get(installedVersion)
-    if (action(current, version, "auto") === "none") {
-      // An earlier check may have installed the update while this client is still running.
-      return action(OPENCODE_VERSION, current, "auto") === "none"
-        ? undefined
-        : { type: "installed" as const, version: current }
-    }
-    return { type: "available" as const, version }
-  })
+  const monitor = (notify: (version: string) => Effect.Effect<void>) => monitorUpdates({ inspect, notify })
 
-  const run = Effect.fn("cli.updater.run")(
-    function* () {
-      const result = yield* inspect()
-      if (!result) return undefined
-      if (result.policy === "notify") return { type: "available" as const, version: result.version }
-      if (!(yield* install(result.version))) return yield* Effect.fail(new Error("Installation method not found"))
-      return { type: "installed" as const, version: result.version }
-    },
-    Effect.catch((error) => Effect.logWarning("update check failed", { error }).pipe(Effect.as(undefined))),
-  )
-
-  return Service.of({ run, check, apply, method, latest, upgrade })
+  return Service.of({ monitor, apply, method, latest, upgrade })
 })
 
 export const layer = Layer.effect(Service, make)

packages/cli/test/fixture/upgrade.ts

@@ -12,8 +12,7 @@ await Effect.runPromise(
     process.argv.slice(2),
   ).pipe(
     Effect.provideService(Updater.Service, {
-      run: () => Effect.die("Manual upgrades must not check for automatic updates"),
-      check: () => Effect.die("Manual upgrades must not check for TUI updates"),
+      monitor: () => Effect.die("Manual upgrades must not monitor automatic updates"),
       apply: () => Effect.die("Manual upgrades must not apply TUI updates"),
       method: () =>
         Effect.sync(() => {

packages/cli/test/updater-monitor.test.ts

@@ -0,0 +1,40 @@
+import { expect } from "bun:test"
+import { Effect, Layer, Queue } from "effect"
+import { TestClock } from "effect/testing"
+import { testEffect } from "../../core/test/lib/effect"
+import { Updater } from "../src/services/updater"
+
+const it = testEffect(Layer.empty)
+
+it.effect("checks after 90 seconds and every 10 minutes after that", () =>
+  Effect.gen(function* () {
+    const updates = yield* Queue.unbounded<string>()
+    yield* Updater.monitorUpdates({
+      inspect: () => Effect.succeed("2.0.0"),
+      notify: (version) => Queue.offer(updates, version).pipe(Effect.asVoid),
+    }).pipe(Effect.forkScoped)
+
+    yield* Effect.yieldNow
+    expect(yield* Queue.size(updates)).toBe(0)
+    yield* TestClock.adjust("89 seconds")
+    expect(yield* Queue.size(updates)).toBe(0)
+    yield* TestClock.adjust("1 second")
+    expect(yield* Queue.take(updates)).toBe("2.0.0")
+    yield* Effect.yieldNow
+    yield* TestClock.adjust("10 minutes")
+    expect(yield* Queue.take(updates)).toBe("2.0.0")
+  }),
+)
+
+it.effect("does not notify when no update is available", () =>
+  Effect.gen(function* () {
+    const updates = yield* Queue.unbounded<string>()
+    yield* Updater.monitorUpdates({
+      inspect: () => Effect.succeed(undefined),
+      notify: (version) => Queue.offer(updates, version).pipe(Effect.asVoid),
+    }).pipe(Effect.forkScoped)
+
+    yield* Effect.yieldNow
+    expect(yield* Queue.size(updates)).toBe(0)
+  }),
+)

packages/cli/test/updater-poll.test.ts

@@ -1,24 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Layer, Queue } from "effect"
-import { TestClock } from "effect/testing"
-import { testEffect } from "../../core/test/lib/effect"
-import { Updater } from "../src/services/updater"
-
-const it = testEffect(Layer.empty)
-
-it.effect("polls after 1 minute and every 10 minutes after that", () =>
-  Effect.gen(function* () {
-    const checks = yield* Queue.unbounded<void>()
-    yield* Updater.pollUpdates({ check: Queue.offer(checks, undefined).pipe(Effect.asVoid) }).pipe(Effect.forkScoped)
-
-    yield* Effect.yieldNow
-    expect(yield* Queue.size(checks)).toBe(0)
-    yield* TestClock.adjust("59 seconds")
-    expect(yield* Queue.size(checks)).toBe(0)
-    yield* TestClock.adjust("1 second")
-    yield* Queue.take(checks)
-    yield* Effect.yieldNow
-    yield* TestClock.adjust("10 minutes")
-    yield* Queue.take(checks)
-  }),
-)

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 }
@@ -1894,7 +1892,7 @@ export type ConfigEntry =
         shell?: string
         model?: string | { providerID: string; model: string; variant?: string }
         default_agent?: string
-        update?: "disable" | "notify" | "auto"
+        update?: "disable" | "notify"
         share?: "manual" | "auto" | "disabled"
         enterprise?: { url?: string }
         username?: 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/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

@@ -74,7 +74,9 @@ export function normalize(input: unknown): Result {
     ? decodeValue(ConfigV1.Info.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics)
     : undefined
   const nativeUpdate = own(input, "update")
-    ? decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics)
+    ? input.update === "auto"
+      ? "notify"
+      : decodeEncoded(Info.fields.update, input.update, ["update"], diagnostics)
     : undefined
   const legacyShare = own(input, "autoshare")
     ? decodeValue(Schema.Boolean, input.autoshare, ["autoshare"], diagnostics) === true
@@ -209,7 +211,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/session/inbox.ts

@@ -409,17 +409,19 @@ export const nextPromotable = Effect.fn("SessionInbox.nextPromotable")(function*
   sessionID: SessionSchema.ID,
   promotable: Promotable,
 ) {
-  const steer = (yield* pendingSteers(db, sessionID))[0]
+  const next = (delivery: Delivery) =>
+    db
+      .select()
+      .from(SessionInboxTable)
+      .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, delivery)))
+      .orderBy(asc(SessionInboxTable.enqueued_seq))
+      .limit(1)
+      .get()
+      .pipe(Effect.orDie)
+  const steer = yield* next("steer")
   if (steer) return fromRow(steer)
   if (promotable !== "input") return undefined
-  const queued = yield* db
-    .select()
-    .from(SessionInboxTable)
-    .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "queue")))
-    .orderBy(asc(SessionInboxTable.enqueued_seq))
-    .limit(1)
-    .get()
-    .pipe(Effect.orDie)
+  const queued = yield* next("queue")
   return queued ? fromRow(queued) : undefined
 })
 
@@ -488,10 +490,9 @@ const publish = Effect.fn("SessionInbox.publish")(function* (
 })
 
 /**
- * Promotes pending input into visible messages and returns the promoted count,
- * or undefined when the runner must first handle a pending control.
- * Steered compaction takes priority over pending prompts, without crossing a move.
- * Only the "input" scope may fall through to one queued input.
+ * Promotes pending input into visible messages and returns the promoted count.
+ * Steers always go first; only the "input" scope may fall through to one queued
+ * input, and it then collects steers that arrived during promotion.
  */
 export const promote = Effect.fn("SessionInbox.promote")(function* (
   db: DatabaseService,
@@ -505,7 +506,6 @@ export const promote = Effect.fn("SessionInbox.promote")(function* (
       const steers = yield* pendingSteers(db, sessionID)
       if (steers.length > 0 || scope === "steer") {
         const control = steers.findIndex((row) => row.type === "compaction" || row.type === "move")
-        if (control === 0) return undefined
         return yield* publish(db, bus, sessionID, control === -1 ? steers : steers.slice(0, control))
       }
 
@@ -518,7 +518,6 @@ export const promote = Effect.fn("SessionInbox.promote")(function* (
         .get()
         .pipe(Effect.orDie)
       if (!queued) return 0
-      if (queued.type === "compaction" || queued.type === "move") return undefined
       const promoted = yield* publish(db, bus, sessionID, [queued])
       const arrivedSteers = yield* pendingSteers(db, sessionID)
       const control = arrivedSteers.findIndex((row) => row.type === "compaction" || row.type === "move")
@@ -537,14 +536,4 @@ const pendingSteers = (db: DatabaseService, sessionID: SessionSchema.ID) =>
     .where(and(eq(SessionInboxTable.session_id, sessionID), eq(SessionInboxTable.delivery, "steer")))
     .orderBy(asc(SessionInboxTable.enqueued_seq))
     .all()
-    .pipe(
-      Effect.orDie,
-      Effect.map((rows) => {
-        // A move changes the context's Location: never pull compaction across it.
-        // Within that boundary, compact before promoting even earlier steers so
-        // their text stays verbatim after the checkpoint, not inside its summary.
-        const control = rows.findIndex((row) => row.type === "compaction" || row.type === "move")
-        if (control > 0 && rows[control].type === "compaction") rows.unshift(...rows.splice(control, 1))
-        return rows
-      }),
-    )
+    .pipe(Effect.orDie)

packages/core/src/session/runner/llm.ts

@@ -147,7 +147,7 @@ const layer = Layer.effect(
               }
               if (!force && !continuing && (!pending || (pending.delivery === "queue" && promotable === "steer")))
                 return DrainResult.Complete()
-              const ready = yield* restore(
+              return yield* restore(
                 Effect.gen(function* () {
                   const selected = yield* prepareContext(sessionID)
                   const promoted = yield* SessionInbox.promote(
@@ -156,8 +156,6 @@ const layer = Layer.effect(
                     sessionID,
                     entering && !continuing ? promotable : "steer",
                   )
-                  // A control admitted during context preparation owns this boundary.
-                  if (promoted === undefined) return undefined
                   if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
                     yield* FiberMap.run(titles, sessionID, title.generate(sessionID), {
                       onlyIfMissing: true,
@@ -166,7 +164,6 @@ const layer = Layer.effect(
                   return { _tag: "Ready" as const, context: yield* context.load(selected) }
                 }),
               )
-              if (ready) return ready
             }
           }),
         ),

packages/core/src/v1/config/migrate.ts

@@ -29,11 +29,9 @@ export function migrate(info: typeof ConfigV1.Info.Type) {
         update:
           info.autoupdate === false
             ? "disable"
-            : info.autoupdate === "notify"
+            : info.autoupdate === "notify" || info.autoupdate === true
               ? "notify"
-              : info.autoupdate === true
-                ? "auto"
-                : undefined,
+              : undefined,
         share: info.share ?? (info.autoshare ? "auto" : undefined),
         enterprise: info.enterprise,
         username: info.username,

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/config/config.test.ts

@@ -666,14 +666,14 @@ describe("Config", () => {
   test("migrates the v1 update policy", () => {
     expect(ConfigMigrateV1.migrate({ autoupdate: false }).update).toBe("disable")
     expect(ConfigMigrateV1.migrate({ autoupdate: "notify" }).update).toBe("notify")
-    expect(ConfigMigrateV1.migrate({ autoupdate: true }).update).toBe("auto")
+    expect(ConfigMigrateV1.migrate({ autoupdate: true }).update).toBe("notify")
     expect(ConfigMigrateV1.migrate({}).update).toBeUndefined()
   })
 
-  test("normalizes the native auto update policy", () => {
+  test("normalizes the previous native auto update policy", () => {
     expect(ConfigNormalize.normalize({ update: "auto" })).toEqual({
       type: "normalized",
-      encoded: { update: "auto" },
+      encoded: { update: "notify" },
       diagnostics: [],
     })
   })

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/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

@@ -1925,185 +1925,6 @@ describe("SessionRunnerLLM", () => {
     ).toEqual(["Replacement context"])
   })
 
-  for (const order of ["before", "between", "after"] as const) {
-    scenario(`prioritizes manual compaction admitted ${order} two steers at the safe boundary`, function* (s) {
-      s.currentModel = recoveryModel
-      yield* s.llm.push(
-        TestLLM.text("Active complete", "active"),
-        TestLLM.text("## Objective\n- Active work checkpoint", "summary"),
-        TestLLM.text("Steers complete", "steers"),
-      )
-      yield* s.admit("Active work")
-      const active = yield* s.resumePaused
-      const compactID = SessionMessage.ID.create()
-      if (order === "before") yield* s.session.compact({ sessionID, id: compactID })
-      const first = yield* s.admit("STEER_A")
-      if (order === "between") yield* s.session.compact({ sessionID, id: compactID })
-      const second = yield* s.admit("STEER_B")
-      if (order === "after") yield* s.session.compact({ sessionID, id: compactID })
-      expect((yield* s.session.compact({ sessionID })).id).toBe(compactID)
-
-      expect(s.requests).toHaveLength(1)
-      expect(yield* s.inbox).toHaveLength(3)
-      expect((yield* s.messages).some((message) => message.type === "compaction")).toBe(false)
-      yield* active.finish
-
-      expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-      expect(s.requests).toHaveLength(3)
-      expect(userTexts(s.requests[1])).not.toContain("STEER_A")
-      expect(userTexts(s.requests[1])).not.toContain("STEER_B")
-      expect(userTexts(s.requests[2]).slice(-2)).toEqual(["STEER_A", "STEER_B"])
-      expect(yield* s.inbox).toEqual([])
-      expect((yield* s.messages).filter((message) => message.id === compactID)).toMatchObject([
-        { type: "compaction", status: "completed" },
-      ])
-      expect((yield* s.context).filter((message) => message.type === "user").map((message) => message.id)).toEqual([
-        first.id,
-        second.id,
-      ])
-      // An advisory drain must not redeliver either steer or rerun compaction.
-      const runner = yield* SessionRunner.Service
-      yield* runner.drain({ sessionID, force: false })
-      expect(s.requests).toHaveLength(3)
-    })
-  }
-
-  scenario("waits for active tools before prioritizing compaction over pending steers", function* (s) {
-    yield* s.llm.push(
-      TestLLM.tool("call-active", "echo", { text: "active" }),
-      TestLLM.text("## Objective\n- Tool work checkpoint", "summary"),
-      TestLLM.text("Steers complete", "steers"),
-    )
-    yield* s.admit("Active work")
-    const tools = yield* s.blockTools()
-    const run = yield* s.resume.pipe(Effect.forkChild)
-    yield* tools.started
-    yield* s.admit("STEER_A")
-    yield* s.admit("STEER_B")
-    const compact = yield* s.session.compact({ sessionID })
-    expect(s.requests).toHaveLength(1)
-    expect((yield* s.messages).some((message) => message.id === compact.id)).toBe(false)
-    yield* tools.release
-    yield* Fiber.join(run)
-
-    expect(s.requests).toHaveLength(3)
-    expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-    expect(s.requests[1].messages.some((message) => message.role === "tool")).toBe(true)
-    expect(userTexts(s.requests[2]).slice(-2)).toEqual(["STEER_A", "STEER_B"])
-    expect(yield* s.inbox).toEqual([])
-  })
-
-  scenario("rechecks compaction admitted during boundary context preparation", function* (s) {
-    yield* s.runPrompt("Earlier work")
-    yield* s.admit("STEER_A")
-    yield* s.admit("STEER_B")
-    const preparing = yield* Deferred.make<void>()
-    const release = yield* Deferred.make<void>()
-    s.systemLoadHook = Deferred.succeed(preparing, undefined).pipe(Effect.andThen(Deferred.await(release)))
-    yield* s.llm.push(
-      TestLLM.text("## Objective\n- Earlier work checkpoint", "summary"),
-      TestLLM.text("Steers complete", "steers"),
-    )
-    const run = yield* s.resume.pipe(Effect.forkChild)
-    yield* Deferred.await(preparing)
-    yield* s.session.compact({ sessionID })
-    yield* Deferred.succeed(release, undefined)
-    yield* Fiber.join(run)
-    expect(s.requests).toHaveLength(3)
-    expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-    expect(userTexts(s.requests[2]).slice(-2)).toEqual(["STEER_A", "STEER_B"])
-    expect(yield* s.inbox).toEqual([])
-  })
-
-  for (const outcome of ["cancelled", "failed"] as const) {
-    scenario(`preserves both earlier steers when prioritized compaction is ${outcome}`, function* (s) {
-      yield* s.llm.push(TestLLM.text("Active complete", "active"))
-      yield* s.admit("Active work")
-      const active = yield* s.resumePaused
-      const first = yield* s.admit("STEER_A")
-      const second = yield* s.admit("STEER_B")
-      const compact = yield* s.session.compact({ sessionID })
-      if (outcome === "cancelled") yield* s.session.cancelInbox({ sessionID, inboxID: compact.id })
-      if (outcome === "failed") yield* s.llm.push([LLMEvent.providerError({ message: "summary unavailable" })])
-      yield* s.llm.push(TestLLM.text("Steers complete", "steers"))
-      yield* active.finish
-
-      expect(s.requests).toHaveLength(outcome === "cancelled" ? 2 : 3)
-      if (outcome === "failed") {
-        expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-        expect((yield* s.messages).find((message) => message.id === compact.id)).toMatchObject({
-          status: "failed",
-          error: { type: "provider.error", message: "summary unavailable" },
-        })
-      }
-      if (outcome === "cancelled") expect((yield* s.messages).some((message) => message.id === compact.id)).toBe(false)
-      expect(userTexts(s.requests[s.requests.length - 1]).slice(-2)).toEqual(["STEER_A", "STEER_B"])
-      expect(
-        (yield* s.context)
-          .filter((message) => message.id === first.id || message.id === second.id)
-          .map((message) => message.id),
-      ).toEqual([first.id, second.id])
-      expect(yield* s.inbox).toEqual([])
-    })
-  }
-
-  scenario("keeps steers durable across interrupted priority compaction and replay", function* (s) {
-    yield* s.runPrompt("Earlier work")
-    const first = yield* s.admit("STEER_A")
-    const second = yield* s.admit("STEER_B")
-    yield* s.llm.push(TestLLM.text("## Objective\n- Interrupted checkpoint", "summary"))
-    const summary = yield* s.llm.gate
-    const compact = yield* s.session.compact({ sessionID })
-    yield* summary.started
-    expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-    expect((yield* s.inbox).map((item) => item.id)).toEqual([first.id, second.id])
-    yield* s.session.interrupt(sessionID)
-    yield* s.session.wait(sessionID)
-    yield* summary.release
-    expect((yield* s.messages).find((message) => message.id === compact.id)).toMatchObject({ status: "failed" })
-    yield* replaySessionProjection(sessionID)
-    expect((yield* s.inbox).map((item) => item.id)).toEqual([first.id, second.id])
-
-    yield* s.llm.push(TestLLM.text("Recovered steers", "steers"))
-    yield* s.resume
-    expect(s.requests).toHaveLength(3)
-    expect(userTexts(s.requests[2]).slice(-2)).toEqual(["STEER_A", "STEER_B"])
-    expect(yield* s.inbox).toEqual([])
-  })
-
-  scenario("does not pull compaction across an earlier move", function* (s) {
-    yield* s.admit("STEER_A")
-    yield* s.sessionInbox.admit({
-      id: SessionMessage.ID.create(),
-      sessionID,
-      item: {
-        type: "move",
-        payload: {
-          location: Location.Ref.make({ directory: AbsolutePath.make("/project") }),
-          projectID: Project.ID.global,
-        },
-        delivery: "steer",
-      },
-    })
-    yield* s.admit("STEER_B")
-    yield* s.sessionInbox.admitCompaction({ id: SessionMessage.ID.create(), sessionID, delivery: "steer" })
-    yield* s.llm.push(
-      TestLLM.text("First steer complete", "first"),
-      TestLLM.text("## Objective\n- Source work checkpoint", "summary"),
-      TestLLM.text("Second steer complete", "second"),
-    )
-    yield* s.resume
-    expect(s.requests).toHaveLength(3)
-    expect(userTexts(s.requests[0])).toEqual(["STEER_A"])
-    expect(userTexts(s.requests[1]).at(-1)).toContain("Summarize only the history shown")
-    expect(userTexts(s.requests[2]).at(-1)).toBe("STEER_B")
-    expect(
-      (yield* recordedEventTypes(sessionID)).filter(
-        (type) => type === "session.moved.1" || type === "session.compaction.started.1",
-      ),
-    ).toEqual(["session.moved.1", "session.compaction.started.1"])
-  })
-
   scenario("runs steers before queued compaction and later queued input", function* (s) {
     s.currentModel = recoveryModel
     yield* s.llm.push(

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/tui/context.ts

@@ -162,21 +162,6 @@ type PromptFooterInput = {
   readonly showDetails: boolean
 }
 
-export type PanelPresentation = "panel" | "fullscreen"
-
-/** Client-local state of the selected session panel. The host owns its layout and input scope. */
-export interface PanelInput {
-  /** Selected content name, set by ui.panel.open. Contributions decide whether to render it. */
-  readonly name: string
-  readonly sessionID: string
-  readonly width: number
-  readonly presentation: PanelPresentation
-  readonly focused: boolean
-  readonly focus: () => void
-  readonly close: () => void
-  readonly toggleFullscreen: () => void
-}
-
 /**
  * The host UI's slot tree. Every path is one slot: a named boundary a plugin
  * may render around, inside, or take over. Paths are absolute and
@@ -195,7 +180,6 @@ export interface SlotMap {
   readonly "prompt.footer.status": PromptFooterInput
   readonly "prompt.footer.file": PromptFooterInput
   readonly "session.composer.top": { readonly sessionID: string }
-  readonly "session.panel": PanelInput
   readonly "sidebar.content": { readonly sessionID: string }
   readonly "sidebar.footer": { readonly sessionID: string }
 }
@@ -466,14 +450,6 @@ export interface UI {
     navigate(destination: Destination): void
     current(): Route
   }
-  readonly panel: {
-    /** Opens the session.panel slot in the current session. */
-    open(name: string, options?: { readonly presentation?: PanelPresentation }): boolean
-    /** Closes this plugin's active panel. Other plugins' panels are unaffected. */
-    close(): void
-    /** This plugin's active panel, if any. Reactive when read in a Solid computation. */
-    current(): { readonly name: string; readonly sessionID: string } | undefined
-  }
   readonly tabs: {
     /** Returns whether session tabs are enabled for this TUI. */
     enabled(): boolean

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"
       }
     },
@@ -14010,7 +13904,7 @@
           },
           "update": {
             "type": "string",
-            "enum": ["disable", "notify", "auto"]
+            "enum": ["disable", "notify"]
           },
           "share": {
             "type": "string",
@@ -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": {
@@ -18340,12 +18221,6 @@
             "type": "string",
             "enum": ["auto", "manual"]
           },
-          "model": {
-            "$ref": "#/components/schemas/Model.Ref"
-          },
-          "providerState": {
-            "$ref": "#/components/schemas/Session.Message.ProviderState_5"
-          },
           "summary": {
             "type": "string"
           },
@@ -18573,9 +18448,6 @@
       "Session.Message.ProviderState_4": {
         "type": "object"
       },
-      "Session.Message.ProviderState_5": {
-        "type": "object"
-      },
       "Session.Message.Shell": {
         "type": "object",
         "properties": {
@@ -19695,27 +19567,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 +19596,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 +19729,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({
@@ -35,8 +34,8 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   default_agent: Schema.String.pipe(optional).annotate({
     description: "Default primary agent to use when no session agent is selected",
   }),
-  update: Schema.Literals(["disable", "notify", "auto"]).pipe(optional).annotate({
-    description: "Disable updates, notify when one is available, or install updates automatically",
+  update: Schema.Literals(["disable", "notify"]).pipe(optional).annotate({
+    description: "Disable updates or notify when one is available",
   }),
   share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
     description: "Control whether sessions may be shared manually, automatically, or not at all",
@@ -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/process.ts

@@ -1,9 +1,7 @@
 export * as ServerProcess from "./process"
 
 import { NodeHttpServer } from "@effect/platform-node"
-import { Bus } from "@opencode-ai/core/bus"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
-import { InstallationEvent } from "@opencode-ai/schema/installation-event"
 import { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
 import { hasPersistentPtyConnectTicketURL } from "@opencode-ai/protocol/groups/persistent-pty"
 import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect"
@@ -116,14 +114,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
       )
     yield* Ref.set(application, Option.some(transform ? transform(app) : app))
     yield* status.ready
-    const bus = Context.get(context, Bus.Service)
-    return {
-      address: bound.http.address,
-      shutdown: shutdown.await,
-      updateAvailable: (version: string) =>
-        bus.publish(InstallationEvent.UpdateAvailable, { version }).pipe(Effect.asVoid),
-      updated: (version: string) => bus.publish(InstallationEvent.Updated, { version }).pipe(Effect.asVoid),
-    }
+    return { address: bound.http.address, shutdown: shutdown.await }
   }).pipe(
     Effect.catchCause((cause) => {
       if (!lifecycle || Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause)

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/process.test.ts

@@ -101,13 +101,7 @@ it.live("allows browser preflight requests without credentials", () =>
     expect(event.headers.get("content-encoding")).toBeNull()
     const body = event.body
     if (!body) return yield* Effect.die(new Error("Event response has no body"))
-    const reader = body.getReader()
-    yield* Effect.promise(() => readUntil(reader, "server.connected"))
-    yield* server.updateAvailable("2.0.0")
-    yield* Effect.promise(() => readUntil(reader, "installation.update-available"))
-    yield* server.updated("2.0.0")
-    yield* Effect.promise(() => readUntil(reader, "installation.updated"))
-    yield* Effect.promise(() => reader.cancel())
+    yield* Effect.promise(() => body.cancel())
 
     const missing = yield* Effect.promise(() =>
       fetch(new URL("/missing", HttpServer.formatAddress(server.address)), {
@@ -132,11 +126,3 @@ it.live("allows browser preflight requests without credentials", () =>
     )
   }),
 )
-
-async function readUntil(reader: ReadableStreamDefaultReader<Uint8Array>, expected: string) {
-  while (true) {
-    const next = await reader.read()
-    if (next.done) throw new Error(`Event stream ended before ${expected}`)
-    if (new TextDecoder().decode(next.value).includes(expected)) return
-  }
-}

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/storybook/.storybook/mocks/app/context/server-sdk.ts

@@ -1,6 +1,6 @@
 const providers = [
-  "opencode-go",
   "opencode",
+  "opencode-go",
   "anthropic",
   "openai",
   "google",

packages/storybook/.storybook/mocks/app/hooks/use-providers.ts

@@ -15,8 +15,8 @@ const provider = {
 }
 
 const popular = [
-  { id: "opencode-go", name: "OpenCode Go", models: {} },
   { id: "opencode", name: "OpenCode Zen", models: {} },
+  { id: "opencode-go", name: "OpenCode Go", models: {} },
   { id: "openai", name: "OpenAI", models: {} },
   provider,
   { id: "google", name: "Google", models: {} },

packages/tui/src/app.tsx

@@ -64,6 +64,7 @@ import { DialogStatus } from "./component/dialog-status"
 import { DialogConfig } from "./component/dialog-config"
 import { DialogDebug } from "./component/dialog-debug"
 import { DialogPair, type DialogPairCredentials } from "./component/dialog-pair"
+import { DialogUpdate } from "./component/dialog-update"
 import { DialogThemeList } from "./component/dialog-theme-list"
 import { DialogHelp } from "./ui/dialog-help"
 import { DialogAgent } from "./component/dialog-agent"
@@ -87,7 +88,6 @@ import open from "open"
 import { PromptRefProvider, usePromptRef } from "./context/prompt"
 import { Config, ConfigProvider, useConfig } from "./config"
 import { newSessionLocation } from "./config/new-session-location"
-import { UpdateNotificationProvider, useUpdateNotification, type UpdateSource } from "./context/update-notification"
 import { PluginProvider, usePlugin, type PackageSource } from "./plugin/context"
 import { localPluginDirectories } from "./plugin/discovery"
 import { PluginRoute, Slot } from "./plugin/render"
@@ -100,7 +100,6 @@ import { cliErrorMessage, errorFormat } from "./util/error"
 import { AttentionProvider } from "./context/attention"
 import { StorageProvider, useStorage } from "./context/storage"
 import { SessionTerminalsProvider } from "./context/session-terminals"
-import { PanelProvider, usePanel } from "./context/panel"
 import { SessionFrame } from "./component/session-frame"
 import { createTuiClipboard } from "./clipboard"
 
@@ -155,7 +154,6 @@ const appBindingCommands = [
   "provider.connect",
   "opencode.settings",
   "opencode.status",
-  "opencode.update",
   "server.pair",
   "service.restart",
   "opencode.debug",
@@ -187,7 +185,10 @@ export type TuiInput = {
   }
   args: Args
   config: Config.Interface
-  updater?: UpdateSource
+  updater?: {
+    monitor: (notify: (version: string) => void, signal: AbortSignal) => Promise<void>
+    apply: (version: string) => Promise<void>
+  }
   packages: PackageSource
   environment?: Readonly<Record<string, string>>
   terminalHandoff?: () => Promise<
@@ -396,27 +397,22 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                                                     <PromptRefProvider>
                                                                       <EditorContextProvider>
                                                                         <AttentionProvider>
-                                                                          <UpdateNotificationProvider
-                                                                            updater={input.updater}
+                                                                          <PluginProvider
+                                                                            packages={input.packages}
+                                                                            directories={pluginDirectories}
                                                                           >
-                                                                            <PanelProvider>
-                                                                              <PluginProvider
-                                                                                packages={input.packages}
-                                                                                directories={pluginDirectories}
-                                                                              >
-                                                                                <App
-                                                                                  pair={
-                                                                                    input.server.endpoint.auth
-                                                                                      ? input.server.endpoint.auth
-                                                                                      : {
-                                                                                          username: "opencode",
-                                                                                          password: "",
-                                                                                        }
-                                                                                  }
-                                                                                />
-                                                                              </PluginProvider>
-                                                                            </PanelProvider>
-                                                                          </UpdateNotificationProvider>
+                                                                            <App
+                                                                              updater={input.updater}
+                                                                              pair={
+                                                                                input.server.endpoint.auth
+                                                                                  ? input.server.endpoint.auth
+                                                                                  : {
+                                                                                      username: "opencode",
+                                                                                      password: "",
+                                                                                    }
+                                                                              }
+                                                                            />
+                                                                          </PluginProvider>
                                                                         </AttentionProvider>
                                                                       </EditorContextProvider>
                                                                     </PromptRefProvider>
@@ -466,7 +462,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
   })
 })
 
-function App(props: { pair?: DialogPairCredentials }) {
+function App(props: { pair?: DialogPairCredentials; updater?: TuiInput["updater"] }) {
   const log = useLog({ component: "app" })
   const app = useTuiApp()
   const startup = useTuiStartup()
@@ -478,12 +474,10 @@ function App(props: { pair?: DialogPairCredentials }) {
   const dialog = useDialog()
   const local = useLocal()
   const sessionTabs = useSessionTabs()
-  const panels = usePanel()
   const keymap = Keymap.use()
   const event = useEvent()
   const client = useClient()
   const toast = useToast()
-  const updater = useUpdateNotification()
   const theme = useTheme()
   const { mode, supports, setMode, locked, lock, unlock } = useThemes()
   const data = useData()
@@ -507,6 +501,40 @@ function App(props: { pair?: DialogPairCredentials }) {
   const [layout, updateLayout] = useStorage().store<{ verticalTabsWidth?: number }>("layout", {
     initial: { verticalTabsWidth: SESSION_SIDEBAR_WIDTH },
   })
+  const [updateNotifications, markUpdateNotification] = useStorage().store<{ versions: string[] }>(
+    "update-notifications",
+    { initial: { versions: [] } },
+  )
+  const showUpdate = (version: string) => {
+    const updater = props.updater
+    if (!updater || updateNotifications.versions.includes(version)) return
+    void markUpdateNotification((draft) => {
+      draft.versions = [...draft.versions, version].slice(-100)
+    }).catch((error) => log.error("failed to persist update notification", { error }))
+    const key = `update:${version}`
+    dialog.replace(
+      () => (
+        <DialogUpdate
+          dialogKey={key}
+          version={version}
+          install={() => updater.apply(version)}
+          restart={client.restart}
+        />
+      ),
+      undefined,
+      { key },
+    )
+    dialog.setCentered(true)
+  }
+  onMount(() => {
+    const updater = props.updater
+    if (!updater) return
+    const controller = new AbortController()
+    onCleanup(() => controller.abort())
+    void updater.monitor(showUpdate, controller.signal).catch((error) => {
+      if (!controller.signal.aborted) log.error("update monitor failed", { error })
+    })
+  })
   const tabsResize = createPaneResize({
     value: () => layout.verticalTabsWidth ?? SESSION_SIDEBAR_WIDTH,
     defaultValue: () => SESSION_SIDEBAR_WIDTH,
@@ -580,22 +608,9 @@ function App(props: { pair?: DialogPairCredentials }) {
   const pasteSummaryEnabled = () => config.data.prompt?.paste !== "full"
   const tabsVertical = () =>
     config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width, tabsResize.preferredSize())
-  const tabsAvailable = () => sessionTabs.enabled() && sessionTabs.tabs().length > 0 && route.data.type !== "plugin"
-  const fullscreenPanel = () =>
-    route.data.type === "session" &&
-    panels.current()?.sessionID === route.data.sessionID &&
-    panels.presentation() === "fullscreen"
-  const tabsVisible = () => tabsAvailable() && !fullscreenPanel()
+  const tabsVisible = () => sessionTabs.enabled() && sessionTabs.tabs().length > 0 && route.data.type !== "plugin"
   const verticalTabsVisible = () => tabsVisible() && tabsVertical()
 
-  // Measure the prospective split layout, even while full-screen hides the tabs.
-  createEffect(() => panels.setWidth(dimensions().width - (tabsAvailable() && tabsVertical() ? tabsResize.size() : 0)))
-  createEffect(() => {
-    const current = panels.current()
-    if (!current || (route.data.type === "session" && route.data.sessionID === current.sessionID)) return
-    panels.close()
-  })
-
   createEffect(() => {
     renderer.useMouse = config.data.mouse
   })
@@ -957,17 +972,6 @@ function App(props: { pair?: DialogPairCredentials }) {
         },
         category: "System",
       },
-      ...(updater.open
-        ? [
-            {
-              name: "opencode.update",
-              title: "Update OpenCode",
-              slash: { name: "update" },
-              run: () => updater.open?.("manual"),
-              category: "System",
-            },
-          ]
-        : []),
       {
         name: "server.pair",
         title: "Pair device",

packages/tui/src/component/dialog-move-session.tsx

@@ -27,7 +27,6 @@ type ProjectDirectory = WorktreeListOutput[number]
 
 type DialogMoveSessionProps = {
   projectID: string
-  location?: { directory: string; workspaceID?: string }
   current?: MoveSessionSelection
   onSelect: (selection: MoveSessionSelection) => void
   onCurrentChange?: (selection: MoveSessionSelection) => void
@@ -46,11 +45,7 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
   const toast = useToast()
   const paths = useTuiPaths()
   const shortcuts = Keymap.useShortcuts()
-  const location = createMemo(() => sessionData.location.info(props.location))
-  const worktreeLocation = () => ({
-    directory: props.location?.directory ?? location()?.directory ?? paths.cwd,
-    workspace: props.location?.workspaceID ?? location()?.workspaceID,
-  })
+  const location = createMemo(() => sessionData.location.info())
   const [working, setWorking] = createSignal(Boolean(props.initialRemoving))
   const [toDelete, setToDelete] = createSignal<string>()
   const [removing, setRemoving] = createSignal(props.initialRemoving)
@@ -81,10 +76,11 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
   })
 
   const [directories, { refetch }] = createResource(
-    () => (props.fixture || props.initialRemoving ? undefined : worktreeLocation()),
-    async (location, info): Promise<ReadonlyArray<ProjectDirectory> | undefined> => {
+    () => (props.fixture || props.initialRemoving ? undefined : props.projectID),
+    async (projectID, info): Promise<ReadonlyArray<ProjectDirectory> | undefined> => {
       try {
-        const directories = await client.api.worktree.list({ location })
+        await client.api.worktree.refresh({ projectID })
+        const directories = await client.api.worktree.list({ projectID })
         setLoadError(undefined)
         return directories
       } catch (error) {
@@ -227,13 +223,10 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
     setToDelete(undefined)
     setRemoving(selected.directory)
     setWorking(true)
-    const request = {
-      directory: selected.directory,
-      location: worktreeLocation(),
-    }
     const error = await client.api.worktree
       .remove({
-        ...request,
+        projectID: props.projectID,
+        directory: selected.directory,
         force: false,
       })
       .then(
@@ -258,7 +251,8 @@ export function DialogMoveSession(props: DialogMoveSessionProps) {
         reopen(selected.directory)
         const forcedError = await client.api.worktree
           .remove({
-            ...request,
+            projectID: props.projectID,
+            directory: selected.directory,
             force: true,
           })
           .then(

packages/tui/src/component/dialog-update.tsx

@@ -1,56 +1,67 @@
+/** @jsxImportSource @opentui/solid */
 import { TextAttributes } from "@opentui/core"
-import { createEffect, createMemo, createResource, createSignal, For, Match, onCleanup, Show, Switch } from "solid-js"
+import { createSignal, For, Match, Show, Switch } from "solid-js"
 import { Keymap } from "../context/keymap"
 import { useTheme } from "../context/theme"
-import type { UpdateState } from "../context/update-notification"
-import { useDialog } from "../ui/dialog"
 import { errorMessage } from "../util/error"
+import { useDialog } from "../ui/dialog"
 import { Spinner } from "./spinner"
 
+type State =
+  | { type: "ready"; active: "update" | "skip" }
+  | { type: "installing" }
+  | { type: "restarting" }
+  | { type: "failed"; message: string }
+
 export function DialogUpdate(props: {
-  check?: (signal: AbortSignal) => Promise<string | undefined>
-  state: () => UpdateState | undefined
+  dialogKey: string
+  version: string
   install: () => Promise<void>
-  restart: () => void
+  restart?: () => Promise<void>
 }) {
   const dialog = useDialog()
   const theme = useTheme("elevated")
-  const [error, setError] = createSignal<string>()
-  const [active, setActive] = createSignal(0)
-  const controller = new AbortController()
-  onCleanup(() => controller.abort())
+  const [state, setState] = createSignal<State>({ type: "ready", active: "update" })
+  const close = () => {
+    if (dialog.key === props.dialogKey) dialog.clear()
+  }
 
-  dialog.setCentered(true)
+  const install = async () => {
+    setState({ type: "installing" })
+    await props.install()
+    if (props.restart) {
+      setState({ type: "restarting" })
+      await props.restart()
+    }
+    close()
+  }
 
-  const [check] = createResource(
-    () => props.check,
-    (check) =>
-      check(controller.signal).catch((error) => {
-        if (!controller.signal.aborted) setError(errorMessage(error))
-        return undefined
-      }),
-  )
-  const state = createMemo(() => {
-    if (check.loading) return { type: "checking" as const }
-    const unavailable = check()
-    if (unavailable) return { type: "unavailable" as const, message: unavailable }
-    const message = error()
-    if (message) return { type: "check-failed" as const, message }
-    return props.state() ?? { type: "current" as const }
-  })
-  const buttons = createMemo(() => {
-    const type = state().type
-    if (type === "installing") return []
-    const confirm =
-      type === "available"
-        ? { label: "Update", run: props.install }
-        : type === "installed"
-          ? { label: "Restart", run: props.restart }
-          : undefined
-    return [{ label: "Skip", run: () => dialog.clear() }, ...(confirm ? [confirm] : [])]
-  })
+  const beginInstall = () => {
+    if (state().type !== "ready") return
+    void install().catch((error) => setState({ type: "failed", message: errorMessage(error) }))
+  }
 
-  createEffect(() => setActive(Math.max(0, buttons().length - 1)))
+  const run = () => {
+    const current = state()
+    if (current.type !== "ready") return
+    if (current.active === "skip") return close()
+    beginInstall()
+  }
+
+  const toggle = () =>
+    setState((current) =>
+      current.type === "ready" ? { ...current, active: current.active === "update" ? "skip" : "update" } : current,
+    )
+
+  const selected = (action: "update" | "skip") => {
+    const current = state()
+    return current.type === "ready" && current.active === action
+  }
+
+  const failure = () => {
+    const current = state()
+    return current.type === "failed" ? current.message : ""
+  }
 
   Keymap.createLayer(() => ({
     mode: "modal",
@@ -59,17 +70,20 @@ export function DialogUpdate(props: {
         bind: "return",
         title: "Confirm update action",
         group: "Dialog",
-        run: () => void buttons()[active()]?.run(),
+        run: () => (state().type === "failed" ? close() : run()),
       },
-      ...["left", "right", "tab", "shift+tab"].map((bind) => ({
-        bind,
-        title: bind === "left" || bind === "shift+tab" ? "Previous update action" : "Next update action",
+      {
+        bind: "left",
+        title: "Previous update action",
         group: "Dialog",
-        run: () => {
-          const count = buttons().length
-          if (count) setActive((value) => (value + 1) % count)
-        },
-      })),
+        run: toggle,
+      },
+      {
+        bind: "right",
+        title: "Next update action",
+        group: "Dialog",
+        run: toggle,
+      },
     ],
   }))
 
@@ -77,65 +91,64 @@ export function DialogUpdate(props: {
     <box paddingLeft={2} paddingRight={2} gap={1}>
       <box flexDirection="row" justifyContent="space-between">
         <text attributes={TextAttributes.BOLD} fg={theme.text.default}>
-          {state().type === "available" || state().type === "installing" || state().type === "failed"
-            ? "Update available"
-            : "Update"}
+          Update available
         </text>
-        <text fg={theme.text.subdued} onMouseUp={() => dialog.clear()}>
+        <text fg={theme.text.subdued} onMouseUp={close}>
           esc
         </text>
       </box>
       <box paddingBottom={1}>
-        <Show when={state()} keyed>
-          {(current) => (
-            <Switch>
-              <Match when={current.type === "checking"}>
-                <Spinner shimmer={theme.text.default}>Checking for updates…</Spinner>
-              </Match>
-              <Match when={current.type === "available"}>
-                <text fg={theme.text.subdued}>
-                  An update is available. After installing, you'll be prompted to restart OpenCode.
-                </text>
-              </Match>
-              <Match when={current.type === "installing"}>
-                <Spinner shimmer={theme.text.default}>
-                  {current.type === "installing" ? `Installing OpenCode ${current.version}…` : ""}
-                </Spinner>
-              </Match>
-              <Match when={current.type === "installed"}>
-                <text fg={theme.text.subdued} wrapMode="word">
-                  Update successful! A restart is required. Any active sessions will be resumed automatically.
-                </text>
-              </Match>
-              <Match when={current.type === "current"}>
-                <text fg={theme.text.subdued}>OpenCode is already up to date.</text>
-              </Match>
-              <Match when={current.type === "unavailable"}>
-                <text fg={theme.text.subdued} wrapMode="word">
-                  {current.type === "unavailable" ? current.message : ""}
-                </text>
-              </Match>
-              <Match when={current.type === "failed" || current.type === "check-failed"}>
-                <text fg={theme.text.feedback.error.default}>
-                  {current.type === "failed" || current.type === "check-failed" ? current.message : ""}
-                </text>
-              </Match>
-            </Switch>
-          )}
-        </Show>
+        <Switch>
+          <Match when={state().type === "ready"}>
+            <text fg={theme.text.subdued}>
+              An update is available. Applying will
+              {props.restart
+                ? " restart the server and active sessions will be resumed."
+                : " install the update but you will need to manually restart."}
+            </text>
+          </Match>
+          <Match when={state().type === "installing"}>
+            <Spinner shimmer={theme.text.default}>Installing OpenCode {props.version}…</Spinner>
+          </Match>
+          <Match when={state().type === "restarting"}>
+            <Spinner shimmer={theme.text.default}>Restarting the background service…</Spinner>
+          </Match>
+          <Match when={state().type === "failed"}>
+            <text fg={theme.text.feedback.error.default}>{failure()}</text>
+          </Match>
+        </Switch>
       </box>
-      <Show when={buttons().length > 0}>
+      <Show
+        when={state().type === "ready"}
+        fallback={
+          <Show when={state().type === "failed"}>
+            <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
+              <box
+                paddingLeft={3}
+                paddingRight={3}
+                backgroundColor={theme.background.action.primary.focused}
+                onMouseUp={close}
+              >
+                <text fg={theme.text.action.primary.focused}>close</text>
+              </box>
+            </box>
+          </Show>
+        }
+      >
         <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
-          <For each={buttons()}>
-            {(button, index) => (
+          <For each={["skip", "update"] as const}>
+            {(action) => (
               <box
                 paddingLeft={1}
                 paddingRight={1}
-                backgroundColor={active() === index() ? theme.background.action.primary.focused : undefined}
-                onMouseUp={() => void button.run()}
+                backgroundColor={selected(action) ? theme.background.action.primary.focused : undefined}
+                onMouseUp={() => {
+                  if (action === "skip") return close()
+                  beginInstall()
+                }}
               >
-                <text fg={active() === index() ? theme.text.action.primary.focused : theme.text.subdued}>
-                  {button.label}
+                <text fg={selected(action) ? theme.text.action.primary.focused : theme.text.subdued}>
+                  {action === "update" ? "Update" : "Skip"}
                 </text>
               </box>
             )}

packages/tui/src/component/fade-in-text.tsx

@@ -1,105 +0,0 @@
-import { RGBA, type OptimizedBuffer, type RenderContext, type TextOptions } from "@opentui/core"
-import { extend, type JSX } from "@opentui/solid"
-import { splitProps } from "solid-js"
-import { useConfig } from "../config"
-import { MaskedTextRenderable } from "./masked-text"
-import { coast, smootherstep } from "./tab-pulse"
-
-type FadeInTextOptions = TextOptions & {
-  backdrop?: RGBA
-  enabled?: boolean
-  sweepOffset?: number
-  sweepWidth?: number
-}
-
-const DURATION = 200
-const FEATHER = 8
-const clamp = (value: number) => Math.max(0, Math.min(1, value))
-
-class FadeInTextRenderable extends MaskedTextRenderable {
-  private _backdrop = RGBA.defaultBackground()
-  private _enabled = true
-  private _sweepOffset = 0
-  private _sweepWidth: number | undefined
-  private elapsed = 0
-
-  constructor(ctx: RenderContext, options: FadeInTextOptions) {
-    super(ctx, options)
-    this.matrix[15] = 1
-    this.updateBackdrop()
-    if (options.backdrop) this.backdrop = options.backdrop
-    if (options.enabled === false) this.enabled = false
-    this.live = this._enabled
-  }
-
-  set backdrop(value: RGBA) {
-    if (value.equals(this._backdrop)) return
-    this._backdrop = value
-    this.updateBackdrop()
-    this.requestRender()
-  }
-
-  set enabled(value: boolean) {
-    if (value === this._enabled) return
-    this._enabled = value
-    this.live = value && this.elapsed < DURATION
-    this.requestRender()
-  }
-
-  set sweepOffset(value: number | undefined) {
-    this._sweepOffset = value ?? 0
-    this.requestRender()
-  }
-
-  set sweepWidth(value: number | undefined) {
-    this._sweepWidth = value
-    this.requestRender()
-  }
-
-  private updateBackdrop() {
-    this.matrix[3] = this._backdrop.r
-    this.matrix[7] = this._backdrop.g
-    this.matrix[11] = this._backdrop.b
-  }
-
-  override render(buffer: OptimizedBuffer, deltaTime: number) {
-    if (!this._enabled || this.elapsed >= DURATION) return super.render(buffer, deltaTime)
-    if (!this.visible || this.isDestroyed || !Number.isFinite(this.width) || this.width <= 0 || this.height <= 0) return
-    this.elapsed = Math.min(DURATION, this.elapsed + deltaTime)
-    this.renderMasked(buffer, 1, (end) => {
-      const progress = this.elapsed / DURATION
-      const front = -FEATHER + coast(progress) * ((this._sweepWidth ?? end) + FEATHER * 2)
-      return (column) => 1 - smootherstep(clamp((front - (this._sweepOffset + column)) / FEATHER))
-    })
-    if (this.elapsed >= DURATION) this.live = false
-  }
-}
-
-extend({ fade_in_text: FadeInTextRenderable })
-
-declare module "@opentui/solid" {
-  interface OpenTUIComponents {
-    fade_in_text: typeof FadeInTextRenderable
-  }
-}
-
-type Props = Omit<JSX.IntrinsicElements["text"], "ref"> & {
-  animate?: boolean
-  backdrop?: RGBA
-  sweepOffset?: number
-  sweepWidth?: number
-}
-
-export function FadeInText(props: Props) {
-  const config = useConfig().data
-  const [local, text] = splitProps(props, ["animate", "backdrop", "sweepOffset", "sweepWidth"])
-  return (
-    <fade_in_text
-      {...text}
-      backdrop={local.backdrop}
-      enabled={(local.animate ?? true) && (config.animations ?? true)}
-      sweepOffset={local.sweepOffset}
-      sweepWidth={local.sweepWidth}
-    />
-  )
-}

packages/tui/src/component/masked-text.ts

@@ -1,56 +0,0 @@
-import { OptimizedBuffer, RGBA, TargetChannel, TextRenderable } from "@opentui/core"
-
-const TRANSPARENT = RGBA.fromValues(0, 0, 0, 0)
-const CONTINUATION = 0xc0000000 | 0
-
-export class MaskedTextRenderable extends TextRenderable {
-  protected readonly matrix = new Float32Array(16)
-  private scratch: OptimizedBuffer | undefined
-  private mask = new Float32Array(0)
-
-  protected renderMasked(
-    buffer: OptimizedBuffer,
-    initialStrength: number,
-    shade: (width: number) => (column: number) => number,
-  ) {
-    if (!this.scratch)
-      this.scratch = OptimizedBuffer.create(this.width, this.height, this._ctx.widthMethod, { respectAlpha: true })
-    if (this.scratch.width !== this.width || this.scratch.height !== this.height)
-      this.scratch.resize(this.width, this.height)
-
-    this.scratch.clear(TRANSPARENT)
-    this.scratch.drawTextBuffer(this.textBufferView, 0, 0)
-    const characters = this.scratch.buffers.char
-    let end = 0
-    for (let row = 0; row < this.height; row++) {
-      let column = this.width
-      while (
-        column > 0 &&
-        (characters[row * this.width + column - 1] === 32 || characters[row * this.width + column - 1] === 0)
-      )
-        column--
-      end = Math.max(end, column)
-    }
-    const intensity = shade(end)
-    if (this.mask.length !== this.width * this.height * 3) this.mask = new Float32Array(this.width * this.height * 3)
-    let strength = initialStrength
-    for (let cell = 0; cell < characters.length; cell++) {
-      const column = cell % this.width
-      // Wide glyph continuation cells retain the head cell's intensity.
-      if ((characters[cell] & CONTINUATION) !== CONTINUATION) strength = intensity(column)
-      this.mask[cell * 3] = column
-      this.mask[cell * 3 + 1] = Math.floor(cell / this.width)
-      this.mask[cell * 3 + 2] = strength
-    }
-    this.scratch.colorMatrix(this.matrix, this.mask, 1, TargetChannel.FG)
-    buffer.drawFrameBuffer(this.screenX, this.screenY, this.scratch)
-    this.markClean()
-    this._ctx.addToHitGrid(this.screenX, this.screenY, this.width, this.height, this.num)
-  }
-
-  override destroy() {
-    this.scratch?.destroy()
-    this.scratch = undefined
-    super.destroy()
-  }
-}