refactor(tui): simplify shell output polling

feat(tui): inspect live shell output
2026-09-03 23:46:16 +00:00 · 2026-09-03 16:37:00 -04:00 · 2026-09-03 16:29:14 -04:00
111 changed files with 1381 additions and 3447 deletions
@@ -1,47 +0,0 @@
-import { benchmark, expect } from "./benchmark"
-import { openCommandPalette } from "../utils/command-palette"
-
-benchmark.use({
-  viewport: { width: 1440, height: 900 },
-  serviceWorkers: "block",
-  traceScope: "interaction",
-  trace: "off",
-  video: "off",
-})
-
-for (const home of [false, true]) {
-  benchmark(`command lookup from ${home ? "home" : "session"}`, async ({ page, report }) => {
-    const { dialog, input } = await openCommandPalette(page, home)
-    const title = home ? "Open settings" : "Copy Session ID"
-    const query = home ? "open settings" : "copy session"
-    // Measure input-to-selected-result in the renderer, without assertion polling overhead.
-    await input.evaluate((element, title) => {
-      element.addEventListener(
-        "input",
-        () => {
-          performance.mark("palette-input")
-          const observer = new MutationObserver(() => {
-            if (document.querySelectorAll('[role="dialog"] [role="option"]').length !== 1) return
-            const selected = document.querySelector('[role="dialog"] [role="option"][aria-selected="true"]')
-            if (!selected?.textContent?.includes(title)) return
-            performance.measure("palette-result", "palette-input")
-            observer.disconnect()
-          })
-          observer.observe(document, { subtree: true, childList: true, attributes: true, characterData: true })
-        },
-        { once: true, capture: true },
-      )
-    }, title)
-    await input.fill(query)
-    await expect(dialog.getByRole("option")).toHaveCount(1)
-    await expect(dialog.getByRole("option", { name: new RegExp(`^${title}(?:$| )`) })).toHaveAttribute(
-      "aria-selected",
-      "true",
-    )
-    const result = await page.evaluate(() =>
-      performance.getEntriesByName("palette-result").map((entry) => entry.duration),
-    )
-    expect(result).toHaveLength(1)
-    report({ inputToResultMs: result[0] }, { home, query, data: "fixture; immediate server responses" })
-  })
-}
@@ -1,50 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block" })
-
-test("failed event-driven reads report an error and recover without an unhandled rejection", async ({ page }) => {
-  const errors: string[] = []
-  page.on("pageerror", (error) => errors.push(error.message))
-  const palette = await openCommandPalette(page)
-  const path = `**/api/session/${paletteSession.id}`
-  await page.route(path, (route) => route.abort("failed"))
-  const requested = page.waitForRequest(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_failed_refresh",
-        created: 2,
-        type: "session.viewed",
-        durable: { aggregateID: sessionID, seq: 1, version: 1 },
-        data: { sessionID, idle: 2 },
-      },
-    ])
-  }, paletteSession.id)
-  await requested
-  await expect(page.getByText("Request failed", { exact: true })).toBeVisible()
-  await palette.input.fill("copy session")
-  await expect(palette.dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await palette.input.press("Escape")
-  await page.unroute(path)
-  await page.evaluate((sessionID) => {
-    const host = window as Window & { __mockServerStream?: { push: (events: unknown[]) => void } }
-    if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-    host.__mockServerStream.push([
-      {
-        id: "evt_recovered_refresh",
-        created: 3,
-        type: "session.renamed",
-        durable: { aggregateID: sessionID, seq: 2, version: 1 },
-        data: { sessionID, title: "Recovered session" },
-      },
-    ])
-  }, paletteSession.id)
-  await expect(page.getByRole("heading", { name: "Recovered session", exact: true })).toBeVisible()
-  expect(errors).toEqual([])
-})
@@ -1,102 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette, paletteSession } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", permissions: ["clipboard-read", "clipboard-write"] })
-
-test("copies the session ID while file and session searches are still pending", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const { dialog, input } = await openCommandPalette(page)
-  const release = Promise.withResolvers<void>()
-  await page.route(/\/api\/(session\?|fs\/find\?)/, async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.pressSequentially("copy session")
-  const copy = dialog.getByRole("option", { name: "Copy Session ID", exact: true })
-  await expect(copy).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect.poll(() => page.evaluate(() => navigator.clipboard.readText())).toBe(paletteSession.id)
-  await expect(page.locator('[data-testid^="toast-v2-"] [data-slot="icon-svg"]')).toBeVisible()
-  expect(warnings).toEqual([])
-  release.resolve()
-})
-
-test("home commands do not wait for session search", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page, true)
-  const release = Promise.withResolvers<void>()
-  await page.route("**/api/session?*", async (route) => {
-    await release.promise
-    await route.fallback()
-  })
-  await input.fill("open settings")
-  await expect(dialog.getByRole("option")).toHaveCount(1)
-  await expect(dialog.getByRole("option", { name: /^Open settings/ })).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences", exact: true })).toBeVisible()
-  release.resolve()
-})
-
-test("appends search results without resetting the selected command", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const files = Promise.withResolvers<void>()
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", async (route) => {
-    await files.promise
-    await route.fulfill({ json: { data: [{ path: "copy.txt", type: "file" }] } })
-  })
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "Copy fixture" }],
-      },
-    })
-  })
-  await input.fill("copy")
-  const project = dialog.getByRole("option", { name: "Copy Project ID", exact: true })
-  await expect(project).toBeVisible()
-  // Select a non-first command with the keyboard before remote results arrive.
-  await input.press("ArrowDown")
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  files.resolve()
-  await expect(dialog.getByRole("option", { name: "/ copy.txt", exact: true })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  // File results are usable even while sessions are still pending.
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /Copy fixture/ })).toBeVisible()
-  await expect(project).toHaveAttribute("aria-selected", "true")
-  await input.fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  await expect(dialog.getByRole("option", { name: "Copy Project ID", exact: true })).toHaveCount(0)
-})
-
-test("keeps the automatically selected file when session results arrive later", async ({ page }) => {
-  const { dialog, input } = await openCommandPalette(page)
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({ json: { data: [{ path: "README.md", type: "file" }] } }),
-  )
-  await page.route("**/api/session?*", async (route) => {
-    await sessions.promise
-    await route.fulfill({
-      json: {
-        data: [{ ...paletteSession, location: { directory: paletteSession.directory }, title: "README work" }],
-      },
-    })
-  })
-  await input.fill("README")
-  const file = dialog.getByRole("option", { name: "/ README.md", exact: true })
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  sessions.resolve()
-  await expect(dialog.getByRole("option", { name: /README work/ })).toBeVisible()
-  await expect(file).toHaveAttribute("aria-selected", "true")
-  await input.press("Enter")
-  await expect(dialog).toHaveCount(0)
-  await expect(page.getByRole("tab", { name: "README.md", exact: true })).toBeVisible()
-  await expect(page.getByRole("heading", { name: paletteSession.title, exact: true })).toBeVisible()
-})
@@ -1,77 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { captureConsoleWarnings, openCommandPalette } from "../utils/command-palette"
-
-test.use({ serviceWorkers: "block", video: "off" })
-
-test("opening and closing files does not duplicate tab commands", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page)
-  await page.route("**/api/fs/find?*", (route) =>
-    route.fulfill({
-      headers: { "access-control-allow-origin": "*" },
-      json: { data: [{ path: "fixture.txt", type: "file" }] },
-    }),
-  )
-  await palette.input.fill("fixture.txt")
-  await palette.dialog.getByRole("option", { name: /fixture\.txt/ }).click()
-  const file = page.getByRole("tab", { name: /fixture\.txt/ })
-  await expect(file).toBeVisible()
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("complementary", { name: "Review and files" })
-    .getByRole("button", { name: "Close tab", exact: true })
-    .click()
-  await expect(file).toHaveCount(0)
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  expect(warnings).toEqual([])
-})
-
-test("navigation replaces commands without retaining disposed owners", async ({ page }) => {
-  const warnings = captureConsoleWarnings(page)
-  const palette = await openCommandPalette(page, true)
-  await palette.input.press("Escape")
-  await expect(palette.dialog).toHaveCount(0)
-  await page
-    .getByRole("region", { name: "Recent sessions" })
-    .getByRole("button", { name: /Palette fixture session/ })
-    .click()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.keyboard.press("ControlOrMeta+t")
-  await expect(page).toHaveURL(/\/new-session\?/)
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await page.locator('[data-component="composer-editor"]').blur()
-  await page.keyboard.press("Control+l")
-  await expect(page.locator('[data-component="composer-editor"]')).toBeFocused()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await expect(dialog.getByRole("textbox")).toHaveAttribute("placeholder", "Search files, commands, and sessions")
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveCount(0)
-  await dialog.getByRole("textbox").press("Escape")
-  await expect(dialog).toHaveCount(0)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  for (const count of [3, 4]) {
-    await page.getByRole("button", { name: "New session", exact: true }).click()
-    await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(count)
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  }
-  await page.setViewportSize({ width: 600, height: 800 })
-  await page.locator('[data-slot="mobile-tabs-trigger"]').click()
-  await expect(page.locator('[data-slot="mobile-tabs-drawer"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.setViewportSize({ width: 1280, height: 800 })
-  await expect(page.locator('[data-slot="titlebar-tabs"] [data-titlebar-tab-link]')).toHaveCount(4)
-  await page.keyboard.press("ControlOrMeta+w")
-  await expect(page.locator("[data-titlebar-tab-link]")).toHaveCount(3)
-  await page.locator("[data-titlebar-tab-link]").filter({ hasText: "Palette fixture session" }).click()
-  await expect(page.getByRole("heading", { name: "Palette fixture session", exact: true })).toBeVisible()
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  await expect(dialog.getByRole("textbox")).toBeFocused()
-  await dialog.getByRole("textbox").fill("copy session")
-  await expect(dialog.getByRole("option", { name: "Copy Session ID", exact: true })).toHaveAttribute(
-    "aria-selected",
-    "true",
-  )
-  expect(warnings).toEqual([])
-})
@@ -1,5 +1,4 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -336,61 +335,6 @@ test("restores the draft after closing and revisiting a pending session that fai
  expect(mock.prompts).toEqual([])
 })

-test("executes a selected slash command after creating its worktree", async ({ page }, testInfo) => {
-  const events: OpenCodeEvent[] = []
-  const mock = await openDraft(page, { command: true, events: () => events.splice(0) })
-  const commands: { sessionID: string; body: Record<string, unknown> }[] = []
-  const expanded =
-    "Review the latest commit for correctness and regressions. Check the relevant tests and report actionable findings."
-  await page.route("**/api/session/*/command", async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    const sessionID = new URL(route.request().url()).pathname.split("/")[3]
-    commands.push({ sessionID, body: route.request().postDataJSON() })
-    // The server owns command expansion; the client receives the expanded inbox item.
-    events.push({
-      id: "evt_workspace_review",
-      type: "session.inbox.enqueued",
-      created: Date.now(),
-      durable: { aggregateID: sessionID, seq: 1, version: 1 },
-      data: {
-        sessionID,
-        inboxID: "msg_workspace_review",
-        item: { type: "user", payload: { text: expanded }, delivery: "steer" },
-      },
-    })
-    await route.fulfill({ status: 204, headers })
-  })
-  const editor = page.locator('[data-component="composer-editor"]')
-  await editor.fill("/review")
-  const suggestion = page.getByRole("button", { name: "/review Review changes", exact: true })
-  await expect(suggestion).toBeVisible()
-  await suggestion.click()
-  await expect(editor).toHaveText("/review")
-  const pending = await submitPending(page, mock, "/review latest commit")
-  await draftFollowUp(page)
-
-  mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-
-  await expect
-    .poll(() => commands)
-    .toEqual([
-      {
-        sessionID: pending.sessionID,
-        body: { command: "review", text: "latest commit", files: [], agents: [], skills: [], delivery: "steer" },
-      },
-    ])
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(page.locator('[data-slot="user-message-text"]')).toHaveText(expanded)
-  await expect(editor).toHaveText(followUp)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  expect(mock.creates).toEqual([expect.objectContaining({ id: pending.sessionID, location: { directory: workspace } })])
-  expect(mock.prompts).toEqual([])
-  await testInfo.attach("expanded-worktree-command", {
-    body: await page.screenshot({ path: testInfo.outputPath("expanded-worktree-command.png") }),
-    contentType: "image/png",
-  })
-})
-
 async function draftFollowUp(page: Page) {
  const editor = page.locator('[data-component="composer-editor"]')
  await editor.pressSequentially("!")
@@ -402,10 +346,7 @@ async function draftFollowUp(page: Page) {
  await expect(editor).toHaveText(followUp)
 }

-async function openDraft(
-  page: Page,
-  options?: { failSessionCreate?: boolean; command?: boolean; events?: () => OpenCodeEvent[] },
-) {
+async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
  const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
  const calls: string[] = []
  const worktreeRequests: Record<string, unknown>[] = []
@@ -437,7 +378,6 @@ async function openDraft(
    sessions,
    pageMessages: () => ({ items: [] }),
    onPrompt: (input) => prompts.push(input),
-    events: options?.events,
  })
  page.on("request", (request) => {
    if (request.method() !== "POST") return
@@ -496,17 +436,6 @@ async function openDraft(
      headers,
    }),
  )
-  if (options?.command) {
-    await page.route("**/api/command?**", (route) =>
-      route.fulfill({
-        json: {
-          location: { directory: new URL(route.request().url()).searchParams.get("location[directory]") ?? directory },
-          data: [{ name: "review", description: "Review changes" }],
-        },
-        headers,
-      }),
-    )
-  }
  await page.addInitScript(
    ({ directory, draftID, otherID, server }) => {
      localStorage.setItem(
@@ -535,8 +464,8 @@ async function openDraft(
  return { worktree, worktreeRequests, calls, creates, prompts }
 }

-async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>, prompt = text) {
-  await page.locator('[data-component="composer-editor"]').fill(prompt)
+async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
+  await page.locator('[data-component="composer-editor"]').fill(text)
  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
  await page.locator('[data-action="composer-submit"]').click()
  await expect(page).toHaveURL((url) => url.pathname.startsWith(sessionPath) && /\/ses_[^/]+$/.test(url.pathname))
@@ -552,7 +481,7 @@ async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDra
  await expect(page.locator('[data-action="composer-submit"]')).toBeDisabled()
  await expect(preparing.locator('[data-component="user-message"]')).toHaveCount(1)
  await expect(message).toHaveCount(1)
-  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(prompt)
+  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(text)
  await expect(message).toHaveAttribute("data-timeline-part-id", /^.+:text:0$/)
  const messageID = (await message.getAttribute("data-timeline-part-id"))!.replace(/:text:0$/, "")
  await expect(shimmer).toBeVisible()
@@ -1,7 +1,6 @@
-import { expect, test, type Page } from "@playwright/test"
+import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
-import { createMockServerHandler } from "../utils/mock-server"
-import { installSseTransport } from "../utils/sse-transport"
+import { currentSession } from "../utils/mock-server"

 const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const serverB = "http://127.0.0.1:4097"
@@ -9,8 +8,6 @@ const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
 const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
 const childB = { ...session("ses_server_b_child", sessionB.directory, "Server B subagent"), parentID: sessionB.id }

-test.use({ serviceWorkers: "block" })
-
 test("tab busy indicator reflects activity in the tab session family", async ({ page }, info) => {
  await mockServers(page)
  await page.addInitScript(
@@ -30,7 +27,7 @@ test("tab busy indicator reflects activity in the tab session family", async ({
  const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
  const hrefB = `/server/${base64Encode(serverB)}/session/${sessionB.id}`
  await page.goto(hrefB)
-  await expect(page.getByRole("heading", { name: sessionB.title, exact: true })).toBeVisible()
+  await expect(page.getByText(sessionB.title).first()).toBeVisible()

  // The parent is idle, but its tab remains active while the background child runs.
  const tabB = page.locator(`[data-titlebar-tab-slot]:has(a[href="${hrefB}"])`)
@@ -55,61 +52,65 @@ function session(id: string, directory: string, title: string) {
 }

 async function mockServers(page: Page) {
-  // Both servers stay connected while the client hydrates their active-session snapshots.
-  await installSseTransport(page, { server: serverA })
-  await installSseTransport(page, { server: serverB })
-  const servers = new Map(
-    [sessionA, sessionB].map(
-      (current) =>
-        [
-          current === sessionA ? serverA : serverB,
-          createMockServerHandler({
-            directory: current.directory,
-            project: {
-              id: current.projectID,
-              worktree: current.directory,
-              vcs: "git",
-              time: { created: 1, updated: 1 },
-              sandboxes: [],
-            },
-            sessions: current === sessionB ? [current, childB] : [current],
-            sessionStatus: current === sessionB ? { [childB.id]: { type: "running" } } : {},
-            provider: { all: [], connected: [], default: {} },
-            pageMessages: () => ({ items: [] }),
-          }),
-        ] as const,
-    ),
-  )
-  page.on("close", () => servers.forEach((server) => void server.dispose()))
  await page.route("**/api/**", async (route) => {
    const url = new URL(route.request().url())
-    const server = servers.get(url.origin)
-    if (!server) return route.fallback()
+    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    const current = url.origin === serverA ? sessionA : sessionB
    const directory = url.searchParams.get("directory")
-    if (directory && directory !== current.directory)
-      return route.fulfill({
-        status: 500,
-        json: { name: "InvalidDirectory" },
-        headers: { "access-control-allow-origin": "*" },
+    if (directory && directory !== current.directory) return json(route, { name: "InvalidDirectory" }, 500)
+    if (url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/api/health") return json(route, { pid: 1 })
+    if (url.pathname === "/api/session/active")
+      return json(route, { data: url.origin === serverB ? { [childB.id]: { type: "running" } } : {} })
+    if (url.pathname === "/api/session")
+      return json(route, {
+        data: url.origin === serverB ? [currentSession(current), currentSession(childB)] : [currentSession(current)],
+        cursor: {},
      })
-    if (route.request().method() === "OPTIONS")
-      return route.fulfill({
-        status: 204,
-        headers: { "access-control-allow-origin": "*", "access-control-allow-headers": "*" },
+    if (url.pathname === `/api/session/${current.id}`) return json(route, { data: currentSession(current) })
+    if (url.pathname === `/api/session/${current.id}/message`) return json(route, { data: [], cursor: {} })
+    if (["/api/agent", "/api/provider", "/api/model", "/api/command", "/api/reference"].includes(url.pathname))
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/model/default")
+      return json(route, { location: { directory: current.directory }, data: null })
+    if (url.pathname === "/api/permission/request" || url.pathname === "/api/question/request")
+      return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp") return json(route, { location: { directory: current.directory }, data: [] })
+    if (url.pathname === "/api/mcp/resource")
+      return json(route, { location: { directory: current.directory }, data: { resources: [], templates: [] } })
+    if (url.pathname === "/api/project" || url.pathname === "/api/project/current") {
+      const project = {
+        id: current.projectID,
+        canonical: current.directory,
+        vcs: "git",
+        time: { created: 1, updated: 1 },
+        sandboxes: [],
+      }
+      return json(route, url.pathname === "/api/project" ? [project] : { id: project.id, directory: current.directory })
+    }
+    if (url.pathname === "/api/location") return json(route, { directory: current.directory })
+    if (url.pathname === "/api/vcs")
+      return json(route, {
+        location: { directory: current.directory },
+        data: { branch: "main", defaultBranch: "main" },
      })
-    const body = route.request().postDataBuffer()
-    const response = await server.handler(
-      new Request(url, {
-        method: route.request().method(),
-        headers: route.request().headers(),
-        body: body ? Uint8Array.from(body) : undefined,
-      }),
-    )
-    return route.fulfill({
-      status: response.status,
-      headers: { ...Object.fromEntries(response.headers), "access-control-allow-origin": "*" },
-      body: Buffer.from(await response.arrayBuffer()),
-    })
+    return json(route, {})
+  })
+}
+
+function json(route: Route, body: unknown, status = 200) {
+  return route.fulfill({
+    status,
+    contentType: "application/json",
+    headers: { "access-control-allow-origin": "*" },
+    body: JSON.stringify(body),
+  })
+}
+
+function sse(route: Route) {
+  return route.fulfill({
+    status: 200,
+    contentType: "text/event-stream",
+    body: 'data: {"id":"evt_connected","type":"server.connected","data":{}}\n\n',
  })
 }
@@ -92,16 +92,10 @@ test("opens and searches project files inline", async ({ page }) => {
  const contextButton = page.getByRole("button", { name: "View context usage" })
  await contextButton.click()
  await expect(panel.getByRole("tab", { name: "Context", selected: true })).toBeVisible()
-  await expect(panel.getByRole("button", { name: "Open file" }).locator("use")).toHaveAttribute(
-    "href",
-    "#opencode-v2-icon-plus",
-  )
  await panel.getByRole("button", { name: "Open file" }).click()
  const openFileTab = panel.getByRole("tab", { name: "Open file" })
  const openFileTabClose = openFileTab.locator("..").getByRole("button", { name: "Close tab" })
  await expect(openFileTab).toHaveAttribute("data-selected", "")
-  await expect(openFileTab.locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(openFileTab.locator("..")).toHaveCSS("gap", "8px")
  await expect(openFileTab.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-file-tree")
  await expect(openFileTab.getByText("Open file", { exact: true }).locator("..")).not.toHaveClass(/italic/)
  await expect(openFileTabClose).toHaveAttribute("data-variant", "ghost-muted")
@@ -120,8 +114,6 @@ test("opens and searches project files inline", async ({ page }) => {

  await panel.getByRole("button", { name: "README.md" }).click()
  await expect(panel.getByRole("tab", { name: "README.md", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "README.md" }).locator("..")).toHaveCSS("gap", "8px")
  await expect(sidebarToggle).toBeEnabled()
  await expect(panel.getByText("contents:README.md", { exact: true })).toBeVisible()
  await expect(sidebar).toHaveCount(0)
@@ -137,8 +129,6 @@ test("opens and searches project files inline", async ({ page }) => {
  await expect(filter).toHaveAttribute("aria-activedescendant", resultID!)
  await filter.press("Enter")
  await expect(panel.getByRole("tab", { name: "nested.ts", selected: true })).toBeVisible()
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("padding-inline-end", "4px")
-  await expect(panel.getByRole("tab", { name: "nested.ts" }).locator("..")).toHaveCSS("gap", "8px")
  await expect(sidebarToggle).toBeEnabled()
  await expect(panel.getByText("contents:src/nested.ts", { exact: true })).toBeVisible()
  expect(searches).toContainEqual({ query: "nested", dirs: "file", limit: 200 })
@@ -23,7 +23,6 @@ for (const direction of ["ltr", "rtl"] as const) {
    await page.goto(stressSessionHref(fixture.targetID))
    const header = page.locator("[data-session-title]")
    const more = header.getByRole("button", { name: "More options", exact: true })
-    const project = header.getByRole("button", { name: fixture.project.name, exact: true })
    const review = header.getByRole("button", { name: "Toggle review", exact: true })
    const details = header.getByRole("button", { name: "Session details", exact: true })
    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
@@ -32,40 +31,22 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(details).toBeVisible()
    const status = page.locator('[data-slot="titlebar-v2"]').getByRole("button", { name: "Status" })
    await expect(status).toBeVisible()
-    const titleBounds = await header.getByRole("heading").boundingBox()
-    expect(titleBounds).not.toBeNull()
-    for (const editing of [false, true]) {
-      if (editing) {
-        await header.getByRole("heading").click()
-        await expect(header.getByRole("textbox")).toHaveValue(fixture.expected.targetTitle)
-        await expect(header.getByRole("textbox")).toBeFocused()
-      }
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-left", "4px")
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveCSS("padding-right", "4px")
-      await expect
-        .poll(async () => {
-          const boxes = await Promise.all(
-            [project, header.locator('[data-slot="session-title-child"]'), more, review, details].map((control) =>
-              control.boundingBox(),
-            ),
-          )
-          const [icon, title, menu, sidebar, summary] = boxes
-          if (!icon || !title || !menu || !sidebar || !summary || !titleBounds) return false
-          if (Math.abs(title.y - titleBounds.y) > 0.5 || Math.abs(title.height - titleBounds.height) > 0.5) return false
-          return direction === "ltr"
-            ? Math.abs(title.x - icon.x - icon.width - 2) <= 0.5 &&
-                Math.abs(menu.x - title.x - title.width - 2) <= 0.5 &&
-                menu.x + menu.width <= summary.x &&
-                summary.x + summary.width <= sidebar.x
-            : Math.abs(icon.x - title.x - title.width - 2) <= 0.5 &&
-                Math.abs(title.x - menu.x - menu.width - 2) <= 0.5 &&
-                sidebar.x + sidebar.width <= summary.x &&
-                summary.x + summary.width <= menu.x
-        })
-        .toBe(true)
-    }
-    await header.getByRole("textbox").press("Escape")
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
+    await expect
+      .poll(async () => {
+        const boxes = await Promise.all(
+          [header.getByRole("heading"), more, review, details].map((button) => button.boundingBox()),
+        )
+        const [title, menu, sidebar, summary] = boxes
+        if (!title || !menu || !sidebar || !summary) return false
+        return direction === "ltr"
+          ? Math.abs(title.x + title.width - menu.x) <= 1 &&
+              menu.x + menu.width <= summary.x &&
+              summary.x + summary.width <= sidebar.x
+          : Math.abs(menu.x + menu.width - title.x) <= 1 &&
+              sidebar.x + sidebar.width <= summary.x &&
+              summary.x + summary.width <= menu.x
+      })
+      .toBe(true)

    await review.click()
    await expect(review).toHaveAttribute("aria-expanded", "true")
@@ -74,52 +55,6 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(review).toHaveAttribute("aria-expanded", "false")

    await more.click()
-    const options = page.getByRole("menu")
-    await expect(options.getByRole("menuitem")).toHaveText(["Rename", "Export…", "Delete…"])
-    if (direction === "ltr") {
-      await expect
-        .poll(async () => {
-          const [button, menu] = await Promise.all([
-            header.getByRole("button", { name: "More options", exact: true, includeHidden: true }).boundingBox(),
-            options.boundingBox(),
-          ])
-          return button && menu ? Math.abs(button.x - menu.x) : Infinity
-        })
-        .toBeLessThanOrEqual(1)
-    }
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const rtl = getComputedStyle(element).direction === "rtl"
-          return Math.min(
-            ...Array.from(element.querySelectorAll('[data-slot="menu-v2-item-content"]'), (label) => {
-              const range = document.createRange()
-              range.selectNodeContents(label)
-              const text = range.getBoundingClientRect()
-              return rtl ? text.left - menu.left : menu.right - text.right
-            }),
-          )
-        }),
-      )
-      .toBeCloseTo(32, 0)
-    await expect
-      .poll(() =>
-        options.evaluate((element) => {
-          const menu = element.getBoundingClientRect()
-          const divider = element.querySelector('[data-slot="menu-v2-separator"]')?.getBoundingClientRect()
-          const rows = Array.from(element.querySelectorAll('[role="menuitem"]'), (row) => row.getBoundingClientRect())
-          return (
-            !!divider &&
-            Math.abs(divider.left - menu.left) <= 0.5 &&
-            Math.abs(divider.right - menu.right) <= 0.5 &&
-            rows.every(
-              (row) => Math.abs(row.left - menu.left - 2) <= 0.5 && Math.abs(menu.right - row.right - 2) <= 0.5,
-            )
-          )
-        }),
-      )
-      .toBe(true)
    await expect(page.getByRole("menuitem", { name: "Server status", exact: true })).toHaveCount(0)
    await page.keyboard.press("Escape")
    await status.click()
@@ -1,327 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { dict } from "../../src/runtime/i18n/ar"
-import en from "../../src/runtime/i18n/en"
-import { fixture, pageMessages } from "../performance/timeline/session-timeline-stress.fixture"
-import { installStressSessionTabs, stressSessionHref } from "../performance/timeline/timeline-test-helpers"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-test.use({ serviceWorkers: "block" })
-
-for (const direction of ["ltr", "rtl"] as const) {
-  for (const workspace of [false, true]) {
-    test(`session project menu for ${workspace ? "worktree" : "local"} in ${direction}`, async ({ page }) => {
-      const copy = direction === "rtl" ? dict : en
-      const directory = workspace
-        ? "C:/OpenCode/Worktrees/مشروع-42/long-folder-name-for-checking-wrapped-worktree-paths/another-long-folder-name-to-exercise-the-full-path-tooltip"
-        : fixture.directory
-      const project = {
-        ...fixture.project,
-        name: workspace
-          ? "مشروع Timeline 42 with a long project name that needs truncation and enough additional text to wrap inside the tooltip"
-          : "Timeline project",
-        sandboxes: workspace ? [directory] : [],
-        icon: {
-          url: `data:image/svg+xml,${encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><circle cx="8" cy="8" r="7" fill="blue"/></svg>')}`,
-        },
-      }
-      await mockOpenCodeServer(page, {
-        directory,
-        project,
-        sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-        provider: fixture.provider,
-        pageMessages,
-      })
-      await installStressSessionTabs(page)
-      await page.addInitScript((direction) => {
-        localStorage.setItem(
-          "opencode.global.dat:language",
-          JSON.stringify({ locale: direction === "rtl" ? "ar" : "en" }),
-        )
-        const settings = JSON.parse(localStorage.getItem("settings.v3") ?? "{}")
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({ ...settings, general: { ...settings.general, showProjectIcon: false } }),
-        )
-      }, direction)
-      await page.setViewportSize({ width: workspace ? 900 : 1440, height: 900 })
-      await page.goto(stressSessionHref(fixture.targetID))
-      const header = page.locator("[data-session-title]")
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-      await expect(page.locator("html")).toHaveAttribute("dir", direction)
-
-      const trigger = header.getByRole("button", { name: project.name, exact: true })
-      await expect(trigger).toBeEnabled()
-      await expect(trigger.locator("use")).toHaveAttribute(
-        "href",
-        `#opencode-v2-icon-${workspace ? "workspace-isolated" : "monitor"}`,
-      )
-      const background = await trigger.evaluate((element) => getComputedStyle(element).backgroundColor)
-      await trigger.hover()
-      await expect(trigger).not.toHaveCSS("background-color", background)
-      await expect(page.getByRole("tooltip")).toHaveText(project.name)
-      await trigger.click()
-
-      const menu = page.getByRole("menu", { name: project.name, exact: true })
-      const settings = menu.getByRole("menuitem", { name: "Edit project", exact: true })
-      const projectItem = menu.getByRole("menuitem", { name: project.name, exact: true })
-      await expect(trigger).toHaveAttribute("aria-expanded", "true")
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await expect(menu.getByText(project.name, { exact: true })).toBeVisible()
-      await expect(menu.locator('[data-slot="project-avatar-image"]')).toHaveAttribute("src", project.icon.url)
-      await expect(menu.getByText(directory, { exact: true })).toBeVisible()
-      await expect(menu.getByText(directory, { exact: true })).toHaveAttribute("dir", "ltr")
-      await expect(menu.locator('use[href="#opencode-v2-icon-folder"]')).toHaveCount(1)
-      await expect(menu).toHaveCSS("direction", direction)
-      await expect(menu.getByRole("menuitem")).toHaveText([project.name, directory, "Edit project"])
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await expect(settings).toBeEnabled()
-      await expect
-        .poll(() => menu.evaluate((element) => element.getBoundingClientRect().width))
-        .toBeLessThanOrEqual(320)
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        await expect(label).toHaveCSS("text-overflow", "ellipsis")
-        await expect(label).toHaveCSS("white-space", "nowrap")
-        if (workspace) {
-          await expect.poll(() => label.evaluate((element) => element.scrollWidth > element.clientWidth)).toBe(true)
-        }
-      }
-      await expect.poll(() => menu.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
-      const icons = menu.locator(
-        '[data-component="project-avatar-v2"], [data-slot="icon-svg"]:not([data-slot="session-project-open-icon"] *)',
-      )
-      await expect(icons).toHaveCount(3)
-      await expect
-        .poll(async () => {
-          const [button, centers] = await Promise.all([
-            trigger.boundingBox(),
-            icons.evaluateAll((elements) =>
-              elements.map((element) => {
-                const box = element.getBoundingClientRect()
-                return box.x + box.width / 2
-              }),
-            ),
-          ])
-          return !!button && centers.every((center) => Math.abs(center - button.x - button.width / 2) <= 1)
-        })
-        .toBe(true)
-
-      if (!workspace) await page.clock.install()
-      for (const text of [project.name, directory]) {
-        const label = menu.getByText(text, { exact: true })
-        const item = menu.getByRole("menuitem", { name: text, exact: true })
-        const anchor = item.locator("..")
-        const openIcon = item.locator('[data-slot="session-project-open-icon"]')
-        const content = item.locator(".session-project-link-content")
-        const width = await label.evaluate((element) => element.getBoundingClientRect().width)
-        await expect(openIcon).toHaveCount(text === directory ? 1 : 0)
-        await anchor.hover()
-        await expect(content).toHaveCSS("mask-image", "none")
-        await expect.poll(() => label.evaluate((element) => element.getBoundingClientRect().width)).toBe(width)
-        if (text === directory) {
-          await expect(openIcon).toHaveCSS("opacity", "0")
-          await expect(openIcon.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-arrow-up-right")
-          await expect
-            .poll(() => openIcon.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-            .toBeGreaterThan(0)
-          await expect
-            .poll(async () => {
-              const [row, icon] = await Promise.all([item.boundingBox(), openIcon.boundingBox()])
-              if (!row || !icon) return false
-              return (
-                Math.abs(row.y + row.height / 2 - icon.y - icon.height / 2) <= 0.5 &&
-                Math.abs((direction === "rtl" ? icon.x - row.x : row.x + row.width - icon.x - icon.width) - 12) <= 0.5
-              )
-            })
-            .toBe(true)
-        }
-        await expect(label).toHaveCSS("cursor", "default")
-        await expect(anchor).toHaveCSS("cursor", "default")
-        const tooltip = page.getByRole("tooltip")
-        if (workspace) {
-          await expect(tooltip).toHaveText(text)
-          await expect(tooltip).toHaveCSS("white-space", "normal")
-          await expect
-            .poll(() => tooltip.evaluate((element) => element.getBoundingClientRect().width))
-            .toBeLessThanOrEqual(480)
-          await expect
-            .poll(() =>
-              tooltip
-                .getByText(text, { exact: true })
-                .evaluate(
-                  (element) =>
-                    element.getBoundingClientRect().height > Number.parseFloat(getComputedStyle(element).lineHeight),
-                ),
-            )
-            .toBe(true)
-          await expect
-            .poll(async () => {
-              const [row, tip] = await Promise.all([anchor.boundingBox(), tooltip.boundingBox()])
-              return !!row && !!tip && Math.abs(row.y - tip.y - tip.height - 2) <= 1
-            })
-            .toBe(true)
-        }
-        if (!workspace) {
-          await page.clock.runFor(500)
-          await expect(tooltip).toBeHidden()
-        }
-        await settings.hover()
-        await expect(tooltip).toBeHidden()
-        if (text === directory) await expect(openIcon).toHaveCSS("opacity", "0")
-        await expect(content).toHaveCSS("mask-image", "none")
-      }
-
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      const pathItem = menu.getByRole("menuitem", { name: directory, exact: true })
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("Enter")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Space")
-      await expect(menu).toBeVisible()
-      await expect(pathItem).toBeFocused()
-      await page.keyboard.press("Escape")
-      await expect(menu).toBeHidden()
-      await expect(trigger).toBeFocused()
-      await trigger.press("ArrowDown")
-      await expect(projectItem).toBeFocused()
-      await page.keyboard.press("ArrowDown")
-      await expect(pathItem).toBeFocused()
-      if (workspace) await expect(page.getByRole("tooltip")).toHaveText(directory)
-      await page.keyboard.press("ArrowDown")
-      await expect(settings).toBeFocused()
-      await expect(page.getByRole("tooltip")).toBeHidden()
-      await page.keyboard.press("Enter")
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("heading", { name: copy["dialog.project.edit.title"], exact: true })).toBeVisible()
-      await expect(dialog.getByRole("textbox", { name: copy["dialog.project.edit.name"], exact: true })).toHaveValue(
-        project.name,
-      )
-      await expect(menu).toBeHidden()
-      await dialog.getByRole("button", { name: copy["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-      await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-
-      await page.setViewportSize({ width: 1440, height: 900 })
-      for (const selected of [false, true]) {
-        if (selected) {
-          await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-          await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-        }
-        await trigger.click()
-        await expect(projectItem).toBeEnabled()
-        const background = await projectItem.evaluate((element) => getComputedStyle(element).backgroundColor)
-        await projectItem.hover()
-        await expect(projectItem).not.toHaveCSS("background-color", background)
-        await projectItem.click()
-        await expect(page).toHaveURL(new URL("/", page.url()).href)
-        await expect(menu).toBeHidden()
-        const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: project.name })
-        await expect(projectRow).toBeVisible()
-        await expect(projectRow).toHaveAttribute("data-selected", "")
-        await expect(
-          page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-        ).toBeVisible()
-      }
-    })
-  }
-}
-
-for (const state of ["closed", "unopened"] as const) {
-  test(`session project menu restores ${state} projects before and after messages load`, async ({ page }) => {
-    const directory = "C:/OpenCode/Worktrees/project-menu-recovery"
-    const messages = Promise.withResolvers<void>()
-    await mockOpenCodeServer(page, {
-      directory,
-      project: { ...fixture.project, sandboxes: [directory] },
-      sessions: fixture.sessions.map((session) => ({ ...session, directory })),
-      provider: fixture.provider,
-      pageMessages,
-      beforeMessagesResponse: (input) => (input.sessionID === fixture.targetID ? messages.promise : Promise.resolve()),
-    })
-    await page.setViewportSize({ width: 1440, height: 900 })
-    if (state === "closed") {
-      await installStressSessionTabs(page)
-      await page.goto("/")
-      const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-      await expect(projectRow).toBeEnabled()
-      await projectRow.locator("..").getByRole("button", { name: "More options", exact: true }).click()
-      await page.getByRole("menuitem", { name: "Close", exact: true }).click()
-      await expect(projectRow).toHaveCount(0)
-      await page.locator(`[data-titlebar-tab-link][href="${stressSessionHref(fixture.targetID)}"]`).click()
-    }
-    if (state === "unopened") await page.goto(stressSessionHref(fixture.targetID))
-
-    const header = page.locator("[data-session-title]")
-    const trigger = header.getByRole("button", { name: fixture.project.name, exact: true })
-    const menu = page.getByRole("menu", { name: fixture.project.name, exact: true })
-    await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-    for (const loaded of [false, true]) {
-      if (loaded) {
-        messages.resolve()
-        await expect(header.getByRole("button", { name: "More options", exact: true })).toBeVisible()
-      }
-      await expect(trigger.locator("use")).toHaveAttribute("href", "#opencode-v2-icon-workspace-isolated")
-      await trigger.click()
-      await expect(menu.getByRole("menuitem", { name: fixture.project.name, exact: true })).toBeEnabled()
-      await expect(menu.getByRole("menuitem", { name: directory, exact: true })).toBeDisabled()
-      await menu.getByRole("menuitem", { name: "Edit project", exact: true }).click()
-      const dialog = page.getByRole("dialog")
-      await expect(dialog.getByRole("textbox", { name: en["dialog.project.edit.name"], exact: true })).toHaveValue(
-        fixture.project.name,
-      )
-      await dialog.getByRole("button", { name: en["common.cancel"], exact: true }).click()
-      await expect(dialog).toBeHidden()
-    }
-    await trigger.click()
-    await menu.getByRole("menuitem", { name: fixture.project.name, exact: true }).click()
-    await expect(page).toHaveURL(new URL("/", page.url()).href)
-    const projectRow = page.locator('[data-component="home-project-row"]').filter({ hasText: fixture.project.name })
-    await expect(projectRow).toBeVisible()
-    await expect(projectRow).toHaveAttribute("data-selected", "")
-    await expect(
-      page.locator(`[data-component="home-session-row-container"][data-session-id="${fixture.targetID}"]`),
-    ).toBeVisible()
-  })
-}
-
-test("path arrow has a glyph when the page has an older icon sprite", async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory: fixture.directory,
-    project: fixture.project,
-    sessions: fixture.sessions,
-    provider: fixture.provider,
-    pageMessages,
-  })
-  await installStressSessionTabs(page)
-  await page.route(
-    (url) => url.pathname === stressSessionHref(fixture.targetID),
-    async (route) => {
-      const response = await route.fetch()
-      await route.fulfill({
-        response,
-        body: (await response.text()).replace(
-          '<div id="root"',
-          '<svg id="opencode-v2-icon-sprite" width="0" height="0" aria-hidden="true"><symbol id="opencode-v2-icon-monitor" viewBox="0 0 16 16"><path d="M1 1h14v14H1z"/></symbol></svg><div id="root"',
-        ),
-      })
-    },
-  )
-  await page.goto(stressSessionHref(fixture.targetID))
-  const header = page.locator("[data-session-title]")
-  await expect(header.getByRole("heading")).toHaveText(fixture.expected.targetTitle)
-  await header.getByRole("button", { name: fixture.project.name, exact: true }).click()
-  const path = page.getByRole("menu").getByRole("menuitem", { name: fixture.directory, exact: true })
-  const arrow = path.locator('[data-slot="session-project-open-icon"]')
-  await expect(arrow).toHaveCount(1)
-  await expect
-    .poll(() => arrow.locator("svg").evaluate((element: SVGSVGElement) => element.getBBox().width))
-    .toBeGreaterThan(0)
-  await expect(page.locator("#opencode-v2-icon-sprite")).toHaveCount(1)
-})
@@ -27,12 +27,6 @@ test.beforeEach(async ({ page }) => {
    })),
    pageMessages: () => ({ items: [] }),
  })
-  await page.addInitScript((directory) => {
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({ projects: { local: [{ worktree: directory, expanded: true }] } }),
-    )
-  }, directory)
  await page.goto("/")
  await page.getByRole("button", { name: "Settings", exact: true }).click()
  await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences" })).toBeVisible()
@@ -56,34 +50,6 @@ test("settings has its own route and returns through app history", async ({ page
  await expect(home).toHaveAttribute("aria-pressed", "true")
 })

-test("new session shortcut leaves settings and opens a new session screen", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await expect(settings).toBeFocused()
-  await page.keyboard.press("Control+t")
-
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await expect(page.locator('[data-titlebar-tab][data-active="true"]')).toHaveCount(1)
-})
-
-test("recording a new session shortcut stays in settings until recording finishes", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Shortcuts", exact: true }).click()
-  const binding = settings.locator('[data-keybind-id="tab.new"]')
-  await binding.click()
-  await expect(binding).toHaveText("Press keys")
-  await page.keyboard.press("Control+t")
-
-  await expect(binding).toHaveText("Ctrl+T")
-  await expect(page).toHaveURL("/settings")
-  await expect(page.locator("[data-titlebar-tab]")).toHaveCount(0)
-  await page.keyboard.press("Control+t")
-  await expect(page).toHaveURL(/\/new-session\?draftId=.+$/)
-  await expect(settings).toBeHidden()
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-})
-
 test("workspaces opens without waiting for inventory or sessions", async ({ page }) => {
  const inventory = Promise.withResolvers<void>()
  const sessions = Promise.withResolvers<void>()
@@ -139,79 +105,6 @@ test("extensions opens without waiting for MCPs", async ({ page }) => {
  await expect(settings.getByRole("switch", { name: "demo-mcp" })).toBeChecked()
 })

-test("about opens without waiting for contributors", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.fulfill({
-      json: [],
-      headers: {
-        "access-control-allow-origin": "*",
-        "access-control-expose-headers": "Link",
-        Link: `<${url}&page=1004>; rel="last"`,
-      },
-    })
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByText(/^Version /)).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByText(/^v\d+\./)).toHaveCount(0)
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeVisible()
-
-  await settings.getByRole("tab", { name: "Preferences", exact: true }).click()
-  await expect(settings.getByRole("tab", { name: "Preferences", exact: true })).toHaveAttribute("aria-selected", "true")
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const website = settings.getByRole("link", { name: "www.opencode.ai", exact: true })
-  await website.focus()
-  contributors.resolve()
-  await expect(settings.getByRole("link", { name: "988 others", exact: true })).toBeVisible()
-  await expect(website).toBeFocused()
-})
-
-test("about is available in the mobile settings menu", async ({ page }) => {
-  await page.route("https://api.github.com/repos/anomalyco/opencode/contributors?*", (route) => route.abort("failed"))
-  await page.setViewportSize({ width: 390, height: 844 })
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("button", { name: "Preferences", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "About", exact: true }).click()
-  await expect(settings.getByRole("button", { name: "About", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await settings.getByRole("button", { name: "About", exact: true }).click()
-  await expect(page.getByRole("menuitemradio", { name: "About", exact: true })).toBeChecked()
-})
-
-test("about keeps its fallback when the contributor request fails", async ({ page }) => {
-  const contributors = Promise.withResolvers<void>()
-  const url = "https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1"
-  await page.route(url, async (route) => {
-    await contributors.promise
-    await route.abort("failed")
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest(url)
-  await settings.getByRole("tab", { name: "About", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-
-  const failed = page.waitForEvent("requestfailed", (request) => request.url() === url)
-  contributors.resolve()
-  await failed
-  await expect(settings.getByRole("link", { name: "935 others", exact: true })).toBeVisible()
-  await expect(settings.getByText("Released under the MIT License", { exact: true })).toBeVisible()
-  await expect(settings.getByRole("tab", { name: "About", exact: true })).toHaveAttribute("aria-selected", "true")
-})
-
 test("workspace inventory uses the settings panel scroll area", async ({ page }) => {
  const settings = page.getByTestId("settings-screen")
  await settings.getByRole("tab", { name: "Worktrees", exact: true }).click()
@@ -1,6 +1,7 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
+import pkg from "../../package.json" with { type: "json" }

 const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const sessionA = session("ses_tab_a", "Tab A session")
@@ -184,9 +185,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
  await expect(tabA).toContainText(sessionA.title)
  await expect(tabB).toContainText(sessionB.title)
  await expect(tabB.locator('[data-slot="tab-project"]')).toHaveText("tab-project")
-  await expect(
-    sidebar.getByRole("button", { name: "Home", exact: true }).getByText("Home", { exact: true }),
-  ).toBeVisible()
+  await expect(sidebar.getByRole("button", { name: "Home", exact: true })).toHaveText("Home")
  await expect(sidebar.getByRole("button", { name: "New session" })).toBeVisible()
  await expect(sidebar.locator('[data-slot="vertical-tabs-footer"]')).toBeVisible()
  const status = sidebar.getByRole("button", { name: "Status", exact: true })
@@ -232,77 +231,7 @@ test("vertical tabs show project details, resize, and navigate", async ({ page }
  await expect(tabB).toBeVisible()
 })

-for (const profile of [
-  { locale: "en", direction: "ltr" },
-  { locale: "en", direction: "rtl" },
-  { locale: "ar", direction: "rtl" },
-]) {
-  test(`vertical shortcut hints align at the row end: ${profile.locale} ${profile.direction}`, async ({ page }) => {
-    await mockServer(page)
-    await page.addInitScript(
-      ({ server, sessionID, locale }) => {
-        localStorage.setItem("opencode.global.dat:language", JSON.stringify({ locale }))
-        localStorage.setItem(
-          "settings.v3",
-          JSON.stringify({
-            appearance: { tabLayout: "vertical" },
-            keybinds: { "home.toggle": "ctrl+alt+h", "tab.new": "ctrl+shift+n" },
-          }),
-        )
-        localStorage.setItem(
-          "opencode.window.browser.dat:tabs",
-          JSON.stringify([{ type: "session", server, sessionId: sessionID }]),
-        )
-      },
-      { server, sessionID: sessionA.id, locale: profile.locale },
-    )
-    await page.goto(`/server/${base64Encode(server)}/session/${sessionA.id}`)
-
-    const sidebar = page.locator('[data-slot="vertical-tabs-sidebar"]')
-    await expect(sidebar).toHaveCSS("width", "260px")
-    await page
-      .locator("html")
-      .evaluate((element, direction) => element.setAttribute("dir", direction), profile.direction)
-    await expect(sidebar).toHaveCSS("direction", profile.direction)
-
-    for (const row of [
-      { action: "home", shortcut: "Ctrl+Alt+H" },
-      { action: "new-session", shortcut: "Ctrl+Shift+N" },
-    ]) {
-      const button = sidebar.locator(`[data-action="vertical-tabs-${row.action}"]`)
-      const hint = button.locator('span[aria-hidden="true"]')
-      await expect(hint).toHaveText(row.shortcut)
-      await expect(hint.getByText(row.shortcut, { exact: true })).toHaveCSS("direction", "ltr")
-      await expect(hint).toHaveCSS("opacity", "0")
-      await button.hover()
-      await expect(hint).toHaveCSS("opacity", "1")
-      await expect
-        .poll(() =>
-          hint.evaluate((element) => {
-            const button = element.closest("button")!
-            const row = button.getBoundingClientRect()
-            const hint = element.getBoundingClientRect()
-            return getComputedStyle(button).direction === "rtl" ? hint.left - row.left : row.right - hint.right
-          }),
-        )
-        .toBeCloseTo(8, 1)
-      await page.getByRole("main").hover()
-      await expect(hint).toHaveCSS("opacity", "0")
-    }
-
-    const home = sidebar.locator('[data-action="vertical-tabs-home"]')
-    const newSession = sidebar.locator('[data-action="vertical-tabs-new-session"]')
-    await home.focus()
-    await page.keyboard.press("Tab")
-    await expect(newSession).toBeFocused()
-    await expect(newSession.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-    await page.keyboard.press("Shift+Tab")
-    await expect(home).toBeFocused()
-    await expect(home.locator('span[aria-hidden="true"]')).toHaveCSS("opacity", "1")
-  })
-}
-
-test("dedicated experimental settings control vertical tab details", async ({ page }) => {
+test("appearance experimental settings control vertical tab details", async ({ page }) => {
  await mockServer(page)
  await page.addInitScript(
    ({ server, sessionA }) => {
@@ -320,14 +249,11 @@ test("dedicated experimental settings control vertical tab details", async ({ pa

  const settings = page.getByTestId("settings-screen")
  await expect(settings).toBeVisible()
-  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toHaveCount(0)
-  await expect(settings.getByRole("tablist").getByText(/^v\d+\./)).toHaveCount(0)
+  const version = settings.getByRole("tablist").getByText(`v${pkg.version}`, { exact: true })
+  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toBeInViewport()
+  await expect(version).toBeInViewport()
  await settings.getByRole("tab", { name: "Appearance" }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(settings.locator('[data-action="settings-tab-layout"]')).toHaveCount(0)
-  await expect(settings.getByRole("switch", { name: "Show project names", exact: true })).toHaveCount(0)
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
+  await expect(settings.getByRole("heading", { name: "Experimental" })).toBeVisible()

  const layout = settings.locator('[data-action="settings-tab-layout"]')
  await expect(layout).toContainText("Horizontal")
@@ -348,27 +274,19 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
  await page.setViewportSize({ width: 920, height: 720 })
  await expect(page.locator('[data-slot="vertical-tabs-sidebar"]')).toHaveCSS("width", "260px")
  await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()

  await page.setViewportSize({ width: 800, height: 720 })
  await expect(settings.getByRole("tablist")).toBeHidden()
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeVisible()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()

  await page.setViewportSize({ width: 390, height: 720 })
-  await settings.getByRole("button", { name: "Experimental", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Appearance", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Appearance", exact: true })).toBeVisible()
-  await expect(layout).toHaveCount(0)
-  await settings.getByRole("button", { name: "Appearance", exact: true }).click()
-  await page.getByRole("menuitemradio", { name: "Experimental", exact: true }).click()
-  await expect(settings.getByRole("heading", { name: "Experimental", level: 2, exact: true })).toBeVisible()
-  await expect(layout).toContainText("Vertical")
-  await expect(projectNameSwitch).toBeChecked()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeVisible()
  await settings.evaluate((element) => element.setAttribute("dir", "rtl"))
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()

  await page.setViewportSize({ width: 390, height: 360 })
-  await expect(settings.getByRole("button", { name: "Experimental", exact: true })).toBeInViewport()
+  await expect(settings.getByRole("button", { name: "Appearance", exact: true })).toBeInViewport()

  // Reload the UI-selected preference without seeding settings storage.
  await page.reload()
@@ -392,7 +310,7 @@ test("dedicated experimental settings control vertical tab details", async ({ pa
  ).toBeVisible()
  await expect(page.locator('[data-slot="titlebar-tabs"]')).toHaveCount(0)
  await page.keyboard.press("Control+,")
-  await settings.getByRole("tab", { name: "Experimental", exact: true }).click()
+  await settings.getByRole("tab", { name: "Appearance" }).click()
  await expect(layout).toContainText("Vertical")
 })

@@ -1,57 +0,0 @@
-import { expect, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { mockOpenCodeServer } from "./mock-server"
-import { APP_READY_TIMEOUT } from "./waits"
-
-export const paletteSession = {
-  id: "ses_command_palette",
-  projectID: "proj_command_palette",
-  directory: "C:/OpenCode/CommandPalette",
-  title: "Palette fixture session",
-  time: { created: 1700000000000, updated: 1700000000000 },
-}
-
-export function captureConsoleWarnings(page: Page) {
-  const warnings: string[] = []
-  page.on("console", (message) => {
-    if (message.type() !== "warning" && message.type() !== "error") return
-    // This message comes from test isolation, not application code.
-    if (message.text() === "Service Worker registration blocked by Playwright") return
-    warnings.push(message.text())
-  })
-  return warnings
-}
-
-export async function openCommandPalette(page: Page, home = false) {
-  await mockOpenCodeServer(page, {
-    directory: paletteSession.directory,
-    project: {
-      id: paletteSession.projectID,
-      worktree: paletteSession.directory,
-      vcs: "git",
-      name: "command-palette",
-      time: paletteSession.time,
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [paletteSession],
-    pageMessages: () => ({ items: [] }),
-    findFiles: () => [],
-  })
-  const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-  await page.goto(home ? "/" : `/server/${base64Encode(server)}/session/${paletteSession.id}`)
-  if (home) {
-    await expect(
-      page.getByRole("region", { name: "Recent sessions" }).getByRole("button", { name: /Palette fixture session/ }),
-    ).toBeEnabled({ timeout: APP_READY_TIMEOUT })
-  }
-  if (!home) {
-    await expect(page.locator('[data-component="composer-editor"]')).toBeEditable({ timeout: APP_READY_TIMEOUT })
-  }
-  await page.keyboard.press("ControlOrMeta+Shift+P")
-  const dialog = page.getByRole("dialog")
-  const input = dialog.getByRole("textbox")
-  await expect(input).toBeFocused()
-  await expect(dialog.getByRole("option")).not.toHaveCount(0)
-  return { dialog, input }
-}
@@ -575,7 +575,7 @@ export function ComposerEditorAddMenu(props: {
        />
        <Menu.Portal>
          <Menu.Content
-            class="[&_[data-slot=menu-v2-item-shortcut]]:w-5 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
+            class="[&_[data-slot=menu-v2-item-shortcut]]:w-8 [&_[data-slot=menu-v2-item-shortcut]]:justify-center"
            style={{ "min-width": "180px" }}
          >
            <Menu.Item onSelect={props.onAttach} shortcut={props.attachShortcut}>
@@ -251,7 +251,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
  const submission = createComposerSubmit({
    adapter,
    mode,
-    commands: () => data.location.command.list({ directory: sdk().directory }),
    editor: () => editor,
    queueScroll: () => requestAnimationFrame(() => editor?.scrollIntoView({ block: "nearest" })),
    addToHistory: (value, mode) => controller.addHistory(value, mode),
@@ -52,12 +52,10 @@ function submitInput(
  adapter: ActiveComposerAdapter | NewSessionComposerAdapter,
  notify = { missingSelection() {}, failed(_kind: "shell" | "command" | "prompt", _error: unknown) {} },
  mode: "normal" | "shell" = "normal",
-  commands: () => readonly { name: string }[] | undefined = () => [],
 ) {
  return createComposerSubmit({
    adapter,
    mode: () => mode,
-    commands,
    editor: () => undefined,
    queueScroll() {},
    addToHistory() {},
@@ -422,6 +420,7 @@ describe("Composer submission", () => {
      prompt: async () => undefined,
      command: async (value) => sent.resolve(value),
    })
+    target.data.location.command.list = () => [{ name: "review", description: "Review changes", template: "" }]
    const adapter: ActiveComposerAdapter = {
      kind: "active-session",
      state,
@@ -434,7 +433,7 @@ describe("Composer submission", () => {
      setEditor() {},
    }

-    await submitInput(adapter, undefined, "normal", () => [{ name: "review" }]).submit(new Event("submit"))
+    await submitInput(adapter).submit(new Event("submit"))
    const request = await sent.promise

    expect(request.files).toMatchObject([{ name: "app.ts", mention: { text: "@src/app.ts" } }])
@@ -443,51 +442,6 @@ describe("Composer submission", () => {
    expect(request.delivery).toBe("steer")
  })

-  test("captures commands before creating a session in a new worktree", async () => {
-    const state = createMemoryComposerState({ prompt: "/review https://github.com/example/repo/pull/1" }).capture()
-    const catalog = [{ name: "review" }]
-    const sent = Promise.withResolvers<"prompt" | "command">()
-    const requests: Parameters<ComposerSession["api"]["command"]>[0][] = []
-    const target = session({
-      calls: [],
-      prompt: async () => sent.resolve("prompt"),
-      command: async (value) => {
-        requests.push(value)
-        sent.resolve("command")
-      },
-    })
-    target.directory = "C:/new-worktree"
-    target.data.location.command.list = () => undefined
-    const adapter: NewSessionComposerAdapter = {
-      kind: "new-session",
-      state,
-      ready: () => true,
-      controls,
-      working: () => false,
-      submitted() {},
-      async start() {
-        // The destination catalog has not loaded, and the source composer is leaving.
-        catalog.splice(0)
-        return { session: target, cleanupReady: Promise.resolve() }
-      },
-    }
-
-    await submitInput(adapter, undefined, "normal", () => catalog).submit(new Event("submit"))
-
-    expect(await sent.promise).toBe("command")
-    expect(requests).toEqual([
-      {
-        sessionID: target.id,
-        command: "review",
-        text: "https://github.com/example/repo/pull/1",
-        files: [],
-        agents: [],
-        skills: [],
-        delivery: "steer",
-      },
-    ])
-  })
-
  test("does not run an empty shell command from hidden attachments", async () => {
    const state = createMemoryComposerState().capture()
    state.set([
@@ -27,7 +27,6 @@ type ComposerSubmission = {
 type ComposerSubmitInput = {
  adapter: ComposerAdapter
  mode: Accessor<"normal" | "shell">
-  commands: Accessor<readonly { name: string }[] | undefined>
  editor: () => HTMLDivElement | undefined
  queueScroll: () => void
  addToHistory: (prompt: Prompt, mode: "normal" | "shell") => void
@@ -66,8 +65,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
    if (submitting.has(input.adapter.state)) return
    submitting.add(input.adapter.state)
    const comments = input.comments.capture()
-    // Capture command intent before starting a session in a worktree whose catalog has not loaded.
-    const command = value.mode === "normal" ? findCommand(input.commands(), value.text) : undefined

    try {
      const started =
@@ -81,6 +78,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
      input.resetHistory()
      const restore = () => restoreSubmission(input, submission, value, comments)

+      const command = value.mode === "normal" ? findCommand(session, value.text) : undefined
      if (value.mode === "normal" && !command) {
        session.handoff?.set(handoffMessage(value))
        const optimisticBusy = !input.adapter.working()
@@ -279,11 +277,12 @@ async function sendShell(session: ComposerSession, value: ComposerSubmission) {
  await session.api.shell({ sessionID: session.id, id: Event.ID.create(), command: value.text })
 }

-function findCommand(commands: ReturnType<ComposerSubmitInput["commands"]>, text: string) {
+function findCommand(session: ComposerSession, text: string) {
  if (!text.startsWith("/")) return
  const [name, ...arguments_] = text.split(" ")
  const command = name.slice(1)
-  if (!commands?.some((item) => item.name === command)) return
+  if (!session.data.location.command.list({ directory: session.directory })?.some((item) => item.name === command))
+    return
  return { command, arguments: arguments_.join(" ") }
 }

@@ -52,9 +52,10 @@ export function HomeCommandPalette(props: {
    }
    if (item.type === "session") props.onSelectSession(item)
  }
-  const items = (query: string) => {
+  const loadItems = async (text: string) => {
+    const query = text.trim()
    if (!query) return commandEntries().slice(0, 5)
-    return commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, query))
+    return [...commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, query)), ...(await sessions(query))]
  }

  onCleanup(() => {
@@ -65,8 +66,7 @@ export function HomeCommandPalette(props: {
  return (
    <CommandPaletteView
      placeholder={language.t("palette.search.placeholder.home")}
-      items={items}
-      sources={[sessions]}
+      loadItems={loadItems}
      highlight={highlight}
      select={select}
      close={() => dialog.close()}
@@ -908,25 +908,6 @@ export const dict = {
  "settings.tab.notifications": "Notifications",
  "settings.tab.projects": "Projects",
  "settings.tab.extensions": "Extensions",
-  "settings.tab.experimental": "Experimental",
-  "settings.experimental.description": "Try experimental features",
-  "settings.tab.about": "About",
-  "settings.about.version": "Version {{version}}",
-  "settings.about.devVersion": "development",
-  "settings.about.license": "Released under the MIT License",
-  "settings.about.writtenBy": "Written by",
-  "settings.about.illustratedBy": "Illustrated by",
-  "settings.about.and": "and",
-  "settings.about.otherContributor.one": "{{count}} other",
-  "settings.about.otherContributor.other": "{{count}} others",
-  "settings.about.firstPublished": "First published in Missouri, USA",
-  "settings.about.firstIllustrated": "First illustrated in London, England",
-  "settings.about.website": "www.opencode.ai",
-  "settings.about.description": "OpenCode, the open source coding agent",
-  "settings.about.trademark": "OpenCode is a registered trademark of Anomaly Innovations, Inc.",
-  "settings.about.typeset": "Typeset in Inter and IBM Plex Mono",
-  "settings.about.tagline": "AI can’t build great software, without you",
-  "settings.about.copyright": "© Anomaly Innovations, Inc.",
  "settings.preferences.description": "Customize preferences and theme and default behavior",
  "settings.appearance.description": "Customize theme and fonts",
  "settings.appearance.section.experimental": "Experimental",
@@ -954,7 +935,6 @@ export const dict = {
  "settings.desktop.wsl.title": "WSL integration",
  "settings.desktop.wsl.description": "Run the OpenCode server inside WSL on Windows.",
  "dialog.server.authenticate.title": "Authenticate",
-  "project.settings.title": "Edit project",
  "project.settings.general.description": "Manage project name and appearance",
  "project.settings.scripts": "Scripts",
  "project.settings.scripts.description": "Configure scripts for this project",
@@ -13,9 +13,6 @@ import { createServerNotificationState } from "@/shell/notifications/notificatio
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { createDesktopData } from "./data"
 import { ModelState } from "./persistence"
-import { useLanguage } from "@/runtime/i18n/language"
-import { showToast } from "@/shell/notifications/toast"
-import { formatServerError } from "./errors"

 export const { use: useGlobal, provider: GlobalProvider } = createSimpleContext({
  name: "Global",
@@ -130,7 +127,6 @@ function createServerController(
  scope: ServerScope,
  projects: ReturnType<typeof createServerProjects>,
 ) {
-  const language = useLanguage()
  const connKey = ServerConnection.key(conn)
  const sdk = createServerSdkContext(conn, scope)
  const source = createData({
@@ -141,13 +137,6 @@ function createServerController(
    },
    connection: sdk.connection,
    directory: "",
-    onError(error) {
-      showToast({
-        variant: "error",
-        title: language.t("common.requestFailed"),
-        description: formatServerError(error, language.t),
-      })
-    },
  })
  const data = createDesktopData({
    data: source,
@@ -321,10 +321,9 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
      }),
      tab &&
        fileCommand({
-          id: "file.close",
+          id: "tab.close",
          title: language.t("command.tab.close"),
-          keybind: settings.keybinds.get("tab.close") ?? "mod+w",
-          when: (event) => !(event.target instanceof Element && event.target.closest('[data-component="terminal"]')),
+          keybind: "mod+w",
          onSelect: closeTab,
        }),
    ].filter((v) => !!v)
@@ -170,10 +170,10 @@ export function SessionFileBrowserTab(props: {
        when={!props.placeholder}
        fallback={
          <SessionFilePanelV2Empty>
-            <div class="flex flex-col items-center gap-2 text-center text-text-weak">
-              <Icon name="file-tree" size="large" class="mb-2" />
-              <div class="text-[13px] font-medium leading-[13px] text-text-strong">{language.t("command.file.open")}</div>
-              <div class="h-5 text-13-regular leading-5">{language.t("session.files.selectToOpen")}</div>
+            <div class="flex flex-col items-center gap-3 text-center text-text-weak">
+              <Icon name="file-tree" size="large" />
+              <div class="text-14-medium text-text-strong">{language.t("command.file.open")}</div>
+              <div class="text-13-regular">{language.t("session.files.selectToOpen")}</div>
            </div>
          </SessionFilePanelV2Empty>
        }
@@ -219,7 +219,7 @@ export function SessionSidePanel(props: {
    return active !== "review" && active !== "context" && active !== "empty"
  })
  const openFileKeybind = createMemo(() => command.keybindParts("file.open"))
-  const closeTabKeybind = createMemo(() => command.keybindParts("file.close"))
+  const closeTabKeybind = createMemo(() => command.keybindParts("tab.close"))
  createEffect(() => {
    if (!file.ready()) return

@@ -417,7 +417,7 @@ export function SessionSidePanel(props: {
                              class="flex items-center"
                            >
                              <IconButton
-                                icon={<Icon name="plus" />}
+                                icon={<Icon name="plus-small" />}
                                variant="ghost-muted"
                                size="large"
                                onClick={() => openFileBrowser()}
@@ -19,7 +19,7 @@ export function SortableTab(props: {
  const file = useFile()
  const language = useLanguage()
  const command = useCommand()
-  const closeTabKeybind = createMemo(() => command.keybindParts("file.close"))
+  const closeTabKeybind = createMemo(() => command.keybindParts("tab.close"))
  const sortable = useSortable({
    get id() {
      return props.tab
@@ -1,55 +0,0 @@
-/* Informational tooltips must not block menu items. Kobalte sets pointer events inline. */
-[data-popper-positioner]:has(.session-project-info-tooltip),
-.session-project-info-tooltip {
-  pointer-events: none !important;
-}
-
-.session-options-menu [data-component="menu-v2-item"] {
-  padding-inline-end: 30px;
-}
-
-.session-project-link {
-  --session-project-fade-direction: to right;
-  position: relative;
-
-  &:dir(rtl) {
-    --session-project-fade-direction: to left;
-  }
-
-  &[aria-disabled="true"] {
-    opacity: 0.5;
-  }
-}
-
-.session-project-link-content {
-  display: flex;
-  flex: 1;
-  min-width: 0;
-  align-items: center;
-  gap: 8px;
-}
-
-.session-project-link-open {
-  position: absolute;
-  inset-inline-end: 12px;
-  inset-block: 0;
-  display: flex;
-  align-items: center;
-  color: var(--v2-icon-icon-muted);
-  pointer-events: none;
-  opacity: 0;
-}
-
-.session-project-link:is(:hover, [data-highlighted]):not([aria-disabled="true"]) {
-  .session-project-link-content {
-    mask-image: linear-gradient(
-      var(--session-project-fade-direction),
-      #000 calc(100% - 40px),
-      transparent calc(100% - 24px)
-    );
-  }
-
-  .session-project-link-open {
-    opacity: 1;
-  }
-}
@@ -1,27 +1,18 @@
 import type { SessionInfo } from "@opencode-ai/client/promise"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Icon } from "@opencode-ai/ui/icon"
-import { IconButton } from "@opencode-ai/ui/icon-button"
-import { Menu } from "@opencode-ai/ui/menu"
 import { ProjectAvatar } from "@opencode-ai/ui/project-avatar"
-import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { createResizeObserver } from "@solid-primitives/resize-observer"
 import { useNavigate } from "@solidjs/router"
 import { createMemo, Show, type ParentProps } from "solid-js"
-import { createStore } from "solid-js/store"
 import { useServer } from "@/runtime/server/current"
 import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform } from "@/runtime/platform/platform"
-import { displayName, errorMessage, getProjectAvatarSource, projectForSession } from "@/shell/layout/helpers"
-import { getProjectAvatarVariant, useLayout, type LocalProject } from "@/shell/state/layout"
+import { displayName, getProjectAvatarSource, projectForSession } from "@/shell/layout/helpers"
+import { getProjectAvatarVariant } from "@/shell/state/layout"
 import { tabKey, useTabs } from "@/shell/tabs/tabs"
 import { useSettings } from "@/settings/model"
 import { pathKey } from "@/workspaces/path-key"
-import { isProjectDirectory, isWorkspaceDirectory } from "@/workspaces/paths"
+import { isWorkspaceDirectory } from "@/workspaces/paths"
 import { sessionHref } from "@/shell/routes/session"
-import { showToast } from "@/shell/notifications/toast"
 import { sessionTitle } from "./title"
-import "./session-identity-header.css"

 export function SessionTitleHeader(props: ParentProps) {
  return (
@@ -34,173 +25,6 @@ export function SessionTitleHeader(props: ParentProps) {
  )
 }

-export function SessionProjectMenu(props: {
-  project?: Omit<LocalProject, "expanded">
-  directory?: string
-  workspace: boolean
-  showProjectIcon: boolean
-}) {
-  const server = useServer()
-  const language = useLanguage()
-  const dialog = useDialog()
-  const platform = usePlatform()
-  const layout = useLayout()
-  const navigate = useNavigate()
-  const [state, setState] = createStore({
-    open: false,
-    projectTruncated: false,
-    pathTruncated: false,
-    pathFocused: false,
-  })
-  const projectName = createMemo(() => displayName(props.project ?? { worktree: props.directory ?? "" }))
-  const canOpenPath = () =>
-    platform.platform === "desktop" && !!platform.openPath && server.isLocal && !!props.directory
-  const openPath = () => {
-    if (!canOpenPath() || !platform.openPath || !props.directory) return
-    void platform.openPath(props.directory).catch((cause: unknown) =>
-      showToast({
-        title: language.t("common.requestFailed"),
-        description: errorMessage(cause, language.t("common.requestFailed")),
-      }),
-    )
-  }
-  const openProjectSettings = async () => {
-    const current = props.project
-    if (!current) return
-    const { DialogEditProject } = await import("@/settings/workspaces/project-dialog")
-    dialog.push(() => <DialogEditProject project={{ expanded: false, ...current }} server={server.conn} />)
-  }
-
-  return (
-    <Menu
-      placement="bottom-start"
-      gutter={4}
-      shift={-10}
-      modal={false}
-      open={state.open}
-      onOpenChange={(open) => setState({ open, pathFocused: false })}
-    >
-      <Tooltip placement="bottom" value={<bdi>{projectName()}</bdi>} class="flex shrink-0">
-        <Menu.Trigger
-          as={IconButton}
-          variant="ghost-muted"
-          aria-label={projectName()}
-          data-slot="session-project-trigger"
-          icon={
-            <Show
-              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"} />
-                </span>
-              }
-            >
-              <ProjectAvatar
-                fallback={projectName()}
-                src={getProjectAvatarSource(props.project?.id, props.project?.icon)}
-                variant={getProjectAvatarVariant(props.project?.icon?.color)}
-              />
-            </Show>
-          }
-        />
-      </Tooltip>
-      <Menu.Portal>
-        <Menu.Content class="w-max max-w-[min(320px,calc(100vw-16px))]" aria-label={projectName()}>
-          <Tooltip
-            placement="top"
-            gutter={2}
-            disabled={!state.projectTruncated}
-            class="min-w-0 cursor-default"
-            contentClass="session-project-info-tooltip max-w-[min(480px,calc(100vw-16px))] whitespace-normal break-all"
-            value={<bdi>{projectName()}</bdi>}
-          >
-            <Menu.Item
-              class="min-w-0 w-full"
-              disabled={!props.project}
-              onSelect={() => {
-                const project = props.project
-                if (!project) return
-                server.ctx.projects.open(project.worktree)
-                layout.home.setSelection({ server: server.key, directory: project.worktree })
-                navigate("/")
-              }}
-            >
-              <span class="session-project-link-content">
-                <ProjectAvatar
-                  class="shrink-0"
-                  aria-hidden="true"
-                  fallback={projectName()}
-                  src={getProjectAvatarSource(props.project?.id, props.project?.icon)}
-                  variant={getProjectAvatarVariant(props.project?.icon?.color)}
-                />
-                <bdi
-                  ref={(element) =>
-                    createResizeObserver(element, () =>
-                      setState("projectTruncated", element.scrollWidth > element.clientWidth),
-                    )
-                  }
-                  class="min-w-0 truncate text-13-medium"
-                >
-                  {projectName()}
-                </bdi>
-              </span>
-            </Menu.Item>
-          </Tooltip>
-          <Tooltip
-            placement="top"
-            gutter={2}
-            disabled={!state.pathTruncated}
-            forceOpen={state.pathFocused && state.pathTruncated ? true : undefined}
-            class="min-w-0 cursor-default"
-            contentClass="session-project-info-tooltip max-w-[min(480px,calc(100vw-16px))] whitespace-normal break-all"
-            value={<bdi dir="ltr">{props.directory}</bdi>}
-          >
-            {/* Read-only paths stay in keyboard navigation so their full tooltip remains accessible. */}
-            <Menu.Item
-              class="session-project-link min-w-0 w-full cursor-default"
-              disabled={!props.directory}
-              aria-disabled={!canOpenPath()}
-              closeOnSelect={canOpenPath()}
-              onSelect={openPath}
-              onFocus={() => setState("pathFocused", true)}
-              onBlur={() => setState("pathFocused", false)}
-              onKeyDown={(event) => {
-                if (event.key !== "Escape") return
-                event.preventDefault()
-                event.stopPropagation()
-                setState({ open: false, pathFocused: false })
-              }}
-            >
-              <span class="session-project-link-content">
-                <Icon name="folder" class="shrink-0 text-v2-icon-icon-muted" />
-                <bdi
-                  ref={(element) =>
-                    createResizeObserver(element, () =>
-                      setState("pathTruncated", element.scrollWidth > element.clientWidth),
-                    )
-                  }
-                  dir="ltr"
-                  class="min-w-0 truncate text-v2-text-text-muted"
-                >
-                  {props.directory}
-                </bdi>
-              </span>
-              <span data-slot="session-project-open-icon" class="session-project-link-open" aria-hidden="true">
-                <Icon name="arrow-up-right" />
-              </span>
-            </Menu.Item>
-          </Tooltip>
-          <Menu.Separator />
-          <Menu.Item disabled={!props.project} onSelect={() => void openProjectSettings()}>
-            <Icon name="settings-gear" class="text-v2-icon-icon-muted" />
-            {language.t("project.settings.title")}
-          </Menu.Item>
-        </Menu.Content>
-      </Menu.Portal>
-    </Menu>
-  )
-}
-
 export function SessionIdentityHeader(props: { sessionID: string; session?: SessionInfo }) {
  const server = useServer()
  const tabs = useTabs()
@@ -247,17 +71,12 @@ export function SessionIdentityHeader(props: { sessionID: string; session?: Sess
  )
  const project = createMemo(() => {
    const projects = server.ctx.projects.list()
-    if (props.session)
-      return (
-        projectForSession(props.session, projects) ?? projectForSession(props.session, server.ctx.sync.data.project)
-      )
+    if (props.session) return projectForSession(props.session, projects)
    const value = directory()
    if (!value) return undefined
    const key = pathKey(value)
-    return (
-      projects.find(
-        (item) => pathKey(item.worktree) === key || item.sandboxes?.some((sandbox) => pathKey(sandbox) === key),
-      ) ?? server.ctx.sync.data.project.find((item) => isProjectDirectory(item, value))
+    return projects.find(
+      (item) => pathKey(item.worktree) === key || item.sandboxes?.some((sandbox) => pathKey(sandbox) === key),
    )
  })
  const showProjectIcon = () =>
@@ -276,13 +95,25 @@ export function SessionIdentityHeader(props: { sessionID: string; session?: Sess
      <SessionTitleHeader>
        <div class="flex h-12 w-full items-center justify-between gap-2">
          <div class="flex min-w-0 flex-1 items-center gap-1">
-            <div class="flex min-w-0 w-full flex-1 items-center gap-0.5">
-              <SessionProjectMenu
-                project={project()}
-                directory={directory()}
-                workspace={workspaceSession()}
-                showProjectIcon={showProjectIcon()}
-              />
+            <div class="flex min-w-0 w-full flex-1 items-center">
+              <span
+                classList={{
+                  "flex size-6 shrink-0 items-center justify-center": true,
+                  "text-v2-icon-icon-accent": workspaceSession() && !showProjectIcon(),
+                  "text-v2-icon-icon-muted": !workspaceSession() && !showProjectIcon(),
+                }}
+              >
+                <Show
+                  when={showProjectIcon()}
+                  fallback={<Icon name={workspaceSession() ? "workspace-isolated" : "monitor"} />}
+                >
+                  <ProjectAvatar
+                    fallback={displayName(project() ?? { worktree: directory() ?? "" })}
+                    src={getProjectAvatarSource(project()?.id, project()?.icon)}
+                    variant={getProjectAvatarVariant(project()?.icon?.color)}
+                  />
+                </Show>
+              </span>
              <Show when={parentTitle()}>
                {(value) => (
                  <button
@@ -310,7 +141,7 @@ export function SessionIdentityHeader(props: { sessionID: string; session?: Sess
                  <h1
                    data-slot={parentID() ? "session-title-child" : undefined}
                    dir="auto"
-                    class="w-fit truncate rounded-[6px] px-1 py-1 text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base"
+                    class="w-fit truncate rounded-[6px] px-2 py-1 text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base"
                  >
                    {value()}
                  </h1>
@@ -10,6 +10,7 @@ import { InlineInput } from "@opencode-ai/ui/inline-input"
 import { Keybind } from "@opencode-ai/ui/keybind"
 import { Menu } from "@opencode-ai/ui/menu"
 import { TextShimmer } from "@opencode-ai/ui/text-shimmer"
+import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { ProjectAvatar } from "@opencode-ai/ui/project-avatar"
 import type { Project } from "@/runtime/server/types"
 import { getFilename } from "@opencode-ai/util/path"
@@ -30,7 +31,7 @@ import { displayName, getProjectAvatarSource, projectForSession } from "@/shell/
 import { parseCommentNote, readPromptPresentation } from "@/composer/comment-note"
 import { useCommand } from "@/shell/commands/command"
 import { useSettings } from "@/settings/model"
-import { SessionProjectMenu, SessionTitleHeader } from "../session-identity-header"
+import { SessionTitleHeader } from "../session-identity-header"
 import { SessionHeader } from "@/session/header/session-header"

 type BackgroundTask = {
@@ -408,9 +409,10 @@ function MessageTimelineView(
  const workspaceSession = createMemo(() => isWorkspaceDirectory(project(), sessionDirectory()))
  const showProjectIcon = () => import.meta.env.VITE_OPENCODE_CHANNEL !== "prod" && settings.general.showProjectIcon()
  const avatarProject = createMemo(() => {
+    if (!showProjectIcon()) return
    const session = props.session.data.info()
    if (!session) return
-    return projectForSession(session, server.ctx.projects.list()) ?? project()
+    return projectForSession(session, server.ctx.projects.list())
  })
  const projectAvatar = () => (
    <ProjectAvatar
@@ -664,13 +666,36 @@ function MessageTimelineView(
          <SessionTitleHeader>
            <div class="h-12 w-full flex items-center justify-between gap-2">
              <div class="flex items-center gap-1 min-w-0 flex-1">
-                <div class="flex items-center gap-0.5 min-w-0 flex-1 w-full">
-                  <SessionProjectMenu
-                    project={avatarProject()}
-                    directory={sessionDirectory()}
-                    workspace={workspaceSession()}
-                    showProjectIcon={showProjectIcon()}
-                  />
+                <div class="flex items-center min-w-0 flex-1 w-full">
+                  <Show
+                    when={workspaceSession()}
+                    fallback={
+                      <span class="flex size-6 shrink-0 items-center justify-center text-v2-icon-icon-muted">
+                        <Show when={showProjectIcon()} fallback={<Icon name="monitor" />}>
+                          {projectAvatar()}
+                        </Show>
+                      </span>
+                    }
+                  >
+                    <Tooltip
+                      placement="bottom-start"
+                      value={sessionDirectory()}
+                      contentClass="max-w-[calc(100vw-32px)] break-all"
+                    >
+                      <span
+                        tabIndex={0}
+                        aria-label={sessionDirectory()}
+                        classList={{
+                          "flex size-6 shrink-0 items-center justify-center": true,
+                          "text-v2-icon-icon-accent": !showProjectIcon(),
+                        }}
+                      >
+                        <Show when={showProjectIcon()} fallback={<Icon name="workspace-isolated" />}>
+                          {projectAvatar()}
+                        </Show>
+                      </span>
+                    </Tooltip>
+                  </Show>
                  <Show when={parentID()}>
                    <button
                      type="button"
@@ -694,7 +719,7 @@ function MessageTimelineView(
                      fallback={
                        <h1
                          data-slot="session-title-child"
-                          class="truncate text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base w-fit rounded-[6px] px-1 py-1 hover:bg-v2-overlay-simple-overlay-hover"
+                          class="truncate text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base w-fit rounded-[6px] px-2 py-1 hover:bg-v2-overlay-simple-overlay-hover"
                          onClick={openTitleEditor}
                        >
                          {childTitle()}
@@ -709,7 +734,7 @@ function MessageTimelineView(
                        dir="auto"
                        value={title.draft}
                        disabled={props.pending.rename()}
-                        class="block text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base field-sizing-content rounded-[6px] px-1 py-1"
+                        class="block text-[13px] font-[530] leading-4 tracking-[-0.04px] text-v2-text-text-base field-sizing-content self-start rounded-[6px] px-2 py-1"
                        style={{
                          "--inline-input-shadow": "none",
                          "text-align": "start",
@@ -736,7 +761,7 @@ function MessageTimelineView(
                    {(id) => (
                      <Menu
                        gutter={6}
-                        placement="bottom-start"
+                        placement="bottom-end"
                        open={title.menuOpen}
                        onOpenChange={(open) => setTitle("menuOpen", open)}
                      >
@@ -751,8 +776,7 @@ function MessageTimelineView(
                        />
                        <Menu.Portal>
                          <Menu.Content
-                            class="session-options-menu w-max"
-                            style={{ "min-width": "0" }}
+                            style={{ "min-width": "160px" }}
                            onCloseAutoFocus={(event) => {
                              if (!title.pendingRename) return
                              event.preventDefault()
@@ -1,123 +0,0 @@
-import { For, createResource, type JSX } from "solid-js"
-import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform } from "@/runtime/platform/platform"
-import { ExternalLink } from "@/runtime/platform/external-link"
-import legal from "./legal.svg"
-import anomalyBrush from "./anomaly-brush.svg"
-import { AnimatedWordmark } from "./animated-wordmark"
-import { FALLBACK_OTHER_CONTRIBUTORS, loadOtherContributorCount } from "./contributors"
-
-const writers = [
-  "thdxr",
-  "adamdotdev",
-  "rekram1-node",
-  "kitlangton",
-  "iamdavidhill",
-  "jayair",
-  "fwang",
-  "brendonovich",
-  "nexxeln",
-  "hona",
-  "kommander",
-  "jlongster",
-  "vimtor",
-  "r44vcorp",
-  "simonklee",
-  "arvsrn",
-] as const
-const illustrators = ["usrnk1", "ludvigrask_", "arvsrn", "iamdavidhill"] as const
-
-export function SettingsAbout(props: { active: boolean }) {
-  const language = useLanguage()
-  const platform = usePlatform()
-  const [otherContributors] = createResource(
-    () => props.active || undefined,
-    () => loadOtherContributorCount(platform.fetch ?? fetch),
-    { initialValue: FALLBACK_OTHER_CONTRIBUTORS },
-  )
-
-  return (
-    <div class="settings-about-content">
-      <div class="settings-about-intro">
-        <p>{language.t("settings.about.version", { version: platform.version ?? language.t("settings.about.devVersion") })}</p>
-        <p>{language.t("settings.about.license")}</p>
-      </div>
-
-      <AnimatedWordmark active={props.active} />
-
-      <div class="settings-about-credits">
-        <CreditLine
-          label={language.t("settings.about.writtenBy")}
-          names={writers}
-          and={language.t("settings.about.and")}
-          tail={
-            <ExternalLink href="https://github.com/anomalyco/opencode/graphs/contributors">
-              {language.plural("settings.about.otherContributor", otherContributors.latest, {
-                count: otherContributors.latest,
-              })}
-            </ExternalLink>
-          }
-        />
-        <CreditLine
-          label={language.t("settings.about.illustratedBy")}
-          names={illustrators}
-          and={language.t("settings.about.and")}
-        />
-      </div>
-
-      <div class="settings-about-publication">
-        <p>{language.t("settings.about.firstPublished")}</p>
-        <p>{language.t("settings.about.firstIllustrated")}</p>
-      </div>
-
-      <p class="settings-about-faint">
-        <ExternalLink href="https://opencode.ai">
-          <bdi dir="ltr">{language.t("settings.about.website")}</bdi>
-        </ExternalLink>
-      </p>
-
-      <div class="settings-about-details">
-        <p>{language.t("settings.about.description")}</p>
-        <p>{language.t("settings.about.trademark")}</p>
-        <p>{language.t("settings.about.typeset")}</p>
-      </div>
-
-      <p>{language.t("settings.about.tagline")}</p>
-      <img class="settings-about-legal" src={legal} alt="" />
-      <div class="settings-about-copyright">
-        <p>{language.t("settings.about.copyright")}</p>
-        <img class="settings-about-anomaly-brush" src={anomalyBrush} alt="" />
-      </div>
-    </div>
-  )
-}
-
-function CreditLine(props: {
-  label: string
-  names: readonly string[]
-  and: string
-  tail?: JSX.Element
-}) {
-  return (
-    <p>
-      {props.label}{" "}
-      <For each={props.names}>
-        {(name, index) => (
-          <>
-            {index() === 0 ? "" : index() === props.names.length - 1 && !props.tail ? `, ${props.and} ` : ", "}
-            <bdi dir="ltr">
-              <ExternalLink href={profile(name)}>{name}</ExternalLink>
-            </bdi>
-          </>
-        )}
-      </For>
-      {props.tail ? <>, {props.and} {props.tail}</> : null}
-    </p>
-  )
-}
-
-function profile(name: string) {
-  if (name === "r44vcorp") return "https://github.com/R44VC0RP"
-  if (name === "ludvigrask_") return "https://x.com/ludvigrask_"
-  return `https://github.com/${name}`
-}
@@ -1,80 +0,0 @@
-import { createEffect, For, on, onCleanup } from "solid-js"
-import { createStore } from "solid-js/store"
-
-const target = ["o", "p", "e", "n", "c", "o", "d", "e"] as const
-const choices = ["o", "p", "e", "n", "c", "d"] as const
-
-export function AnimatedWordmark(props: { active: boolean }) {
-  const [state, setState] = createStore({ letters: [...target] })
-  const timers = new Set<ReturnType<typeof setTimeout>>()
-
-  createEffect(
-    on(
-      () => props.active,
-      (active) => {
-        timers.forEach(clearTimeout)
-        timers.clear()
-        if (!active || matchMedia("(prefers-reduced-motion: reduce)").matches) {
-          setState("letters", [...target])
-          return
-        }
-
-        const starts = target.map(() => choices[Math.floor(Math.random() * choices.length)])
-        const settles = target.map(() => 6 + Math.floor(Math.random() * 8))
-        const last = Math.max(...settles)
-        setState("letters", starts)
-
-        Array.from({ length: last }, (_, index) => index + 1).forEach((tick) => {
-          const timer = setTimeout(() => {
-            setState(
-              "letters",
-              target.map((letter, index) =>
-                tick >= settles[index] ? letter : choices[Math.floor(Math.random() * choices.length)],
-              ),
-            )
-            timers.delete(timer)
-          }, tick * 75)
-          timers.add(timer)
-        })
-      },
-    ),
-  )
-
-  onCleanup(() => timers.forEach(clearTimeout))
-
-  return (
-    <svg class="settings-about-wordmark" viewBox="0 0 234 42" aria-hidden="true">
-      <defs>
-        <symbol id="settings-about-letter-o" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M18 30H6V18H18V30Z" />
-          <path d="M18 12H6V30H18V12ZM24 36H0V6H24V36Z" />
-        </symbol>
-        <symbol id="settings-about-letter-p" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M18 30H6V18H18V30Z" />
-          <path d="M6 30H18V12H6V30ZM24 36H6V42H0V6H24V36Z" />
-        </symbol>
-        <symbol id="settings-about-letter-e" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M24 24V30H6V24H24Z" />
-          <path d="M24 24H6V30H24V36H0V6H24V24ZM6 18H18V12H6V18Z" />
-        </symbol>
-        <symbol id="settings-about-letter-n" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M18 36H6V18H18V36Z" />
-          <path d="M18 12H6V36H0V6H18V12ZM24 36H18V12H24V36Z" />
-        </symbol>
-        <symbol id="settings-about-letter-c" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M24 30H6V18H24V30Z" />
-          <path d="M24 12H6V30H24V36H0V6H24V12Z" />
-        </symbol>
-        <symbol id="settings-about-letter-d" viewBox="0 0 24 42">
-          <path class="settings-about-letter-shadow" d="M18 30H6V18H18V30Z" />
-          <path d="M18 12H6V30H18V12ZM24 36H0V6H18V0H24V36Z" />
-        </symbol>
-      </defs>
-      <For each={state.letters}>
-        {(letter, index) => (
-          <use href={`#settings-about-letter-${letter}`} x={index() * 30} width="24" height="42" />
-        )}
-      </For>
-    </svg>
-  )
-}
@@ -1,17 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { FALLBACK_OTHER_CONTRIBUTORS, otherContributorCount } from "./contributors"
-
-describe("otherContributorCount", () => {
-  test("subtracts the contributors named in the colophon", () => {
-    expect(
-      otherContributorCount(
-        '<https://api.github.com/repositories/975734319/contributors?anon=1&per_page=1&page=2>; rel="next", <https://api.github.com/repositories/975734319/contributors?anon=1&per_page=1&page=1004>; rel="last"',
-      ),
-    ).toBe(988)
-  })
-
-  test("falls back when pagination metadata is unavailable", () => {
-    expect(otherContributorCount(null)).toBe(FALLBACK_OTHER_CONTRIBUTORS)
-    expect(otherContributorCount("invalid")).toBe(FALLBACK_OTHER_CONTRIBUTORS)
-  })
-})
@@ -1,23 +0,0 @@
-const CREDITED_CONTRIBUTORS = 16
-let request: Promise<number> | undefined
-
-export const FALLBACK_OTHER_CONTRIBUTORS = 935
-
-export function otherContributorCount(link: string | null) {
-  const total = Number.parseInt(link?.match(/[?&]page=(\d+)[^>]*>;\s*rel="last"/)?.[1] ?? "", 10)
-  if (!Number.isFinite(total) || total <= CREDITED_CONTRIBUTORS) return FALLBACK_OTHER_CONTRIBUTORS
-  return total - CREDITED_CONTRIBUTORS
-}
-
-export function loadOtherContributorCount(fetcher: typeof fetch) {
-  request ??= fetcher("https://api.github.com/repos/anomalyco/opencode/contributors?anon=1&per_page=1", {
-    headers: {
-      Accept: "application/vnd.github+json",
-      "X-GitHub-Api-Version": "2022-11-28",
-    },
-  }).then(
-    (response) => (response.ok ? otherContributorCount(response.headers.get("Link")) : FALLBACK_OTHER_CONTRIBUTORS),
-    () => FALLBACK_OTHER_CONTRIBUTORS,
-  )
-  return request
-}
@@ -1,9 +0,0 @@
-<svg width="91" height="16" viewBox="0 0 91 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-  <g opacity=".5" fill="#808080">
-    <path d="M22.463 16H11.231c6.203 0 11.232-3.582 11.232-8s-5.029-8-11.232-8S0 3.582 0 8s5.028 8 11.231 8H0V0h22.463v16Z"/>
-    <path d="M13.672 4.799h5.354v.988h-2.102v5.54h-1.158v-5.54h-2.094v-.988ZM11.724 4.799h1.158v6.528h-1.158V4.799ZM3.474 4.799h1.63l1.825 5.11h.018l1.779-5.11h1.612v6.528H9.235V6.289h-.018l-1.834 5.038h-.954L4.595 6.289h-.019v5.038H3.474V4.799Z"/>
-    <path fill-rule="evenodd" d="M50.363 1a7.363 7.363 0 1 1 0 14.726 7.363 7.363 0 0 1 0-14.726Zm-1.938 1.04a6.615 6.615 0 0 0-3.338 2.34c.483.014.783.079.783.37 0 .375.375.625 1.123-.625.543-.906 1.02-1.681 1.432-2.086Zm8.547 6.585h-2.241c-.999 0-1.123 1-1.623 1.75-.499.75-.748 1.5-.748 2.625s-.749 1.25-1.124 1.375c-.374.125-.623-.375-1.123-.75-.499-.375-.25-2.375-.25-2.75s0-.625-.374-.75c-.374-.125-1.997-.375-2.121-.75-.125-.375 0-.75.748-1.75.44-.625 1.123-.25 1.373-.25.25 0 .999.25 1.498.25.499 0 .624.25 1.373.25.748 0 .25-.25.25-1 0-.75-.5-.375-.999-.25-.499.125-.624.25-1.747.25s-.25-.375.25-.625c.498-.25.498-.25.873-.875.374-.625 0-.25-.624-.375-.624-.125-.25.375-.874.375s-.124-.625.375-1c.499-.375.374-.5.499-1.25.125-.75.25-.25.873-.5.624-.25.874 0 1.123-.25.088-.088.098-.191.092-.288a6.616 6.616 0 0 0-8.702 6.288A6.614 6.614 0 0 0 50.363 15c3.569 0 6.478-2.832 6.61-6.375Z" clip-rule="evenodd"/>
-    <path fill-rule="evenodd" d="M66.836 1a7.363 7.363 0 1 1 0 14.726 7.363 7.363 0 0 1 0-14.726Zm2.496 3.5c-.624 0-.999 1.125-1.623 1.75-.624.625-.499 1.375-.25 2.375.25 1-.623 1.625-1.372 1.625s-.874-.375-1.248-.75c-.375-.375-1.248-.375-2.247-.25-.998.125-.624 1.625-.748 2.375-.125.75-.624-.25-.749-1-.079-.475-.459-1-.822-1.417A6.614 6.614 0 0 0 66.836 15a6.59 6.59 0 0 0 2.518-.498c-.378-.049-.972-.333-1.395-.502-.624-.25-.874 0-1.622-.5-.749-.5-.25-.875-.25-1.875.25-.625.998-.25 1.373-.25h2.246c.874 0 .874 1.25.874 1.875 0 .604-.7.741-.86 1.088a6.625 6.625 0 0 0 2.489-9.827A8.822 8.822 0 0 0 71.952 4.5h-2.62Z" clip-rule="evenodd"/>
-    <path fill-rule="evenodd" d="M83.308 1a7.363 7.363 0 1 1 0 14.726 7.363 7.363 0 0 1 0-14.726Zm.656.782c-.752.31-.387 1.473.093 1.593.5.125.5-.625.874-.625s1.123.375 1.123.625-.25.375-.5.75c-.249.375.375.375 1.124 0 .748-.375.624.375.499 1.25s-.749 1-1.622 1h-1.498c-.328 0-.391 1.633-.25 1.75.141.117.345.375.5.375h1.871c.624 0 .749.25 1.248.375s.375.75.5 1.125c.124.375-.375.75-.75 1.25-.374.5-.748 1-.998 1.375-.25.375-.374.875-.374 1.375s-.375.5-.624.5c-.25 0-.374-.125-.374-.625s-.125-.625-.25-1.375c-.125-.75-.374-1.375-.374-1.75 0-.375-.25-.25-.669-.25s-.454-.125-.454-.75.809-.305.873-.75c.014-.097 0-.25 0-.25 0-.279-.25-.375-.419-.468-.17-.093-.598-.214-.704-.532-.125-.375-.5-.625-1.248-.625-.749 0-.998-.125-.998-.75V4.5c0-.875-.5-.5-1.498-.75.076-.114.282-.435.544-.868A6.614 6.614 0 1 0 83.964 1.782Z" clip-rule="evenodd"/>
-  </g>
-</svg>
@@ -1,6 +1,7 @@
-import { Component } from "solid-js"
+import { Component, createMemo } from "solid-js"
 import { Select } from "@opencode-ai/ui/select"
 import { TextInput } from "@opencode-ai/ui/text-input"
+import { Switch } from "@opencode-ai/ui/switch"
 import { useLanguage } from "@/runtime/i18n/language"
 import { ExternalLink } from "@/runtime/platform/external-link"
 import { SettingsList } from "@/settings/list"
@@ -9,6 +10,7 @@ import { createAppearanceSettingsController, type AppearanceSettingsController }
 import "@/settings/settings.css"

 const schemeOptions: ("system" | "light" | "dark")[] = ["system", "light", "dark"]
+const tabLayoutOptions: ("horizontal" | "vertical")[] = ["horizontal", "vertical"]
 const fontSettings = {
  ui: {
    action: "settings-ui-font",
@@ -126,6 +128,44 @@ export const SettingsAppearance: Component = () => {
            <FontSetting kind="terminal" fonts={appearance.fonts} />
          </SettingsList>
        </div>
+
+        <div class="settings-section">
+          <h3 class="settings-section-title">{language.t("settings.appearance.section.experimental")}</h3>
+          <SettingsList>
+            <SettingsRow
+              title={language.t("settings.appearance.row.tabs.title")}
+              description={language.t("settings.appearance.row.tabs.description")}
+            >
+              <Select
+                data-action="settings-tab-layout"
+                options={tabLayoutOptions}
+                current={tabLayoutOptions.find((option) => option === appearance.tabs.current())}
+                placement="bottom-end"
+                gutter={6}
+                label={(option) =>
+                  option === "horizontal"
+                    ? language.t("settings.appearance.row.tabs.horizontal")
+                    : language.t("settings.appearance.row.tabs.vertical")
+                }
+                onSelect={(option) => option && appearance.tabs.select(option)}
+              />
+            </SettingsRow>
+            <SettingsRow
+              title={language.t("settings.appearance.row.projectName.title")}
+              description={language.t("settings.appearance.row.projectName.description")}
+            >
+              <div data-action="settings-show-project-name">
+                <Switch
+                  checked={appearance.projectName.current()}
+                  onChange={appearance.projectName.set}
+                  hideLabel
+                >
+                  {language.t("settings.appearance.row.projectName.title")}
+                </Switch>
+              </div>
+            </SettingsRow>
+          </SettingsList>
+        </div>
      </div>
    </>
  )
@@ -1,69 +0,0 @@
-import { Component } from "solid-js"
-import { Select } from "@opencode-ai/ui/select"
-import { Switch } from "@opencode-ai/ui/switch"
-import { useLanguage } from "@/runtime/i18n/language"
-import { SettingsList } from "@/settings/list"
-import { useSettings } from "@/settings/model"
-import { SettingsRow } from "@/settings/row"
-import "@/settings/settings.css"
-
-const tabLayoutOptions: ("horizontal" | "vertical")[] = ["horizontal", "vertical"]
-
-export const SettingsExperimental: Component = () => {
-  const language = useLanguage()
-  const settings = useSettings()
-
-  return (
-    <>
-      <div class="settings-tab-header">
-        <div class="settings-tab-header-row">
-          <div class="flex flex-col gap-1">
-            <h2 class="settings-tab-title">{language.t("settings.tab.experimental")}</h2>
-            <span class="text-11-regular text-v2-text-text-muted">
-              {language.t("settings.experimental.description")}
-            </span>
-          </div>
-        </div>
-      </div>
-
-      <div class="settings-tab-body">
-        <div class="settings-section">
-          <SettingsList>
-            <SettingsRow
-              title={language.t("settings.appearance.row.tabs.title")}
-              description={language.t("settings.appearance.row.tabs.description")}
-            >
-              <Select
-                data-action="settings-tab-layout"
-                options={tabLayoutOptions}
-                current={tabLayoutOptions.find((option) => option === settings.appearance.tabLayout())}
-                placement="bottom-end"
-                gutter={6}
-                label={(option) =>
-                  option === "horizontal"
-                    ? language.t("settings.appearance.row.tabs.horizontal")
-                    : language.t("settings.appearance.row.tabs.vertical")
-                }
-                onSelect={(option) => option && settings.appearance.setTabLayout(option)}
-              />
-            </SettingsRow>
-            <SettingsRow
-              title={language.t("settings.appearance.row.projectName.title")}
-              description={language.t("settings.appearance.row.projectName.description")}
-            >
-              <div data-action="settings-show-project-name">
-                <Switch
-                  checked={settings.appearance.showProjectName()}
-                  onChange={settings.appearance.setShowProjectName}
-                  hideLabel
-                >
-                  {language.t("settings.appearance.row.projectName.title")}
-                </Switch>
-              </div>
-            </SettingsRow>
-          </SettingsList>
-        </div>
-      </div>
-    </>
-  )
-}
@@ -81,6 +81,14 @@ export function createAppearanceSettingsController() {
      setCode: (value: string) => settings.appearance.setFont(value),
      setTerminal: (value: string) => settings.appearance.setTerminalFont(value),
    },
+    tabs: {
+      current: settings.appearance.tabLayout,
+      select: settings.appearance.setTabLayout,
+    },
+    projectName: {
+      current: settings.appearance.showProjectName,
+      set: settings.appearance.setShowProjectName,
+    },
  }
 }

@@ -91,100 +91,19 @@
  overflow-y: auto;
 }

-.settings-about {
-  align-items: center;
-  padding-inline: 24px;
-}
-
-.settings-about-content {
+.settings-nav-footer {
  display: flex;
-  width: 100%;
-  max-width: 560px;
-  min-height: 462px;
+  flex-shrink: 0;
  flex-direction: column;
-  align-items: center;
-  justify-content: flex-start;
-  gap: 24px;
-  padding-block: 80px 32px;
-  color: var(--v2-text-text-muted);
-  font-size: 13px;
+  gap: 8px;
+  margin-top: auto;
+  padding-block: 20px 4px;
+  padding-inline-start: 4px;
+  font-size: 11px;
  font-weight: 440;
-  line-height: var(--line-height-base);
-  letter-spacing: -0.04px;
-  text-align: center;
-}
-
-.settings-about-content p {
-  margin: 0;
-}
-
-.settings-about-intro,
-.settings-about-credits,
-.settings-about-publication,
-.settings-about-details {
-  display: flex;
-  flex-direction: column;
-}
-
-.settings-about-intro {
-  gap: 14px;
-}
-
-.settings-about-credits,
-.settings-about-publication,
-.settings-about-details {
-  gap: 16px;
-}
-
-.settings-about-wordmark {
-  width: 178px;
-  height: 32px;
-  flex-shrink: 0;
-  opacity: 0.2;
-  color: var(--v2-text-text-muted);
-  fill: currentColor;
-}
-
-.settings-about-letter-shadow {
-  opacity: 0.3;
-}
-
-.settings-about-faint,
-.settings-about-credits {
+  line-height: var(--line-height-tight);
  color: var(--v2-text-text-faint);
-}
-
-.settings-about-legal {
-  width: 109.2px;
-  height: 19.2px;
-}
-
-.settings-about-copyright {
-  display: flex;
-  width: 100%;
-  flex-shrink: 0;
-  flex-direction: column;
-  align-items: center;
-  gap: 12px;
-}
-
-.settings-about-anomaly-brush {
-  width: 126.72px;
-  height: 48.384px;
-  flex-shrink: 0;
-  pointer-events: none;
-}
-
-.settings-about-content a {
-  color: inherit;
-  cursor: pointer;
-  text-decoration: none;
-}
-
-.settings-about-content a:hover,
-.settings-about-content a:focus-visible {
-  color: var(--v2-text-text-base);
-  text-decoration: underline;
+  user-select: none;
 }

 .settings-back {
@@ -1,12 +1,12 @@
-import { Component, createEffect, createMemo, For, Show, onMount, startTransition } from "solid-js"
+import { Component, createEffect, createMemo, For, Show, onCleanup, onMount, startTransition } from "solid-js"
 import { Tabs } from "@opencode-ai/ui/tabs"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Menu } from "@opencode-ai/ui/menu"
 import { Button } from "@opencode-ai/ui/button"
 import { useLanguage } from "@/runtime/i18n/language"
+import { usePlatform } from "@/runtime/platform/platform"
 import { SettingsGeneral } from "./general/general"
 import { SettingsAppearance } from "./appearance/appearance"
-import { SettingsExperimental } from "./experimental/experimental"
 import { SettingsKeybinds } from "./keybinds/keybinds"
 import { SettingsNotifications } from "./notifications/notifications"
 import { SettingsProviders } from "./providers/providers"
@@ -15,13 +15,13 @@ import { SettingsServers } from "./servers/servers"
 import { SettingsWorkspaces } from "./workspaces/workspaces"
 import { SettingsProjects } from "./workspaces/projects"
 import { SettingsExtensions } from "./providers/extensions"
-import { SettingsAbout } from "./about/about"
 import { SettingsServerScope } from "./server-scope"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { useLayout } from "@/shell/state/layout"
 import { useTabs } from "@/shell/tabs/tabs"
 import { useGlobal, useServerCtx } from "@/runtime/server/runtime"
 import { ServerConnection, useServers } from "@/runtime/server/registry"
+import { useCommand } from "@/shell/commands/command"
 import { useSettingsSurface } from "./surface"
 import "@/settings/settings.css"

@@ -42,13 +42,13 @@ const sections = [
    { value: "models", icon: "models", label: "settings.models.title" },
    { value: "extensions", icon: "extensions", label: "settings.tab.extensions" },
  ],
-  [{ value: "experimental", icon: "flask", label: "settings.tab.experimental" }],
-  [{ value: "about", icon: "info", label: "settings.tab.about" }],
 ] as const

 export const SettingsScreen: Component = () => {
  const language = useLanguage()
+  const platform = usePlatform()
  const dialog = useDialog()
+  const command = useCommand()
  const surface = useSettingsSurface()
  const layout = useLayout()
  const servers = useServers()
@@ -57,8 +57,10 @@ export const SettingsScreen: Component = () => {
  let root: HTMLDivElement | undefined

  onMount(() => {
+    command.keybinds(false)
    root?.focus({ preventScroll: true })
  })
+  onCleanup(() => command.keybinds(true))

  const server = createMemo(() => {
    const route = surface.route()
@@ -183,6 +185,12 @@ export const SettingsScreen: Component = () => {
              </For>
            </div>
          </div>
+          <div class="settings-nav-footer">
+            <span>{language.t("app.name.desktop")}</span>
+            <span>
+              <bdi dir="ltr">v{platform.version}</bdi>
+            </span>
+          </div>
        </Tabs.List>

        <Tabs.Content value="general" class="settings-panel">
@@ -197,9 +205,6 @@ export const SettingsScreen: Component = () => {
        <Tabs.Content value="shortcuts" class="settings-panel">
          <SettingsKeybinds />
        </Tabs.Content>
-        <Tabs.Content value="experimental" class="settings-panel">
-          <SettingsExperimental />
-        </Tabs.Content>
        <Tabs.Content value="servers" class="settings-panel">
          <SettingsServers />
        </Tabs.Content>
@@ -220,9 +225,6 @@ export const SettingsScreen: Component = () => {
            <SettingsExtensions />
          </Tabs.Content>
        </SettingsServerScope>
-        <Tabs.Content value="about" class="settings-panel settings-about">
-          <SettingsAbout active={surface.tab() === "about"} />
-        </Tabs.Content>
      </Tabs>
    </div>
  )
@@ -430,9 +430,7 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
        key: id,
        options,
      }
-      // Register only committed owners. Updating the registry during a transition
-      // can restore its pending snapshot after the outgoing owner's cleanup.
-      onMount(() => setStore("registrations", (arr) => addCommandRegistration(arr, entry)))
+      setStore("registrations", (arr) => addCommandRegistration(arr, entry))
      onCleanup(() => {
        setStore("registrations", (arr) => arr.filter((x) => x !== entry))
      })
@@ -5,15 +5,21 @@ import { Dialog, DialogBody } from "@opencode-ai/ui/dialog"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Keybind } from "@opencode-ai/ui/keybind"
 import { TextInput } from "@opencode-ai/ui/text-input"
-import { createEffect, createMemo, For, Match, Show, Switch } from "solid-js"
-import { createStore } from "solid-js/store"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
+import { createEffect, createMemo, createResource, createSignal, For, Match, Show, Switch } from "solid-js"
 import { formatKeybindParts } from "@/shell/commands/command"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useTabs } from "@/shell/tabs/tabs"
 import { SessionTabAvatar } from "@/shell/layout/session-tab-avatar"
 import { getRelativeTime } from "@/shell/time"
-import { createCommandPaletteFileEntry, createCommandPaletteModel, type CommandPaletteEntry } from "./palette"
-import { createCommandPaletteSearch } from "./search"
+import {
+  createCommandPaletteCommandEntry,
+  createCommandPaletteFileEntry,
+  createCommandPaletteModel,
+  createServerSessionEntries,
+  uniqueCommandPaletteEntries,
+  type CommandPaletteEntry,
+} from "./palette"
 import "./dialog.css"

 function groups(entries: CommandPaletteEntry[]) {
@@ -29,24 +35,23 @@ export function matchesCommandPaletteEntry(entry: CommandPaletteEntry, query: st

 export function DialogCommandPalette(props: { onOpenFile?: (path: string) => void }) {
  const palette = createCommandPaletteModel(props)
-  const items = (q: string) => {
+  const loadItems = async (text: string) => {
+    const q = text.trim()
    if (!q) return [...palette.preferredCommandEntries(), ...palette.recentFileEntries()]
-    return palette.commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, q))
+
+    const [files, nextSessions] = await Promise.all([palette.file.searchFiles(q), Promise.resolve(palette.sessions(q))])
+    const category = palette.language.t("palette.group.files")
+    return [
+      ...palette.commandEntries().filter((entry) => matchesCommandPaletteEntry(entry, q)),
+      ...nextSessions,
+      ...files.map((path) => createCommandPaletteFileEntry(path, category)),
+    ]
  }

  return (
    <CommandPaletteView
      placeholder={palette.language.t("palette.search.placeholder")}
-      items={items}
-      sources={[
-        palette.sessions,
-        async (query, signal) => {
-          if (!query) return []
-          const files = await palette.file.searchFiles(query, { signal })
-          const category = palette.language.t("palette.group.files")
-          return files.map((path) => createCommandPaletteFileEntry(path, category))
-        },
-      ]}
+      loadItems={loadItems}
      highlight={palette.highlight}
      select={palette.select}
      close={palette.close}
@@ -56,31 +61,29 @@ export function DialogCommandPalette(props: { onOpenFile?: (path: string) => voi

 export function CommandPaletteView(props: {
  placeholder: string
-  items: (query: string) => CommandPaletteEntry[]
-  sources: ((query: string, signal: AbortSignal) => Promise<CommandPaletteEntry[]>)[]
+  loadItems: (text: string) => CommandPaletteEntry[] | Promise<CommandPaletteEntry[]>
  highlight: (item: CommandPaletteEntry | undefined) => void
  select: (item: CommandPaletteEntry | undefined) => void
  close: () => void
 }) {
  const language = useLanguage()
  const tabs = useTabs()
-  const [store, setStore] = createStore({ query: "", active: undefined as string | undefined })
+  const [query, setQuery] = createSignal("")
+  const [active, setActive] = createSignal(0)

-  const search = createCommandPaletteSearch({ query: () => store.query, items: props.items, sources: props.sources })
-  const visibleEntries = search.items
+  const [entries] = createResource(query, props.loadItems, { initialValue: [] as CommandPaletteEntry[] })
+  // Render stale results while a new query loads to avoid flashing "Loading" per keystroke.
+  const visibleEntries = createMemo(() => uniqueCommandPaletteEntries(entries.latest ?? []))
  const groupedEntries = createMemo(() => groups(visibleEntries()))
-  // Keep keyboard selection stable when another search source adds results.
-  const activeEntry = createMemo(
-    () => visibleEntries().find((entry) => entry.id === store.active) ?? visibleEntries()[0],
-  )
+  const activeEntry = createMemo(() => visibleEntries()[active()])
  const openSessions = createMemo(
    () => new Set(tabs.store.flatMap((tab) => (tab.type === "session" ? [`${tab.server}\0${tab.sessionId}`] : []))),
  )

  createEffect(() => {
-    // Pin automatic selection too: a later source can insert rows before it.
-    const id = activeEntry()?.id
-    if (store.active !== id) setStore("active", id)
+    query()
+    visibleEntries()
+    setActive(0)
  })

  createEffect(() => {
@@ -92,8 +95,7 @@ export function CommandPaletteView(props: {
  const move = (delta: -1 | 1) => {
    const count = visibleEntries().length
    if (count === 0) return
-    const index = visibleEntries().findIndex((entry) => entry.id === activeEntry()?.id)
-    setStore("active", visibleEntries()[(index + delta + count) % count].id)
+    setActive((index) => (index + delta + count) % count)
    requestAnimationFrame(() => {
      resultsRef?.querySelector("[data-active]")?.scrollIntoView({ block: "nearest" })
    })
@@ -126,14 +128,14 @@ export function CommandPaletteView(props: {
      <DialogBody class="command-palette-body">
        <div class="command-palette-search">
          <TextInput
-            value={store.query}
+            value={query()}
            autofocus
            autocomplete="off"
            spellcheck={false}
            appearance="large"
            placeholder={props.placeholder}
            leadingIcon={<Icon name="magnifying-glass" />}
-            onInput={(event) => setStore({ query: event.currentTarget.value, active: undefined })}
+            onInput={(event) => setQuery(event.currentTarget.value)}
            onKeyDown={handleKeyDown}
          />
        </div>
@@ -143,7 +145,7 @@ export function CommandPaletteView(props: {
              when={visibleEntries().length > 0}
              fallback={
                <div class="command-palette-state">
-                  {search.loading() ? language.t("common.loading") : language.t("palette.empty")}
+                  {entries.loading ? language.t("common.loading") : language.t("palette.empty")}
                </div>
              }
            >
@@ -164,7 +166,7 @@ export function CommandPaletteView(props: {
                              ? openSessions().has(`${item.server}\0${item.sessionID}`)
                              : false
                          }
-                          onActive={() => setStore("active", item.id)}
+                          onActive={() => setActive(visibleEntries().findIndex((entry) => entry.id === item.id))}
                          onSelect={() => props.select(item)}
                        />
                      )}
@@ -1,41 +0,0 @@
-import { createMemo, createResource, onCleanup } from "solid-js"
-import { uniqueCommandPaletteEntries, type CommandPaletteEntry } from "./palette"
-
-export function createCommandPaletteSearch(props: {
-  query: () => string
-  items: (query: string) => CommandPaletteEntry[]
-  sources: ((query: string, signal: AbortSignal) => Promise<CommandPaletteEntry[]>)[]
-}) {
-  const query = createMemo(() => props.query().trim())
-  const local = createMemo(() => props.items(query()))
-  const sources = props.sources.map((load) => {
-    let abort: AbortController | undefined
-    onCleanup(() => abort?.abort())
-    const [result] = createResource(
-      query,
-      async (query) => {
-        abort?.abort()
-        const current = new AbortController()
-        abort = current
-        return { query, items: await load(query, current.signal).catch(() => []) }
-      },
-      // Remote searches must not suspend the dialog's local results on first render.
-      { initialValue: { query: "", items: [] as CommandPaletteEntry[] } },
-    )
-    return result
-  })
-
-  return {
-    items: createMemo(() =>
-      uniqueCommandPaletteEntries([
-        ...local(),
-        ...sources.flatMap((source) => {
-          // Never keep results for an older query selectable while the next one loads.
-          const result = source.latest
-          return result.query === query() ? result.items : []
-        }),
-      ]),
-    ),
-    loading: () => sources.some((source) => source.loading),
-  }
-}
@@ -1,6 +1,5 @@
 import { Icon, type IconProps } from "@opencode-ai/ui/icon"
 import { Toast, showToast, toaster, type ToastOptions } from "@opencode-ai/ui/toast"
-import type { JSX } from "solid-js"

 type AppToastOptions = Omit<ToastOptions, "icon"> & {
  icon?: IconProps["name"]
@@ -31,7 +30,6 @@ export function dismissToast(toastId: number) {

 function resolveIcon(icon: IconProps["name"] | undefined, variant: ToastOptions["variant"]) {
  const name = icon ?? (variant === "success" ? "check" : undefined)
-  if (!name) return undefined
-  // Solid resolves JSX accessors under the toast's render owner, not this imperative call site.
-  return (() => <Icon name={name} />) as unknown as JSX.Element
+  if (!name) return
+  return <Icon name={name} />
 }
@@ -348,19 +348,13 @@ export function Titlebar(props: {
                  type="button"
                  data-action="vertical-tabs-home"
                  data-state={layout.route().type === "home" ? "pressed" : undefined}
-                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base data-[state=pressed]:bg-v2-background-bg-layer-02 data-[state=pressed]:text-v2-text-text-base"
+                  class="mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] px-1.5 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base data-[state=pressed]:bg-v2-background-bg-layer-02 data-[state=pressed]:text-v2-text-text-base"
                  onClick={toggleHome}
                  aria-label={language.t("home.title")}
                  aria-pressed={layout.route().type === "home"}
                >
                  <Icon name="grid-plus" />
-                  <span class="min-w-0 truncate">{language.t("home.title")}</span>
-                  <span
-                    class="ms-auto shrink-0 whitespace-nowrap text-v2-text-text-faint opacity-0 group-hover:opacity-100 group-focus-visible:opacity-100"
-                    aria-hidden="true"
-                  >
-                    <bdi dir="ltr">{command.keybind("home.toggle")}</bdi>
-                  </span>
+                  {language.t("home.title")}
                </button>
              </Show>
            )
@@ -652,18 +646,12 @@ export function Titlebar(props: {
                            <button
                              type="button"
                              data-action="vertical-tabs-new-session"
-                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
+                              class="flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] px-1.5 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
                              onClick={openNewTab}
                              aria-label={language.t("command.session.new")}
                            >
                              <Icon name="edit" />
-                              <span class="min-w-0 truncate">{language.t("command.session.new")}</span>
-                              <span
-                                class="ms-auto shrink-0 whitespace-nowrap text-v2-text-text-faint opacity-0 group-hover:opacity-100 group-focus-visible:opacity-100"
-                                aria-hidden="true"
-                              >
-                                <bdi dir="ltr">{command.keybind("tab.new")}</bdi>
-                              </span>
+                              {language.t("command.session.new")}
                            </button>
                            <div class="h-4 w-full shrink-0" aria-hidden="true" />
                            <div class="flex min-h-0 flex-1 flex-col gap-1">
@@ -1,97 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createComputed, createRoot, createSignal } from "solid-js"
-import type { CommandPaletteEntry } from "@/shell/commands/palette"
-import { createCommandPaletteSearch } from "@/shell/commands/search"
-
-const copy: CommandPaletteEntry = {
-  id: "command:session.copyID",
-  type: "command",
-  title: "Copy Session ID",
-  category: "Commands",
-}
-const file: CommandPaletteEntry = { id: "file:copy.txt", type: "file", title: "copy.txt", category: "Files" }
-const session: CommandPaletteEntry = {
-  id: "session:copy",
-  type: "session",
-  title: "Copy session",
-  category: "Sessions",
-}
-
-describe("command palette search", () => {
-  test("matches commands synchronously and cancels obsolete requests", () => {
-    const signals: AbortSignal[] = []
-    const root = createRoot((dispose) => {
-      const [query, setQuery] = createSignal("")
-      const search = createCommandPaletteSearch({
-        query,
-        items: (text) => (text === "copy session" ? [copy] : []),
-        sources: [
-          (_text, signal) => {
-            signals.push(signal)
-            return new Promise<CommandPaletteEntry[]>(() => {})
-          },
-        ],
-      })
-      return { search, setQuery, dispose }
-    })
-    root.setQuery(" copy session ")
-    expect(root.search.items()).toEqual([copy])
-    expect(root.search.loading()).toBe(true)
-    expect(signals[0].aborted).toBe(true)
-    root.setQuery("no match")
-    expect(root.search.items()).toEqual([])
-    expect(signals[1].aborted).toBe(true)
-    root.dispose()
-    expect(signals[2].aborted).toBe(true)
-  })
-
-  test("publishes each source independently and drops stale results on a new query", async () => {
-    const files = Promise.withResolvers<CommandPaletteEntry[]>()
-    const sessions = Promise.withResolvers<CommandPaletteEntry[]>()
-    const fileVisible = Promise.withResolvers<void>()
-    const sessionVisible = Promise.withResolvers<void>()
-    const root = createRoot((dispose) => {
-      const [query, setQuery] = createSignal("copy")
-      const search = createCommandPaletteSearch({
-        query,
-        items: () => [copy],
-        sources: [() => sessions.promise, () => files.promise],
-      })
-      createComputed(() => {
-        if (search.items().some((entry) => entry.id === file.id)) fileVisible.resolve()
-        if (search.items().some((entry) => entry.id === session.id)) sessionVisible.resolve()
-      })
-      return { search, setQuery, dispose }
-    })
-    expect(root.search.items()).toEqual([copy])
-    files.resolve([file])
-    await fileVisible.promise
-    expect(root.search.items()).toEqual([copy, file])
-    expect(root.search.loading()).toBe(true)
-    sessions.resolve([session])
-    await sessionVisible.promise
-    expect(root.search.items()).toEqual([copy, session, file])
-    expect(root.search.loading()).toBe(false)
-    root.setQuery("new query")
-    expect(root.search.items()).toEqual([copy])
-    root.dispose()
-  })
-
-  test("failed searches do not hide commands or successful sources", async () => {
-    const settled = Promise.withResolvers<void>()
-    const root = createRoot((dispose) => {
-      const search = createCommandPaletteSearch({
-        query: () => "copy",
-        items: () => [copy],
-        sources: [() => Promise.reject(new Error("offline")), () => Promise.resolve([file])],
-      })
-      createComputed(() => {
-        if (!search.loading()) settled.resolve()
-      })
-      return { search, dispose }
-    })
-    await settled.promise
-    expect(root.search.items()).toEqual([copy, file])
-    root.dispose()
-  })
-})
@@ -59,7 +59,6 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
  commands: [
    Spec.make("upgrade", {
      description: "Upgrade OpenCode to the latest or a specific version",
-      aliases: ["update"],
      params: {
        target: Argument.string("target").pipe(
          Argument.withDescription("Version to upgrade to (with or without a leading v)"),
@@ -47,6 +47,7 @@ export default Runtime.handler(Commands, (input) =>
      ),
    )
    const updater = yield* Updater.Service
+    if (!server.service) yield* updater.check().pipe(Effect.forkScoped)
    preflight.loading()
    const config = yield* Config.Service
    const npm = yield* Npm.Service
@@ -82,14 +83,11 @@ export default Runtime.handler(Commands, (input) =>
        get: () => runPromise(config.get()),
        update: (update) => runPromise(config.update(update)),
      },
-      updater: {
-        monitor: (notify, signal) =>
-          runPromise(
-            updater.monitor((version) => Effect.sync(() => notify(version))),
-            { signal },
-          ),
-        apply: (version) => runPromise(updater.apply(version)),
-      },
+      updater: service
+        ? {
+            apply: (version) => runPromise(updater.apply(version)),
+          }
+        : undefined,
      packages: {
        prepare: (spec, install = true) => runPromise(install ? npm.add(spec) : npm.resolve(spec)),
      },
@@ -67,13 +67,9 @@ export function handlers<const Root extends Spec.Any>(root: Root, handlers: Hand
  function add(node: Spec.Any, value: RuntimeHandlers) {
    if (typeof value === "function") {
      result.push({ spec: node.spec, load: value as () => Promise<{ default: RuntimeHandler }> })
-      for (const alias of node.aliases) result.push({ spec: alias.spec, load: value as () => Promise<{ default: RuntimeHandler }> })
      return
    }
-    if (value.$) {
-      result.push({ spec: node.spec, load: value.$ as () => Promise<{ default: RuntimeHandler }> })
-      for (const alias of node.aliases) result.push({ spec: alias.spec, load: value.$ as () => Promise<{ default: RuntimeHandler }> })
-    }
+    if (value.$) result.push({ spec: node.spec, load: value.$ as () => Promise<{ default: RuntimeHandler }> })
    for (const [name, child] of Object.entries(node.commands)) add(child, value[name] as RuntimeHandlers)
  }

@@ -103,12 +99,8 @@ function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): Provided
      )
    : node.spec
  if (!Object.keys(node.commands).length) return spec as ProvidedCommand
-  const children = Object.values(node.commands)
  return spec.pipe(
-    Command.withSubcommands([
-      ...children.map((child) => provide(child, handlers)),
-      ...children.flatMap((child) => child.aliases.map((alias) => provide(alias, handlers))),
-    ]),
+    Command.withSubcommands(Object.values(node.commands).map((child) => provide(child, handlers))),
  ) as ProvidedCommand
 }

@@ -2,7 +2,6 @@ import { Command } from "effect/unstable/cli"

 type Options<Config extends Command.Command.Config, Commands extends ReadonlyArray<Any>> = {
  readonly description?: string
-  readonly aliases?: ReadonlyArray<string>
  readonly params?: Config
  readonly commands?: Commands
 }
@@ -15,7 +14,6 @@ export interface Node<
  readonly name: Name
  readonly spec: Spec
  readonly commands: Commands
-  readonly aliases: ReadonlyArray<Any>
 }

 export type Any = Node<string, Command.Command<any, any, any, any, any>, Children>
@@ -26,28 +24,14 @@ export function make<
  const Config extends Command.Command.Config = {},
  const Commands extends ReadonlyArray<Any> = [],
 >(name: Name, options: Options<Config, Commands> = {}) {
-  const aliases = options.aliases ?? []
-  const params = options.params ?? ({} as Config)
-  const command = Command.make(name, params)
-  const described = options.description ? command.pipe(Command.withDescription(options.description)) : command
-  // Effect supports a single native alias, shown inline as `name, alias` in help.
-  // Extra aliases become sibling commands sharing params and subcommands.
-  const spec = aliases.length > 0 ? described.pipe(Command.withAlias(aliases[0])) : described
-  const commands = Object.fromEntries(
-    (options.commands ?? []).map((command) => [command.name, command]),
-  ) as ChildrenOf<Commands>
-  const extra = aliases.slice(1).map((alias) => {
-    const aliasCommand = Command.make(alias, params)
-    const aliasSpec = options.description
-      ? aliasCommand.pipe(Command.withDescription(options.description))
-      : aliasCommand
-    return { name: alias, spec: aliasSpec, commands, aliases: [] }
-  })
+  const command = Command.make(name, options.params ?? ({} as Config))
+  const spec = options.description ? command.pipe(Command.withDescription(options.description)) : command
  return {
    name,
    spec,
-    commands,
-    aliases: extra,
+    commands: Object.fromEntries(
+      (options.commands ?? []).map((command) => [command.name, command]),
+    ) as ChildrenOf<Commands>,
  }
 }

@@ -7,12 +7,14 @@ import { Global } from "@opencode-ai/util/global"
 import { OPENCODE_ARTIFACT, OPENCODE_CHANNEL, OPENCODE_VERSION } from "./version"
 import { AppProcess } from "@opencode-ai/util/process"
 import { randomBytes, randomUUID } from "node:crypto"
-import { Effect, Option, Redacted, Schedule, Schema } from "effect"
+import { spawn } from "node:child_process"
+import { Deferred, Effect, Option, Redacted, Schedule, Schema } from "effect"
 import { PersistentPty } from "@opencode-ai/schema/persistent-pty"
 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"
@@ -27,6 +29,7 @@ export type Options = {
 // The process effect lives until server shutdown; tracing it would parent every request to one process-lifetime trace.
 export const run = Effect.fnUntraced(function* (options: Options) {
  return yield* processEffect(options).pipe(
+    Effect.provide(Updater.layer),
    Effect.provide(
      LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]), {
        replacements: [
@@ -51,7 +54,8 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
        )
  const global = yield* Global.Service
  if (options.mode === "service") yield* Effect.sync(() => process.chdir(global.home))
-  return yield* Effect.scoped(
+  const replacement = yield* Deferred.make<PersistentPty.Handoff | null>()
+  const next = yield* Effect.scoped(
    Effect.gen(function* () {
      const foreground = options.mode === "default"
      const serviceOptions = options.mode === "service" ? yield* ServiceConfig.options() : undefined
@@ -62,7 +66,7 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
        serviceOptions !== undefined && port !== undefined
          ? yield* Service.incumbent({ ...serviceOptions, url: serviceURL(hostname, port) })
          : undefined
-      if (incumbent !== undefined) return
+      if (incumbent !== undefined) return Option.none<PersistentPty.Handoff | null>()
      const { start } = yield* Effect.promise(() => import("@opencode-ai/server/process"))
      const environmentPassword = yield* Env.password
      // Keep the lease credential out of the environment inherited by tools.
@@ -159,17 +163,62 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
          )
        }),
      )
-      if (server === undefined) return
+      if (server === undefined) return Option.none<PersistentPty.Handoff | null>()
      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}`)
+      const updater = yield* Updater.Service
+      yield* updater
+        .monitor({
+          url,
+          password,
+          managed: options.mode === "service",
+          notify: server.updateAvailable,
+          restart: (handoff) => Deferred.succeed(replacement, handoff).pipe(Effect.asVoid),
+        })
+        .pipe(Effect.forkScoped)
      return yield* options.mode === "service"
-        ? server.shutdown
+        ? Effect.raceFirst(
+            server.shutdown.pipe(Effect.as(Option.none<PersistentPty.Handoff | null>())),
+            Deferred.await(replacement).pipe(Effect.map(Option.some)),
+          )
        : options.mode === "stdio"
-          ? waitForStdinClose()
+          ? waitForStdinClose().pipe(Effect.as(Option.none<PersistentPty.Handoff | null>()))
          : Effect.never
    }).pipe(Effect.annotateLogs({ role: "server" })),
  )
+  if (Option.isNone(next)) return
+  yield* spawnReplacement(next.value)
+})
+
+const spawnReplacement = Effect.fnUntraced(function* (handoff: PersistentPty.Handoff | null) {
+  const options = yield* ServiceConfig.options()
+  const [command, ...args] = options.command
+  if (!command) return yield* Effect.fail(new Error("Failed to resolve CLI command for restart"))
+  // We do not monitor the replacement after spawn. A managed TUI
+  // recovers with Service.ensure if startup fails; a future client
+  // restart signal could coordinate that recovery instead.
+  yield* Effect.tryPromise({
+    try: () =>
+      new Promise<void>((resolve, reject) => {
+        const child = spawn(command, args, {
+          detached: true,
+          stdio: "ignore",
+          windowsHide: true,
+          env: {
+            ...process.env,
+            ...options.env,
+            OPENCODE_PTY_HANDOFF: handoff ? JSON.stringify(handoff) : undefined,
+          },
+        })
+        child.once("spawn", () => {
+          child.unref()
+          resolve()
+        })
+        child.once("error", reject)
+      }),
+    catch: (cause) => new Error("Failed to start replacement server", { cause }),
+  })
 })

 const recognizeIncumbent = Effect.fnUntraced(function* (options: DiscoverOptions, hostname: string, port: number) {
@@ -1,5 +1,5 @@
-export type Policy = "disable" | "notify"
-export type Action = "none" | "notify"
+export type Policy = "disable" | "notify" | "auto"
+export type Action = "none" | "notify" | "upgrade"

 const maximumComponent = "9007199254740991"
 const versionPattern =
@@ -10,7 +10,10 @@ 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 "notify"
+  if (policy === "notify") return "notify"
+  // Major upgrades are never installed automatically.
+  if (currentVersion.major !== latestVersion.major) return "notify"
+  return "upgrade"
 }

 export function parseReleaseVersion(input: string) {
@@ -6,17 +6,22 @@ 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("notify")
+    expect(decodePolicy('{ "update": "auto" }')).toBe("auto")
    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("notify")
+    expect(decodePolicy('{ "autoupdate": true }')).toBe("auto")
  })

-  test("reports every available release", () => {
+  test("automatically updates patches and minors", () => {
+    expect(action("1.2.3", "1.2.4", "auto")).toBe("upgrade")
+    expect(action("1.2.3", "1.3.0", "auto")).toBe("upgrade")
+  })
+
+  test("reports patches and minors without automatically installing them", () => {
    expect(action("1.2.3", "1.2.4", "notify")).toBe("notify")
    expect(action("1.2.3", "1.3.0", "notify")).toBe("notify")
    expect(action("1.2.3", "2.0.0", "notify")).toBe("notify")
@@ -27,21 +32,25 @@ describe("updater", () => {
    expect(action("1.2.3", "1.2.4", "disable")).toBe("none")
  })

-  test("reports up-to-date only when versions match", () => {
-    expect(action("1.2.3", "1.2.3", "notify")).toBe("none")
+  test("reports majors instead of automatically installing them", () => {
+    expect(action("1.2.3", "2.0.0", "auto")).toBe("notify")
  })

-  test("reports when latest is lower (rollback)", () => {
-    expect(action("1.2.4", "1.2.3", "notify")).toBe("notify")
+  test("reports up-to-date only when versions match", () => {
+    expect(action("1.2.3", "1.2.3", "auto")).toBe("none")
+  })
+
+  test("upgrades when latest is lower (rollback)", () => {
+    expect(action("1.2.4", "1.2.3", "auto")).toBe("upgrade")
  })

  test("accepts strict release version variants", () => {
-    expect(action("v1.2.3", " 1.2.4\n", "notify")).toBe("notify")
-    expect(action("1.2.3-alpha.1", "1.2.3-alpha.2", "notify")).toBe("notify")
-    expect(action("0.0.0-dev-17403", "0.0.0-dev-17403.2", "notify")).toBe("notify")
-    expect(action("0.0.0-next-17403", "0.0.0-beta-17404", "notify")).toBe("notify")
-    expect(action("1.2.3+old", "1.2.3+new", "notify")).toBe("none")
-    expect(action("v1.2.3+old", "1.2.3", "notify")).toBe("none")
+    expect(action("v1.2.3", " 1.2.4\n", "auto")).toBe("upgrade")
+    expect(action("1.2.3-alpha.1", "1.2.3-alpha.2", "auto")).toBe("upgrade")
+    expect(action("0.0.0-dev-17403", "0.0.0-dev-17403.2", "auto")).toBe("upgrade")
+    expect(action("0.0.0-next-17403", "0.0.0-beta-17404", "auto")).toBe("upgrade")
+    expect(action("1.2.3+old", "1.2.3+new", "auto")).toBe("none")
+    expect(action("v1.2.3+old", "1.2.3", "auto")).toBe("none")
  })

  test("preserves strict validity", () => {
@@ -62,21 +71,21 @@ describe("updater", () => {
      "0.9007199254740992.0",
      "0.0.9007199254740992",
    ]
-    invalid.forEach((version) => expect(action("1.2.3", version, "notify"), version).toBe("none"))
+    invalid.forEach((version) => expect(action("1.2.3", version, "auto"), version).toBe("none"))
  })

  test("handles numeric limits without losing precision", () => {
-    expect(action("9007199254740991.0.0", "9007199254740991.0.1", "notify")).toBe("notify")
-    expect(action("9007199254740990.0.0", "9007199254740991.0.0", "notify")).toBe("notify")
+    expect(action("9007199254740991.0.0", "9007199254740991.0.1", "auto")).toBe("upgrade")
+    expect(action("9007199254740990.0.0", "9007199254740991.0.0", "auto")).toBe("notify")
  })

  test("preserves equality for oversized numeric prerelease identifiers", () => {
-    expect(action("1.0.0-9007199254740992", "1.0.0-9007199254740993", "notify")).toBe("none")
-    expect(action("1.0.0-9007199254740991", "1.0.0-9007199254740992", "notify")).toBe("notify")
+    expect(action("1.0.0-9007199254740992", "1.0.0-9007199254740993", "auto")).toBe("none")
+    expect(action("1.0.0-9007199254740991", "1.0.0-9007199254740992", "auto")).toBe("upgrade")
  })

  test("rejects versions longer than semver's limit before trimming", () => {
-    expect(action("1.2.3", `${" ".repeat(251)}1.2.3`, "notify")).toBe("none")
-    expect(action("1.2.3", `1.2.4+${"a".repeat(250)}`, "notify")).toBe("notify")
+    expect(action("1.2.3", `${" ".repeat(251)}1.2.3`, "auto")).toBe("none")
+    expect(action("1.2.3", `1.2.4+${"a".repeat(250)}`, "auto")).toBe("upgrade")
  })
 })
@@ -1,36 +1,154 @@
 import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
+import { OpenCode } from "@opencode-ai/client"
+import { PersistentPty } from "@opencode-ai/schema/persistent-pty"
 import { OPENCODE_ARTIFACT, OPENCODE_CHANNEL, OPENCODE_LOCAL, OPENCODE_VERSION } from "../version"
-import { Context, Duration, Effect, FileSystem, Layer, Schedule } from "effect"
+import { Context, Duration, Effect, FileSystem, Layer, Ref, Schedule, Semaphore, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
-import { action, parseReleaseVersion, type Policy } from "./updater-action"
+import { action, parseReleaseVersion, type Action, type Policy } from "./updater-action"

 export const methods = ["curl", "npm", "pnpm", "bun", "yarn"] as const
 export type Method = (typeof methods)[number]

 export interface Interface {
-  readonly monitor: (notify: (version: string) => Effect.Effect<void>) => Effect.Effect<void>
+  readonly check: () => Effect.Effect<void>
+  readonly monitor: (input: {
+    readonly url: string
+    readonly password: string
+    readonly managed: boolean
+    readonly notify: (version: string) => Effect.Effect<void>
+    readonly restart: (handoff: PersistentPty.Handoff | null) => 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 monitorUpdates = Effect.fnUntraced(function* (input: {
-  readonly inspect: () => Effect.Effect<string | undefined, Error>
-  readonly notify: (version: string) => Effect.Effect<void>
-  readonly initialDelay?: Duration.Input
+export type Inspection =
+  | { readonly action: "none" }
+  | { readonly action: Exclude<Action, "none">; readonly version: string }
+
+type State =
+  | { readonly type: "current" }
+  | { readonly type: "available"; readonly version: string; readonly availableSince: number }
+  | { readonly type: "ready-to-restart"; readonly version: string }
+
+export interface MonitorInput {
+  readonly url: string
+  readonly password: string
+  readonly managed: boolean
+  readonly inspect: () => Effect.Effect<Inspection, Error>
+  readonly install: (version: string) => Effect.Effect<boolean, Error>
+  readonly restart: (handoff: PersistentPty.Handoff | null) => Effect.Effect<void>
  readonly interval?: Duration.Input
-}) {
-  const interval = input.interval ?? "10 minutes"
-  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))
+  readonly notificationThreshold?: Duration.Input
+  readonly notify: (version: string) => Effect.Effect<void>
+}
+
+export const monitorServer = Effect.fnUntraced(function* (input: MonitorInput) {
+  const state = yield* Ref.make<State>({ type: "current" })
+  const applyLock = yield* Semaphore.make(1)
+  const client = OpenCode.make({
+    baseUrl: input.url,
+    headers: { authorization: `Basic ${btoa(`opencode:${input.password}`)}` },
+  })
+
+  const applyIfIdle = () =>
+    applyLock.withPermit(
+      Effect.gen(function* () {
+        const pending = yield* Ref.get(state)
+        if (pending.type !== "available") return
+        const active = yield* Effect.tryPromise({
+          try: () => client.session.active(),
+          catch: (cause) => new Error("Failed to read active sessions", { cause }),
+        })
+        if (Object.keys(active).length > 0) return
+        const latest = yield* input.inspect()
+        if (latest.action !== "upgrade") {
+          yield* Ref.set(state, { type: "current" })
+          return
+        }
+        const installed = yield* input
+          .install(latest.version)
+          .pipe(
+            Effect.catch((error) =>
+              Effect.logWarning("automatic update failed", { cause: error }).pipe(Effect.as(false)),
+            ),
+          )
+        if (!installed) return
+        const handoff = input.managed
+          ? yield* Effect.tryPromise({
+              try: () => client.experimental.persistentPty.handoff(),
+              catch: (cause) => new Error("Failed to prepare persistent terminals for restart", { cause }),
+            })
+          : undefined
+        yield* Ref.set(state, { type: "ready-to-restart", version: latest.version })
+        if (handoff) yield* input.restart(handoff.handoff)
+      }),
+    )
+
+  const checkServer = Effect.gen(function* () {
+    const result = yield* input.inspect()
+    if (result.action === "notify") {
+      yield* input.notify(result.version)
+      return
+    }
+    if (result.action !== "upgrade") {
+      yield* Ref.update(
+        state,
+        (current): State => (current.type === "ready-to-restart" ? current : { type: "current" }),
+      )
+      return
+    }
+    yield* Ref.update(state, (current): State => {
+      if (current.type === "ready-to-restart" && current.version === result.version) return current
+      return {
+        type: "available",
+        version: result.version,
+        availableSince: current.type === "available" ? current.availableSince : Date.now(),
+      }
+    })
+    yield* applyIfIdle()
+    const pending = yield* Ref.get(state)
+    if (
+      pending.type === "available" &&
+      Date.now() - pending.availableSince >= Duration.toMillis(input.notificationThreshold ?? "3 days")
+    )
+      yield* input.notify(pending.version)
+  }).pipe(Effect.catch((cause) => Effect.logWarning("automatic update check failed", { cause })))
+
+  const subscribe = Effect.suspend(() =>
+    Stream.fromAsyncIterable(
+      client.event.subscribe(),
+      (cause) => new Error("Update event stream failed", { cause }),
+    ).pipe(
+      Stream.runForEach((event) => {
+        if (event.type === "server.connected") return applyIfIdle()
+        if (
+          event.type !== "session.execution.succeeded" &&
+          event.type !== "session.execution.failed" &&
+          event.type !== "session.execution.interrupted"
+        )
+          return Effect.void
+        return Effect.tryPromise({
+          try: () => client.session.wait({ sessionID: event.data.sessionID }),
+          catch: (cause) => new Error(`Failed to wait for Session ${event.data.sessionID}`, { cause }),
+        }).pipe(Effect.andThen(applyIfIdle()))
+      }),
+      Effect.catch((cause) => Effect.logWarning("update event stream disconnected", { cause })),
+    ),
+  ).pipe(Effect.repeat(Schedule.spaced("1 second")))
+
+  return yield* Effect.all(
+    [checkServer.pipe(Effect.repeat(Schedule.spaced(input.interval ?? "10 minutes"))), subscribe],
+    {
+      concurrency: "unbounded",
+      discard: true,
+    },
+  )
 })

 export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Updater") {}
@@ -43,14 +161,13 @@ 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") return value
-    if (value === "auto") return "notify"
+    if (value === "disable" || value === "notify" || value === "auto") return value
    return
  }
  if (!("autoupdate" in input)) return
  if (input.autoupdate === false) return "disable"
  if (input.autoupdate === "notify") return "notify"
-  if (input.autoupdate === true) return "notify"
+  if (input.autoupdate === true) return "auto"
 }

 const make = Effect.gen(function* () {
@@ -75,7 +192,7 @@ const make = Effect.gen(function* () {
        Effect.orElseSucceed(() => undefined),
      ),
    )
-    return values.findLast((value) => value !== undefined) ?? "notify"
+    return values.findLast((value) => value !== undefined) ?? "auto"
  })

  const run = Effect.fnUntraced(function* (command: string[], timeout: Duration.Input = "10 seconds") {
@@ -185,19 +302,19 @@ const make = Effect.gen(function* () {
    return yield* Effect.fail(new Error(result.stderr.trim() || `Failed to update with ${method}`))
  })

-  const inspect = Effect.fnUntraced(function* () {
+  const inspect = Effect.fnUntraced(function* (): Effect.fn.Return<Inspection, Error> {
    if (OPENCODE_LOCAL || ["1", "true"].includes(process.env.OPENCODE_DISABLE_AUTOUPDATE?.toLowerCase() ?? "")) {
      yield* Effect.logInfo("update check skipped", {
        reason: OPENCODE_LOCAL ? "local-install" : "disabled",
        version: OPENCODE_VERSION,
        channel: OPENCODE_CHANNEL,
      })
-      return undefined
+      return { action: "none" }
    }
    const policy = yield* readPolicy()
    if (policy === "disable") {
      yield* Effect.logInfo("update check skipped", { reason: "policy-disabled" })
-      return undefined
+      return { action: "none" }
    }

    const version = yield* latest()
@@ -208,16 +325,19 @@ const make = Effect.gen(function* () {
    const next = action(OPENCODE_VERSION, version, policy)
    if (next === "none") {
      yield* Effect.logInfo("update check done", { action: "up-to-date" })
-      return undefined
+      return { action: "none" }
    }
-    yield* Effect.logInfo("OpenCode update available", { current: OPENCODE_VERSION, latest: version })
-    return version
+    if (next === "notify") {
+      yield* Effect.logInfo("OpenCode update available", { current: OPENCODE_VERSION, latest: version })
+      return { action: next, version }
+    }
+    return { action: next, version }
  })

  const install = Effect.fnUntraced(function* (version: string) {
    const detected = yield* method()
    if (!detected) {
-      yield* Effect.logWarning("update skipped: installation method not found")
+      yield* Effect.logWarning("automatic update skipped: installation method not found")
      return false
    }
    yield* upgrade(detected, version)
@@ -229,9 +349,26 @@ const make = Effect.gen(function* () {
    if (!(yield* install(version))) return yield* Effect.fail(new Error("Installation method not found"))
  })

-  const monitor = (notify: (version: string) => Effect.Effect<void>) => monitorUpdates({ inspect, notify })
+  const check = Effect.fn("cli.updater.check")(
+    function* () {
+      const result = yield* inspect()
+      if (result.action !== "upgrade") return
+      yield* install(result.version)
+    },
+    Effect.catchCause((cause) => Effect.logWarning("automatic update failed", { cause })),
+  )

-  return Service.of({ monitor, apply, method, latest, upgrade })
+  const monitor = Effect.fn("cli.updater.monitor")(function* (input: {
+    readonly url: string
+    readonly password: string
+    readonly managed: boolean
+    readonly notify: (version: string) => Effect.Effect<void>
+    readonly restart: (handoff: PersistentPty.Handoff | null) => Effect.Effect<void>
+  }) {
+    return yield* monitorServer({ ...input, inspect, install })
+  })
+
+  return Service.of({ check, monitor, apply, method, latest, upgrade })
 })

 export const layer = Layer.effect(Service, make)
@@ -5,7 +5,7 @@ describe("acp command", () => {
  test("is registered", async () => {
    const result = await cli(["--help"])
    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toMatch(/^  acp[ \t]+Start an Agent Client Protocol server\r?$/m)
+    expect(result.stdout).toContain("acp        Start an Agent Client Protocol server")
  })
 })

@@ -12,8 +12,9 @@ await Effect.runPromise(
    process.argv.slice(2),
  ).pipe(
    Effect.provideService(Updater.Service, {
+      check: () => Effect.die("Manual upgrades must not run the automatic update check"),
      monitor: () => Effect.die("Manual upgrades must not monitor automatic updates"),
-      apply: () => Effect.die("Manual upgrades must not apply TUI updates"),
+      apply: () => Effect.die("Manual upgrades must not apply automatic updates"),
      method: () =>
        Effect.sync(() => {
          record("method")
@@ -117,8 +117,8 @@ describe("mini command", () => {
    const result = await cli(["--help"])

    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toMatch(/^  mini[ \t]+Start the minimal interactive interface\r?$/m)
-    expect(result.stdout).toMatch(/^  run[ \t]+Run OpenCode with a message\r?$/m)
+    expect(result.stdout).toContain("mini       Start the minimal interactive interface")
+    expect(result.stdout).toContain("run        Run OpenCode with a message")
  })

  test("exposes run without legacy interactive, attach, or command modes", async () => {
@@ -1,40 +1,107 @@
 import { expect } from "bun:test"
-import { Effect, Layer, Queue } from "effect"
-import { TestClock } from "effect/testing"
+import { Deferred, Effect, Layer, Option } from "effect"
 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", () =>
+it.live("installs and restarts after the final Session settles", () =>
  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),
+    const fixture = yield* Effect.acquireRelease(Effect.sync(makeServer), (server) => Effect.sync(() => server.stop()))
+    const installed = yield* Deferred.make<string>()
+    const restarted = yield* Deferred.make<void>()
+    yield* Updater.monitorServer({
+      url: fixture.url,
+      password: "test",
+      managed: true,
+      inspect: () => Effect.succeed({ action: "upgrade", version: "1.1.0" }),
+      install: (version) => Deferred.succeed(installed, version).pipe(Effect.as(true)),
+      restart: () => Deferred.succeed(restarted, undefined).pipe(Effect.asVoid),
+      notify: () => Effect.void,
    }).pipe(Effect.forkScoped)
+    yield* wait(fixture.activeRead, () => "Updater did not check active Sessions")
+    yield* wait(fixture.eventOpened, () => "Updater did not open the server event stream")
+    expect(Option.isNone(yield* Deferred.poll(installed))).toBe(true)

-    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")
+    fixture.settle()
+    yield* wait(fixture.waited, () => "Updater did not receive the settlement event")
+    expect(
+      yield* Effect.raceFirst(
+        Deferred.await(installed),
+        Effect.sleep("1 second").pipe(Effect.andThen(Effect.fail(new Error("Updater did not install the update")))),
+      ),
+    ).toBe("1.1.0")
+    yield* Effect.raceFirst(
+      Deferred.await(restarted),
+      Effect.sleep("1 second").pipe(Effect.andThen(Effect.fail(new Error("Updater did not restart the server")))),
+    )
  }),
 )

-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)
+const wait = (promise: Promise<unknown>, message: () => string) =>
+  Effect.tryPromise(() => Promise.race([promise, Bun.sleep(1_000).then(() => Promise.reject(new Error(message())))]))

-    yield* Effect.yieldNow
-    expect(yield* Queue.size(updates)).toBe(0)
-  }),
-)
+function makeServer() {
+  const encoder = new TextEncoder()
+  const activeRead = Promise.withResolvers<void>()
+  const eventOpened = Promise.withResolvers<void>()
+  const waited = Promise.withResolvers<void>()
+  let active = true
+  let events: ReadableStreamDefaultController<Uint8Array> | undefined
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    fetch(request) {
+      const url = new URL(request.url)
+      if (url.pathname === "/api/session/active") {
+        activeRead.resolve()
+        return Response.json({ data: active ? { ses_test: { type: "running" } } : {} })
+      }
+      if (url.pathname === "/api/session/ses_test/wait" && request.method === "POST") {
+        waited.resolve()
+        return new Response(null, { status: 204 })
+      }
+      if (url.pathname === "/api/experimental/persistent-pty/handoff" && request.method === "POST") {
+        return Response.json({ handoff: null })
+      }
+      if (url.pathname === "/api/event") {
+        return new Response(
+          new ReadableStream<Uint8Array>({
+            start(controller) {
+              events = controller
+              eventOpened.resolve()
+            },
+          }),
+          { headers: { "content-type": "text/event-stream" } },
+        )
+      }
+      return new Response("Not found", { status: 404 })
+    },
+  })
+
+  return {
+    url: server.url.origin,
+    activeRead: activeRead.promise,
+    eventOpened: eventOpened.promise,
+    waited: waited.promise,
+    settle() {
+      active = false
+      events?.enqueue(
+        encoder.encode(
+          `data: ${JSON.stringify({
+            id: "evt_settled",
+            created: Date.now(),
+            type: "session.execution.succeeded",
+            durable: { aggregateID: "ses_test", seq: 0, version: 1 },
+            data: { sessionID: "ses_test" },
+          })}\n\n`,
+        ),
+      )
+      events?.close()
+      events = undefined
+    },
+    stop() {
+      server.stop(true)
+    },
+  }
+}
@@ -1892,7 +1892,7 @@ export type ConfigEntry =
        shell?: string
        model?: string | { providerID: string; model: string; variant?: string }
        default_agent?: string
-        update?: "disable" | "notify"
+        update?: "disable" | "notify" | "auto"
        share?: "manual" | "auto" | "disabled"
        enterprise?: { url?: string }
        username?: string
@@ -66,8 +66,6 @@ export type CreateDataInput = {
  readonly connection?: {
    readonly status: () => "connected" | "connecting" | "reconnecting"
  }
-  /** Receives failed event-driven reads. Explicit reads still reject to their caller. */
-  readonly onError?: (error: unknown) => void
 }

 const messageIDFromEvent = (eventID: string) => eventID.replace(/^evt_/, "msg_")
@@ -189,17 +187,6 @@ function createSync() {

 export function createData(config: CreateDataInput) {
  const api = config.api
-  let disposed = false
-  onCleanup(() => (disposed = true))
-
-  function refresh(load: () => Promise<unknown>) {
-    if (disposed || (config.connection && config.connection.status() !== "connected")) return
-    void load().catch((error) => {
-      if (disposed || (config.connection && config.connection.status() !== "connected")) return
-      if (config.onError) return config.onError(error)
-      console.error("Failed to refresh client data", error)
-    })
-  }

  const [store, setStore] = createStore<Store>({
    session: {
@@ -567,34 +554,31 @@ export function createData(config: CreateDataInput) {
      case "server.connected": {
        const updates = new Map<string, DataSessionStatus | undefined>()
        activeUpdates = updates
-        refresh(() =>
-          api()
-            .session.active()
-            .then((active) => {
-              if (activeUpdates !== updates) return
-              // Lifecycle events received during hydration supersede the snapshot.
-              const snapshot = new Map<string, DataSessionStatus>(Object.keys(active).map((id) => [id, "running"]))
-              updates.forEach((status, id) => {
-                if (status === undefined) return snapshot.delete(id)
-                snapshot.set(id, status)
-              })
-              activeUpdates = undefined
-              setStore("session", "active", reconcile(Object.fromEntries(snapshot)))
+        void api()
+          .session.active()
+          .then((active) => {
+            if (activeUpdates !== updates) return
+            // Lifecycle events received during hydration supersede the snapshot.
+            const snapshot = new Map<string, DataSessionStatus>(Object.keys(active).map((id) => [id, "running"]))
+            updates.forEach((status, id) => {
+              if (status === undefined) return snapshot.delete(id)
+              snapshot.set(id, status)
            })
-            .catch(() => {
-              if (activeUpdates === updates) activeUpdates = undefined
-            }),
-        )
-        refresh(() =>
-          api()
-            .location.get({ location: locationQuery(defaultLocation()) })
-            .then((location) => {
-              const key = locationKey(location)
-              setStore("location", key, { info: location })
-            }),
-        )
-        refresh(() => result.location.vcs.sync())
-        refresh(() => result.project.sync())
+            activeUpdates = undefined
+            setStore("session", "active", reconcile(Object.fromEntries(snapshot)))
+          })
+          .catch(() => {
+            if (activeUpdates === updates) activeUpdates = undefined
+          })
+        void api()
+          .location.get({ location: locationQuery(defaultLocation()) })
+          .then((location) => {
+            const key = locationKey(location)
+            setStore("location", key, { info: location })
+          })
+          .catch((error) => console.error("Failed to preload location", error))
+        void result.location.vcs.sync().catch((error) => console.error("Failed to preload VCS info", error))
+        void result.project.sync().catch((error) => console.error("Failed to preload projects", error))
        return
      }
      case "project.updated":
@@ -603,7 +587,7 @@ export function createData(config: CreateDataInput) {
      case "session.created":
        sessionOutbox.delete(event.data.sessionID)
        result.session.invalidate(event.data.sessionID)
-        refresh(() => result.session.sync(event.data.sessionID))
+        void result.session.sync(event.data.sessionID)
        // Band-aid: a newly created session starts empty, so live events can be its source of truth.
        // Fetching pending inputs and projected messages separately lets promotion move an input between snapshots,
        // causing both requests to miss it and overwrite event-built state. Skip those racy initial reads until
@@ -644,28 +628,25 @@ export function createData(config: CreateDataInput) {
          model: event.data.model,
          time: { created: event.created },
        })
-        refresh(() =>
-          api()
-            .session.message({ sessionID: event.data.sessionID, messageID: messageIDFromEvent(event.id) })
-            .then((item) => {
-              message.update(event.data.sessionID, (draft, index) => {
-                const position = index.get(item.id)
-                if (position === undefined) return message.append(draft, index, item)
-                draft[position] = item
-              })
-            }),
-        )
+        void api()
+          .session.message({ sessionID: event.data.sessionID, messageID: messageIDFromEvent(event.id) })
+          .then((item) => {
+            message.update(event.data.sessionID, (draft, index) => {
+              const position = index.get(item.id)
+              if (position === undefined) return message.append(draft, index, item)
+              draft[position] = item
+            })
+          })
+          .catch((error) => console.error("Failed to load projected model switch message", error))
        return
      case "session.renamed": {
        // Preserve the live title when it races the session's initial read.
-        refresh(() => {
-          const family = sync.pending(`session.family:${event.data.sessionID}`)
-            ? result.session.sync(event.data.sessionID, { children: true })
-            : Promise.resolve()
-          return Promise.all([result.session.sync(event.data.sessionID), family]).then(() => {
-            if (store.session.info[event.data.sessionID])
-              setStore("session", "info", event.data.sessionID, "title", event.data.title)
-          })
+        const family = sync.pending(`session.family:${event.data.sessionID}`)
+          ? result.session.sync(event.data.sessionID, { children: true })
+          : Promise.resolve()
+        void Promise.all([result.session.sync(event.data.sessionID), family]).then(() => {
+          if (store.session.info[event.data.sessionID])
+            setStore("session", "info", event.data.sessionID, "title", event.data.title)
        })
        return
      }
@@ -699,7 +680,7 @@ export function createData(config: CreateDataInput) {
          if (!directory) {
            if (info.location.workspaceID) continue
            result.session.invalidate(sessionID)
-            refresh(() => result.session.sync(sessionID))
+            void result.session.sync(sessionID)
            continue
          }
          const adopted = Worktree.adopt(
@@ -810,7 +791,7 @@ export function createData(config: CreateDataInput) {
          })
        if (!sync.pending(`session.message:${event.data.sessionID}`)) return
        result.session.message.invalidate(event.data.sessionID)
-        refresh(() => result.session.message.sync(event.data.sessionID))
+        void result.session.message.sync(event.data.sessionID)
        return
      }
      case "session.step.started":
@@ -1011,12 +992,12 @@ export function createData(config: CreateDataInput) {
        // An event can overtake the first read; queue a revalidation when that read is still active.
        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
        result.session.invalidate(event.data.sessionID)
-        refresh(() => result.session.sync(event.data.sessionID))
+        void result.session.sync(event.data.sessionID)
        return
      case "session.viewed":
        if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
        result.session.invalidate(event.data.sessionID)
-        refresh(() => result.session.sync(event.data.sessionID))
+        void result.session.sync(event.data.sessionID)
        return
      case "session.revert.staged":
        if (store.session.info[event.data.sessionID])
@@ -1124,7 +1105,7 @@ export function createData(config: CreateDataInput) {
        const location = { directory: ref[0], workspaceID: ref[1] ?? undefined }
        if (event.type === "credential.updated") {
          result.location.integration.invalidate(location)
-          refresh(() => result.location.integration.sync(location))
+          void result.location.integration.sync(location)
          return
        }
        setStore("location", key, (data) => ({
@@ -1142,7 +1123,7 @@ export function createData(config: CreateDataInput) {
        }))
        result.location.model.invalidate(location)
        result.location.provider.invalidate(location)
-        refresh(() => Promise.all([result.location.model.sync(location), result.location.provider.sync(location)]))
+        void Promise.all([result.location.model.sync(location), result.location.provider.sync(location)])
      })
      return
    }
@@ -1153,19 +1134,19 @@ export function createData(config: CreateDataInput) {
      case "catalog.updated":
        result.location.model.invalidate(location)
        result.location.provider.invalidate(location)
-        refresh(() => Promise.all([result.location.model.sync(location), result.location.provider.sync(location)]))
+        void Promise.all([result.location.model.sync(location), result.location.provider.sync(location)])
        break
      case "agent.updated":
        result.location.agent.invalidate(location)
-        refresh(() => result.location.agent.sync(location))
+        void result.location.agent.sync(location)
        break
      case "command.updated":
        result.location.command.invalidate(location)
-        refresh(() => result.location.command.sync(location))
+        void result.location.command.sync(location)
        break
      case "skill.updated":
        result.location.skill.invalidate(location)
-        refresh(() => result.location.skill.sync(location))
+        void result.location.skill.sync(location)
        break
      case "vcs.branch.updated":
        setStore("location", locationKey(location), (data) => ({
@@ -1200,33 +1181,31 @@ export function createData(config: CreateDataInput) {
        break
      case "reference.updated":
        result.location.reference.invalidate(location)
-        refresh(() => result.location.reference.sync(location))
+        void result.location.reference.sync(location)
        break
      case "integration.updated":
        result.location.integration.invalidate(location)
        result.location.model.invalidate(location)
        result.location.provider.invalidate(location)
-        refresh(() =>
-          Promise.all([
-            result.location.integration.sync(location),
-            result.location.model.sync(location),
-            result.location.provider.sync(location),
-          ]),
-        )
+        void Promise.all([
+          result.location.integration.sync(location),
+          result.location.model.sync(location),
+          result.location.provider.sync(location),
+        ])
        break
      case "config.updated":
      case "websearch.updated":
-        refresh(() => result.location.websearch.refresh(location))
+        void result.location.websearch.refresh(location)
        break
      // Authenticating an MCP integration reconnects its server, which emits mcp.status.changed,
      // so the mcp list syncs here rather than off integration.updated.
      case "mcp.status.changed":
        result.location.mcp.server.invalidate(location)
-        refresh(() => result.location.mcp.server.sync(location))
+        void result.location.mcp.server.sync(location)
        break
      case "mcp.resources.changed":
        result.location.mcp.resource.invalidate(location)
-        refresh(() => result.location.mcp.resource.sync(location))
+        void result.location.mcp.resource.sync(location)
        break
    }
  }
@@ -1,117 +0,0 @@
-import { expect, test } from "bun:test"
-import { createRoot } from "solid-js"
-import { createData, type CreateDataInput } from "../src/solid"
-import { OpenCode, type OpenCodeEvent, type SessionInfo } from "../src/promise"
-
-test("event refreshes report failures, remain retryable, and preserve explicit read errors", async () => {
-  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
-  const reported = Promise.withResolvers<unknown>()
-  const errors: unknown[] = []
-  const state = { offline: true, requests: 0 }
-  const session: SessionInfo = {
-    id: "ses_refresh_failure",
-    projectID: "project",
-    cost: 0,
-    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: 0, updated: 0, idle: 2 },
-    location: { directory: "/project" },
-  }
-  const api = OpenCode.make({
-    baseUrl: "http://opencode.local",
-    fetch: async () => {
-      state.requests++
-      if (state.offline) throw new TypeError("Failed to fetch")
-      return Response.json({ data: { ...session, title: "Recovered" } })
-    },
-  })
-  const setup = createRoot((dispose) => ({
-    data: createData({
-      api: () => api,
-      directory: "/project",
-      event: {
-        on: () => () => {},
-        listen(handler) {
-          listeners.add(handler)
-          return () => listeners.delete(handler)
-        },
-      },
-      onError(error) {
-        errors.push(error)
-        reported.resolve(error)
-      },
-    }),
-    dispose,
-  }))
-  const event: OpenCodeEvent = {
-    id: "evt_refresh_failure",
-    created: 2,
-    type: "session.viewed",
-    durable: { aggregateID: session.id, seq: 1, version: 1 },
-    data: { sessionID: session.id, idle: 2 },
-  }
-  try {
-    setup.data.session.remember(session)
-    setup.data.session.invalidate(session.id)
-    await expect(setup.data.session.sync(session.id)).rejects.toThrow("Transport")
-    expect(errors).toEqual([])
-    listeners.forEach((listener) => listener({ name: event.type, details: event }))
-    expect(String(await reported.promise)).toContain("Transport")
-    expect(errors).toHaveLength(1)
-    expect(setup.data.session.get(session.id)?.title).toBeUndefined()
-    state.offline = false
-    listeners.forEach((listener) => listener({ name: event.type, details: event }))
-    await setup.data.session.sync(session.id)
-    expect(setup.data.session.get(session.id)?.title).toBe("Recovered")
-    expect(state.requests).toBe(3)
-  } finally {
-    setup.dispose()
-  }
-})
-
-test.each(["reconnecting", "disposed"] as const)("background reads respect %s owners", async (mode) => {
-  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
-  const pending = Promise.withResolvers<Response>()
-  const errors: unknown[] = []
-  const state = { requests: 0 }
-  const api = OpenCode.make({
-    baseUrl: "http://opencode.local",
-    fetch: () => {
-      state.requests++
-      return pending.promise
-    },
-  })
-  const setup = createRoot((dispose) => ({
-    data: createData({
-      api: () => api,
-      directory: "/project",
-      event: {
-        on: () => () => {},
-        listen(handler) {
-          listeners.add(handler)
-          return () => listeners.delete(handler)
-        },
-      },
-      connection: { status: () => (mode === "reconnecting" ? "reconnecting" : "connected") },
-      onError: (error) => errors.push(error),
-    }),
-    dispose,
-  }))
-  const event: OpenCodeEvent = {
-    id: "evt_refresh_owner",
-    type: "command.updated",
-    location: { directory: "/project" },
-    data: {},
-  }
-  listeners.forEach((listener) => listener({ name: event.type, details: event }))
-  if (mode === "reconnecting") {
-    expect(state.requests).toBe(0)
-    setup.dispose()
-    return
-  }
-  const joined = setup.data.location.command.sync()
-  setup.dispose()
-  pending.reject(new TypeError("Failed to fetch"))
-  await expect(joined).rejects.toThrow("Transport")
-  expect(state.requests).toBe(1)
-  expect(errors).toEqual([])
-})
@@ -8,7 +8,7 @@ import { CodeModeCatalog } from "./catalog.js"
 // prettier-ignore
 const prompt = (hasMoreTools: boolean) => `The Code Mode tool catalog below is ${hasMoreTools ? "partial" : "complete"}.

-${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools callable inside \`execute\`. It does not affect tools exposed directly outside Code Mode.${hasMoreTools ? `
+${hasMoreTools ? "The Code Mode catalog and `search` results are" : "This catalog is"} the complete set of tools available within Code Mode. Tools presented elsewhere are not available in this runtime.${hasMoreTools ? `

 ## Search

@@ -73,11 +73,6 @@ export function normalize(input: unknown): Result {
  const legacyUpdate = own(input, "autoupdate")
    ? decodeValue(ConfigV1.Info.fields.autoupdate, input.autoupdate, ["autoupdate"], diagnostics)
    : undefined
-  const nativeUpdate = own(input, "update")
-    ? 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
      ? "auto"
@@ -91,10 +86,7 @@ export function normalize(input: unknown): Result {
    if (migrated !== undefined) encoded.media = canonical(ConfigMedia.Info, migrated)
  }
  if (legacySnapshots !== undefined) encoded.snapshots = legacySnapshots
-  const migratedUpdate =
-    legacyUpdate === undefined ? undefined : ConfigMigrateV1.migrate({ autoupdate: legacyUpdate }).update
-  const update = prefer(migratedUpdate, nativeUpdate, ["update"], diagnostics)
-  if (update !== undefined) encoded.update = update
+  if (legacyUpdate !== undefined) encoded.update = ConfigMigrateV1.migrate({ autoupdate: legacyUpdate }).update
  if (legacyShare !== undefined) encoded.share = legacyShare

  const legacyReferences = decodeMap(input.reference, ConfigReference.Entry, ["reference"], diagnostics, decodeEncoded)
@@ -204,6 +196,7 @@ export function normalize(input: unknown): Result {
    shell: Info.fields.shell,
    model: Info.fields.model,
    default_agent: Info.fields.default_agent,
+    update: Info.fields.update,
    share: Info.fields.share,
    enterprise: Info.fields.enterprise,
    username: Info.fields.username,
@@ -18,9 +18,7 @@ const RemoteModel = Schema.Struct({
        Schema.Struct({
          batch_size: Schema.Number,
          default: Schema.Struct({
-            // API version 2026-08-01 renamed cache_price to cache_read_price.
-            cache_price: Schema.optional(Schema.Number),
-            cache_read_price: Schema.optional(Schema.Number),
+            cache_price: Schema.Number,
            input_price: Schema.Number,
            output_price: Schema.Number,
          }),
@@ -168,9 +166,7 @@ function build(id: Model.ID, remote: UsableModel, baseURL: string, previous?: Mo
        input: Money.USDPerMillionTokens.make((prices?.default.input_price ?? 0) * usdPerMillion),
        output: Money.USDPerMillionTokens.make((prices?.default.output_price ?? 0) * usdPerMillion),
        cache: {
-          read: Money.USDPerMillionTokens.make(
-            (prices?.default.cache_read_price ?? prices?.default.cache_price ?? 0) * usdPerMillion,
-          ),
+          read: Money.USDPerMillionTokens.make((prices?.default.cache_price ?? 0) * usdPerMillion),
          write: Money.USDPerMillionTokens.zero,
        },
      },
@@ -55,6 +55,7 @@ type Active = {
  done: Deferred.Deferred<Info>
  backgrounded: Deferred.Deferred<Info>
  scope: Scope.Closeable
+  token: object
  blockingSessions: Map<SessionSchema.ID, number>
  isBackgrounded: boolean
  recovery?: Recovery
@@ -76,7 +77,7 @@ type BackgroundResult = {
  backgrounded?: Deferred.Deferred<Info>
 }

-type StartResult = { info: Info } | { info: Info; scope: Scope.Closeable }
+type StartResult = { info: Info } | { info: Info; scope: Scope.Closeable; token: object }

 type BlockWait = {
  done: Deferred.Deferred<Info>
@@ -183,14 +184,14 @@ export const make = Effect.gen(function* () {
    })
  })

-  const settle = Effect.fnUntraced(function* (id: string, scope: Scope.Closeable, exit: Exit.Exit<string, unknown>) {
+  const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
    const completed_at = yield* Clock.currentTimeMillis
    const result = yield* SynchronizedRef.modifyEffect(
      state.jobs,
      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [FinishResult, Map<string, Active>]> {
        const job = jobs.get(id)
        if (!job) return [{}, jobs]
-        if (job.scope !== scope) return [{}, jobs]
+        if (job.token !== token) return [{}, jobs]
        if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
        const status: Exclude<Status, "running"> = Exit.isSuccess(exit)
          ? "completed"
@@ -240,6 +241,7 @@ export const make = Effect.gen(function* () {
              return [{ info: snapshot(existing) }, jobs]
            }
            const scope = yield* Scope.fork(state.scope, "parallel")
+            const token = {}
            const job = {
              info: {
                id,
@@ -253,17 +255,18 @@ export const make = Effect.gen(function* () {
              done,
              backgrounded,
              scope,
+              token,
              blockingSessions: new Map<SessionSchema.ID, number>(),
              isBackgrounded: false,
              recovery: input.recovery,
            }
-            return [{ info: snapshot(job), scope }, new Map(jobs).set(id, job)]
+            return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)]
          }),
        )
        if ("scope" in result)
          yield* restore(input.run).pipe(
            Effect.exit,
-            Effect.flatMap((exit) => settle(id, result.scope, exit)),
+            Effect.flatMap((exit) => settle(id, result.token, exit)),
            Effect.asVoid,
            Effect.forkIn(result.scope, { startImmediately: true }),
          )
@@ -1,141 +0,0 @@
-export * as ModalModels from "./models.js"
-
-import { Money } from "@opencode-ai/schema/money"
-import { Option, Schema } from "effect"
-import { Model } from "../model.js"
-import { Provider } from "../provider.js"
-
-const providerID = Provider.ID.make("modal")
-
-const ReasoningOption = Schema.Struct({
-  type: Schema.Literal("effort"),
-  values: Schema.Array(Schema.NullOr(Schema.String)),
-})
-
-const RemoteModel = Schema.Struct({
-  id: Schema.String,
-  base_model_id: Schema.optional(Schema.String),
-  hugging_face_id: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  input_modalities: Schema.optional(Schema.Array(Schema.String)),
-  output_modalities: Schema.optional(Schema.Array(Schema.String)),
-  context_length: Schema.optional(Schema.Number),
-  max_output_length: Schema.optional(Schema.Number),
-  pricing: Schema.optional(
-    Schema.Struct({
-      prompt: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-      completion: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-      input_cache_read: Schema.optional(Schema.Union([Schema.String, Schema.Number])),
-    }),
-  ),
-  supported_sampling_parameters: Schema.optional(Schema.Array(Schema.String)),
-  supported_features: Schema.optional(Schema.Array(Schema.String)),
-  reasoning_options: Schema.optional(Schema.Array(ReasoningOption)),
-  interleaved: Schema.optional(
-    Schema.Union([
-      Schema.Boolean,
-      Schema.Struct({
-        field: Schema.Literals(["reasoning", "reasoning_content", "reasoning_details"]),
-      }),
-    ]),
-  ),
-})
-
-const Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) })
-const decodeResponse = Schema.decodeUnknownSync(Response)
-const decodeModel = Schema.decodeUnknownOption(RemoteModel)
-
-type RemoteModel = typeof RemoteModel.Type
-
-export async function get(baseURL: string, apiKey: string, existing: readonly Model.Info[]) {
-  const response = await fetch(`${baseURL.replace(/\/+$/, "")}/models`, {
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-    },
-    signal: AbortSignal.timeout(3_000),
-  })
-  if (!response.ok) throw new Error(`Failed to fetch Modal models: ${response.status}`)
-
-  // Decode each item tolerantly so one malformed entry cannot discard the
-  // whole inventory. A malformed envelope still fails the fetch.
-  const remote = decodeResponse(await response.json()).data.flatMap((raw) => {
-    const model = Option.getOrUndefined(decodeModel(raw))
-    return model ? [model] : []
-  })
-  const templates = new Map(existing.map((model) => [model.id, model]))
-  const result = new Map<Model.ID, Model.Info>()
-  for (const item of remote) {
-    const template = templates.get(Model.ID.make(item.base_model_id ?? item.hugging_face_id ?? item.id))
-    const id = Model.ID.make(item.id)
-    result.set(id, build(id, item, baseURL, template))
-  }
-  return result
-}
-
-function price(value: string | number | undefined, fallback: Money.USDPerMillionTokens) {
-  if (value === undefined) return fallback
-  const parsed = Number(value) * 1_000_000
-  return Number.isFinite(parsed) ? Money.USDPerMillionTokens.make(parsed) : fallback
-}
-
-function limit(value: number | undefined, fallback: number) {
-  const parsed = value === undefined ? fallback : Math.trunc(value)
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback
-}
-
-function build(id: Model.ID, remote: RemoteModel, baseURL: string, previous?: Model.Info) {
-  const cost = previous?.cost[0]
-  const input = previous?.limit.input
-  return Model.Info.make({
-    ...Model.Info.default(providerID, id),
-    id,
-    modelID: Model.ID.make(remote.id),
-    providerID,
-    name: remote.name ?? previous?.name ?? remote.id,
-    family: previous?.family,
-    compatibility:
-      remote.interleaved === undefined
-        ? previous?.compatibility
-        : (Model.compatibility(remote.interleaved) ?? previous?.compatibility),
-    package: Provider.aisdk("@ai-sdk/openai-compatible"),
-    settings: Provider.mergeOverlay(previous?.settings, { baseURL }),
-    headers: previous?.headers,
-    body: previous?.body,
-    capabilities: {
-      tools: remote.supported_features?.includes("tools") ?? previous?.capabilities.tools ?? true,
-      input: remote.input_modalities ?? previous?.capabilities.input ?? ["text"],
-      output: remote.output_modalities ?? previous?.capabilities.output ?? ["text"],
-    },
-    variants: remote.reasoning_options === undefined ? (previous?.variants ?? []) : variants(remote),
-    time: previous?.time ?? { released: 0 },
-    cost: [
-      {
-        input: price(remote.pricing?.prompt, cost?.input ?? Money.USDPerMillionTokens.zero),
-        output: price(remote.pricing?.completion, cost?.output ?? Money.USDPerMillionTokens.zero),
-        cache: {
-          read: price(remote.pricing?.input_cache_read, cost?.cache.read ?? Money.USDPerMillionTokens.zero),
-          write: cost?.cache.write ?? Money.USDPerMillionTokens.zero,
-        },
-      },
-    ],
-    status: previous?.status ?? "active",
-    enabled: previous?.enabled ?? true,
-    limit: {
-      context: limit(remote.context_length, previous?.limit.context ?? 0),
-      ...(input === undefined ? {} : { input }),
-      output: limit(remote.max_output_length, previous?.limit.output ?? 0),
-    },
-  })
-}
-
-function variants(remote: RemoteModel): Model.Info["variants"] {
-  const seen = new Map<string, Model.Info["variants"][number]>()
-  for (const option of remote.reasoning_options ?? []) {
-    for (const value of option.values) {
-      const effort = value ?? "none"
-      if (!seen.has(effort))
-        seen.set(effort, { id: Model.VariantID.make(effort), settings: { reasoningEffort: effort } })
-    }
-  }
-  return [...seen.values()]
-}
@@ -15,7 +15,6 @@ import { KiloPlugin } from "./provider/kilo.js"
 import { LLMGatewayPlugin } from "./provider/llmgateway.js"
 import { LMStudioPlugin } from "./provider/lmstudio.js"
 import { MistralPlugin } from "./provider/mistral.js"
-import { ModalPlugin } from "./provider/modal.js"
 import { NvidiaPlugin } from "./provider/nvidia.js"
 import { OllamaPlugin } from "./provider/ollama.js"
 import { OpenAIPlugin } from "./provider/openai.js"
@@ -49,7 +48,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
  LLMGatewayPlugin,
  LMStudioPlugin,
  MistralPlugin,
-  ModalPlugin,
  NvidiaPlugin,
  OllamaPlugin,
  OpencodePlugin,
@@ -13,7 +13,7 @@ import { Provider } from "../../provider.js"
 import type { PluginInternal } from "../internal.js"

 const clientID = "Ov23li8tweQw6odWQebz"
-const apiVersion = "2026-08-01"
+const apiVersion = "2026-06-01"
 const userApiVersion = "2025-04-01"
 const pollingSafetyMargin = 3000
 const methodID = Integration.MethodID.make("device")
@@ -1,67 +0,0 @@
-import { Effect, Semaphore, Stream } from "effect"
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { Bus } from "../../bus.js"
-import { Catalog } from "../../catalog.js"
-import { Credential } from "../../credential.js"
-import { Integration } from "../../integration.js"
-import { ModalModels } from "../../modal/models.js"
-import { Model } from "../../model.js"
-import { Provider } from "../../provider.js"
-import type { PluginInternal } from "../internal.js"
-
-const providerID = Provider.ID.make("modal")
-
-export const ModalPlugin = define({
-  id: "opencode.provider.modal",
-  effect: Effect.fn(function* (ctx) {
-    const catalog = yield* Catalog.Service
-    const bus = yield* Bus.Service
-    const loading = Semaphore.makeUnsafe(1)
-    const loaded: {
-      baseURL?: string
-      models?: Map<Model.ID, Model.Info>
-    } = {}
-
-    const load = Effect.fn("ModalPlugin.load")(function* () {
-      const connection = yield* ctx.integration.connection.active("modal")
-      const credential = connection
-        ? yield* ctx.integration.connection.resolve(connection).pipe(Effect.orElseSucceed(() => undefined))
-        : undefined
-      const apiKey = credential?.type === "key" ? credential.key : process.env.MODAL_PROXY_TOKEN
-      const provider = yield* catalog.provider.get(providerID)
-      const baseURL = typeof provider?.settings?.baseURL === "string" ? provider.settings.baseURL : undefined
-      if (!apiKey || !baseURL) {
-        loaded.baseURL = undefined
-        loaded.models = undefined
-        return
-      }
-      loaded.baseURL = baseURL
-      const existing = (yield* catalog.model.all()).filter((model) => model.providerID === providerID)
-      loaded.models = yield* Effect.tryPromise({
-        try: () => ModalModels.get(baseURL, apiKey, existing),
-        catch: (cause) => cause,
-      }).pipe(
-        Effect.catch((cause) => Effect.logWarning("failed to sync Modal models", { cause }).pipe(Effect.as(undefined))),
-      )
-    })
-
-    yield* ctx.catalog.transform((evt) => {
-      const item = evt.provider.get(providerID)
-      if (!item) return
-      if (!loaded.models) return
-      for (const id of item.models.keys()) {
-        if (!loaded.models.has(Model.ID.make(id))) evt.model.remove(item.provider.id, id)
-      }
-      for (const [id, model] of loaded.models) {
-        evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)))
-      }
-    })
-    const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
-    yield* bus.subscribe(Credential.Event.Switched).pipe(
-      Stream.filter((event) => event.data.integrationID === Integration.ID.make("modal")),
-      Stream.runForEach(refresh),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-    yield* refresh().pipe(Effect.forkScoped)
-  }),
-} satisfies PluginInternal.InternalPlugin)
@@ -1,24 +1,8 @@
-import { dlopen } from "bun:ffi"
 import { spawn } from "bun-pty"
 import type { Opts, Proc } from "./pty.js"

 export type { Disp, Exit, Opts, Proc } from "./pty.js"

-if (process.platform === "win32") {
-  const library = dlopen("kernel32.dll", {
-    SetConsoleCtrlHandler: { args: ["ptr", "i32"], returns: "i32" },
-    GetLastError: { args: [], returns: "u32" },
-  })
-  try {
-    // Detached servers start with Ctrl+C ignored, and ConPTY shells inherit it.
-    // Clear that attribute once before spawning shells; keep registered handlers.
-    if (library.symbols.SetConsoleCtrlHandler(null, 0) === 0)
-      throw new Error(`Failed to enable PTY Ctrl+C handling: Windows error ${library.symbols.GetLastError()}`)
-  } finally {
-    library.close()
-  }
-}
-
 function spawnPty(file: string, args: string[], opts: Opts): Proc {
  const pty = spawn(file, args, opts)
  return {
@@ -28,9 +28,11 @@ const events = Metric.counter("opencode_session_websocket_events_total", {
 const metric = (event: string, attributes: Record<string, string> = {}) =>
  Metric.update(events.pipe(Metric.withAttributes({ event, ...attributes })), 1)

+type Delivery = "queued" | "connecting" | "ready" | "send-attempted" | "provider-observed" | "terminal"
+
 interface Active {
  readonly queue: Queue.Queue<string, AIError>
-  delivery: "send-attempted" | "provider-observed" | "terminal"
+  readonly lifecycle: { delivery: Delivery }
 }

 interface Channel {
@@ -128,9 +130,14 @@ export const makeLayer = (connector: WebSocketConnector) =>
                code: "close",
                phase: "close",
                delivery:
-                  channel.active.delivery === "provider-observed" || channel.active.delivery === "terminal"
-                    ? "accepted"
-                    : "ambiguous",
+                  channel.active.lifecycle.delivery === "queued" ||
+                  channel.active.lifecycle.delivery === "connecting" ||
+                  channel.active.lifecycle.delivery === "ready"
+                    ? "not-sent"
+                    : channel.active.lifecycle.delivery === "provider-observed" ||
+                        channel.active.lifecycle.delivery === "terminal"
+                      ? "accepted"
+                      : "ambiguous",
              }),
            ),
          )
@@ -191,7 +198,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
                      code: "idle-data",
                      phase: "receive",
                    })
-                  active.delivery = "provider-observed"
+                  active.lifecycle.delivery = "provider-observed"
                  if (typeof message !== "string")
                    return yield* transportError("Unsupported binary WebSocket frame", {
                      url: exchange.connect.url,
@@ -219,8 +226,8 @@ export const makeLayer = (connector: WebSocketConnector) =>
                        phase:
                          error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
                        delivery:
-                          channel.active?.delivery === "provider-observed" ||
-                          channel.active?.delivery === "terminal" ||
+                          channel.active?.lifecycle.delivery === "provider-observed" ||
+                          channel.active?.lifecycle.delivery === "terminal" ||
                          (error.reason._tag === "Transport" && error.reason.code === "queue-overflow")
                            ? "accepted"
                            : error.reason._tag === "Transport" && error.reason.code === "1009"
@@ -249,6 +256,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
      const start = Effect.fn("SessionModelTransport.start")(function* (
        owner: State,
        exchange: WebSocketChannelExchange,
+        lifecycle: { delivery: Delivery },
      ) {
        if (owner.closed)
          return yield* transportError("Session WebSocket owner is closed", {
@@ -280,6 +288,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
          yield* closeChannel(owner, current)
        }

+        lifecycle.delivery = owner.channel ? "ready" : "connecting"
        if (owner.channel)
          yield* Effect.logDebug("session websocket reused", {
            sessionTransport: "websocket",
@@ -305,6 +314,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
              ),
            )
        if (!channel) return fallback(exchange)
+        lifecycle.delivery = "ready"

        if (channel.pending) {
          channel.pending = undefined
@@ -316,11 +326,9 @@ export const makeLayer = (connector: WebSocketConnector) =>
          Effect.onInterrupt(() => closeChannel(owner, channel)),
        )
        if (create.mode === "full") channel.checkpoint = undefined
-        const active: Active = {
-          queue: yield* Queue.bounded<string, AIError>(INBOUND_CAPACITY),
-          delivery: "send-attempted",
-        }
+        const active: Active = { queue: yield* Queue.bounded<string, AIError>(INBOUND_CAPACITY), lifecycle }
        channel.active = active
+        lifecycle.delivery = "send-attempted"
        const sent = yield* channel.connection.sendText(create.message).pipe(
          Effect.withSpan("SessionModelTransport.send"),
          Effect.onInterrupt(() => closeChannel(owner, channel)),
@@ -358,7 +366,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
                  operation: "read",
                  code: "idle-timeout",
                  phase: "receive",
-                  delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous",
+                  delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous",
                }),
              ),
          }),
@@ -367,7 +375,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
            Effect.sync(() => {
              if (!observationTerminal(observation)) return
              terminal = observation
-              active.delivery = "terminal"
+              lifecycle.delivery = "terminal"
              const staged = observation.type === "completed" ? observation.checkpoint : undefined
              if (staged) channel.pending = { token, checkpoint: staged }
              if (observation.type !== "completed" || !staged) channel.checkpoint = undefined
@@ -403,7 +411,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
                    operation: "read",
                    code: "incomplete",
                    phase: "receive",
-                    delivery: active.delivery === "provider-observed" ? "accepted" : "ambiguous",
+                    delivery: lifecycle.delivery === "provider-observed" ? "accepted" : "ambiguous",
                  })
              yield* poison(owner, channel, error)
            }),
@@ -440,6 +448,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
      const bind = (sessionID: SessionSchema.ID): WebSocketChannelExecutor => ({
        execute: (exchange) => {
          const owner = state(sessionID)
+          const lifecycle = { delivery: "queued" as Delivery }
          let execution: WebSocketChannelExecution | undefined
          return Effect.succeed({
            get http() {
@@ -447,7 +456,7 @@ export const makeLayer = (connector: WebSocketConnector) =>
            },
            frames: Stream.unwrap(
              Effect.acquireRelease(owner.lock.take(1), () => owner.lock.release(1), { interruptible: true }).pipe(
-                Effect.andThen(start(owner, exchange)),
+                Effect.andThen(start(owner, exchange, lifecycle)),
                Effect.tap((started) =>
                  Effect.sync(() => {
                    execution = started
@@ -29,9 +29,11 @@ export function migrate(info: typeof ConfigV1.Info.Type) {
        update:
          info.autoupdate === false
            ? "disable"
-            : info.autoupdate === "notify" || info.autoupdate === true
+            : info.autoupdate === "notify"
              ? "notify"
-              : undefined,
+              : info.autoupdate === true
+                ? "auto"
+                : undefined,
        share: info.share ?? (info.autoshare ? "auto" : undefined),
        enterprise: info.enterprise,
        username: info.username,
@@ -47,7 +47,7 @@ describe("CodeModeInstructions", () => {
    Effect.gen(function* () {
      const initialized = yield* readInitial(CodeModeInstructions.make({ tools: [echo] }))
      expect(initialized.text).toContain(
-        "This catalog is the complete set of tools callable inside `execute`. It does not affect tools exposed directly outside Code Mode.",
+        "This catalog is the complete set of tools available within Code Mode. Tools presented elsewhere are not available in this runtime.",
      )
      expect(initialized.text).toContain("## Available tools")
      expect(initialized.text).not.toContain("## Search")
@@ -13,7 +13,6 @@ import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Credential } from "@opencode-ai/core/credential"
 import { ConfigMigrateV1 } from "@opencode-ai/core/v1/config/migrate"
 import { ConfigV1 } from "@opencode-ai/core/v1/config/config"
-import { ConfigNormalize } from "@opencode-ai/core/config/normalize"
 import { Watcher } from "@opencode-ai/core/filesystem/watcher"
 import { Bus } from "@opencode-ai/core/bus"
 import { Global } from "@opencode-ai/util/global"
@@ -666,18 +665,10 @@ 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("notify")
+    expect(ConfigMigrateV1.migrate({ autoupdate: true }).update).toBe("auto")
    expect(ConfigMigrateV1.migrate({}).update).toBeUndefined()
  })

-  test("normalizes the previous native auto update policy", () => {
-    expect(ConfigNormalize.normalize({ update: "auto" })).toEqual({
-      type: "normalized",
-      encoded: { update: "notify" },
-      diagnostics: [],
-    })
-  })
-
  test("migrates v1 provider lists to policies", () => {
    expect(
      ConfigMigrateV1.migrate({
@@ -1,69 +0,0 @@
-import assert from "node:assert/strict"
-import { spawn } from "../../src/pty/pty.bun"
-
-const raw = process.argv[2] === "raw"
-const pty = spawn(
-  Bun.which("pwsh") ?? "powershell.exe",
-  [
-    "-NoLogo",
-    "-NoProfile",
-    ...(raw ? [] : ["-NoExit"]),
-    "-Command",
-    raw
-      ? "[Console]::TreatControlCAsInput = $true; Write-Output 'PTY_RAW_READY'; $key = [Console]::ReadKey($true); Write-Output ('PTY_KEY:' + [int]$key.KeyChar)"
-      : "Remove-Module PSReadLine -ErrorAction SilentlyContinue; function prompt { 'PTY_PROMPT> ' }",
-  ],
-  { name: "xterm-256color", cols: 160, rows: 24, env: { ...process.env, TERM: "xterm-256color" } },
-)
-const output = { text: "", cursor: 0 }
-const listeners = new Set<() => void>()
-const exited = Promise.withResolvers<number>()
-pty.onExit((event) => exited.resolve(event.exitCode))
-pty.onData((text) => {
-  output.text += text
-  listeners.forEach((check) => check())
-})
-
-try {
-  if (raw) {
-    await waitFor("PTY_RAW_READY")
-    pty.write("\x03")
-    await waitFor("PTY_KEY:3")
-  }
-  if (!raw) {
-    await waitFor("PTY_PROMPT>")
-    // Split markers so echoed command text cannot satisfy the output checks.
-    pty.write("Write-Output ('PTY_' + 'BUSY'); Start-Sleep -Seconds 60; Write-Output ('PTY_' + 'COMPLETED')\r")
-    await waitFor("PTY_BUSY")
-    pty.write("\x03")
-    await waitFor("PTY_PROMPT>")
-    assert.ok(!output.text.includes("PTY_COMPLETED"))
-    pty.write("Write-Output ('PTY_' + 'REUSED')\r")
-    await waitFor("PTY_REUSED")
-    await waitFor("PTY_PROMPT>")
-    pty.write("exit 0\r")
-  }
-  assert.equal(await exited.promise, 0)
-} finally {
-  pty.kill()
-}
-process.exit(0)
-
-function waitFor(text: string) {
-  return new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      listeners.delete(check)
-      reject(new Error(`Timed out waiting for ${JSON.stringify(text)}: ${output.text}`))
-    }, 5_000)
-    const check = () => {
-      const index = output.text.indexOf(text, output.cursor)
-      if (index === -1) return
-      output.cursor = index + text.length
-      listeners.delete(check)
-      clearTimeout(timeout)
-      resolve()
-    }
-    listeners.add(check)
-    check()
-  })
-}
@@ -118,40 +118,3 @@ test("defensively syncs advertised Copilot models", async () => {
    await server.stop(true)
  }
 })
-
-test("prices cache reads from either token price spelling", async () => {
-  // API version 2026-08-01 renamed cache_price to cache_read_price; older payloads still use cache_price.
-  const item = (id: string, prices: Record<string, number>) => ({
-    model_picker_enabled: true,
-    id,
-    name: id,
-    version: `${id}-2026-08-01`,
-    supported_endpoints: ["/chat/completions"],
-    billing: { token_prices: { batch_size: 1_000_000, default: { input_price: 250, output_price: 1500, ...prices } } },
-    capabilities: {
-      family: "gpt",
-      limits: { max_output_tokens: 1000, max_prompt_tokens: 8000 },
-      supports: { tool_calls: true },
-    },
-  })
-  const server = Bun.serve({
-    port: 0,
-    fetch: () =>
-      Response.json({
-        data: [
-          item("renamed", { cache_read_price: 25, cache_write_price: 0 }),
-          item("legacy", { cache_price: 25 }),
-          item("unpriced", {}),
-        ],
-      }),
-  })
-
-  try {
-    const models = await CopilotModels.get(server.url.origin, {}, [])
-    expect(models.get(Model.ID.make("renamed"))?.cost[0]).toMatchObject({ input: 2.5, output: 15, cache: { read: 0.25 } })
-    expect(models.get(Model.ID.make("legacy"))?.cost[0]).toMatchObject({ input: 2.5, output: 15, cache: { read: 0.25 } })
-    expect(models.get(Model.ID.make("unpriced"))?.cost[0]).toMatchObject({ cache: { read: 0 } })
-  } finally {
-    await server.stop(true)
-  }
-})
@@ -64,71 +64,6 @@ describe("Job", () => {
    }),
  )

-  it.live("reuses running work when started again with the same ID", () =>
-    Effect.gen(function* () {
-      const jobs = yield* Job.Service
-      const output = yield* Deferred.make<string>()
-      const job = yield* jobs.start({ id: "job_reused", type: "test", run: Deferred.await(output) })
-
-      expect(
-        yield* jobs.start({ id: job.id, type: "duplicate", run: Effect.die("Duplicate work must not run") }),
-      ).toEqual(job)
-
-      yield* Deferred.succeed(output, "original output")
-      expect((yield* jobs.wait({ id: job.id })).info).toMatchObject({
-        type: "test",
-        status: "completed",
-        output: "original output",
-      })
-    }),
-  )
-
-  it.live("ignores an obsolete callback after a cancellation waiter starts a same-ID replacement", () =>
-    Effect.gen(function* () {
-      const jobs = yield* Job.Service
-      const callback = yield* Deferred.make<() => void>()
-      const output = yield* Deferred.make<string>()
-      const finalized = yield* Deferred.make<void>()
-      const job = yield* jobs.start({
-        id: "job_replaced",
-        type: "test",
-        run: Effect.callback<string>((resume) => {
-          Deferred.doneUnsafe(
-            callback,
-            Effect.succeed(() => resume(Effect.succeed("obsolete output"))),
-          )
-        }),
-      })
-      const complete = yield* Deferred.await(callback)
-      // Cancellation wakes waiters before closing the old scope, allowing the old callback to race replacement.
-      const replacement = yield* jobs.wait({ id: job.id }).pipe(
-        Effect.tap((result) => Effect.sync(() => expect(result.info?.status).toBe("cancelled"))),
-        Effect.andThen(
-          jobs.start({
-            id: job.id,
-            type: "replacement",
-            run: Deferred.await(output).pipe(Effect.ensuring(Deferred.succeed(finalized, undefined))),
-          }),
-        ),
-        Effect.andThen(Effect.sync(complete)),
-        Effect.forkChild({ startImmediately: true }),
-      )
-
-      yield* jobs.cancel(job.id)
-      yield* Fiber.join(replacement)
-      expect(yield* jobs.get(job.id)).toMatchObject({ type: "replacement", status: "running" })
-      expect(yield* Deferred.isDone(finalized)).toBe(false)
-
-      yield* Deferred.succeed(output, "replacement output")
-      expect((yield* jobs.wait({ id: job.id })).info).toMatchObject({
-        type: "replacement",
-        status: "completed",
-        output: "replacement output",
-      })
-      expect(yield* Deferred.isDone(finalized)).toBe(true)
-    }),
-  )
-
  it.live("returns finished from a blocking wait when completion wins", () =>
    Effect.gen(function* () {
      const jobs = yield* Job.Service
@@ -1,137 +0,0 @@
-import { expect, test } from "bun:test"
-import { ModalModels } from "@opencode-ai/core/modal/models"
-import { Model } from "@opencode-ai/core/model"
-import { Provider } from "@opencode-ai/core/provider"
-import { ProviderPlugins } from "@opencode-ai/core/plugin/provider"
-import { Money } from "@opencode-ai/schema/money"
-
-const providerID = Provider.ID.make("modal")
-
-test("modal plugin is registered", () => {
-  expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.modal")
-})
-
-function template(id: string, overrides: Partial<Model.Info> = {}) {
-  return Model.Info.make({
-    ...Model.Info.default(providerID, Model.ID.make(id)),
-    name: `${id} catalog`,
-    family: Model.Family.make("catalog-family"),
-    ...overrides,
-  })
-}
-
-test("maps live Modal models onto catalog templates", async () => {
-  const server = Bun.serve({
-    port: 0,
-    fetch: (request) => {
-      expect(request.headers.get("Authorization")).toBe("Bearer test-key")
-      expect(new URL(request.url).pathname).toBe("/v1/models")
-      return Response.json({
-        data: [
-          {
-            id: "live-model",
-            base_model_id: "base-model",
-            name: "Live Model",
-            input_modalities: ["text", "image"],
-            output_modalities: ["text"],
-            context_length: 128000,
-            max_output_length: 8192,
-            pricing: { prompt: "0.000001", completion: 0.000002, input_cache_read: "0.0000002" },
-            supported_sampling_parameters: ["temperature"],
-            supported_features: ["tools", "reasoning"],
-            reasoning_options: [{ type: "effort", values: ["low", "high", null] }],
-            interleaved: { field: "reasoning_content" },
-          },
-          {
-            id: "standalone",
-            context_length: 64000,
-          },
-          { id: "malformed", context_length: "huge" },
-        ],
-      })
-    },
-  })
-
-  try {
-    const base = template("base-model")
-    const stale = template("stale")
-    const models = await ModalModels.get(`${server.url.origin}/v1`, "test-key", [base, stale])
-
-    expect(models.has(Model.ID.make("stale"))).toBe(false)
-    expect(models.has(Model.ID.make("malformed"))).toBe(false)
-
-    const model = models.get(Model.ID.make("live-model"))
-    expect(model?.name).toBe("Live Model")
-    expect(model?.family).toBe(Model.Family.make("catalog-family"))
-    expect(model?.providerID).toBe(providerID)
-    expect(model?.modelID).toBe(Model.ID.make("live-model"))
-    expect(model?.package).toBe(Provider.aisdk("@ai-sdk/openai-compatible"))
-    expect(model?.settings).toMatchObject({ baseURL: `${server.url.origin}/v1` })
-    expect(model?.compatibility).toMatchObject({ reasoningField: "reasoning_content" })
-    expect(model?.capabilities).toMatchObject({ tools: true, input: ["text", "image"], output: ["text"] })
-    expect(model?.cost[0]?.input).toBe(Money.USDPerMillionTokens.make(1))
-    expect(model?.cost[0]?.output).toBe(Money.USDPerMillionTokens.make(2))
-    expect(Number(model?.cost[0]?.cache.read)).toBeCloseTo(0.2, 10)
-    expect(model?.cost[0]?.cache.write).toBe(Money.USDPerMillionTokens.zero)
-    expect(model?.limit).toMatchObject({ context: 128000, output: 8192 })
-    expect(model?.variants.map((variant) => variant.id)).toEqual([
-      Model.VariantID.make("low"),
-      Model.VariantID.make("high"),
-      Model.VariantID.make("none"),
-    ])
-    expect(model?.variants[0]?.settings).toMatchObject({ reasoningEffort: "low" })
-    expect(model?.status).toBe("active")
-
-    const fresh = models.get(Model.ID.make("standalone"))
-    expect(fresh?.name).toBe("standalone")
-    expect(fresh?.family).toBeUndefined()
-    expect(fresh?.capabilities).toMatchObject({ tools: true, input: ["text"], output: ["text"] })
-    expect(fresh?.variants).toEqual([])
-    expect(fresh?.limit).toMatchObject({ context: 64000, output: 0 })
-  } finally {
-    await server.stop(true)
-  }
-})
-
-test("keeps template cost and limits when the proxy omits them", async () => {
-  const server = Bun.serve({
-    port: 0,
-    fetch: () =>
-      Response.json({
-        data: [{ id: "sparse", hugging_face_id: "hf-base" }],
-      }),
-  })
-
-  try {
-    const base = template("hf-base", {
-      cost: [
-        {
-          input: Money.USDPerMillionTokens.make(5),
-          output: Money.USDPerMillionTokens.make(10),
-          cache: { read: Money.USDPerMillionTokens.make(1), write: Money.USDPerMillionTokens.make(2) },
-        },
-      ],
-      limit: { context: 1000, input: 500, output: 250 },
-    })
-    const models = await ModalModels.get(server.url.origin, "test-key", [base])
-    const model = models.get(Model.ID.make("sparse"))
-    expect(model?.name).toBe("hf-base catalog")
-    expect(model?.cost[0]).toMatchObject({ input: 5, output: 10, cache: { read: 1, write: 2 } })
-    expect(model?.limit).toMatchObject({ context: 1000, input: 500, output: 250 })
-  } finally {
-    await server.stop(true)
-  }
-})
-
-test("throws on proxy failure so the plugin can fail soft", async () => {
-  const server = Bun.serve({
-    port: 0,
-    fetch: () => new Response("nope", { status: 500 }),
-  })
-
-  try {
-    await expect(ModalModels.get(server.url.origin, "test-key", [])).rejects.toThrow()
-  } finally {
-    await server.stop(true)
-  }
-})
@@ -122,7 +122,7 @@ describe("GithubCopilotPlugin", () => {
      expect(requests[0]?.has("x-api-key")).toBe(false)
      expect(requests[0]?.get("x-initiator")).toBe("user")
      expect(requests[0]?.get("copilot-vision-request")).toBe("true")
-      expect(requests[0]?.get("x-github-api-version")).toBe("2026-08-01")
+      expect(requests[0]?.get("x-github-api-version")).toBe("2026-06-01")
      expect(requests[0]?.get("user-agent")).toBe("opencode/beta/1.2.3/test")
    }),
  )
@@ -145,7 +145,7 @@ describe("GithubCopilotPlugin", () => {
      expect(event.request.headers.has("x-api-key")).toBe(false)
      expect(event.request.headers.get("x-initiator")).toBe("user")
      expect(event.request.headers.get("anthropic-beta")).toBe("interleaved-thinking-2025-05-14")
-      expect(event.request.headers.get("x-github-api-version")).toBe("2026-08-01")
+      expect(event.request.headers.get("x-github-api-version")).toBe("2026-06-01")
    }),
  )

@@ -1,41 +0,0 @@
-import { expect } from "bun:test"
-import { spawn } from "node:child_process"
-import path from "node:path"
-import { Effect } from "effect"
-import { it } from "../lib/effect"
-
-const windowsTest = process.platform === "win32" ? it.live : it.live.skip
-
-Array.of("interrupt", "raw").forEach((scenario) => {
-  windowsTest(
-    scenario === "interrupt"
-      ? "detached PTY hosts interrupt commands without closing the shell"
-      : "detached PTY hosts preserve Ctrl+C input for raw-mode programs",
-    Effect.gen(function* () {
-      // Isolate the inheritable Windows console state from the test runner.
-      const worker = yield* Effect.acquireRelease(
-        Effect.sync(() => {
-          const child = spawn(process.execPath, [path.join(import.meta.dir, "../fixture/pty-windows.ts"), scenario], {
-            detached: true,
-            stdio: ["ignore", "ignore", "pipe"],
-            timeout: 30_000,
-          })
-          const output: string[] = []
-          child.stderr.on("data", (chunk: Buffer) => output.push(chunk.toString()))
-          const exited = new Promise<number | null>((resolve, reject) => {
-            child.once("error", reject)
-            child.once("close", resolve)
-          })
-          return { child, output, exited }
-        }),
-        (worker) =>
-          Effect.sync(() => {
-            if (worker.child.exitCode === null && worker.child.signalCode === null) worker.child.kill()
-          }),
-      )
-      const code = yield* Effect.promise(() => worker.exited)
-      expect({ code, output: worker.output.join("") }).toEqual({ code: 0, output: "" })
-    }),
-    35_000,
-  )
-})
@@ -445,17 +445,14 @@ describe("SessionModelTransport", () => {
    )
  })

-  test.each([false, true])("classifies active and queued close (observed: %s)", async (observed) => {
+  test("closes an active exchange without waiting for its Session permit", async () => {
    const started = Deferred.makeUnsafe<void>()
    const messages = queue<string | Uint8Array, AIError>()
    let closed = 0
    const connector: WebSocketConnector = {
      open: () =>
        Effect.succeed({
-          sendText: () =>
-            observed
-              ? Queue.offer(messages, "frame").pipe(Effect.asVoid)
-              : Deferred.succeed(started, undefined).pipe(Effect.asVoid),
+          sendText: () => Deferred.succeed(started, undefined),
          messages: Stream.fromQueue(messages),
          close: Effect.sync(() => closed++).pipe(Effect.andThen(Queue.shutdown(messages)), Effect.asVoid),
        }),
@@ -465,30 +462,17 @@ describe("SessionModelTransport", () => {
      connector,
      Effect.gen(function* () {
        const transport = yield* SessionModelTransport.Service
-        const executor = transport.bind(session)
-        const item = exchange("active")
-        const running = yield* collect(executor, {
-          ...item,
-          driver: {
-            ...item.driver,
-            observe: (_create, frame) => Deferred.succeed(started, undefined).pipe(Effect.as({ type: "frame", frame })),
-          },
-        }).pipe(Effect.result, Effect.forkChild({ startImmediately: true }))
-        yield* Deferred.await(started)
-        const queued = yield* collect(executor, exchange("queued")).pipe(
-          Effect.result,
+        const running = yield* collect(transport.bind(session), exchange("active")).pipe(
          Effect.forkChild({ startImmediately: true }),
        )
+        yield* Deferred.await(started)

        yield* transport.close(session)
+        const result = yield* Effect.result(Fiber.join(running))

-        expect(yield* Fiber.join(running)).toMatchObject({
+        expect(result).toMatchObject({
          _tag: "Failure",
-          failure: { reason: { _tag: "Transport", code: "close", delivery: observed ? "accepted" : "ambiguous" } },
-        })
-        expect(yield* Fiber.join(queued)).toMatchObject({
-          _tag: "Failure",
-          failure: { reason: { _tag: "Transport", code: "owner-closed", phase: "queue", delivery: "not-sent" } },
+          failure: { reason: { _tag: "Transport", code: "close", delivery: "ambiguous" } },
        })
        expect(closed).toBe(1)
      }),
@@ -561,43 +545,6 @@ describe("SessionModelTransport", () => {
    )
  })

-  test("closes a connection returned after its owner closes during setup", async () => {
-    const connecting = Deferred.makeUnsafe<void>()
-    const release = Deferred.makeUnsafe<void>()
-    let closed = 0
-    const connector: WebSocketConnector = {
-      open: () =>
-        Deferred.succeed(connecting, undefined).pipe(
-          Effect.andThen(Deferred.await(release)),
-          Effect.as({
-            sendText: () => Effect.die("Unexpected send after owner close"),
-            messages: Stream.never,
-            close: Effect.sync(() => closed++).pipe(Effect.asVoid),
-          }),
-        ),
-    }
-
-    await run(
-      connector,
-      Effect.gen(function* () {
-        const transport = yield* SessionModelTransport.Service
-        const running = yield* collect(
-          transport.bind(session),
-          exchange("first", { fallback: () => Stream.die("Unexpected fallback after owner close") }),
-        ).pipe(Effect.result, Effect.forkChild({ startImmediately: true }))
-        yield* Deferred.await(connecting)
-        yield* transport.close(session)
-        yield* Deferred.succeed(release, undefined)
-
-        expect(yield* Fiber.join(running)).toMatchObject({
-          _tag: "Failure",
-          failure: { reason: { _tag: "Transport", code: "owner-closed", phase: "connect", delivery: "not-sent" } },
-        })
-        expect(closed).toBe(1)
-      }),
-    )
-  })
-
  test("falls back once when connection setup fails before send", async () => {
    let fallbacks = 0
    const connector: WebSocketConnector = { open: () => Effect.fail(error("upgrade rejected", "not-sent")) }
@@ -1,5 +1,4 @@
 import { defineConfig } from "electron-vite"
-import { pickerPlugin } from "./scripts/picker"

 const channel = (() => {
  const raw = process.env.OPENCODE_CHANNEL
@@ -11,6 +10,7 @@ const channel = (() => {
 const nodePtyPkg = `@lydell/node-pty-${process.platform}-${process.arch}`

 const appPlugin = (await import("@opencode-ai/app/vite")).default
+const picker = (await import("@brendonovich/vite-plugin-opencode")).default()
 const sentry =
  process.env.SENTRY_AUTH_TOKEN && process.env.SENTRY_ORG && process.env.SENTRY_PROJECT
    ? (await import("@sentry/vite-plugin")).sentryVitePlugin({
@@ -91,7 +91,7 @@ const require = __cjs_mod__.createRequire(import.meta.url);
      "import.meta.env.OPENCODE_VERSION": JSON.stringify(process.env.OPENCODE_VERSION),
      "import.meta.env.VITE_OPENCODE_CHANNEL": JSON.stringify(channel),
    },
-    plugins: [pickerPlugin(), appPlugin, sentry],
+    plugins: [picker, appPlugin, sentry],
    publicDir: "../../../app/public",
    root: "src/renderer",
    build: {
@@ -1,10 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <title>Picker fixture</title>
-  </head>
-  <body>
-    <button>Pick this element</button>
-    <script type="module" src="./main.ts"></script>
-  </body>
-</html>
@@ -1 +0,0 @@
-document.body.dataset.ready = "true"
@@ -1,76 +0,0 @@
-import { expect, test } from "bun:test"
-import { loadConfigFromFile, RendererConfigFactory } from "electron-vite"
-import { createServer } from "vite"
-import { fileURLToPath } from "node:url"
-import { pickerPlugin } from "./picker"
-
-test("injects a browser-loadable URL instead of a bare virtual module", () => {
-  const plugin = pickerPlugin()
-  const tag = plugin.transformIndexHtml.handler()[0]
-  expect(tag.attrs.src).toBe("/__vite_opencode_picker_client.js")
-  const id = plugin.resolveId(tag.attrs.src)
-  expect(id).toBeDefined()
-  expect(plugin.load(id!)).toContain("opencodePickerUi")
-})
-
-test.each([true, false])(
-  "serves browser-loadable picker scripts with bundled dev = %s",
-  async (bundledDev) => {
-    const loaded = await loadConfigFromFile(
-      { command: "serve", mode: "development" },
-      fileURLToPath(new URL("../electron.vite.config.ts", import.meta.url)),
-    )
-    if (!loaded.config.renderer) throw new Error("Missing renderer configuration")
-    const config = await new RendererConfigFactory(
-      loaded.config.renderer,
-      { configFile: false, mode: "development" },
-      { root: fileURLToPath(new URL("..", import.meta.url)) },
-    ).build()
-    const server = await createServer({
-      ...config,
-      configFile: false,
-      root: fileURLToPath(new URL("./fixtures/picker", import.meta.url)),
-      build: {
-        ...config.build,
-        rolldownOptions: { input: { main: fileURLToPath(new URL("./fixtures/picker/index.html", import.meta.url)) } },
-      },
-      experimental: { bundledDev },
-      server: { host: "127.0.0.1", port: 0 },
-      logLevel: "silent",
-    })
-    await server.listen()
-    const url = server.resolvedUrls?.local[0]
-    if (!url) throw new Error("Missing fixture server URL")
-    const socket = bundledDev
-      ? new WebSocket(`${url.replace("http:", "ws:")}?token=${server.config.webSocketToken}`, "vite-hmr")
-      : undefined
-    try {
-      if (socket && !server.environments.client.bundledDev?.hasBuildOutput) {
-        await new Promise<void>((resolve, reject) => {
-          socket.addEventListener("error", reject, { once: true })
-          socket.addEventListener("message", (event) => {
-            const message: { type: string } = JSON.parse(String(event.data))
-            if (message.type === "full-reload") resolve()
-          })
-        })
-      }
-      for (const path of ["/", "/index.html", "/server/example/session/example", "/new-session?draftId=example"]) {
-        const html = await fetch(new URL(path, url)).then((response) => response.text())
-        const sources = [...html.matchAll(/<script[^>]*\bsrc="([^"]+)"/g)].map((match) => match[1])
-        const scripts = await Promise.all(
-          sources.map((source) => fetch(new URL(source, url)).then((response) => response.text())),
-        )
-        expect(scripts.length).toBeGreaterThan(0)
-        if (bundledDev) expect(scripts.join("\n")).toContain("opencodePickerUi")
-        expect([html, ...scripts].join("\n")).not.toMatch(/\bimport(?:\s*\(\s*|\s*)["']virtual:/)
-      }
-      const direct = await fetch(new URL("/__vite_opencode_picker_client.js", url))
-      expect(direct.ok).toBe(true)
-      expect(await direct.text()).toContain("opencodePickerUi")
-    } finally {
-      socket?.close()
-      await server.close()
-    }
-  },
-  30_000,
-)
@@ -1,26 +0,0 @@
-import picker from "@brendonovich/vite-plugin-opencode"
-
-export function pickerPlugin() {
-  const plugin = picker()
-  const client = "/__vite_opencode_picker_client.js"
-  return {
-    ...plugin,
-    resolveId(id: string) {
-      return plugin.resolveId(id === client ? "virtual:vite-opencode-picker/client" : id)
-    },
-    configureServer(server: Parameters<typeof plugin.configureServer>[0]) {
-      server.middlewares.use(client, (_request, response) => {
-        response.setHeader("content-type", "text/javascript")
-        response.end(plugin.load(plugin.resolveId("virtual:vite-opencode-picker/client")!))
-      })
-      plugin.configureServer(server)
-    },
-    transformIndexHtml: {
-      order: "pre" as const,
-      handler() {
-        // A real URL stays loadable if bundled dev leaves the HTML import unbundled.
-        return [{ tag: "script", attrs: { type: "module", src: client }, injectTo: "body" as const }]
-      },
-    },
-  }
-}
@@ -60,10 +60,3 @@ describe("electron vite publicDir", () => {
    expect(existsSync(join(resolved, "oc-theme-preload.js"))).toBe(true)
  })
 })
-
-test("renders before loading optional telemetry", async () => {
-  const source = await Bun.file(join(dir, "index.tsx")).text()
-  expect(source.indexOf("render(() =>")).toBeGreaterThan(-1)
-  expect(source.indexOf("render(() =>")).toBeLessThan(source.indexOf("initializeSentry(version)"))
-  expect(source).not.toContain("await initializeSentry")
-})
@@ -13,10 +13,10 @@ import { desktopVersion, initializeSentry } from "./startup/sentry"

 const root = requireRendererRoot()
 const version = desktopVersion()
+await initializeSentry(version)

 const updater = startDesktopUpdater(api)
 startDesktopMenu(api)
 startDeepLinks(api)

 render(() => <DesktopApp api={api} updater={updater} version={version} />, root)
-void initializeSentry(version)
@@ -13904,7 +13904,7 @@
          },
          "update": {
            "type": "string",
-            "enum": ["disable", "notify"]
+            "enum": ["disable", "notify", "auto"]
          },
          "share": {
            "type": "string",
@@ -34,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"]).pipe(optional).annotate({
-    description: "Disable updates or notify when one is available",
+  update: Schema.Literals(["disable", "notify", "auto"]).pipe(optional).annotate({
+    description: "Disable updates, notify when one is available, or install automatically",
  }),
  share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
    description: "Control whether sessions may be shared manually, automatically, or not at all",
@@ -1,9 +1,11 @@
 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 { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
 import { hasPersistentPtyConnectTicketURL } from "@opencode-ai/protocol/groups/persistent-pty"
+import { InstallationEvent } from "@opencode-ai/schema/installation-event"
 import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect"
 import {
  HttpMiddleware,
@@ -114,7 +116,12 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
      )
    yield* Ref.set(application, Option.some(transform ? transform(app) : app))
    yield* status.ready
-    return { address: bound.http.address, shutdown: shutdown.await }
+    return {
+      address: bound.http.address,
+      shutdown: shutdown.await,
+      updateAvailable: (version: string) =>
+        Context.get(context, Bus.Service).publish(InstallationEvent.UpdateAvailable, { version }).pipe(Effect.asVoid),
+    }
  }).pipe(
    Effect.catchCause((cause) => {
      if (!lifecycle || Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause)
@@ -1,4 +1,5 @@
 import { expect } from "bun:test"
+import { InstallationEvent } from "@opencode-ai/schema/installation-event"
 import { Effect } from "effect"
 import { HttpServer, HttpServerError, HttpServerResponse } from "effect/unstable/http"
 import { it } from "../../core/test/lib/effect"
@@ -99,9 +100,12 @@ it.live("allows browser preflight requests without credentials", () =>
    )
    expect(event.status).toBe(200)
    expect(event.headers.get("content-encoding")).toBeNull()
-    const body = event.body
-    if (!body) return yield* Effect.die(new Error("Event response has no body"))
-    yield* Effect.promise(() => body.cancel())
+    if (!event.body) return yield* Effect.die(new Error("Event response has no body"))
+    const reader = event.body.getReader()
+    yield* Effect.promise(() => readUntil(reader, "server.connected"))
+    yield* server.updateAvailable("2.0.0")
+    yield* Effect.promise(() => readUntil(reader, "installation.update-available"))
+    yield* Effect.promise(() => reader.cancel())

    const missing = yield* Effect.promise(() =>
      fetch(new URL("/missing", HttpServer.formatAddress(server.address)), {
@@ -126,3 +130,11 @@ 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
+  }
+}
@@ -494,7 +494,7 @@
  flex-direction: column;
  align-items: center;
  justify-content: center;
-  gap: 8px;
+  gap: 16px;
  padding: 24px;
  padding-bottom: 160px;
  text-align: center;
@@ -502,26 +502,25 @@

 [data-slot="session-review-v2-empty-changes"] [data-slot="icon-svg"] {
  flex: none;
-  margin-bottom: 8px;
  color: var(--v2-icon-icon-muted);
 }

 [data-slot="session-review-v2-empty-changes-title"] {
  flex: none;
+  margin-top: 4px;
  font-size: 13px;
  font-weight: 530;
-  line-height: 13px;
+  line-height: var(--line-height-compact);
  letter-spacing: -0.04px;
  color: var(--v2-text-text-base);
 }

 [data-slot="session-review-v2-empty-changes-description"] {
  flex: none;
-  height: 20px;
  max-width: 282px;
  font-size: 13px;
  font-weight: 440;
-  line-height: var(--line-height-base);
+  line-height: 20px;
  text-align: center;
  letter-spacing: -0.04px;
  color: var(--v2-text-text-muted);
@@ -186,7 +186,6 @@ export type TuiInput = {
  args: Args
  config: Config.Interface
  updater?: {
-    monitor: (notify: (version: string) => void, signal: AbortSignal) => Promise<void>
    apply: (version: string) => Promise<void>
  }
  packages: PackageSource
@@ -221,6 +220,9 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
  const service = managed
    ? {
        reconnect: async (signal: AbortSignal) => {
+          // Give the server a chance to respawn itself before starting client-side recovery.
+          await new Promise((resolve) => setTimeout(resolve, 50))
+          if (signal.aborted) throw signal.reason ?? new Error("Server reconnect cancelled")
          const endpoint = await managed.reconnect(signal)
          const next = { baseUrl: endpoint.url, headers: Service.headers(endpoint) }
          return { api: OpenCode.make(next), url: endpoint.url }
@@ -505,36 +507,6 @@ function App(props: { pair?: DialogPairCredentials; updater?: TuiInput["updater"
    "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,
@@ -1243,6 +1215,19 @@ function App(props: { pair?: DialogPairCredentials; updater?: TuiInput["updater"
    })
  })

+  event.on("installation.update-available", (evt) => {
+    const updater = props.updater
+    const restart = client.restart
+    if (!updater || !restart) return
+    const version = evt.data.version
+    if (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 }))
+    dialog.replace(() => <DialogUpdate version={version} install={() => updater.apply(version)} restart={restart} />)
+    dialog.setCentered(true)
+  })
+
  event.on("tui.session.select", (evt, { workspace }) => {
    if (workspace !== (location.current?.workspaceID ?? data.location.default().workspaceID)) return
    route.navigate({
@@ -0,0 +1,144 @@
+import { TextAttributes, type ScrollBoxRenderable } from "@opentui/core"
+import { useTerminalDimensions } from "@opentui/solid"
+import { isShellNotFoundError, type LocationRef, type ShellInfo } from "@opencode-ai/client"
+import { createEffect, createMemo, createSignal, onCleanup, Show, untrack } from "solid-js"
+import stripAnsi from "strip-ansi"
+import { useClient } from "../context/client"
+import { Keymap } from "../context/keymap"
+import { useTheme } from "../context/theme"
+import { useDialog } from "../ui/dialog"
+
+const PAGE_BYTES = 64 * 1024
+
+export function DialogShellOutput(props: { shell: ShellInfo; location: LocationRef }) {
+  const client = useClient()
+  const dialog = useDialog()
+  const theme = useTheme("elevated")
+  const dimensions = useTerminalDimensions()
+  const [info, setInfo] = createSignal(props.shell)
+  const [output, setOutput] = createSignal<string>()
+  const [omitted, setOmitted] = createSignal(false)
+  const [error, setError] = createSignal("")
+  const text = createMemo(() => stripAnsi(output() ?? "").replace(/\r\n?/g, "\n"))
+  const height = () => Math.max(3, Math.floor(dimensions().height * 0.6) - 6)
+  let scroll: ScrollBoxRenderable | undefined
+
+  dialog.setSize("xlarge")
+  dialog.setCentered(true)
+
+  createEffect(() => {
+    // The running-shell inventory drops exited commands. Keep this view tied to
+    // the opened ID and its original Location, not the list's current selection.
+    const id = props.shell.id
+    const location = { directory: props.location.directory, workspace: props.location.workspaceID }
+    let cursor: number | undefined
+    let disposed = false
+    let missing = false
+    let timer: ReturnType<typeof setTimeout> | undefined
+
+    const load = async () => {
+      if (untrack(info).status === "running") {
+        const current = await client.api.shell.get({ id, location })
+        if (disposed) return false
+        setInfo(current.data)
+      }
+      if (cursor === undefined) {
+        const head = await client.api.shell.output({ id, location, cursor: Number.MAX_SAFE_INTEGER })
+        if (disposed) return false
+        cursor = Math.max(0, head.data.size - PAGE_BYTES)
+        setOmitted(cursor > 0)
+      }
+      const page = await client.api.shell.output({ id, location, cursor, limit: PAGE_BYTES })
+      if (disposed) return false
+      cursor = page.data.cursor
+      setOutput((previous) => {
+        const next = (previous ?? "") + page.data.output
+        if (next.length > PAGE_BYTES) setOmitted(true)
+        return next.slice(-PAGE_BYTES)
+      })
+      setError("")
+      return cursor < page.data.size
+    }
+
+    const poll = () => {
+      void load()
+        .catch((cause: unknown) => {
+          if (disposed) return
+          missing = isShellNotFoundError(cause)
+          setError(missing ? "Shell output is no longer available." : "Unable to read shell output. Retrying…")
+        })
+        .then((more) => {
+          // Poll only while the viewer is open, including after exit so the final
+          // file flush is observed. Never overlap reads or reload earlier pages.
+          if (!disposed && !missing) timer = setTimeout(poll, more ? 0 : 1_000)
+        })
+    }
+    poll()
+    onCleanup(() => {
+      disposed = true
+      clearTimeout(timer)
+    })
+  })
+
+  const status = () => {
+    if (info().status === "running") return "Running"
+    if (info().status === "timeout") return "Timed out"
+    if (info().status === "killed") return "Killed"
+    return info().exit === undefined ? "Exited" : `Exited · code ${info().exit}`
+  }
+
+  Keymap.createLayer(() => ({
+    mode: "modal",
+    commands: [
+      { bind: "up", title: "Scroll output up", group: "Shell", run: () => scroll?.scrollBy(-1) },
+      { bind: "down", title: "Scroll output down", group: "Shell", run: () => scroll?.scrollBy(1) },
+      { bind: "pageup", title: "Previous output page", group: "Shell", run: () => scroll?.scrollBy(-height()) },
+      { bind: "pagedown", title: "Next output page", group: "Shell", run: () => scroll?.scrollBy(height()) },
+      { bind: "home", title: "First loaded output", group: "Shell", run: () => scroll?.scrollTo(0) },
+      { bind: "end", title: "Follow shell output", group: "Shell", run: () => scroll?.scrollTo(Infinity) },
+    ],
+  }))
+
+  return (
+    <box paddingLeft={2} paddingRight={2} paddingBottom={1} gap={1}>
+      <box flexDirection="row" gap={2}>
+        <text fg={theme.text.default} attributes={TextAttributes.BOLD} flexGrow={1}>
+          Shell output
+        </text>
+        <text fg={theme.text.subdued}>{status()}</text>
+        <text fg={theme.text.subdued} onMouseUp={() => dialog.clear()}>
+          esc
+        </text>
+      </box>
+      <text fg={theme.text.subdued} maxHeight={3} wrapMode="word">
+        {props.shell.command}
+      </text>
+      <Show when={omitted()}>
+        <text fg={theme.text.subdued}>Earlier output omitted · showing recent output</text>
+      </Show>
+      <scrollbox
+        id="shell-output-scroll"
+        ref={(value: ScrollBoxRenderable) => (scroll = value)}
+        height={height()}
+        stickyScroll
+        stickyStart="bottom"
+        scrollbarOptions={{ visible: false }}
+      >
+        <text fg={theme.text.default} wrapMode="word">
+          {text() ||
+            (output() === undefined
+              ? "Loading output…"
+              : "No captured output. Output redirected to files is not shown here.")}
+        </text>
+      </scrollbox>
+      <Show when={error()}>
+        <text fg={theme.text.feedback.error.default}>{error()}</text>
+      </Show>
+      <box flexDirection="row" gap={2} flexWrap="wrap">
+        <text fg={theme.text.subdued}>↑/↓ scroll</text>
+        <text fg={theme.text.subdued}>end follow</text>
+        <text fg={theme.text.subdued}>esc back</text>
+      </box>
+    </box>
+  )
+}
@@ -8,32 +8,22 @@ import { useDialog } from "../ui/dialog"
 import { Spinner } from "./spinner"

 type State =
-  | { type: "ready"; active: "update" | "skip" }
+  | { type: "ready"; active: "update" | "ignore" }
  | { type: "installing" }
  | { type: "restarting" }
  | { type: "failed"; message: string }

-export function DialogUpdate(props: {
-  dialogKey: string
-  version: string
-  install: () => Promise<void>
-  restart?: () => Promise<void>
-}) {
+export function DialogUpdate(props: { version: string; install: () => Promise<void>; restart: () => Promise<void> }) {
  const dialog = useDialog()
  const theme = useTheme("elevated")
  const [state, setState] = createSignal<State>({ type: "ready", active: "update" })
-  const close = () => {
-    if (dialog.key === props.dialogKey) dialog.clear()
-  }

  const install = async () => {
    setState({ type: "installing" })
    await props.install()
-    if (props.restart) {
-      setState({ type: "restarting" })
-      await props.restart()
-    }
-    close()
+    setState({ type: "restarting" })
+    await props.restart()
+    dialog.clear()
  }

  const beginInstall = () => {
@@ -44,16 +34,16 @@ export function DialogUpdate(props: {
  const run = () => {
    const current = state()
    if (current.type !== "ready") return
-    if (current.active === "skip") return close()
+    if (current.active === "ignore") return dialog.clear()
    beginInstall()
  }

  const toggle = () =>
    setState((current) =>
-      current.type === "ready" ? { ...current, active: current.active === "update" ? "skip" : "update" } : current,
+      current.type === "ready" ? { ...current, active: current.active === "update" ? "ignore" : "update" } : current,
    )

-  const selected = (action: "update" | "skip") => {
+  const selected = (action: "update" | "ignore") => {
    const current = state()
    return current.type === "ready" && current.active === action
  }
@@ -70,7 +60,7 @@ export function DialogUpdate(props: {
        bind: "return",
        title: "Confirm update action",
        group: "Dialog",
-        run: () => (state().type === "failed" ? close() : run()),
+        run: () => (state().type === "failed" ? dialog.clear() : run()),
      },
      {
        bind: "left",
@@ -91,9 +81,9 @@ 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}>
-          Update available
+          Update
        </text>
-        <text fg={theme.text.subdued} onMouseUp={close}>
+        <text fg={theme.text.subdued} onMouseUp={() => dialog.clear()}>
          esc
        </text>
      </box>
@@ -101,17 +91,14 @@ export function DialogUpdate(props: {
        <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."}
+              Update to v{props.version}? It will be applied in the background and active sessions will be restarted.
            </text>
          </Match>
          <Match when={state().type === "installing"}>
-            <Spinner shimmer={theme.text.default}>Installing OpenCode {props.version}…</Spinner>
+            <Spinner>Installing OpenCode {props.version}…</Spinner>
          </Match>
          <Match when={state().type === "restarting"}>
-            <Spinner shimmer={theme.text.default}>Restarting the background service…</Spinner>
+            <Spinner>Restarting the background service…</Spinner>
          </Match>
          <Match when={state().type === "failed"}>
            <text fg={theme.text.feedback.error.default}>{failure()}</text>
@@ -127,7 +114,7 @@ export function DialogUpdate(props: {
                paddingLeft={3}
                paddingRight={3}
                backgroundColor={theme.background.action.primary.focused}
-                onMouseUp={close}
+                onMouseUp={() => dialog.clear()}
              >
                <text fg={theme.text.action.primary.focused}>close</text>
              </box>
@@ -136,19 +123,19 @@ export function DialogUpdate(props: {
        }
      >
        <box flexDirection="row" justifyContent="flex-end" paddingBottom={1}>
-          <For each={["skip", "update"] as const}>
+          <For each={["ignore", "update"] as const}>
            {(action) => (
              <box
                paddingLeft={1}
                paddingRight={1}
                backgroundColor={selected(action) ? theme.background.action.primary.focused : undefined}
                onMouseUp={() => {
-                  if (action === "skip") return close()
+                  if (action === "ignore") return dialog.clear()
                  beginInstall()
                }}
              >
                <text fg={selected(action) ? theme.text.action.primary.focused : theme.text.subdued}>
-                  {action === "update" ? "Update" : "Skip"}
+                  {action === "update" ? "Update" : "Ignore"}
                </text>
              </box>
            )}
@@ -1,104 +0,0 @@
-import {
-  OptimizedBuffer,
-  RGBA,
-  TargetChannel,
-  TextRenderable,
-  type RenderContext,
-  type TextOptions,
-} from "@opentui/core"
-import { extend, type JSX } from "@opentui/solid"
-import { splitProps } from "solid-js"
-import { coast, intensityAt } from "./tab-pulse"
-
-type ShimmerTextOptions = TextOptions & {
-  shimmer: RGBA
-}
-
-const DURATION = 1200
-const TRANSPARENT = RGBA.fromValues(0, 0, 0, 0)
-const CONTINUATION = 0xc0000000 | 0
-
-class ShimmerTextRenderable extends TextRenderable {
-  private _shimmer = RGBA.defaultForeground()
-  private elapsed = 0
-  private scratch: OptimizedBuffer | undefined
-  private mask = new Float32Array(0)
-  private matrix = new Float32Array(16)
-
-  constructor(ctx: RenderContext, options: ShimmerTextOptions) {
-    super(ctx, options)
-    this.matrix[3] = this._shimmer.r
-    this.matrix[7] = this._shimmer.g
-    this.matrix[11] = this._shimmer.b
-    this.matrix[15] = 1
-    if (options.shimmer) this.shimmer = options.shimmer
-    this.live = true
-  }
-
-  set shimmer(value: RGBA) {
-    if (value.equals(this._shimmer)) return
-    this._shimmer = value
-    this.matrix[3] = value.r
-    this.matrix[7] = value.g
-    this.matrix[11] = value.b
-    this.requestRender()
-  }
-
-  override render(buffer: OptimizedBuffer, deltaTime: number) {
-    if (!this.visible || this.isDestroyed || !Number.isFinite(this.width) || this.width <= 0 || this.height <= 0) return
-    this.elapsed = (this.elapsed + deltaTime) % DURATION
-    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 front = -4 + coast(this.elapsed / DURATION) * (end + 22)
-    if (this.mask.length !== this.width * this.height * 3) this.mask = new Float32Array(this.width * this.height * 3)
-    let strength = 0
-    for (let cell = 0; cell < characters.length; cell++) {
-      const column = cell % this.width
-      if ((characters[cell] & CONTINUATION) !== CONTINUATION) strength = intensityAt(column, front, 4, 18)
-      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()
-  }
-}
-
-extend({ shimmer_text: ShimmerTextRenderable })
-
-declare module "@opentui/solid" {
-  interface OpenTUIComponents {
-    shimmer_text: typeof ShimmerTextRenderable
-  }
-}
-
-type Props = Omit<JSX.IntrinsicElements["text"], "ref"> & { shimmer: RGBA }
-
-export function ShimmerText(props: Props) {
-  const [local, text] = splitProps(props, ["shimmer"])
-  return <shimmer_text {...text} shimmer={local.shimmer} />
-}
@@ -1,48 +1,30 @@
-import { createEffect, createSignal, onCleanup, Show } from "solid-js"
+import { Show } from "solid-js"
 import { useTheme } from "../context/theme"
 import { useConfig } from "../config"
 import type { JSX } from "@opentui/solid"
 import type { RGBA } from "@opentui/core"
 import { registerOpencodeSpinner } from "./register-spinner"
 import { SPINNER_FRAMES } from "./spinner-frames"
-import { ShimmerText } from "./shimmer-text"

 export { SPINNER_FRAMES } from "./spinner-frames"

 registerOpencodeSpinner()

-export function Spinner(props: { children?: JSX.Element; color?: RGBA; shimmer?: RGBA }) {
+export function Spinner(props: { children?: JSX.Element; color?: RGBA }) {
  const theme = useTheme()
  const config = useConfig().data
  const color = () => props.color ?? theme.text.subdued
-  const [frame, setFrame] = createSignal(0)
-  createEffect(() => {
-    if (!(config.animations ?? true) || !props.shimmer) return
-    const timer = setInterval(() => setFrame((value) => (value + 1) % SPINNER_FRAMES.length), 80)
-    onCleanup(() => clearInterval(timer))
-  })
  return (
    <Show
      when={config.animations ?? true}
      fallback={<text fg={color()}>{props.children ? <>⋯ {props.children}</> : "⋯"}</text>}
    >
-      <Show
-        when={props.shimmer}
-        fallback={
-          <box flexDirection="row" gap={1}>
-            <spinner frames={SPINNER_FRAMES} interval={80} color={color()} />
-            <Show when={props.children}>
-              <text fg={color()}>{props.children}</text>
-            </Show>
-          </box>
-        }
-      >
-        {(shimmer) => (
-          <ShimmerText fg={color()} shimmer={shimmer()}>
-            {SPINNER_FRAMES[frame()]} {props.children}
-          </ShimmerText>
-        )}
-      </Show>
+      <box flexDirection="row" gap={1}>
+        <spinner frames={SPINNER_FRAMES} interval={80} color={color()} />
+        <Show when={props.children}>
+          <text fg={color()}>{props.children}</text>
+        </Show>
+      </box>
    </Show>
  )
 }
@@ -244,6 +244,7 @@ export const Definitions = {
  "composer.subagent.interrupt": keybind("ctrl+d", "Interrupt subagent"),
  "composer.shell.up": keybind("up", "Previous shell"),
  "composer.shell.down": keybind("down", "Next shell"),
+  "composer.shell.select": keybind("return", "View shell output"),
  "composer.shell.kill": keybind("ctrl+d", "Kill shell command"),
  "composer.terminal.up": keybind("up,k", "Previous terminal"),
  "composer.terminal.down": keybind("down,j", "Next terminal"),
@@ -6,6 +6,8 @@ import { useClient } from "../../../context/client"
 import { useTheme } from "../../../context/theme"
 import { Keymap } from "../../../context/keymap"
 import { useComposerTab } from "./index"
+import { useDialog } from "../../../ui/dialog"
+import { DialogShellOutput } from "../../../component/dialog-shell-output"

 export function ShellTab(props: { sessionID: string }) {
  const data = useData()
@@ -13,6 +15,7 @@ export function ShellTab(props: { sessionID: string }) {
  const theme = useTheme()
  const composer = useComposerTab()
  const shortcuts = Keymap.useShortcuts()
+  const dialog = useDialog()

  const entries = createMemo(() =>
    data.shell.listBySession(props.sessionID).filter((shell) => shell.status === "running"),
@@ -23,6 +26,11 @@ export function ShellTab(props: { sessionID: string }) {

  const selectedEntry = createMemo(() => entries()[store.selected])

+  const open = () => {
+    const entry = selectedEntry()
+    if (entry) dialog.replace(() => <DialogShellOutput shell={entry} location={entry.location} />)
+  }
+
  createEffect(() => {
    if (store.selected >= entries().length) setStore("selected", Math.max(0, entries().length - 1))
  })
@@ -42,7 +50,13 @@ export function ShellTab(props: { sessionID: string }) {
    const cleanup = composer.register({
      id: "shell",
      label: "Shell",
-      hints: () => (selectedEntry() ? [{ label: "kill", shortcut: shortcuts.get("composer.shell.kill") ?? "" }] : []),
+      hints: () =>
+        selectedEntry()
+          ? [
+              { label: "output", shortcut: shortcuts.get("composer.shell.select") ?? "" },
+              { label: "kill", shortcut: shortcuts.get("composer.shell.kill") ?? "" },
+            ]
+          : [],
    })
    onCleanup(cleanup)
  })
@@ -74,6 +88,12 @@ export function ShellTab(props: { sessionID: string }) {
          setStore("selected", (prev) => (prev + 1) % list.length)
        },
      },
+      {
+        id: "composer.shell.select",
+        title: "View shell output",
+        group: "Composer",
+        run: open,
+      },
      {
        id: "composer.shell.kill",
        title: "Kill shell command",
@@ -106,6 +126,10 @@ export function ShellTab(props: { sessionID: string }) {
                    active() ? theme.background.action.primary.focused : theme.background.action.primary.default
                  }
                  onMouseOver={() => setStore("selected", index())}
+                  onMouseUp={() => {
+                    setStore("selected", index())
+                    open()
+                  }}
                >
                  <text
                    fg={active() ? theme.text.action.primary.focused : theme.text.action.primary.default}
@@ -11,6 +11,8 @@ import { LocationProvider } from "../../../src/context/location"
 import { RouteProvider, useRoute } from "../../../src/context/route"
 import { ThemeProvider } from "../../../src/context/theme"
 import { Composer } from "../../../src/routes/session/composer"
+import { DialogProvider } from "../../../src/ui/dialog"
+import { ToastProvider } from "../../../src/ui/toast"
 import { createApi, createEventStream, createFetch, directory, json } from "../../fixture/tui-client"
 import { TestTuiContexts } from "../../fixture/tui-environment"
 import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
@@ -31,6 +33,7 @@ async function renderComposer(
  const events = createEventStream()
  const interrupted: string[] = []
  const removed: string[] = []
+  const viewed: string[] = []
  const ready = Promise.withResolvers<void>()
  let closed = 0
  let dispatch!: ReturnType<typeof Keymap.use>["dispatch"]
@@ -53,6 +56,13 @@ async function renderComposer(
      })
    }
    const shellID = url.pathname.match(/^\/api\/shell\/([^/]+)$/)?.[1]
+    if (shellID && request.method === "GET") {
+      viewed.push(shellID)
+      return json({ location: { directory }, data: shells.find((shell) => shell.id === shellID) })
+    }
+    if (url.pathname.endsWith("/output")) {
+      return json({ location: { directory }, data: { output: "", cursor: 0, size: 0, truncated: false } })
+    }
    if (shellID && request.method === "DELETE") {
      removed.push(shellID)
      return new Response(null, { status: 204 })
@@ -100,7 +110,11 @@ async function renderComposer(
                <LocationProvider>
                  <RouteProvider initialRoute={{ type: "session", sessionID: "parent" }}>
                    <ThemeProvider mode="dark" source={{ discover: async () => ({}) }}>
-                      <Content />
+                      <ToastProvider>
+                        <DialogProvider>
+                          <Content />
+                        </DialogProvider>
+                      </ToastProvider>
                    </ThemeProvider>
                  </RouteProvider>
                </LocationProvider>
@@ -119,6 +133,7 @@ async function renderComposer(
    app,
    interrupted,
    removed,
+    viewed,
    route: () => route.data,
    dispatch: (command: string) => dispatch(command),
    closed: () => closed,
@@ -154,15 +169,18 @@ test("disabled shell bindings have no component fallbacks", async () => {
  const composer = await renderComposer("shell", {
    "composer.shell.up": "none",
    "composer.shell.down": "none",
+    "composer.shell.select": "none",
    "composer.shell.kill": "none",
  })
  try {
    expect(composer.app.captureCharFrame()).toContain("bun test")
    composer.app.mockInput.pressArrow("up")
+    composer.app.mockInput.pressEnter()
    composer.app.mockInput.pressKey("d", { ctrl: true })
    await composer.app.renderOnce()
    expect(composer.closed()).toBe(0)
    expect(composer.removed).toEqual([])
+    expect(composer.viewed).toEqual([])

    composer.app.mockInput.pressArrow("down")
    composer.dispatch("composer.shell.kill")
@@ -198,6 +216,22 @@ test("ctrl+c closes the active composer", async () => {
  }
 })

+test("shell output respects a configured binding with a focused textarea", async () => {
+  const composer = await renderComposer("shell", { "composer.shell.select": "ctrl+o" }, true)
+  try {
+    composer.app.mockInput.pressEnter()
+    await composer.app.renderOnce()
+    expect(composer.viewed).toEqual([])
+    composer.app.mockInput.pressKey("o", { ctrl: true })
+    await wait(() => composer.viewed.length > 0)
+    await composer.app.renderOnce()
+    expect(composer.app.captureCharFrame()).toContain("Shell output")
+    expect(composer.viewed).toEqual(["sh-a"])
+  } finally {
+    composer.app.renderer.destroy()
+  }
+})
+
 function session(id: string, title: string, parentID?: string) {
  return {
    id,
@@ -15,6 +15,8 @@ import { LocationProvider, useLocation } from "../../../src/context/location"
 import { RouteProvider } from "../../../src/context/route"
 import { ThemeProvider } from "../../../src/context/theme"
 import { Composer } from "../../../src/routes/session/composer"
+import { DialogProvider } from "../../../src/ui/dialog"
+import { ToastProvider } from "../../../src/ui/toast"
 import { createSessionRows, type SessionRow } from "../../../src/routes/session/rows"
 import { createApi, createEventStream, createFetch, directory, json, worktree } from "../../fixture/tui-client"
 import { emptyThemeSource } from "../../fixture/fixture"
@@ -2020,7 +2022,11 @@ test("keeps shell state scoped to location", async () => {
      <RouteProvider initialRoute={{ type: "session", sessionID: "ses_shared" }}>
        <Keymap.Provider>
          <ThemeProvider mode="dark" source={emptyThemeSource}>
-            <Composer sessionID="ses_shared" open={true} defaultTab="shell" />
+            <ToastProvider>
+              <DialogProvider>
+                <Composer sessionID="ses_shared" open={true} defaultTab="shell" />
+              </DialogProvider>
+            </ToastProvider>
          </ThemeProvider>
        </Keymap.Provider>
      </RouteProvider>
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kit Langton	00580291b8	refactor(tui): simplify shell output polling	2026-09-03 16:37:00 -04:00
Kit Langton	2e17a66530	feat(tui): inspect live shell output	2026-09-03 16:29:14 -04:00