fix(schema): keep legacy blobs on replay, import, and V1 migration

Freeze session.message.content.updated at the stored shape and translate on replay, run persisted() on CLI session import, write native from the V1 migration, regenerate the OpenAPI docs, and mirror text.ended state in the client fold.
test(core): use native for text and reasoning provider blobs
2026-09-22 08:37:36 +00:00 · 2026-09-22 00:37:59 -05:00 · 2026-09-21 23:39:41 -05:00 · 2026-09-21 23:37:54 -05:00 · 2026-09-21 23:27:12 -05:00 · 2026-09-20 21:41:03 -05:00
87 changed files with 324 additions and 1519 deletions
@@ -92,7 +92,6 @@
        "solid-js": "catalog:",
        "solid-presence": "0.2.0",
        "tailwindcss": "4.3.3",
-        "uqr": "0.1.3",
      },
      "devDependencies": {
        "@happy-dom/global-registrator": "20.0.11",
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8hc0Typ9cA1NDpToM0Pq7q3AutSp+I80Sakthq10F4c=",
-    "aarch64-linux": "sha256-7bzI4zWOdxuoMdMHMuqIAOgnuzWiHmpdCMYCYPbs+3c=",
-    "aarch64-darwin": "sha256-EWDHUSVH2AjsNvoKvzC392H6GjCWVh07cOg2x0mAsng=",
-    "x86_64-darwin": "sha256-7b2BRdRRVG+PMCSd/cm4E+slziwWIKLVttYkotdSrK4="
+    "x86_64-linux": "sha256-/jah4P2a0aGJNJ0aMdlFEbGHAXx33lqxHbc7UmpLFDg=",
+    "aarch64-linux": "sha256-L3SoZ24qNXicsE2FK6LATQjOmjPxY679RjugrUyO/1Y=",
+    "aarch64-darwin": "sha256-pI9NT8KWUPi+JCk6DYMqIAYmBqTbi13uL4VdNV3WS6Y=",
+    "x86_64-darwin": "sha256-rMAGhTTz46KA5Ya7E5J0af7Bn1QzTDhTaNfNJm8qfsw="
  }
 }
@@ -95,7 +95,7 @@ In Vite development mode, `origin` uses `VITE_OPENCODE_SERVER_HOST` / `VITE_OPEN
 from storage. Desktop provides the local server it discovers or starts through native initialization.

 With no configured servers, the app shows a full-screen connection form. Enter a server address and password,
-or choose **Scan QR code** to open the camera and read the pairing code from `opencode pair`.
+or choose **Scan QR code** to open the camera and read the JSON pairing code from `opencode pair`.
 Scanning fills the form and immediately attempts to connect. Failed connections leave the details available
 to edit and retry with **Connect**. Credentials are checked before saving the server. Camera access requires
 HTTPS (or localhost) and browser permission. Saved offline servers continue to use the normal app UI.
@@ -103,7 +103,7 @@ HTTPS (or localhost) and browser permission. Saved offline servers continue to u
 When the service is exposed through an HTTPS reverse proxy, advertise its external address at runtime:

 ```bash
-opencode pair --url https://opencode.example.com
+opencode pair --url https://your-machine.your-tailnet.ts.net
 ```

 This replaces the addresses printed and encoded in the QR code while retaining the local service password.
@@ -703,7 +703,7 @@ function messageContent(
    return {
      type: "reasoning",
      text: part.text,
-      state: jsonRecord(part.metadata),
+      native: jsonRecord(part.metadata),
      time: part.time
        ? { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) }
        : undefined,
@@ -1,145 +0,0 @@
-import { base64Encode } from "@opencode/util/encode"
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:/OpenCode/BtwSidebar"
-const projectID = "proj_btw_sidebar"
-const sessionID = "ses_btw_sidebar"
-const otherSessionID = "ses_btw_sidebar_other"
-const title = "Side question session"
-const otherTitle = "Other side question session"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const sessionHref = (id: string) => `/server/${base64Encode(server)}/session/${id}`
-
-test.use({ viewport: { width: 1440, height: 900 } })
-
-test("answers /btw in the side panel without admitting a prompt", async ({ page }) => {
-  const generations: { sessionID: string; prompt: string }[] = []
-  const prompts: unknown[] = []
-  const generated = Promise.withResolvers<void>()
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      worktree: directory,
-      vcs: "git",
-      name: "btw-sidebar",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { test: { id: "test", name: "Test", limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "test" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        slug: sessionID,
-        projectID,
-        directory,
-        title,
-        version: "dev",
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-      {
-        id: otherSessionID,
-        slug: otherSessionID,
-        projectID,
-        directory,
-        title: otherTitle,
-        version: "dev",
-        time: { created: 1700000001000, updated: 1700000001000 },
-      },
-    ],
-    pageMessages: () => ({ items: [] }),
-    vcsDiff: [],
-    onPrompt: (input) => prompts.push(input),
-    generate: async (input) => {
-      generations.push(input)
-      if (input.sessionID === otherSessionID) return { text: "This answer belongs to the **other session**." }
-      await generated.promise
-      return {
-        text: "The retry loop uses **exponential backoff** and stops after three attempts.\n\n```ts\nconst delay = 2 ** attempt\n```",
-      }
-    },
-  })
-  await page.addInitScript(
-    ({ directory, server, sessionID, otherSessionID }) => {
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({
-          projects: { local: [{ worktree: directory, expanded: true }] },
-          lastProject: { local: directory },
-        }),
-      )
-      localStorage.setItem(
-        "opencode.window.browser.dat:tabs",
-        JSON.stringify([
-          { type: "session", server, sessionId: sessionID },
-          { type: "session", server, sessionId: otherSessionID },
-        ]),
-      )
-    },
-    { directory, server, sessionID, otherSessionID },
-  )
-
-  await page.goto(sessionHref(sessionID))
-  await expectSessionTitle(page, title)
-  const editor = page.locator('[data-component="composer-editor"]')
-  await expect(editor).toBeEditable()
-
-  await editor.fill("/btw")
-  const suggestion = page.locator('[data-suggestion-id="session.btw"]')
-  await expect(suggestion).toBeVisible()
-  await suggestion.click()
-  await expect(editor).toHaveText("/btw ")
-  await editor.press("Enter")
-
-  const panel = page.locator('[data-slot="session-btw-panel"]')
-  await expect(panel).toBeHidden()
-  await expect(page.getByText("Add a question after /btw", { exact: true })).toBeVisible()
-  expect(generations).toEqual([])
-  expect(prompts).toEqual([])
-
-  await editor.fill("/btw how does the retry loop work?")
-  await editor.press("Enter")
-
-  const tab = page.getByRole("tab", { name: "/btw" })
-  await expect(panel).toBeVisible()
-  await expect(panel.getByRole("textbox")).toHaveCount(0)
-  await expect(panel.getByRole("status")).toContainText("Working")
-  await expect(tab).toHaveAttribute("data-selected", "")
-  generated.resolve()
-  await expect(panel.getByText("how does the retry loop work?", { exact: true })).toBeVisible()
-  await expect(panel.getByText("exponential backoff", { exact: false })).toBeVisible()
-  await expect(panel.getByText("const delay = 2 ** attempt", { exact: true })).toBeVisible()
-  expect(generations).toHaveLength(1)
-  expect(generations[0]?.sessionID).toBe(sessionID)
-  expect(generations[0]?.prompt).toContain("how does the retry loop work?")
-  expect(prompts).toEqual([])
-  await expect(editor).toHaveText("")
-
-  await page.locator(`[data-titlebar-tab-link][href="${sessionHref(otherSessionID)}"]`).click()
-  await expectSessionTitle(page, otherTitle)
-  await editor.fill("/btw what belongs here?")
-  await editor.press("Enter")
-  await expect(panel.getByText("other session", { exact: false })).toBeVisible()
-
-  await page.locator(`[data-titlebar-tab-link][href="${sessionHref(sessionID)}"]`).click()
-  await expectSessionTitle(page, title)
-  await expect(panel.getByText("exponential backoff", { exact: false })).toBeVisible()
-  await expect(panel.getByText("other session", { exact: false })).toHaveCount(0)
-
-  await page.reload()
-  await expectSessionTitle(page, title)
-  await expect(page.getByRole("tab", { name: "/btw" })).toHaveCount(0)
-  await expect(page.locator('[data-slot="session-btw-panel"]')).toHaveCount(0)
-})
@@ -1,54 +0,0 @@
-import { expect, test } from "@playwright/test"
-
-test("pairs locally without checking the server and authenticates subsequent requests", async ({ page, baseURL }) => {
-  const origin = new URL(baseURL ?? "http://127.0.0.1:3000").origin
-  const password = "pairing-secret"
-  const authorization = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`
-  const requests: { origin: string; authorization: string | undefined }[] = []
-  await page.addInitScript((origin) => {
-    if (localStorage.getItem("opencode.global.dat:server")) return
-    localStorage.setItem(
-      "opencode.global.dat:server",
-      JSON.stringify({ list: [{ type: "http", http: { url: origin, password: "old-password" } }] }),
-    )
-  }, origin)
-  await page.route("**/api/**", async (route) => {
-    requests.push({
-      origin: new URL(route.request().url()).origin,
-      authorization: route.request().headers().authorization,
-    })
-    // Pairing must succeed even when the API is unavailable.
-    await route.fulfill({ status: 503, contentType: "application/json", body: "{}" })
-  })
-
-  await page.goto(`/connect#${Buffer.from(JSON.stringify({ username: "opencode", password })).toString("base64url")}`)
-  await expect(page).toHaveURL(`${origin}/`)
-  await expect(page.getByRole("button", { name: "Home", exact: true })).toBeVisible()
-  await expect
-    .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("opencode.global.dat:server") ?? "{}").list))
-    .toEqual([{ type: "http", http: { url: origin, password } }])
-  await expect.poll(() => requests.filter((request) => request.origin === origin).length).toBeGreaterThan(0)
-  expect(
-    requests.filter((request) => request.origin === origin).every((request) => request.authorization === authorization),
-  ).toBe(true)
-
-  requests.length = 0
-  await page.reload()
-  await expect(page.getByRole("button", { name: "Home", exact: true })).toBeVisible()
-  await expect.poll(() => requests.filter((request) => request.origin === origin).length).toBeGreaterThan(0)
-  expect(
-    requests.filter((request) => request.origin === origin).every((request) => request.authorization === authorization),
-  ).toBe(true)
-})
-
-test("the unpaired page loads without starting server requests", async ({ page }) => {
-  const requests: string[] = []
-  await page.route("**/api/**", async (route) => {
-    requests.push(route.request().url())
-    await route.abort()
-  })
-  await page.goto("/connect")
-  await expect(page.getByRole("heading", { name: "Connect to a server" })).toBeVisible()
-  await expect(page.getByLabel("Password", { exact: true })).toBeEditable()
-  expect(requests).toEqual([])
-})
@@ -197,13 +197,6 @@ const Group = HttpApiGroup.make("mock")
      success: Json,
    }),
  )
-  .add(
-    HttpApiEndpoint.post("sessionGenerate", "/api/session/:sessionID/generate", {
-      params: SessionParams,
-      payload: Schema.Struct({ prompt: Schema.String }),
-      success: Json,
-    }),
-  )
  .add(
    HttpApiEndpoint.post("sessionSwitchAgent", "/api/session/:sessionID/agent", {
      params: SessionParams,
@@ -42,7 +42,6 @@ export interface MockServerConfig {
  sessionStatus?: Record<string, unknown> | (() => Record<string, unknown>)
  inbox?: unknown[] | (() => unknown[])
  onPrompt?: (input: { sessionID: string; body: Record<string, unknown> }) => void
-  generate?: (input: { sessionID: string; prompt: string }) => { text: string } | Promise<{ text: string }>
  onInboxChange?: (input: { sessionID: string; inboxID: string; action: "cancel" | "steer" | "queue" }) => void
 }

@@ -457,12 +456,6 @@ function mockHandlers(config: MockServerConfig, state: { cursors: Map<string, st
              },
            }
          }),
-        sessionGenerate: (ctx) =>
-          Effect.promise(async () => ({
-            data: (await config.generate?.({ sessionID: ctx.params.sessionID, prompt: ctx.payload.prompt })) ?? {
-              text: "Side-question answer",
-            },
-          })),
        sessionInboxCancel: (ctx) =>
          Effect.sync(() =>
            config.onInboxChange?.({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID, action: "cancel" }),
@@ -91,7 +91,6 @@
    "remeda": "catalog:",
    "solid-js": "catalog:",
    "solid-presence": "0.2.0",
-    "tailwindcss": "4.3.3",
-    "uqr": "0.1.3"
+    "tailwindcss": "4.3.3"
  }
 }
@@ -4,9 +4,9 @@ import { FileComponentProvider } from "@opencode/ui/context/file"
 import { Font } from "@opencode/ui/font"
 import { ThemeProvider } from "@opencode/ui/theme/context"
 import { MetaProvider } from "@solidjs/meta"
-import { type BaseRouterProps, Router, useLocation } from "@solidjs/router"
+import { type BaseRouterProps, Router } from "@solidjs/router"
 import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
-import { type Component, createRenderEffect, ErrorBoundary, type JSX, type ParentProps, Show } from "solid-js"
+import { type Component, createRenderEffect, ErrorBoundary, type JSX, type ParentProps } from "solid-js"
 import { Dynamic } from "solid-js/web"
 import { CommandProvider } from "@/shell/commands/command"
 import { DesktopCommands } from "@/shell/commands/desktop"
@@ -107,29 +107,21 @@ export function AppInterface(props: {
  // The visual layout lives in the router root so it remains mounted across
  // route changes. Draft and session routes override only their server-bound data
  // providers beneath it.
-  const Root = (rootProps: ParentProps) => {
-    const location = useLocation()
-    // Pairing saves credentials before mounting any server connections or health checks.
-    return (
-      <>
+  const Root = (rootProps: ParentProps) => (
+    <TabsProvider>
+      <GlobalProvider>
        <BodyTypography />
-        <Show when={location.pathname !== "/connect"} fallback={rootProps.children}>
-          <TabsProvider>
-            <GlobalProvider>
-              <CommandProvider>
-                <DesktopCommands />
-                <SshRestore />
-                <HighlightsProvider>
-                  {props.children}
-                  {rootProps.children}
-                </HighlightsProvider>
-              </CommandProvider>
-            </GlobalProvider>
-          </TabsProvider>
-        </Show>
-      </>
-    )
-  }
+        <CommandProvider>
+          <DesktopCommands />
+          <SshRestore />
+          <HighlightsProvider>
+            {props.children}
+            {rootProps.children}
+          </HighlightsProvider>
+        </CommandProvider>
+      </GlobalProvider>
+    </TabsProvider>
+  )

  return (
    <ServersProvider
@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { parseClientSlashCommand } from "./client-slash-command"
-
-const options = [
-  { id: "session.btw", trigger: "btw", arguments: true, type: "builtin" as const },
-  { id: "custom.btw", trigger: "custom", type: "custom" as const },
-  { id: "model.choose", trigger: "model", type: "builtin" as const },
-]
-
-describe("parseClientSlashCommand", () => {
-  test("parses inline and multiline arguments", () => {
-    expect(parseClientSlashCommand(options, "/btw why this approach?")).toEqual({
-      id: "session.btw",
-      input: "why this approach?",
-    })
-    expect(parseClientSlashCommand(options, "/btw\nwhy this approach?")).toEqual({
-      id: "session.btw",
-      input: "why this approach?",
-    })
-  })
-
-  test("accepts a bare argument command", () => {
-    expect(parseClientSlashCommand(options, "/btw")).toEqual({ id: "session.btw", input: "" })
-  })
-
-  test("rejects prefixes, custom commands, and ordinary slash commands", () => {
-    expect(parseClientSlashCommand(options, "/btwx nope")).toBeUndefined()
-    expect(parseClientSlashCommand(options, "/custom nope")).toBeUndefined()
-    expect(parseClientSlashCommand(options, "/model opus")).toBeUndefined()
-    expect(parseClientSlashCommand(options, "ask /btw later")).toBeUndefined()
-  })
-})
@@ -1,24 +0,0 @@
-type ClientSlashCommand = {
-  id: string
-  trigger: string
-  arguments?: boolean
-  type: "builtin" | "custom"
-}
-
-export function parseSlashCommand(text: string) {
-  if (!text.startsWith("/")) return
-  const separator = text.search(/\s/)
-  const name = text.slice(1, separator === -1 ? undefined : separator)
-  return { name, input: separator === -1 ? "" : text.slice(separator).trim() }
-}
-
-export function parseClientSlashCommand(options: readonly ClientSlashCommand[], text: string) {
-  const command = parseSlashCommand(text)
-  if (!command) return
-  const option = options.find((item) => item.type === "builtin" && item.arguments && item.trigger === command.name)
-  if (!option) return
-  return {
-    id: option.id,
-    input: command.input,
-  }
-}
@@ -24,7 +24,6 @@ import { createComposerHistory } from "./history/store"
 import { composerPlaceholder } from "./placeholder"
 import { createComposerSubmit } from "./submit"
 import { useAttachmentDestination } from "./attachments/destination"
-import { parseClientSlashCommand } from "./client-slash-command"

 export type ComposerModel = ComposerEditorModel & {
  readonly model: ComposerControls["model"]
@@ -74,7 +73,9 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      return [...result, path]
    }, [])
  })
-  const attachments = createMemo(() => prompt.current().filter(isAttachment))
+  const attachments = createMemo(() =>
+    prompt.current().filter(isAttachment),
+  )
  const commentCount = createMemo(() => {
    if (mode() === "shell") return 0
    return prompt.context.items().filter((item) => !!item.comment?.trim()).length
@@ -241,7 +242,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
        trigger: item.slash!,
        title: item.title,
        description: item.description,
-        arguments: item.slashArguments,
        type: "builtin" as const,
      })),
  ])
@@ -299,11 +299,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      clear: comments.clear,
      restore: restoreHistoryComments,
    },
-    clientCommand: (text) => {
-      const selected = parseClientSlashCommand(slashCommands(), text)
-      if (!selected) return
-      return () => command.trigger(selected.id, "slash", selected.input)
-    },
  })
  const controller = createComposerEditor({
    store: prompt.store,
@@ -345,7 +340,6 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      if (item.kind !== "command") return
      const selected = slashCommands().find((entry) => entry.id === item.id)
      if (!selected || selected.type === "custom") return
-      if (selected.arguments) return
      return () => command.trigger(selected.id, "slash")
    },
    attachments: {
@@ -54,17 +54,14 @@ function submitInput(
  mode: "normal" | "shell" = "normal",
  commands: () => readonly { name: string }[] | undefined = () => [],
  history: string[] = [],
-  clientCommand?: (text: string) => (() => void | Promise<void>) | undefined,
 ) {
  return createComposerSubmit({
    adapter,
    mode: () => mode,
    commands,
-    clientCommand,
    editor: () => undefined,
    queueScroll() {},
-    addToHistory: (prompt) =>
-      history.push(`add:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
+    addToHistory: (prompt) => history.push(`add:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
    removeFromHistory: (prompt) =>
      history.push(`remove:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
    resetHistory() {},
@@ -121,61 +118,6 @@ function session(input: {
 }

 describe("Composer submission", () => {
-  test("runs a client argument command without admitting it to the session", async () => {
-    const state = createMemoryComposerState().capture()
-    state.set([
-      { type: "text", content: "/btw why this approach?", start: 0, end: 23 },
-      {
-        type: "image",
-        id: "attachment",
-        filename: "diagram.png",
-        mime: "image/png",
-        blob: { id: "attachment", url: "data:image/png;base64,YQ==" },
-      },
-    ])
-    state.context.add({ type: "file", path: "src/retry.ts" })
-    const calls: string[] = []
-    const target = session({
-      calls,
-      prompt: async () => {
-        throw new Error("client command must not call prompt")
-      },
-    })
-    const adapter: ActiveComposerAdapter = {
-      kind: "active-session",
-      state,
-      ready: () => true,
-      controls,
-      working: () => false,
-      session: () => target,
-      interrupt: async () => undefined,
-      submitted() {},
-      setEditor() {},
-    }
-
-    const history: string[] = []
-    await submitInput(adapter, undefined, "normal", undefined, history, (text) => {
-      expect(text).toBe("/btw why this approach?")
-      return () => {
-        calls.push("btw")
-      }
-    }).submit(new Event("submit"))
-
-    expect(calls).toEqual(["btw"])
-    expect(history).toEqual([])
-    expect(state.current()).toEqual([
-      { type: "text", content: "", start: 0, end: 0 },
-      {
-        type: "image",
-        id: "attachment",
-        filename: "diagram.png",
-        mime: "image/png",
-        blob: { id: "attachment", url: "data:image/png;base64,YQ==" },
-      },
-    ])
-    expect(state.context.items()).toHaveLength(1)
-  })
-
  test("applies the captured agent and model before a custom command without passing over its overrides", async () => {
    const state = createMemoryComposerState({ prompt: "/review changes" }).capture()
    const calls: string[] = []
@@ -683,7 +625,12 @@ describe("Composer submission", () => {
      },
    }

-    await submitInput(adapter, undefined, "normal", () => catalog).submit(new Event("submit"))
+    await submitInput(
+      adapter,
+      undefined,
+      "normal",
+      () => catalog,
+    ).submit(new Event("submit"))

    expect(await sent.promise).toBe("command")
    expect(requests).toEqual([
@@ -11,7 +11,6 @@ import { setCursorPosition } from "./editor/dom"
 import { blobDataUrl, resolveBlobUrl } from "@/runtime/persistence/drafts"
 import { isAttachment } from "./prompt-parts"
 import type { ModelSelection } from "@/providers/models/selection"
-import { parseSlashCommand } from "./client-slash-command"

 const submitting = new WeakSet<object>()

@@ -38,7 +37,6 @@ type ComposerSubmitInput = {
  setMode: (mode: "normal" | "shell") => void
  closePopover: () => void
  delivery?: (alternate: boolean) => ComposerDelivery
-  clientCommand?: (text: string) => (() => void | Promise<void>) | undefined
  notify: {
    missingSelection: () => void
    failed: (kind: "shell" | "command" | "prompt", error: unknown) => void
@@ -54,31 +52,15 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
  const submit = async (event: globalThis.Event, options?: { alternate?: boolean }) => {
    event.preventDefault()

-    const prompt = clonePrompt(input.adapter.state.current())
-    const text = submissionText(prompt)
-    const clientCommand = input.mode() === "normal" ? input.clientCommand?.(text) : undefined
-    if (clientCommand) {
-      if (submitting.has(input.adapter.state)) return
-      submitting.add(input.adapter.state)
-      try {
-        clearClientCommand(input, prompt)
-        await clientCommand()
-      } catch (error) {
-        input.notify.failed("command", error)
-      } finally {
-        submitting.delete(input.adapter.state)
-      }
-      return
-    }
    const submission = createComposerSubmission({
      target: input.adapter.state,
-      prompt,
+      prompt: clonePrompt(input.adapter.state.current()),
      context: input.adapter.state.context.items().map((item) => ({
        ...item,
        selection: item.selection ? { ...item.selection } : undefined,
      })),
    })
-    const read = readSubmission(input, submission.prompt, submission.context, text, options?.alternate ?? false)
+    const read = readSubmission(input, submission.prompt, submission.context, options?.alternate ?? false)
    if (!read) {
      if (input.adapter.working() && input.adapter.kind === "active-session") void input.adapter.interrupt()
      return
@@ -168,17 +150,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
  }
 }

-function clearClientCommand(input: ComposerSubmitInput, prompt: Prompt) {
-  input.adapter.state.set([{ type: "text", content: "", start: 0, end: 0 }, ...prompt.filter(isAttachment)], 0)
-  input.adapter.state.mode.set("normal")
-  input.setMode("normal")
-  input.closePopover()
-}
-
-function submissionText(prompt: Prompt) {
-  return prompt.map((part) => ("content" in part ? part.content : "")).join("")
-}
-
 function handoffMessage(value: ComposerSubmission): SessionMessageUser {
  return {
    id: value.id,
@@ -222,9 +193,9 @@ function readSubmission(
  input: ComposerSubmitInput,
  prompt: Prompt,
  context: ComposerSubmission["context"],
-  text: string,
  alternate: boolean,
 ): ComposerSubmission | undefined {
+  const text = prompt.map((part) => ("content" in part ? part.content : "")).join("")
  const mode = input.mode()
  if (mode === "shell" && !text.trim()) return
  const images = prompt.filter((part): part is ImageAttachmentPart => part.type === "image")
@@ -327,11 +298,14 @@ async function sendShell(session: ComposerSession, value: ComposerSubmission) {
 }

 function findCommand(commands: ReturnType<ComposerSubmitInput["commands"]>, text: string) {
-  const parsed = parseSlashCommand(text)
-  if (!parsed || !commands?.some((item) => item.name === parsed.name)) return
-  return { command: parsed.name, arguments: parsed.input }
+  if (!text.startsWith("/")) return
+  const [name, ...arguments_] = text.split(" ")
+  const command = name.slice(1)
+  if (!commands?.some((item) => item.name === command)) return
+  return { command, arguments: arguments_.join(" ") }
 }

+
 async function sendCommand(
  session: ComposerSession,
  value: ComposerSubmission,
@@ -416,10 +390,7 @@ async function sendPrompt(

 async function buildSubmissionRequest(session: ComposerSession, value: ComposerSubmission) {
  const images = await Promise.all(
-    value.images.map(async (attachment) => ({
-      ...attachment,
-      dataUrl: await blobDataUrl(attachment.blob, attachment.mime),
-    })),
+    value.images.map(async (attachment) => ({ ...attachment, dataUrl: await blobDataUrl(attachment.blob, attachment.mime) })),
  )
  return buildPromptRequest({
    prompt: value.prompt,
@@ -47,7 +47,7 @@ export function HomeCommandPalette(props: {
    state.cleanup = undefined
    dialog.close()
    if (item.type === "command") {
-      void item.option?.onSelect?.("palette")
+      item.option?.onSelect?.("palette")
      return
    }
    if (item.type === "session") props.onSelectSession(item)
@@ -151,8 +151,6 @@ export const dict = {
  "command.session.compact.description": "Summarize the session to reduce context size",
  "command.session.fork": "Fork from message",
  "command.session.fork.description": "Create a new session from a previous message",
-  "command.session.btw": "Ask a side question",
-  "command.session.btw.description": "Get a one-shot answer without adding to the conversation",
  "command.session.export": "Export session",
  "command.session.export.description": "Export the full session transcript as JSON",
  "command.session.import": "Import session",
@@ -442,19 +440,6 @@ export const dict = {
    "No camera is available to this browser. Enter your connection details manually.",
  "server.connect.camera.error":
    "Could not open the camera. Allow camera access or enter your connection details manually.",
-  "command.server.pair": "Pair device",
-  "settings.pairing.title": "Pairing",
-  "settings.pairing.connection": "Local Network",
-  "pair.local.description": "View connection details and a QR code to connect a device on the same network.",
-  "pair.local.open": "Show details",
-  "pair.screenActive.title": "Keep screen active",
-  "pair.screenActive.description": "Prevent this computer’s display from sleeping while OpenCode is running.",
-  "pair.screenActive.error": "Could not update the screen activity setting. Try again.",
-  "pair.description": "Connect another device to this machine's OpenCode server.",
-  "pair.qr": "Pairing QR code",
-  "pair.copy": "Copy details",
-  "pair.copy.error": "Could not copy pairing details. Try again.",
-  "pair.error": "Could not update pairing details. Try again.",
  "dialog.server.edit.title": "Edit server",
  "dialog.server.default.title": "Default server",
  "dialog.server.default.description":
@@ -771,7 +756,6 @@ export const dict = {
  "session.tab.browser": "Browser",
  "session.tab.add": "Add tab",
  "session.tab.context": "Context",
-  "session.tab.btw": "/btw",
  "session.tab.unknown": "Unknown Session",
  "session.panel.reviewAndFiles": "Review and files",
  "session.error.notFound": "This session cannot be found",
@@ -949,10 +933,6 @@ export const dict = {
  "common.dismiss": "Dismiss",
  "common.moreCountSuffix": " (+{{count}} more)",
  "common.requestFailed": "Request failed",
-  "session.btw.questionRequired": "Add a question after /btw",
-  "session.btw.error": "Couldn’t answer that question",
-  "session.btw.retry": "Retry",
-  "session.btw.copy": "Copy answer",
  "common.moreOptions": "More options",
  "common.learnMore": "Learn more",
  "common.rename": "Rename",
@@ -22,12 +22,6 @@ type SaveFilePickerOptions = { title?: string; defaultPath?: string }
 type PlatformName = "web" | "desktop"
 type DesktopOS = "macos" | "windows" | "linux"

-export type PairingInfo = {
-  readonly urls: readonly string[]
-  readonly username: "opencode"
-  readonly password: string
-}
-
 export type FatalRendererErrorLog = {
  error: string
  url: string
@@ -107,10 +101,6 @@ type PlatformBase = {
  /** Allow native pinch/Ctrl-scroll zoom gestures (desktop only) */
  setPinchZoomEnabled?(enabled: boolean): Promise<void> | void

-  /** Prevent the local display from sleeping while the desktop app is running. */
-  getKeepScreenActive?(): Promise<boolean>
-  setKeepScreenActive?(enabled: boolean): Promise<void>
-
  /** Run a desktop-only menu action from the app chrome */
  runDesktopMenuAction?(action: DesktopMenuAction): Promise<void> | void

@@ -134,11 +124,6 @@ type PlatformBase = {

  /** Native browser pane hosted by the platform (desktop only). */
  browserPane?: BrowserPanePlatform
-
-  /** Pair another device with the local desktop server. */
-  pair?: {
-    info(): Promise<PairingInfo>
-  }
 }

 export type Platform = PlatformBase &
@@ -1,50 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { decodePairingCode, decodePairingUrl, pairingUrl } from "./pairing"
-
-describe("pairing URL", () => {
-  test("pairs with the current origin using credentials without server URLs", () => {
-    const info = { username: "opencode" as const, password: "a+b & café" }
-    const origin = "https://opencode.example.com:49709"
-    const url = new URL(pairingUrl(info, origin))
-
-    expect(url.origin).toBe(origin)
-    expect(url.pathname).toBe("/connect")
-    expect(url.search).toBe("")
-    expect(url.hash).not.toBe("")
-    expect(decodePairingUrl(url.hash, origin)).toEqual({ urls: [origin], password: info.password })
-    expect(decodePairingCode(JSON.stringify(info))).toBeUndefined()
-  })
-
-  test("keeps accepting query pairing data", () => {
-    const info = { urls: ["http://192.168.1.2:4096"], username: "opencode", password: "a+b & café" }
-    expect(decodePairingUrl(`?data=${encodeURIComponent(JSON.stringify(info))}`)).toEqual({
-      urls: info.urls,
-      password: info.password,
-    })
-  })
-
-  test("accepts CLI base64url fragments", () => {
-    const value = { urls: ["http://localhost:4096"], username: "opencode", password: "a+b & café" }
-    expect(decodePairingUrl(`#${Buffer.from(JSON.stringify(value)).toString("base64url")}`)).toEqual({
-      urls: value.urls,
-      password: value.password,
-    })
-  })
-
-  test("rejects invalid query data", () => {
-    expect(decodePairingUrl("?data=invalid")).toBeUndefined()
-    expect(decodePairingUrl("?other=value")).toBeUndefined()
-  })
-
-  test("accepts legacy JSON fragments", () => {
-    const value = { urls: ["http://localhost:4096"], username: "opencode", password: "secret" }
-    expect(decodePairingUrl(`#${encodeURIComponent(JSON.stringify(value))}`)).toEqual({
-      urls: value.urls,
-      password: value.password,
-    })
-  })
-
-  test("rejects an invalid fragment", () => {
-    expect(decodePairingUrl("#not-a-pairing-code")).toBeUndefined()
-  })
-})
@@ -1,10 +1,9 @@
 import { Option, Schema } from "effect"
-import { base64Encode } from "@opencode/util/encode"
 import { normalizeServerUrl } from "@/runtime/server/registry"

 const pairing = Schema.fromJsonString(
  Schema.Struct({
-    urls: Schema.optional(Schema.Array(Schema.String)),
+    urls: Schema.Array(Schema.String),
    username: Schema.Literal("opencode"),
    password: Schema.String,
  }),
@@ -20,35 +19,10 @@ export function serverAddress(value: string) {
  return normalized
 }

-export function decodePairingCode(value: string, origin?: string) {
+export function decodePairingCode(value: string) {
  const result = Schema.decodeUnknownOption(pairing)(value)
  if (Option.isNone(result)) return
-  const urls = [
-    ...new Set((result.value.urls ?? (origin ? [origin] : [])).map(serverAddress).filter((url) => url !== undefined)),
-  ]
+  const urls = [...new Set(result.value.urls.map(serverAddress).filter((url) => url !== undefined))]
  if (!urls.length) return
  return { urls, password: result.value.password }
 }
-
-export function pairingUrl(value: { username: "opencode"; password: string }, host: string) {
-  return `${new URL("/connect", host)}#${base64Encode(JSON.stringify(value))}`
-}
-
-export function decodePairingUrl(value: string, origin?: string) {
-  if (value.startsWith("?")) {
-    const data = new URLSearchParams(value).get("data")
-    return data === null ? undefined : decodePairingCode(data, origin)
-  }
-  const encoded = value.startsWith("#") ? value.slice(1) : value
-  if (!encoded) return
-  const legacy = new URLSearchParams(`value=${encoded}`).get("value") ?? ""
-  if (legacy.startsWith("{")) return decodePairingCode(legacy)
-  if (!/^[A-Za-z0-9_-]+$/.test(encoded) || encoded.length % 4 === 1) return
-  const binary = atob(
-    encoded
-      .replaceAll("-", "+")
-      .replaceAll("_", "/")
-      .padEnd(Math.ceil(encoded.length / 4) * 4, "="),
-  )
-  return decodePairingCode(new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0))), origin)
-}
@@ -9,28 +9,19 @@ import { usePlatform } from "@/runtime/platform/platform"
 import { useCheckServerHealth } from "@/runtime/server/health"
 import { useServers } from "@/runtime/server/registry"
 import { serverAddress } from "./pairing"
-import type { decodePairingCode } from "./pairing"
 import { isMixedContent } from "./browser"
 import { createCameraAvailability } from "./camera"
 import "./screen.css"

 const PairingScanner = lazy(() => import("./scanner").then((module) => ({ default: module.PairingScanner })))

-export function ConnectServerScreen(
-  props: { pairing?: NonNullable<ReturnType<typeof decodePairingCode>>; onConnect?: () => void } = {},
-) {
+export function ConnectServerScreen() {
  const language = useLanguage()
  const platform = usePlatform()
  const servers = useServers()
  const check = useCheckServerHealth()
  const camera = createCameraAvailability()
-  const [state, setState] = createStore({
-    url: props.pairing?.urls[0] ?? "",
-    password: props.pairing?.password ?? "",
-    urls: props.pairing?.urls ?? ([] as string[]),
-    error: "",
-    scanning: false,
-  })
+  const [state, setState] = createStore({ url: "", password: "", urls: [] as string[], error: "", scanning: false })
  const connectionError = () =>
    language.t(
      platform.platform === "web" && isMixedContent(location.href, state.url)
@@ -51,7 +42,6 @@ export function ConnectServerScreen(
        return
      }
      servers.add({ type: "http", http })
-      props.onConnect?.()
    },
    onError: () => setState("error", connectionError()),
  }))
@@ -1,114 +0,0 @@
-import { createEffect, onCleanup } from "solid-js"
-import { createStore } from "solid-js/store"
-import { useLanguage } from "@/runtime/i18n/language"
-import { useServerSDK } from "@/runtime/server/client"
-import { useCommand } from "@/shell/commands/command"
-import { showToast } from "@/shell/notifications/toast"
-import { SESSION_BTW_TAB } from "@/session/helpers"
-import type { SessionModel } from "../model"
-
-const instructions = [
-  "The user is asking a quick side question about the conversation so far.",
-  "Answer directly and concisely in markdown from what you already know.",
-  "Do not call any tools and do not take any actions.",
-].join(" ")
-
-const empty = {
-  question: "",
-  answer: "",
-  error: false,
-  pending: false,
-}
-
-export function createSessionBtw(session: SessionModel) {
-  const command = useCommand()
-  const language = useLanguage()
-  const server = useServerSDK()
-  const [states, setStates] = createStore<Record<string, typeof empty>>({})
-  const requests = new Map<string, number>()
-  const controllers = new Map<string, AbortController>()
-  const state = () => states[session.identity.sessionKey()] ?? empty
-
-  createEffect(() => {
-    const key = session.identity.sessionKey()
-    onCleanup(() => {
-      const controller = controllers.get(key)
-      if (!controller) return
-      controller.abort()
-      controllers.delete(key)
-      if (states[key]?.pending) setStates(key, { pending: false, error: true })
-    })
-  })
-
-  const open = () => {
-    session.layout.view().reviewPanel.open()
-    const tabs = session.layout.tabs()
-    if (tabs.active() !== SESSION_BTW_TAB) tabs.open(SESSION_BTW_TAB)
-  }
-  const ask = (value?: string) => {
-    const question = value?.trim()
-    if (!question) {
-      showToast({ title: language.t("session.btw.questionRequired") })
-      return
-    }
-    open()
-    const sessionID = session.identity.sessionID()
-    if (!sessionID) return
-
-    const key = session.identity.sessionKey()
-    const request = (requests.get(key) ?? 0) + 1
-    requests.set(key, request)
-    controllers.get(key)?.abort()
-    const controller = new AbortController()
-    controllers.set(key, controller)
-    const owner = session.ownership.capture()
-    setStates(key, { question, answer: "", error: false, pending: true })
-    return server.api.session
-      .generate(
-        {
-          sessionID,
-          prompt: [instructions, question].join("\n\n"),
-        },
-        { signal: controller.signal },
-      )
-      .then((result) => {
-        owner.run(() => {
-          if (requests.get(key) !== request) return
-          setStates(key, { answer: result.text.trim(), pending: false })
-        })
-      })
-      .catch(() => {
-        owner.run(() => {
-          if (controller.signal.aborted || requests.get(key) !== request) return
-          setStates(key, { error: true, pending: false })
-        })
-      })
-      .finally(() => {
-        if (controllers.get(key) === controller) controllers.delete(key)
-      })
-  }
-
-  command.register("session.btw", () => [
-    {
-      id: "session.btw",
-      title: language.t("command.session.btw"),
-      description: language.t("command.session.btw.description"),
-      category: language.t("command.category.session"),
-      slash: "btw",
-      slashArguments: true,
-      hidden: true,
-      disabled: !session.isDesktop(),
-      onSelect: (_source, input) => ask(input),
-    },
-  ])
-
-  return {
-    answer: () => state().answer,
-    error: () => state().error,
-    pending: () => state().pending,
-    question: () => state().question,
-    retry: () => ask(state().question),
-  }
-}
-
-export type SessionBtwModel = ReturnType<typeof createSessionBtw>
@@ -1,80 +0,0 @@
-import { createEffect, createSignal, Match, Show, Switch } from "solid-js"
-import { Button } from "@opencode/ui/button"
-import { Icon } from "@opencode/ui/icon"
-import { IconButton } from "@opencode/ui/icon-button"
-import { ScrollView } from "@opencode/ui/scroll-view"
-import { TextShimmer } from "@opencode/ui/text-shimmer"
-import { Tooltip } from "@opencode/ui/tooltip"
-import { Markdown } from "@opencode/session-ui/markdown"
-import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform } from "@/runtime/platform/platform"
-import { showToast } from "@/shell/notifications/toast"
-import type { SessionBtwModel } from "./model"
-
-export function SessionBtwPanel(props: { btw: SessionBtwModel }) {
-  const language = useLanguage()
-  const platform = usePlatform()
-  const [copied, setCopied] = createSignal(false)
-
-  createEffect(() => {
-    props.btw.answer()
-    setCopied(false)
-  })
-
-  const copy = () => {
-    const answer = props.btw.answer()
-    if (!answer) return
-    void (platform.writeClipboardText?.(answer) ?? navigator.clipboard.writeText(answer)).then(
-      () => setCopied(true),
-      () => showToast({ title: language.t("common.requestFailed") }),
-    )
-  }
-
-  return (
-    <div class="flex h-full min-h-0 flex-col bg-v2-background-bg-base" data-slot="session-btw-panel">
-      <div class="flex shrink-0 items-start justify-between gap-3 border-b border-v2-border-border-base px-5 py-4">
-        <div class="min-w-0 text-13-regular text-text-weak">{props.btw.question()}</div>
-        <Show when={props.btw.answer()}>
-          <Tooltip value={copied() ? language.t("common.copied") : language.t("session.btw.copy")}>
-            <IconButton
-              size="small"
-              variant="ghost-muted"
-              icon={<Icon name={copied() ? "check" : "outline-copy"} />}
-              aria-label={copied() ? language.t("common.copied") : language.t("session.btw.copy")}
-              onClick={copy}
-            />
-          </Tooltip>
-        </Show>
-      </div>
-
-      <div class="relative min-h-0 flex-1">
-        <Switch>
-          <Match when={props.btw.pending()}>
-            <div
-              data-component="session-working"
-              role="status"
-              class="flex h-9 items-center px-5 pt-3 text-[13px] font-[530] leading-text-compact"
-            >
-              <TextShimmer text={language.t("session.timeline.working")} active />
-            </div>
-          </Match>
-          <Match when={props.btw.error()}>
-            <div class="flex h-full flex-col items-center justify-center gap-3 px-8 pb-24 text-center">
-              <div class="text-13-regular text-text-weak">{language.t("session.btw.error")}</div>
-              <Button size="small" variant="outline" onClick={props.btw.retry}>
-                {language.t("session.btw.retry")}
-              </Button>
-            </div>
-          </Match>
-          <Match when={props.btw.answer()}>
-            <ScrollView class="absolute inset-0">
-              <div class="px-5 py-4 pb-8">
-                <Markdown text={props.btw.answer()} class="text-14-regular" />
-              </div>
-            </ScrollView>
-          </Match>
-        </Switch>
-      </div>
-    </div>
-  )
-}
@@ -37,7 +37,6 @@ import { useSettings } from "@/settings/model"
 import { createFileTabListSync } from "@/session/files/file-tab-scroll"
 import {
  SESSION_OPEN_FILE_TAB,
-  SESSION_BTW_TAB,
  isSessionBrowserTab,
  sessionBrowserTab,
  createOpenSessionFileTab,
@@ -75,7 +74,6 @@ export function SessionSidePanel(props: {
  size: Sizing
  stacked?: boolean
  browser: ReturnType<typeof createSessionBrowser>
-  btwPanel: () => JSX.Element
 }) {
  const layout = useLayout()
  const settings = useSettings()
@@ -229,7 +227,7 @@ export function SessionSidePanel(props: {
  })
  const fileBrowserVisible = createMemo(() => {
    const active = activeTab()
-    return active === SESSION_OPEN_FILE_TAB || active === activeFileTab()
+    return active !== "review" && active !== "context" && active !== "empty" && !isSessionBrowserTab(active)
  })
  const openFileKeybind = createMemo(() => command.keybindParts("file.open"))
  const openBrowserKeybind = createMemo(() => command.keybindParts("browser.open"))
@@ -387,14 +385,6 @@ export function SessionSidePanel(props: {
                                  />
                                }
                              >
-                                <Match when={tab === SESSION_BTW_TAB}>
-                                  <SortableTab tab={tab} index={tabs().all().indexOf(tab)} onTabClose={tabs().close}>
-                                    <div class="flex items-center gap-1.5">
-                                      <Icon name="bubble-5" size="small" />
-                                      <span>{language.t("session.tab.btw")}</span>
-                                    </div>
-                                  </SortableTab>
-                                </Match>
                                <Match when={isSessionBrowserTab(tab)}>
                                  <Show when={props.browser.tabs().find((item) => sessionBrowserTab(item.id) === tab)}>
                                    {(item) => (
@@ -593,12 +583,6 @@ export function SessionSidePanel(props: {
                        </Tabs.Content>
                      </Show>

-                      <Show when={activeTab() === SESSION_BTW_TAB}>
-                        <Tabs.Content value={SESSION_BTW_TAB} class="flex h-full min-h-0 flex-col overflow-hidden">
-                          {props.btwPanel()}
-                        </Tabs.Content>
-                      </Show>
-
                      <Show when={props.browser.opened()}>
                        <div
                          id={browserTabPanelID}
@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import { createMemo, createRoot } from "solid-js"
 import { createStore } from "solid-js/store"
 import {
-  SESSION_BTW_TAB,
  SESSION_BROWSER_TAB,
  sessionBrowserTab,
  SESSION_OPEN_FILE_TAB,
@@ -237,24 +236,6 @@ describe("createSessionTabs", () => {
    })
  })

-  test("exposes the BTW tab without treating it as a file tab", () => {
-    createRoot((dispose) => {
-      const tabs = createMemo(() => ({ active: () => SESSION_BTW_TAB, all: () => [SESSION_BTW_TAB] }))
-      const result = createSessionTabs({
-        tabs,
-        pathFromTab: () => undefined,
-        normalizeTab: (tab) => tab,
-      })
-
-      expect(result.panelTabs()).toEqual([SESSION_BTW_TAB])
-      expect(result.openedTabs()).toEqual([])
-      expect(result.activeTab()).toBe(SESSION_BTW_TAB)
-      expect(result.activeFileTab()).toBeUndefined()
-      expect(result.closableTab()).toBe(SESSION_BTW_TAB)
-      dispose()
-    })
-  })
-
  test("exposes one browser tab without treating it as a file tab", () => {
    createRoot((dispose) => {
      const tabs = createMemo(() => ({ active: () => SESSION_BROWSER_TAB, all: () => [SESSION_BROWSER_TAB] }))
@@ -2,11 +2,10 @@ import { batch, createMemo, onCleanup, onMount, type Accessor } from "solid-js"
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { same } from "@/runtime/persistence/equality"
-import { isSessionBrowserTab, SESSION_BTW_TAB, SESSION_OPEN_FILE_TAB } from "@/shell/state/session-tabs"
+import { isSessionBrowserTab, SESSION_OPEN_FILE_TAB } from "@/shell/state/session-tabs"

 export {
  SESSION_BROWSER_TAB,
-  SESSION_BTW_TAB,
  SESSION_OPEN_FILE_TAB,
  sessionBrowserTab,
  isSessionBrowserTab,
@@ -64,17 +63,13 @@ export const createSessionTabs = (input: TabsInput) => {
    { equals: same },
  )
  const openedTabs = createMemo(
-    () =>
-      panelTabs().filter(
-        (tab) => tab !== SESSION_OPEN_FILE_TAB && tab !== SESSION_BTW_TAB && !isSessionBrowserTab(tab),
-      ),
+    () => panelTabs().filter((tab) => tab !== SESSION_OPEN_FILE_TAB && !isSessionBrowserTab(tab)),
    emptyTabs,
    { equals: same },
  )
  const activeTab = createMemo(() => {
    const active = input.tabs().active()
    if (active === "context") return active
-    if (active === SESSION_BTW_TAB) return active
    if (active === SESSION_OPEN_FILE_TAB && openFileOpen()) return active
    if (active && isSessionBrowserTab(active) && browser()) return active
    if (active === "review" && review()) return active
@@ -94,7 +89,6 @@ export const createSessionTabs = (input: TabsInput) => {
  const closableTab = createMemo<string | undefined>(() => {
    const active = activeTab()
    if (active === "context") return active
-    if (active === SESSION_BTW_TAB) return active
    if (active === SESSION_OPEN_FILE_TAB && openFileOpen()) return active
    if (active && isSessionBrowserTab(active) && browser()) return active
    if (!openedTabs().includes(active)) return
@@ -14,8 +14,6 @@ import { ReviewPanel } from "./panel"
 import { SessionReviewTab } from "./review-tab"
 import type { ChangeMode, SessionReviewModel } from "./model"
 import type { createSessionBrowser } from "../browser/model"
-import type { SessionBtwModel } from "../btw/model"
-import { SessionBtwPanel } from "../btw/panel"

 const MobilePanelDrawer = lazy(async () => {
  const { MobilePanelDrawer } = await import("@/shell/mobile-panel-drawer")
@@ -129,7 +127,6 @@ export function SessionMobileReview(props: { review: SessionReviewModel }) {
 export function SessionDesktopReview(props: {
  review: SessionReviewModel
  browser: ReturnType<typeof createSessionBrowser>
-  btw: SessionBtwModel
  present?: boolean
 }) {
  return (
@@ -156,7 +153,6 @@ export function SessionDesktopReview(props: {
        size={props.review.screen.size}
        stacked={props.review.screen.side.layout().stacked}
        browser={props.browser}
-        btwPanel={() => <SessionBtwPanel btw={props.btw} />}
      />
    </Suspense>
  )
@@ -39,7 +39,6 @@ import { createAnimatedPresence } from "@/runtime/animated-presence"
 import { createSessionBrowser } from "./browser/model"
 import { createTimelineCache } from "./timeline/cache"
 import { ArtifactMarkdownProvider, ArtifactOpenerProvider } from "./files/open-artifact"
-import { createSessionBtw } from "./btw/model"

 const SessionMobileFiles = lazy(async () => {
  const { SessionMobileFiles } = await import("./files/session-mobile-files")
@@ -72,7 +71,6 @@ function SessionScreenContent(props: { session: SessionModel; browser: ReturnTyp
    return info ? projectForSession(info, server.ctx.sync.data.project) : undefined
  })
  const isDesktop = session.isDesktop
-  const btw = createSessionBtw(session)
  const screen = createSessionScreenLayout(session)
  const timeline = createSessionTimelineInteraction(session)
  const timelineSearch = createTimelineSearchController({
@@ -453,12 +451,7 @@ function SessionScreenContent(props: { session: SessionModel; browser: ReturnTyp
                        setStore("sideReviewPresent", false)
                      }}
                    >
-                      <SessionDesktopReview
-                        review={review}
-                        browser={browser}
-                        btw={btw}
-                        present={store.sideReviewPresent}
-                      />
+                      <SessionDesktopReview review={review} browser={browser} present={store.sideReviewPresent} />
                    </div>
                  </Show>
                </div>
@@ -7,7 +7,6 @@ export const pageIcons = {
  appearance: "appearance",
  notifications: "notifications",
  shortcuts: "keyboard",
-  pairing: "server",
  projects: "folder",
  workspaces: "outline-worktree",
  providers: "providers",
@@ -23,7 +22,6 @@ export const pageLabels = {
  appearance: "settings.general.section.appearance",
  notifications: "settings.tab.notifications",
  shortcuts: "settings.shortcuts.title",
-  pairing: "settings.pairing.title",
  projects: "settings.tab.projects",
  workspaces: "settings.tab.workspaces",
  providers: "settings.providers.title",
@@ -1,193 +0,0 @@
-import { Button } from "@opencode/ui/button"
-import { useDialog } from "@opencode/ui/context/dialog"
-import { Dialog, DialogBody, DialogHeader, DialogTitleGroup } from "@opencode/ui/dialog"
-import { Icon } from "@opencode/ui/icon"
-import { Switch } from "@opencode/ui/switch"
-import { Tooltip } from "@opencode/ui/tooltip"
-import { useMutation, useQuery, useQueryClient } from "@tanstack/solid-query"
-import { createEffect, createMemo, onCleanup, Show } from "solid-js"
-import { renderSVG } from "uqr"
-import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform, type PairingInfo } from "@/runtime/platform/platform"
-import { pairingUrl } from "@/servers/connect/pairing"
-import { SettingsList } from "@/settings/list"
-import { SettingsRow } from "@/settings/row"
-
-export function SettingsPairing() {
-  const language = useLanguage()
-  const dialog = useDialog()
-  const platform = usePlatform()
-  const queryClient = useQueryClient()
-  const pair = platform.pair
-  if (!pair) return null
-  const local = useQuery(() => ({
-    queryKey: ["pairing", "local"],
-    queryFn: pair.info,
-  }))
-  // Reading pending query data would suspend the entire settings surface.
-  const localInfo = () => (local.isSuccess ? local.data : undefined)
-  const localHost = createMemo(() =>
-    localInfo()?.urls.find((value) => {
-      const host = new URL(value).hostname
-      return (
-        host !== "localhost" &&
-        !host.endsWith(".localhost") &&
-        !host.startsWith("127.") &&
-        host !== "[::1]" &&
-        host !== "0.0.0.0" &&
-        host !== "[::]"
-      )
-    }),
-  )
-  const screenActive = useQuery(() => ({
-    queryKey: ["pairing", "screen-active"],
-    queryFn: () => platform.getKeepScreenActive!(),
-    enabled: !!platform.getKeepScreenActive,
-  }))
-  const screenActivity = useMutation(() => ({
-    mutationFn: async (enabled: boolean) => platform.setKeepScreenActive?.(enabled),
-    onSuccess: (_, enabled) => queryClient.setQueryData(["pairing", "screen-active"], enabled),
-  }))
-
-  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.pairing.title")}</h2>
-            <span class="text-11-regular text-v2-text-text-muted">{language.t("pair.description")}</span>
-          </div>
-        </div>
-      </div>
-
-      <div class="settings-tab-body settings-tab-body--sectioned">
-        <section class="settings-section" aria-label={language.t("settings.pairing.connection")}>
-          <SettingsList>
-            <SettingsRow
-              title={language.t("settings.pairing.connection")}
-              description={language.t("pair.local.description")}
-            >
-              <Button
-                variant="neutral"
-                disabled={!localHost()}
-                onClick={() =>
-                  dialog.push(() => (
-                    <DialogPairing
-                      title={language.t("settings.pairing.connection")}
-                      info={localInfo()}
-                      host={localHost()!}
-                    />
-                  ))
-                }
-              >
-                {language.t("pair.local.open")}
-              </Button>
-            </SettingsRow>
-            <Show when={platform.getKeepScreenActive && platform.setKeepScreenActive}>
-              <div data-action="settings-keep-screen-active">
-                <SettingsRow
-                  title={language.t("pair.screenActive.title")}
-                  description={language.t("pair.screenActive.description")}
-                >
-                  <Switch
-                    hideLabel
-                    checked={screenActive.isSuccess && screenActive.data}
-                    disabled={screenActive.isPending || !!screenActive.error || screenActivity.isPending}
-                    onChange={(enabled) => screenActivity.mutate(enabled)}
-                  >
-                    {language.t("pair.screenActive.title")}
-                  </Switch>
-                </SettingsRow>
-              </div>
-            </Show>
-          </SettingsList>
-          <Show when={screenActive.error || screenActivity.error}>
-            <p class="text-text-danger-base" role="alert">
-              {language.t("pair.screenActive.error")}
-            </p>
-          </Show>
-          <Show when={local.error}>
-            <p class="text-text-danger-base" role="alert">
-              {language.t("pair.error")}
-            </p>
-          </Show>
-        </section>
-      </div>
-    </>
-  )
-}
-
-function DialogPairing(props: { title: string; info: PairingInfo | null | undefined; host: string }) {
-  const language = useLanguage()
-  const platform = usePlatform()
-  const url = createMemo(() => {
-    if (!props.info) return
-    return pairingUrl({ username: props.info.username, password: props.info.password }, props.host)
-  })
-  const origin = createMemo(() => {
-    const value = url()
-    if (!value) return
-    return new URL(value).origin
-  })
-  const copy = useMutation(() => ({
-    mutationFn: async () => {
-      const value = url()
-      if (!value) return
-      await (platform.writeClipboardText?.(value) ?? navigator.clipboard.writeText(value))
-    },
-  }))
-  createEffect(() => {
-    if (!copy.isSuccess) return
-    const timeout = setTimeout(() => copy.reset(), 2000)
-    onCleanup(() => clearTimeout(timeout))
-  })
-  const qr = createMemo(() => {
-    const value = url()
-    if (!value) return
-    return renderSVG(value, { border: 4, blackColor: "currentColor", whiteColor: "transparent" })
-  })
-
-  return (
-    <Dialog fit containerClass="max-w-[min(400px,calc(100vw-32px),calc(100dvh-180px))]">
-      <DialogHeader>
-        <DialogTitleGroup title={props.title} description={language.t("pair.description")} />
-      </DialogHeader>
-      <DialogBody class="flex flex-col gap-4 px-4 pb-4">
-        <Show when={props.info}>
-          <div
-            class="aspect-square w-full shrink-0 rounded-[6px] bg-v2-background-bg-base p-6 text-v2-text-text-base [&>svg]:size-full"
-            role="img"
-            aria-label={language.t("pair.qr")}
-            innerHTML={qr()}
-          />
-          <div class="flex min-w-0 justify-center pb-2">
-            <Tooltip
-              class="min-w-0 max-w-full"
-              value={language.t(copy.isSuccess ? "common.copied" : "pair.copy")}
-              placement="top"
-              forceOpen={copy.isSuccess ? true : undefined}
-            >
-              <button
-                type="button"
-                class="inline-flex min-h-8 max-w-full select-none items-center justify-center gap-2 rounded-[6px] px-2 py-1 text-[13px] font-[440] leading-text-compact tracking-[-0.04px] text-v2-text-text-muted transition-colors hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base focus-visible:bg-v2-background-bg-layer-02 focus-visible:outline-none disabled:opacity-50"
-                disabled={copy.isPending}
-                aria-label={language.t("pair.copy")}
-                onClick={() => copy.mutate()}
-              >
-                <Icon name={copy.isSuccess ? "check" : "copy"} size="small" class="shrink-0" />
-                <bdi dir="ltr" class="min-w-0 break-all text-start">
-                  {origin()}
-                </bdi>
-              </button>
-            </Tooltip>
-          </div>
-        </Show>
-        <Show when={copy.error}>
-          <p class="text-text-danger-base" role="alert">
-            {language.t("pair.copy.error")}
-          </p>
-        </Show>
-      </DialogBody>
-    </Dialog>
-  )
-}
@@ -20,20 +20,6 @@ export const clientSettings: Entry<SettingsRootTab>[] = [
  { tab: "appearance", label: "settings.general.section.appearance" },
  { tab: "notifications", label: "settings.tab.notifications" },
  { tab: "shortcuts", label: "settings.shortcuts.title", keywords: "keybind keyboard hotkey" },
-  {
-    tab: "pairing",
-    label: "settings.pairing.title",
-    keywords: "pair device qr local",
-    available: "desktop",
-  },
-  {
-    tab: "pairing",
-    label: "pair.screenActive.title",
-    description: "pair.screenActive.description",
-    target: "settings-keep-screen-active",
-    keywords: "display sleep awake local",
-    available: "desktop",
-  },
  { tab: "experimental", label: "settings.tab.experimental" },
  { tab: "about", label: "settings.tab.about", keywords: "version license credits" },
  { tab: "general", label: "settings.general.row.language.title", target: "settings-language" },
@@ -3,7 +3,6 @@ import { useDialog } from "@opencode/ui/context/dialog"
 import { createEffect, createMemo, on, onCleanup, onMount, Show, Switch, Match, type Accessor } from "solid-js"
 import { createStore } from "solid-js/store"
 import { useLanguage } from "@/runtime/i18n/language"
-import { usePlatform } from "@/runtime/platform/platform"
 import { useLayout } from "@/shell/state/layout"
 import { useTabs } from "@/shell/tabs/tabs"
 import { displayName } from "@/shell/layout/helpers"
@@ -19,7 +18,6 @@ import { SettingsAppearance } from "./appearance/appearance"
 import { SettingsExperimental } from "./experimental/experimental"
 import { SettingsKeybinds } from "./keybinds/keybinds"
 import { SettingsNotifications } from "./notifications/notifications"
-import { SettingsPairing } from "./pairing/pairing"
 import { SettingsProviders } from "./providers/providers"
 import { SettingsModels } from "./models/models"
 import { SettingsServerGeneral } from "./servers/servers"
@@ -43,7 +41,6 @@ const rootClientTabs = [
  { value: "appearance", icon: pageIcons.appearance, label: "settings.general.section.appearance" },
  { value: "notifications", icon: pageIcons.notifications, label: "settings.tab.notifications" },
  { value: "shortcuts", icon: pageIcons.shortcuts, label: "settings.tab.shortcuts" },
-  { value: "pairing", icon: pageIcons.pairing, label: "settings.pairing.title" },
 ] as const

 const serverTabs = [
@@ -190,7 +187,6 @@ function RootSettings() {
  const tabs = useTabs()
  const servers = useServerCollectionController()
  const inventory = useSettingsServers()
-  const platform = usePlatform()
  const [state, setState] = createStore({ worktreeFilterReset: 0 })
  const list = servers.collection.items
  const singleEntry = createMemo(() => (inventory().length === 1 ? inventory()[0] : undefined))
@@ -220,11 +216,7 @@ function RootSettings() {
      <DialogServer mode="add" onSave={(server) => surface.openServer(ServerConnection.key(server))} />
    ))
  const groups = createMemo<SettingsNavGroup[]>(() => [
-    {
-      items: rootClientTabs
-        .filter((item) => item.value !== "pairing" || !!platform.pair)
-        .map((item) => ({ ...item, label: language.t(item.label) })),
-    },
+    { items: rootClientTabs.map((item) => ({ ...item, label: language.t(item.label) })) },
    ...(multiple()
      ? [
          {
@@ -290,9 +282,6 @@ function RootSettings() {
      <Tabs.Content value="shortcuts" class="settings-panel">
        <SettingsKeybinds active={surface.view().tab === "shortcuts"} autofocus={!surface.search.state.selected} />
      </Tabs.Content>
-      <Tabs.Content value="pairing" class="settings-panel">
-        <SettingsPairing />
-      </Tabs.Content>
      <Tabs.Content value="experimental" class="settings-panel">
        <SettingsExperimental />
      </Tabs.Content>
@@ -11,7 +11,6 @@ export type SettingsRootTab =
  | "appearance"
  | "notifications"
  | "shortcuts"
-  | "pairing"
  | "projects"
  | "workspaces"
  | "providers"
@@ -45,7 +44,6 @@ const rootTabs: Record<SettingsRootTab, true> = {
  appearance: true,
  notifications: true,
  shortcuts: true,
-  pairing: true,
  projects: true,
  workspaces: true,
  providers: true,
@@ -88,12 +88,11 @@ export interface CommandOption {
  category?: string
  keybind?: KeybindConfig
  slash?: string
-  slashArguments?: boolean
  suggested?: boolean
  disabled?: boolean
  hidden?: boolean
  when?: (event: KeyboardEvent) => boolean
-  onSelect?: (source?: "palette" | "keybind" | "slash", input?: string) => void | Promise<void>
+  onSelect?: (source?: "palette" | "keybind" | "slash") => void
  onHighlight?: () => (() => void) | void
 }

@@ -390,9 +389,9 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
      return map
    })

-    const run = (id: string, source?: CommandSource, input?: string) => {
+    const run = (id: string, source?: CommandSource) => {
      const option = optionMap().get(id)
-      return option?.onSelect?.(source, input)
+      option?.onSelect?.(source)
    }

    const showPalette = () => {
@@ -421,7 +420,7 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
      if (!option) return
      event.preventDefault()
      event.stopPropagation()
-      void option.onSelect?.("keybind")
+      option.onSelect?.("keybind")
    }

    onMount(() => {
@@ -455,8 +454,8 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex

    return {
      register,
-      trigger(id: string, source?: CommandSource, input?: string) {
-        return run(id, source, input)
+      trigger(id: string, source?: CommandSource) {
+        run(id, source)
      },
      keybind(id: string) {
        const config = keybindConfig(id)
@@ -4,7 +4,6 @@ import { useCommand, type CommandOption } from "./command"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { DialogSsh } from "@/servers/ssh/dialog"
 import { useUpdaterAction } from "@/shell/updates/action"
-import { useSettingsSurface } from "@/settings/surface"

 export function DesktopCommands() {
  const command = useCommand()
@@ -41,25 +40,3 @@ export function DesktopCommands() {

  return null
 }
-
-export function DesktopPairingCommand() {
-  const command = useCommand()
-  const language = useLanguage()
-  const platform = usePlatform()
-  const settings = useSettingsSurface()
-
-  command.register("desktop-pairing", () =>
-    platform.platform === "desktop" && platform.pair
-      ? [
-          {
-            id: "server.pair",
-            title: language.t("command.server.pair"),
-            category: language.t("command.category.server"),
-            onSelect: () => settings.open("pairing"),
-          },
-        ]
-      : [],
-  )
-
-  return null
-}
@@ -166,7 +166,7 @@ export function createCommandPaletteModel(props: { filesOnly?: () => boolean; on
    state.cleanup = undefined
    dialog.close()
    if (item.type === "command") {
-      void item.option?.onSelect?.("palette")
+      item.option?.onSelect?.("palette")
      return
    }
    if (item.type === "session") {
@@ -1,5 +1,5 @@
-import { Route, useNavigate, useParams } from "@solidjs/router"
-import { createMemo, lazy, onMount, Show, Suspense, type ParentProps } from "solid-js"
+import { Route, useParams } from "@solidjs/router"
+import { createMemo, lazy, Show, Suspense, type ParentProps } from "solid-js"
 import { Home } from "@/home/route"
 import { ServerProvider } from "@/runtime/server/current"
 import { useGlobal } from "@/runtime/server/runtime"
@@ -10,8 +10,6 @@ import { LayoutProvider } from "@/shell/state/layout"
 import { SettingsSurfaceProvider } from "@/settings/surface"
 import Shell from "@/shell/shell"
 import { requireServerKey } from "./session"
-import { decodePairingUrl } from "@/servers/connect/pairing"
-import { DesktopPairingCommand } from "@/shell/commands/desktop"

 export const File = lazy(() => import("@opencode/session-ui/file").then((module) => ({ default: module.File })))
 const loadSessionRoute = () => Promise.all([import("@/session/route"), File.preload()]).then(([module]) => module)
@@ -28,7 +26,6 @@ export function preloadRoute(url: string) {
  const pathname = url.split(/[?#]/, 1)[0]
  if (pathname === "/new-session") return DraftRoute.preload().then(() => undefined)
  if (pathname === "/settings") return SettingsScreen.preload().then(() => undefined)
-  if (pathname === "/connect") return ConnectServerScreen.preload().then(() => undefined)
  if (/^\/server\/[^/]+\/session\/[^/]+$/.test(pathname))
    return TargetSessionRouteContent.preload().then(() => undefined)
  return Promise.resolve()
@@ -36,48 +33,29 @@ export function preloadRoute(url: string) {

 export function AppRoutes() {
  return (
-    <>
-      <Route path="/connect" component={ConnectRoute} />
-      <Route component={AppLayout}>
-        <Route path="/" component={Home} />
-        <Route path="/settings" component={SettingsScreen} />
-        <Route
-          path="/server/:serverKey/session/:id"
-          component={() => (
-            <SessionRouteFrame>
-              <Suspense
-                fallback={
-                  <div class="flex min-h-0 flex-1 px-2 pb-[var(--shell-bottom-inset,8px)] pt-[var(--shell-top-inset,8px)]">
-                    <SessionPanelFrame raised />
-                  </div>
-                }
-              >
-                <TargetServerRoute>
-                  <TargetSessionRouteContent />
-                </TargetServerRoute>
-              </Suspense>
-            </SessionRouteFrame>
-          )}
-        />
-        <Route path="/new-session" component={DraftRoute} />
-      </Route>
-    </>
-  )
-}
-
-function ConnectRoute() {
-  const navigate = useNavigate()
-  const servers = useServers()
-  const pairing = decodePairingUrl(location.search, location.origin) ?? decodePairingUrl(location.hash, location.origin)
-  onMount(() => {
-    if (!pairing) return
-    servers.add({ type: "http", http: { url: pairing.urls[0], password: pairing.password } })
-    navigate("/", { replace: true })
-  })
-  return (
-    <Show when={!pairing}>
-      <ConnectServerScreen onConnect={() => navigate("/", { replace: true })} />
-    </Show>
+    <Route component={AppLayout}>
+      <Route path="/" component={Home} />
+      <Route path="/settings" component={SettingsScreen} />
+      <Route
+        path="/server/:serverKey/session/:id"
+        component={() => (
+          <SessionRouteFrame>
+            <Suspense
+              fallback={
+                <div class="flex min-h-0 flex-1 px-2 pb-[var(--shell-bottom-inset,8px)] pt-[var(--shell-top-inset,8px)]">
+                  <SessionPanelFrame raised />
+                </div>
+              }
+            >
+              <TargetServerRoute>
+                <TargetSessionRouteContent />
+              </TargetServerRoute>
+            </Suspense>
+          </SessionRouteFrame>
+        )}
+      />
+      <Route path="/new-session" component={DraftRoute} />
+    </Route>
  )
 }

@@ -101,7 +79,6 @@ function AppLayout(props: ParentProps) {
    <Show when={servers.list.length > 0} fallback={<ConnectServerScreen />}>
      <LayoutProvider>
        <SettingsSurfaceProvider>
-          <DesktopPairingCommand />
          <BrowserAttachmentsProvider>
            <Shell>{props.children}</Shell>
          </BrowserAttachmentsProvider>
@@ -10,10 +10,6 @@ test("settings has its own layout route", () => {
  expect(currentRoute("/settings", "")).toEqual({ type: "settings" })
 })

-test("connect has its own layout route", () => {
-  expect(currentRoute("/connect", "")).toEqual({ type: "connect" })
-})
-
 describe("layout persistence", () => {
  const schema = Persistence.withInitial(layoutPersistence, initialLayout(ServerConnection.Key.make("local")))
  const decode = Schema.decodeUnknownSync(schema)
@@ -100,7 +96,7 @@ describe("layout persistence", () => {
  test("keeps scoped state and salvages valid tab entries", () => {
    const key = "local\u0000L3Byb2plY3Q/session"
    const value = decode({
-      sessionTabs: { old: { all: ["old"] }, [key]: { all: ["a", null, "a", "b", "btw"], active: "btw" } },
+      sessionTabs: { old: { all: ["old"] }, [key]: { all: ["a", null, "a", "b"], active: 12 } },
      sessionView: { old: { scroll: {} }, [key]: { scroll: {}, reviewOpen: ["a", null, "b"] } },
    })
    expect(value.sessionTabs).toEqual({ [key]: { all: ["a", "b"], active: undefined } })
@@ -18,7 +18,7 @@ import type { ProjectAvatarVariant } from "@opencode/ui/project-avatar"
 import { SessionStateKey } from "@/runtime/server/scope"
 import { createSessionKeyReader, ensureSessionKey, pruneSessionKeys } from "./helpers"
 import { requireServerKey } from "@/shell/routes/session"
-import { closeSessionTab, openSessionTab, previewSessionTab, SESSION_BTW_TAB, type SessionTabs } from "./session-tabs"
+import { closeSessionTab, openSessionTab, previewSessionTab, type SessionTabs } from "./session-tabs"

 export { createSessionKeyReader, ensureSessionKey, pruneSessionKeys }

@@ -67,7 +67,6 @@ export type TabPanes = {
 export type LayoutRoute =
  | { type: "home" }
  | { type: "settings" }
-  | { type: "connect" }
  | { type: "draft"; draftID: string }
  | { type: "session"; sessionId: string; server: ServerConnection.Key }

@@ -98,9 +97,8 @@ const normalizeSessionTabList = (path: ReturnType<typeof createPathHelpers> | un
 const normalizeStoredSessionTabs = (key: string, tabs: SessionTabs) => {
  const path = sessionPath(key)
  return {
-    all: normalizeSessionTabList(path, tabs.all).filter((tab) => tab !== SESSION_BTW_TAB),
-    active:
-      tabs.active === SESSION_BTW_TAB ? undefined : tabs.active ? normalizeSessionTab(path, tabs.active) : tabs.active,
+    all: normalizeSessionTabList(path, tabs.all),
+    active: tabs.active ? normalizeSessionTab(path, tabs.active) : tabs.active,
  }
 }

@@ -108,7 +106,6 @@ export const currentRoute = (pathname: string, search: string): LayoutRoute => {
  const parts = pathname.split("/").filter(Boolean)
  if (parts.length === 0) return { type: "home" }
  if (parts[0] === "settings") return { type: "settings" }
-  if (parts[0] === "connect") return { type: "connect" }

  if (parts[0] === "new-session") {
    const draftID = new URLSearchParams(search).get("draftId")
@@ -1,6 +1,5 @@
 export const SESSION_OPEN_FILE_TAB = "open-file"
 export const SESSION_BROWSER_TAB = "browser"
-export const SESSION_BTW_TAB = "btw"
 export const sessionBrowserTab = (tabID: string) => `${SESSION_BROWSER_TAB}:${tabID}`
 export const isSessionBrowserTab = (tab: string | undefined) =>
  !!tab && (tab === SESSION_BROWSER_TAB || tab.startsWith(`${SESSION_BROWSER_TAB}:`))
@@ -303,7 +303,6 @@ export function Titlebar(props: {
                  return
                }
                case "settings":
-                case "connect":
                case "home": {
                  const selection = layout.home.selection()
                  const conn =
@@ -1,8 +1,9 @@
 import { OpenCode } from "@opencode/client"
 import { Service } from "@opencode/client/effect/service"
 import { Session } from "@opencode/schema/session"
+import { SessionMessage } from "@opencode/schema/session-message"
 import { SessionTransfer } from "@opencode/schema/session-transfer"
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Predicate, Schema } from "effect"
 import { EOL } from "node:os"
 import path from "node:path"
 import { Commands } from "../../commands"
@@ -23,7 +24,13 @@ export default Runtime.handler(
      catch: (cause) =>
        new Error(`Failed to read session data: ${cause instanceof Error ? cause.message : String(cause)}`),
    })
-    const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(SessionTransfer.Data))(text)
+    const raw = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(text)
+    // Exports written before provider blobs were renamed to `native` still carry the old keys.
+    const data = yield* Schema.decodeUnknownEffect(SessionTransfer.Data)(
+      Predicate.isObject(raw) && Array.isArray(raw.messages)
+        ? { ...raw, messages: raw.messages.map(SessionMessage.persisted) }
+        : raw,
+    )
    const encoded = Schema.encodeSync(SessionTransfer.Data)(data)
    const server = yield* ServerConnection.resolve({
      server: Option.getOrUndefined(input.server),
@@ -564,7 +564,7 @@ export async function runNonInteractivePrompt(input: Input) {
            messageID: message.id,
            type: "reasoning",
            text,
-            metadata: item.state,
+            metadata: item.native,
            time: { start: message.time.created, end: timestamp },
          }
          renderedReasoning.set(key, item.text)
@@ -10,16 +10,18 @@ export const handler = Effect.fn("cli.web-ui.handler")(function* (options?: { re
    ? Effect.succeed(options.assets)
    : yield* Effect.cached(load().pipe(Effect.provideService(FileSystem.FileSystem, fileSystem)))
  return <E, R>(api: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) =>
-    Effect.gen(function* () {
-      const request = yield* HttpServerRequest.HttpServerRequest
-      const url = new URL(request.url, "http://localhost")
-      // Serve the web shell before API authentication so /connect can load credentials in JavaScript.
-      if (url.pathname === "/api" || url.pathname.startsWith("/api/") || url.pathname === "/openapi.json")
-        return yield* api.pipe(
-          Effect.catchIf(isRouteNotFound, () => Effect.succeed(HttpServerResponse.empty({ status: 404 }))),
-        )
-      return yield* assets.pipe(Effect.flatMap((files) => serveUI(request, url, files)))
-    })
+    api.pipe(
+      Effect.catchIf(isRouteNotFound, () =>
+        HttpServerRequest.HttpServerRequest.pipe(
+          Effect.flatMap((request) => {
+            const url = new URL(request.url, "http://localhost")
+            if (url.pathname === "/api" || url.pathname.startsWith("/api/"))
+              return Effect.succeed(HttpServerResponse.empty({ status: 404 }))
+            return assets.pipe(Effect.flatMap((files) => serveUI(request, url, files)))
+          }),
+        ),
+      ),
+    )
 })

 function serveUI(request: HttpServerRequest.HttpServerRequest, url: URL, assets: AssetMap) {
@@ -1,5 +1,4 @@
 import { NodeFileSystem, NodeHttpServer } from "@effect/platform-node"
-import { ServerProcess } from "@opencode/server/process"
 import { afterAll, describe, expect, test } from "bun:test"
 import { Effect } from "effect"
 import { HttpServer, HttpServerError, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
@@ -8,69 +7,11 @@ import { mkdtemp, rm, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import path from "node:path"
 import { WebUi } from "../src/services/web-ui"
-import { it } from "../../core/test/lib/effect"

 const root = await mkdtemp(path.join(tmpdir(), "opencode-web-ui-"))
 afterAll(() => rm(root, { recursive: true, force: true }))

 describe("web UI", () => {
-  it.live("serves the web shell and assets before server authentication", () =>
-    Effect.gen(function* () {
-      const transform = yield* WebUi.handler({
-        assets: {
-          "index.html": "<html><body>connect</body></html>",
-          "_assets/app.js": "console.log('connect')",
-          "_assets/app.css": "body { color: black; }",
-          "icons/icon.svg": "<svg></svg>",
-          "font.woff2": new Uint8Array([0, 1, 2, 255]),
-          "sw.js": "service worker",
-        },
-      })
-      const server = yield* ServerProcess.start<never, never>(
-        { hostname: "127.0.0.1", port: 0, password: "secret", database: { path: ":memory:" } },
-        undefined,
-        transform,
-      )
-      const origin = HttpServer.formatAddress(server.address)
-      yield* Effect.forEach(
-        [
-          "/",
-          "/connect?data=%7B%7D",
-          "/workspace/example",
-          "/_assets/app.js",
-          "/_assets/app.css",
-          "/icons/icon.svg",
-          "/font.woff2",
-          "/sw.js",
-        ],
-        (pathname) =>
-          Effect.gen(function* () {
-            yield* Effect.forEach(["GET", "HEAD"], (method) =>
-              Effect.gen(function* () {
-                const response = yield* Effect.promise(() => fetch(new URL(pathname, origin), { method }))
-                expect(response.status).toBe(200)
-                expect(response.headers.get("www-authenticate")).toBeNull()
-                yield* Effect.promise(() => response.arrayBuffer())
-              }),
-            )
-          }),
-      )
-      yield* Effect.forEach(["/api", "/api/info", "/api/event", "/api/missing", "/openapi.json"], (pathname) =>
-        Effect.gen(function* () {
-          const response = yield* Effect.promise(() => fetch(new URL(pathname, origin)))
-          expect(response.status).toBe(401)
-          expect(response.headers.get("www-authenticate")).toBe('Basic realm="Secure Area"')
-          yield* Effect.promise(() => response.arrayBuffer())
-        }),
-      )
-      const response = yield* Effect.promise(() =>
-        fetch(new URL("/api/info", origin), { headers: { authorization: `Basic ${btoa("opencode:secret")}` } }),
-      )
-      expect(response.status).toBe(200)
-      expect(yield* Effect.promise(() => response.json())).toHaveProperty("pid")
-    }).pipe(Effect.provide(NodeFileSystem.layer)),
-  )
-
  test("falls back from API routes to assets and the SPA index", async () => {
    const index = path.join(root, "index.html")
    const asset = path.join(root, "app.js")
@@ -509,12 +509,12 @@ export type PromptAgentAttachment = { name: string; mention?: PromptMention }

 export type PromptSkillAttachment = { id: string; name: string; text?: string; mention?: PromptMention }

-export type SessionMessageAssistantText = { type: "text"; text: string; state?: SessionMessageProviderState }
+export type SessionMessageAssistantText = { type: "text"; text: string; native?: SessionMessageProviderState }

 export type SessionMessageAssistantReasoning = {
  type: "reasoning"
  text: string
-  state?: SessionMessageProviderState
+  native?: SessionMessageProviderState
  time?: { created: number; completed?: number }
 }

@@ -1354,15 +1354,6 @@ export type SessionToolCalled = {
  }
 }

-export type SessionMessageAssistantText1 = { type: "text"; text: string; state?: SessionMessageProviderState1 }
-
-export type SessionMessageAssistantReasoning1 = {
-  type: "reasoning"
-  text: string
-  state?: SessionMessageProviderState1
-  time?: { created: number; completed?: number }
-}
-
 export type ToolContent1 = ToolTextContent | ToolFileContent1

 export type FormNumberField = {
@@ -1762,7 +1753,7 @@ export type SessionMessageCompactionCompleted = {
  status: "completed"
  reason: "auto" | "manual"
  model?: ModelRef
-  providerState?: SessionMessageProviderState
+  native?: SessionMessageProviderState
  summary: string
  recent: string
  providerContext?: SessionProviderContext
@@ -2228,7 +2219,7 @@ export type SessionMessageAssistant = {
  snapshot?: { start?: string; end?: string; files?: Array<string> }
  finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
  rawFinish?: string
-  providerState?: SessionMessageProviderState
+  native?: SessionMessageProviderState
  cost?: MoneyUSD
  tokens?: TokenUsageInfo
  error?: SessionStructuredError
@@ -2236,8 +2227,13 @@ export type SessionMessageAssistant = {
 }

 export type SessionMessageAssistantContentEncoded =
-  | SessionMessageAssistantText1
-  | SessionMessageAssistantReasoning1
+  | { type: "text"; text: string; state?: SessionMessageProviderState1 }
+  | {
+      type: "reasoning"
+      text: string
+      time?: { created: number; completed?: number }
+      state?: SessionMessageProviderState1
+    }
  | SessionMessageAssistantTool1

 export type FormInfo = { id: string; sessionID: string; title: string; metadata?: FormMetadata; fields: FormFields }
@@ -3102,11 +3098,11 @@ export type SessionImportInput = {
          readonly agent: string
          readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
          readonly content: ReadonlyArray<
-            | { readonly type: "text"; readonly text: string; readonly state?: { readonly [x: string]: JsonValue } }
+            | { readonly type: "text"; readonly text: string; readonly native?: { readonly [x: string]: JsonValue } }
            | {
                readonly type: "reasoning"
                readonly text: string
-                readonly state?: { readonly [x: string]: JsonValue }
+                readonly native?: { readonly [x: string]: JsonValue }
                readonly time?: { readonly created: number; readonly completed?: number }
              }
            | {
@@ -3180,7 +3176,7 @@ export type SessionImportInput = {
          readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
          readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
+          readonly native?: { readonly [x: string]: JsonValue }
          readonly cost?: number
          readonly tokens?: {
            readonly input: number
@@ -3214,7 +3210,7 @@ export type SessionImportInput = {
              readonly status: "completed"
              readonly reason: "auto" | "manual"
              readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string }
-              readonly providerState?: { readonly [x: string]: JsonValue }
+              readonly native?: { readonly [x: string]: JsonValue }
              readonly summary: string
              readonly recent: string
              readonly providerContext?: {
@@ -3419,11 +3415,11 @@ export type SessionImportInput = {
          readonly agent: string
          readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
          readonly content: ReadonlyArray<
-            | { readonly type: "text"; readonly text: string; readonly state?: { readonly [x: string]: JsonValue } }
+            | { readonly type: "text"; readonly text: string; readonly native?: { readonly [x: string]: JsonValue } }
            | {
                readonly type: "reasoning"
                readonly text: string
-                readonly state?: { readonly [x: string]: JsonValue }
+                readonly native?: { readonly [x: string]: JsonValue }
                readonly time?: { readonly created: number; readonly completed?: number }
              }
            | {
@@ -3497,7 +3493,7 @@ export type SessionImportInput = {
          readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
          readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
+          readonly native?: { readonly [x: string]: JsonValue }
          readonly cost?: number
          readonly tokens?: {
            readonly input: number
@@ -3531,7 +3527,7 @@ export type SessionImportInput = {
              readonly status: "completed"
              readonly reason: "auto" | "manual"
              readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string }
-              readonly providerState?: { readonly [x: string]: JsonValue }
+              readonly native?: { readonly [x: string]: JsonValue }
              readonly summary: string
              readonly recent: string
              readonly providerContext?: {
@@ -3736,11 +3732,11 @@ export type SessionImportInput = {
          readonly agent: string
          readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
          readonly content: ReadonlyArray<
-            | { readonly type: "text"; readonly text: string; readonly state?: { readonly [x: string]: JsonValue } }
+            | { readonly type: "text"; readonly text: string; readonly native?: { readonly [x: string]: JsonValue } }
            | {
                readonly type: "reasoning"
                readonly text: string
-                readonly state?: { readonly [x: string]: JsonValue }
+                readonly native?: { readonly [x: string]: JsonValue }
                readonly time?: { readonly created: number; readonly completed?: number }
              }
            | {
@@ -3814,7 +3810,7 @@ export type SessionImportInput = {
          readonly snapshot?: { readonly start?: string; readonly end?: string; readonly files?: ReadonlyArray<string> }
          readonly finish?: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
          readonly rawFinish?: string
-          readonly providerState?: { readonly [x: string]: JsonValue }
+          readonly native?: { readonly [x: string]: JsonValue }
          readonly cost?: number
          readonly tokens?: {
            readonly input: number
@@ -3848,7 +3844,7 @@ export type SessionImportInput = {
              readonly status: "completed"
              readonly reason: "auto" | "manual"
              readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string }
-              readonly providerState?: { readonly [x: string]: JsonValue }
+              readonly native?: { readonly [x: string]: JsonValue }
              readonly summary: string
              readonly recent: string
              readonly providerContext?: {
@@ -846,7 +846,7 @@ export function createData(config: CreateDataInput) {
            existing.error = undefined
            existing.finish = undefined
            existing.rawFinish = undefined
-            existing.providerState = undefined
+            existing.native = undefined
            existing.time.created = event.data.started
            existing.time.streamed = undefined
            existing.time.completed = undefined
@@ -880,7 +880,7 @@ export function createData(config: CreateDataInput) {
          assistant.time.completed = event.created
          assistant.finish = event.data.finish
          assistant.rawFinish = event.data.rawFinish
-          assistant.providerState = event.data.providerState
+          assistant.native = event.data.providerState
          assistant.cost = event.data.cost
          assistant.tokens = event.data.tokens
          if (event.data.snapshot) assistant.snapshot = { ...assistant.snapshot, end: event.data.snapshot }
@@ -892,7 +892,7 @@ export function createData(config: CreateDataInput) {
          assistant.time.completed = event.created
          assistant.finish = event.data.finish ?? "error"
          assistant.rawFinish = event.data.rawFinish
-          assistant.providerState = event.data.providerState
+          assistant.native = event.data.providerState
          assistant.error = event.data.error
          assistant.retry = undefined
          if (event.data.cost !== undefined && event.data.tokens !== undefined) {
@@ -914,6 +914,7 @@ export function createData(config: CreateDataInput) {
      case "session.text.ended":
        message.editText(event.data.sessionID, event.data.assistantMessageID, (text) => {
          text.text = event.data.text
+          text.native = event.data.state
        })
        return
      case "session.tool.input.started":
@@ -984,7 +985,7 @@ export function createData(config: CreateDataInput) {
          assistant.content.push({
            type: "reasoning",
            text: "",
-            state: event.data.state,
+            native: event.data.state,
            time: { created: event.created },
          })
        })
@@ -998,7 +999,7 @@ export function createData(config: CreateDataInput) {
        message.editReasoning(event.data.sessionID, event.data.assistantMessageID, (reasoning) => {
          reasoning.text = event.data.text
          reasoning.time = { created: reasoning.time?.created ?? event.created, completed: event.created }
-          if (event.data.state !== undefined) reasoning.state = event.data.state
+          if (event.data.state !== undefined) reasoning.native = event.data.state
        })
        return
      case "session.retry.scheduled":
@@ -1105,7 +1106,7 @@ export function createData(config: CreateDataInput) {
              status: "completed",
              reason: event.data.reason,
              model: event.data.model,
-              providerState: event.data.providerState,
+              native: event.data.providerState,
              providerContext: event.data.providerContext,
              summary: event.data.text,
              recent: event.data.recent,
@@ -1120,7 +1121,7 @@ export function createData(config: CreateDataInput) {
            status: "completed",
            reason: event.data.reason,
            model: event.data.model,
-            providerState: event.data.providerState,
+            native: event.data.providerState,
            providerContext: event.data.providerContext,
            summary: event.data.text,
            recent: event.data.recent,
@@ -135,7 +135,7 @@ test.each(["started", "cancelled", "failed"])(
          status: "completed",
          summary: "Summary",
          model,
-          providerState,
+          native: providerState,
          providerContext,
          cost: 0.01,
          tokens,
@@ -379,13 +379,13 @@ export function transformSession(input: TransformInput): TransformResult {
        return []
      const content = owned.flatMap((part): Array<Record<string, unknown>> => {
        if (part.type === "text")
-          return [{ type: "text", text: part.text, ...(part.metadata ? { state: part.metadata } : {}) }]
+          return [{ type: "text", text: part.text, ...(part.metadata ? { native: part.metadata } : {}) }]
        if (part.type === "reasoning")
          return [
            {
              type: "reasoning",
              text: part.text,
-              ...(part.metadata ? { state: part.metadata } : {}),
+              ...(part.metadata ? { native: part.metadata } : {}),
              time: { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) },
            },
          ]
@@ -60,7 +60,7 @@ export const latestCompaction = Effect.fnUntraced(function* (
 })

 export const decodeMessageRow = (row: typeof SessionMessageTable.$inferSelect) =>
-  decode({ ...row.data, id: row.id, type: row.type }).pipe(
+  decode(SessionMessage.persisted({ ...row.data, id: row.id, type: row.type })).pipe(
    Effect.tap((message) =>
      SessionProviderContext.isCheckpoint(message)
        ? SessionProviderContext.validate(message.providerContext)
@@ -125,7 +125,7 @@ const promotedFromMessage = Effect.fn("SessionInbox.promotedFromMessage")(functi
  if (row === undefined) return undefined
  if (row.session_id !== sessionID || (row.type !== "user" && row.type !== "synthetic"))
    return yield* new LifecycleConflict({ id })
-  const message = decodeMessage({ ...row.data, id: row.id, type: row.type })
+  const message = decodeMessage(SessionMessage.persisted({ ...row.data, id: row.id, type: row.type }))
  const base = { id, sessionID, time: { created: message.time.created }, delivery }
  if (message.type === "user")
    return User.make({
@@ -83,7 +83,9 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
      "session.message.content.updated": (event) =>
        updateOwnedAssistant(event.data.messageID, (draft) => {
          draft.content = castDraft(
-            Schema.decodeUnknownSync(Schema.Array(SessionMessage.AssistantContent))(event.data.content),
+            Schema.decodeUnknownSync(Schema.Array(SessionMessage.AssistantContent))(
+              SessionMessage.persistedContent(event.data.content),
+            ),
          )
        }),
      "session.usage.recorded": () => Effect.void,
@@ -222,7 +224,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                draft.error = undefined
                draft.finish = undefined
                draft.rawFinish = undefined
-                draft.providerState = undefined
+                draft.native = undefined
                draft.time.created = DateTime.makeUnsafe(event.data.started)
                draft.time.streamed = undefined
                draft.time.completed = undefined
@@ -263,7 +265,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
          draft.time.completed = created
          draft.finish = event.data.finish
          draft.rawFinish = event.data.rawFinish
-          draft.providerState = castDraft(event.data.providerState)
+          draft.native = castDraft(event.data.providerState)
          draft.cost = event.data.cost
          draft.tokens = event.data.tokens
          projectTerminalSnapshot(draft, event)
@@ -274,7 +276,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
          draft.time.completed = created
          draft.finish = event.data.finish ?? "error"
          draft.rawFinish = event.data.rawFinish
-          draft.providerState = castDraft(event.data.providerState)
+          draft.native = castDraft(event.data.providerState)
          draft.error = castDraft(event.data.error)
          draft.retry = undefined
          if (event.data.cost !== undefined && event.data.tokens !== undefined) {
@@ -294,7 +296,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
          const match = latestText(draft)
          if (match) {
            match.text = event.data.text
-            match.state = castDraft(event.data.state)
+            match.native = castDraft(event.data.state)
          }
        })
      },
@@ -382,7 +384,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
              SessionMessage.AssistantReasoning.make({
                type: "reasoning",
                text: "",
-                state: event.data.state,
+                native: event.data.state,
                time: { created },
              }),
            ),
@@ -395,7 +397,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
          if (match) {
            match.text = event.data.text
            match.time = { created: match.time?.created ?? created, completed: created }
-            if (event.data.state !== undefined) match.state = event.data.state
+            if (event.data.state !== undefined) match.native = event.data.state
          }
        })
      },
@@ -431,7 +433,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
              metadata: event.metadata ? { ...current.metadata, ...event.metadata } : current.metadata,
              reason: event.data.reason,
              model: event.data.model,
-              providerState: event.data.providerState,
+              native: event.data.providerState,
              summary: event.data.text,
              providerContext: event.data.providerContext,
              recent: event.data.recent,
@@ -448,7 +450,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
              metadata: event.metadata,
              reason: event.data.reason,
              model: event.data.model,
-              providerState: event.data.providerState,
+              native: event.data.providerState,
              summary: event.data.text,
              providerContext: event.data.providerContext,
              recent: event.data.recent,
@@ -228,7 +228,7 @@ const projectFork = Effect.fn("SessionProjector.projectFork")(function* (
 function run(db: DatabaseService, event: MessageEvent) {
  return Effect.gen(function* () {
    const decodeRow = (row: typeof SessionMessageTable.$inferSelect) =>
-      decodeMessage({ ...row.data, id: row.id, type: row.type })
+      decodeMessage(SessionMessage.persisted({ ...row.data, id: row.id, type: row.type }))
    const updateMessage = (message: SessionMessage.Info) => {
      const encoded = encodeMessage(message)
      const { id, type, ...data } = encoded
@@ -107,7 +107,9 @@ const plan = Effect.fn("SessionRevert.plan")(function* (db: Database.Interface["
  const decode = Schema.decodeUnknownEffect(SessionMessage.Info)
  const files = new Map<RelativePath, Snapshot.ID>()
  for (const row of rows) {
-    const message = yield* decode({ ...row.data, id: row.id, type: row.type }).pipe(Effect.orDie)
+    const message = yield* decode(SessionMessage.persisted({ ...row.data, id: row.id, type: row.type })).pipe(
+      Effect.orDie,
+    )
    if (message.type !== "assistant" || !message.snapshot?.start) continue
    for (const file of message.snapshot.files ?? [])
      if (!files.has(file)) files.set(file, Snapshot.ID.make(message.snapshot.start))
@@ -162,7 +162,7 @@ const assistant = (message: SessionMessage.Assistant, model: Model.Ref, provider
          text: item.text,
          // Text can carry provider-bound state (e.g. Gemini thought signatures),
          // which is only replayable against the model that produced it.
-          providerMetadata: reuseProviderMetadata ? providerMetadata(providerMetadataKey, item.state) : undefined,
+          providerMetadata: reuseProviderMetadata ? providerMetadata(providerMetadataKey, item.native) : undefined,
        },
      ]
    // Let the destination adapter handle readable reasoning after a model/provider switch.
@@ -172,7 +172,7 @@ const assistant = (message: SessionMessage.Assistant, model: Model.Ref, provider
            {
              type: "reasoning",
              text: item.text,
-              providerMetadata: providerMetadata(providerMetadataKey, item.state),
+              providerMetadata: providerMetadata(providerMetadataKey, item.native),
            },
          ]
        : item.text.length > 0
@@ -269,13 +269,13 @@ function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info {
          return {
            ...content,
            text: redact("text", message.id, content.text),
-            state: content.state ? { redacted: `text-state:${message.id}` } : undefined,
+            native: content.native ? { redacted: `text-native:${message.id}` } : undefined,
          }
        if (content.type === "reasoning")
          return {
            ...content,
            text: redact("reasoning", message.id, content.text),
-            state: content.state ? { redacted: `reasoning-state:${message.id}` } : undefined,
+            native: content.native ? { redacted: `reasoning-native:${message.id}` } : undefined,
          }
        return {
          ...content,
@@ -299,7 +299,7 @@ function sanitizeMessage(message: SessionMessage.Info): SessionMessage.Info {
      summary: redact("compaction-summary", message.id, message.summary),
      recent: redact("compaction-recent", message.id, message.recent),
      ...(message.status === "completed"
-        ? { providerState: metadata("compaction-provider-state", message.id, message.providerState) }
+        ? { native: metadata("compaction-native", message.id, message.native) }
        : {}),
    }
  }
@@ -422,15 +422,6 @@ describe("MCP OAuth", () => {
    expect(tokenRequests[0]?.get("grant_type")).toBe("refresh_token")
  })

-  test("requests offline_access without forcing a consent prompt", async () => {
-    const { server } = authorizationServer({ scopes_supported: ["read", "offline_access"] })
-    const { url } = await Effect.runPromise(
-      Effect.scoped(start(server, { client_id: "client", scope: "read" })),
-    ).finally(() => server.stop(true))
-    expect(url.searchParams.get("scope")).toBe("read offline_access")
-    expect(url.searchParams.has("prompt")).toBe(false)
-  })
-
  test("forwards iss from the redirect so issuer-advertising servers can complete", async () => {
    const { server } = authorizationServer({ authorization_response_iss_parameter_supported: true })
    const result = await Effect.runPromise(
@@ -1272,7 +1272,7 @@ describe("SessionTransfer", () => {
      const runningCompactionID = SessionMessage.ID.create()
      const completedCompactionID = SessionMessage.ID.create()
      const model = Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") })
-      const providerState = { responseId: "summary-response" }
+      const native = { responseId: "summary-response" }

      yield* transfer.import({
        data: {
@@ -1328,7 +1328,7 @@ describe("SessionTransfer", () => {
              status: "completed",
              reason: "manual",
              model,
-              providerState,
+              native,
              summary: "summary",
              recent: "recent",
              time: { created: DateTime.makeUnsafe(9) },
@@ -1345,10 +1345,10 @@ describe("SessionTransfer", () => {
        completedCompactionID,
      ])
      expect(yield* Bus.latestSequence(db, sessionID)).toBe(4)
-      expect((yield* transfer.export({ sessionID })).messages.at(-1)).toMatchObject({ model, providerState })
+      expect((yield* transfer.export({ sessionID })).messages.at(-1)).toMatchObject({ model, native })
      expect((yield* transfer.export({ sessionID, sanitize: true })).messages.at(-1)).toMatchObject({
        model,
-        providerState: { redacted: `compaction-provider-state:${completedCompactionID}` },
+        native: { redacted: `compaction-native:${completedCompactionID}` },
      })
    }),
  )
@@ -426,7 +426,7 @@ it.live("compaction hooks supply the summary instead of provider compaction", ()
      status: "completed",
      summary: "## Objective\n- hooked summary",
      recent: "",
-      providerState: { responseId: "plugin" },
+      native: { responseId: "plugin" },
      metadata: { plugin: "custom" },
      tokens: { input: 10, output: 5 },
    })
@@ -690,7 +690,7 @@ describe("SessionProjector", () => {
        type: "assistant",
        finish: "stop",
        rawFinish: "stop_sequence",
-        providerState: { response: "ended" },
+        native: { response: "ended" },
        cost: Money.USD.make(1),
        tokens: { input: 2, output: 3, reasoning: 4, cache: { read: 5, write: 6 } },
        snapshot: { end: "snap_ended", files: ["src/ended.ts"] },
@@ -700,7 +700,7 @@ describe("SessionProjector", () => {
        type: "assistant",
        finish: "content-filter",
        rawFinish: "blocked",
-        providerState: { response: "failed" },
+        native: { response: "failed" },
        error: { type: "provider.invalid-request", message: "Failed" },
        snapshot: { end: "snap_failed", files: ["src/failed.ts"] },
        time: { completed: created },
@@ -72,7 +72,7 @@ describe("toLLMMessages", () => {
          SessionMessage.AssistantReasoning.make({
            type: "reasoning",
            text: "",
-            state: { signature: "sig_1" },
+            native: { signature: "sig_1" },
          }),
        ]),
      ],
@@ -711,7 +711,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
-              state: { signature: "sig_1" },
+              native: { signature: "sig_1" },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
@@ -860,7 +860,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
-              state: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
+              native: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
            }),
          ],
          time: { created, completed: created },
@@ -891,7 +891,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Think",
-              state: { signature: "signed" },
+              native: { signature: "signed" },
            }),
          ],
          time: { created, completed: created },
@@ -918,7 +918,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Partial thought",
-              state: { itemId: "rs_failed", reasoningEncryptedContent: null },
+              native: { itemId: "rs_failed", reasoningEncryptedContent: null },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
@@ -1016,7 +1016,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Visible thought",
-              state: { signature: "sig_old" },
+              native: { signature: "sig_old" },
            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
@@ -1110,7 +1110,7 @@ Recent work
            SessionMessage.AssistantReasoning.make({
              type: "reasoning",
              text: "Visible thought",
-              state: { reasoningEncryptedContent: "encrypted" },
+              native: { reasoningEncryptedContent: "encrypted" },
            }),
          ],
          time: { created, completed: created },
@@ -1140,7 +1140,7 @@ Recent work
            SessionMessage.AssistantText.make({
              type: "text",
              text: "Checking.",
-              state: { phase: "commentary" },
+              native: { phase: "commentary" },
            }),
          ],
          error: { type: "provider.unknown", message: "Interrupted after commentary" },
@@ -1171,7 +1171,7 @@ Recent work
            SessionMessage.AssistantText.make({
              type: "text",
              text: "Checking.",
-              state: { phase: "commentary" },
+              native: { phase: "commentary" },
            }),
          ],
          time: { created, completed: created },
@@ -2558,7 +2558,7 @@ describe("SessionRunnerLLM", () => {
        expect(s.executions).toEqual(["x".repeat(4_000)])
        expect((yield* s.messages).find((message) => message.type === "compaction")).toMatchObject({
          model: { id: s.currentModel.id, providerID: s.currentModel.provider, variant },
-          providerState: { responseId: "summary" },
+          native: { responseId: "summary" },
        })

        // Compare wire content without the cache breakpoints that move to the new final message.
@@ -3508,12 +3508,12 @@ describe("SessionRunnerLLM", () => {
        {
          type: "reasoning",
          text: "Signed thought",
-          state: { signature: "sig_1" },
+          native: { signature: "sig_1" },
        },
        {
          type: "reasoning",
          text: "Encrypted thought",
-          state: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
+          native: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" },
        },
      ]),
    ])
@@ -3565,7 +3565,7 @@ describe("SessionRunnerLLM", () => {
        {
          type: "reasoning",
          text: "thinking",
-          state: { reasoningField: "reasoning", reasoningDetails: details },
+          native: { reasoningField: "reasoning", reasoningDetails: details },
        },
        { type: "text", text: "Hello world" },
      ]),
@@ -3609,7 +3609,7 @@ describe("SessionRunnerLLM", () => {
    expect(yield* s.context).toMatchObject([
      Expected.user("Check first"),
      Expected.assistant({}, [
-        { type: "text", text: "Checking.", state: { itemId: "msg_commentary", phase: "commentary" } },
+        { type: "text", text: "Checking.", native: { itemId: "msg_commentary", phase: "commentary" } },
      ]),
    ])

@@ -4966,7 +4966,7 @@ describe("SessionRunnerLLM", () => {
        type: "assistant",
        finish: "stop",
        rawFinish: "end_turn",
-        providerState: { responseId: "response-1", serviceTier: "priority" },
+        native: { responseId: "response-1", serviceTier: "priority" },
        content: [Expected.text("Complete")],
      },
    ])
@@ -4997,7 +4997,7 @@ describe("SessionRunnerLLM", () => {
        type: "assistant",
        finish: "content-filter",
        rawFinish: "SAFETY",
-        providerState: {
+        native: {
          responseId: "response-blocked",
          refusal: { category: "safety", explanation: "Prompt blocked" },
        },
@@ -5444,7 +5444,7 @@ describe("SessionRunnerLLM", () => {
          {
            type: "reasoning",
            text: "",
-            state: { itemId: "rs_disconnected", reasoningEncryptedContent: "encrypted-state" },
+            native: { itemId: "rs_disconnected", reasoningEncryptedContent: "encrypted-state" },
          },
        ]),
        { type: "synthetic", text: INCOMPLETE_STREAM_CONTINUATION },
@@ -337,8 +337,8 @@ describe("V1Migration.transformSession", () => {
      agent: "build",
      model: { id: "model", providerID: "provider", variant: "fast" },
      content: [
-        { type: "text", text: "", state: { separator: true } },
-        { type: "reasoning", text: "think", state: { provider: 1 }, time: { created: 21, completed: 22 } },
+        { type: "text", text: "", native: { separator: true } },
+        { type: "reasoning", text: "think", native: { provider: 1 }, time: { created: 21, completed: 22 } },
      ],
      snapshot: { start: "snap_start", end: "snap_end", files: ["a.ts", "b.ts", "c.ts"] },
      finish: "stop",
@@ -45,10 +45,6 @@ function selectOptions(): DevOptions {
 async function prepareServer(source: ServerSource) {
  if (source.type === "download")
    return downloadCliToResources(source.version, windowsify("resources/opencode-cli-dev"))
-  await $`bun run --cwd ${join(import.meta.dirname, "../../app")} build`.env({
-    ...process.env,
-    VITE_OPENCODE_SERVER_MODE: "origin",
-  })
  process.env.OPENCODE_DESKTOP_CLI_DEV = join(import.meta.dirname, "../../cli")
  await $`bun run --cwd ${process.env.OPENCODE_DESKTOP_CLI_DEV} --define=OPENCODE_VERSION=${JSON.stringify(process.env.OPENCODE_VERSION)} src/index.ts --version`
  if (process.platform !== "win32") return
@@ -5,7 +5,6 @@ import { AppRpcs } from "../../shared/ipc-rpc"
 import { openExternalURL } from "../files"
 import { checkAppExists, resolveAppPath } from "../files/apps"
 import { setForceFocus } from "../native/debug"
-import { createScreenActivity } from "../native/screen-activity"
 import { showCliInstaller } from "../native/install-cli"
 import { DesktopLogging, scoped } from "../native/logging"
 import { createMenu, sendMenuCommand } from "../native/menu"
@@ -18,8 +17,6 @@ import { DesktopCli } from "../service/desktop-cli"
 import { SidecarCredentials } from "../service/sidecar-credentials"
 import { getDefaultServerUrl, setDefaultServerUrl } from "../service/server-settings"
 import { Updater } from "../updater"
-import { DesktopStorage } from "../storage"
-import { createPairing } from "../service/pairing"
 import { getLastFocusedWindow, setBackgroundColor } from "../windows"
 import { sender } from "./context"

@@ -31,10 +28,6 @@ export const appHandlers = AppRpcs.toLayer(
    const desktopCli = yield* DesktopCli.Service
    const updater = yield* Updater.Service
    const logging = yield* DesktopLogging.Service
-    const storage = yield* DesktopStorage.Service
-    const screenActivity = createScreenActivity(storage)
-    yield* Effect.addFinalizer(() => Effect.sync(screenActivity.dispose))
-    const pairing = createPairing()
    const runFork = Effect.runForkWith(yield* Effect.context())
    return AppRpcs.of({
      AppAwaitInitialization: () => background.connection.pipe(Effect.map(SidecarCredentials.ready)),
@@ -75,10 +68,6 @@ export const appHandlers = AppRpcs.toLayer(
          })
        }),
      AppRelaunch: () => Effect.sync(lifecycle.relaunch),
-      AppPairInfo: () => pair(pairing.info),
-      AppGetKeepScreenActive: () => Effect.sync(screenActivity.get),
-      AppSetKeepScreenActive: ({ enabled }) =>
-        Effect.try(() => screenActivity.set(enabled)).pipe(Effect.mapError(String)),
    })
  }),
 )
@@ -86,10 +75,3 @@ export const appHandlers = AppRpcs.toLayer(
 function promise<A>(evaluate: () => A | Promise<A>) {
  return Effect.tryPromise(async () => evaluate()).pipe(Effect.orDie)
 }
-
-function pair<A>(evaluate: () => Promise<A>) {
-  return Effect.tryPromise({
-    try: evaluate,
-    catch: (cause) => (cause instanceof Error ? cause.message : String(cause)),
-  })
-}
@@ -1,25 +0,0 @@
-import { powerSaveBlocker } from "electron"
-import type { DesktopStorage } from "../storage"
-import { KEEP_SCREEN_ACTIVE_KEY, SETTINGS_STORE } from "../storage/keys"
-
-export function createScreenActivity(storage: DesktopStorage.Interface) {
-  const state = { blocker: undefined as number | undefined }
-  const dispose = () => {
-    if (state.blocker === undefined) return
-    powerSaveBlocker.stop(state.blocker)
-    state.blocker = undefined
-  }
-  const set = (enabled: boolean) => {
-    if (enabled && state.blocker === undefined) {
-      state.blocker = powerSaveBlocker.start("prevent-display-sleep")
-    }
-    if (!enabled) dispose()
-    storage.state.set(SETTINGS_STORE, KEEP_SCREEN_ACTIVE_KEY, JSON.stringify(enabled))
-  }
-  if (storage.state.get(SETTINGS_STORE, KEEP_SCREEN_ACTIVE_KEY) === "true") set(true)
-  return {
-    get: () => state.blocker !== undefined && powerSaveBlocker.isStarted(state.blocker),
-    set,
-    dispose,
-  }
-}
@@ -44,7 +44,7 @@ const connect = Effect.fn("BackgroundService.connect")(function* (mode: "initial
          ? path.join(app.getPath("userData"), "opencode", "service-local.json")
          : undefined,
      version,
-      command: [...cli.command, "serve", "--service", ...(isolated ? ["--hostname", "0.0.0.0", "--port", "0"] : [])],
+      command: [...cli.command, "serve", "--service", ...(isolated ? ["--port", "0"] : [])],
      onStart: (reason, previousVersion) =>
        runFork(Effect.logInfo("v2 CLI background service starting", { reason, previousVersion })),
    })
@@ -1,21 +0,0 @@
-import { SidecarCredentials } from "./sidecar-credentials"
-
-export function createPairing() {
-  const requireCredentials = () => {
-    const credentials = SidecarCredentials.get()
-    if (!credentials) throw new Error("The local desktop server is not ready")
-    return credentials
-  }
-  const readInfo = async (credentials: ReturnType<typeof requireCredentials>) => {
-    const { OpenCode } = await import("@opencode/client/promise")
-    const info = await OpenCode.make({
-      baseUrl: credentials.url,
-      headers: credentials.password
-        ? { Authorization: `Basic ${Buffer.from(`opencode:${credentials.password}`).toString("base64")}` }
-        : undefined,
-    }).server.info()
-    return { urls: info.urls, username: "opencode" as const, password: credentials.password ?? "" }
-  }
-  const info = () => readInfo(requireCredentials())
-  return { info }
-}
@@ -3,7 +3,6 @@ export const DEFAULT_SERVER_URL_KEY = "defaultServerUrl"
 export const FIRST_LAUNCH_ONBOARDING_COMPLETE_KEY = "firstLaunchOnboardingComplete"
 export const WSL_SERVERS_KEY = "wslServers"
 export const PINCH_ZOOM_ENABLED_KEY = "pinchZoomEnabled"
-export const KEEP_SCREEN_ACTIVE_KEY = "keepScreenActive"
 export const BACKGROUND_COLOR_KEY = "backgroundColor"
 export const WINDOW_IDS_KEY = "windowIds"
 export const BUNDLED_CLI_VERSION_KEY = "bundledCliVersion"
@@ -16,7 +16,6 @@ import type {
  ServerReadyData,
  TitlebarTheme,
 } from "../shared/ipc-contract"
-import type { PairingInfo } from "../shared/ipc-rpc/app"

 export type WslServersAPI = WslServersPlatform
 export type UpdaterAPI = {
@@ -90,7 +89,4 @@ export type ElectronAPI = {
  setForceFocus(enabled: boolean): Promise<void>
  recordFatalRendererError(error: FatalRendererError): Promise<void>
  setNativeTranslations(bundle: DesktopNativeBundle): Promise<void>
-  pairInfo(): Promise<typeof PairingInfo.Type>
-  getKeepScreenActive(): Promise<boolean>
-  setKeepScreenActive(enabled: boolean): Promise<void>
 }
@@ -161,7 +161,4 @@ export const api: ElectronAPI = {
  setForceFocus: (enabled) => invoke("AppSetForceFocus", { enabled }),
  recordFatalRendererError: (error) => invoke("AppRecordFatalRendererError", { error }),
  setNativeTranslations: (bundle) => invoke("AppSetNativeTranslations", { value: bundle }),
-  pairInfo: () => invoke("AppPairInfo").then(mutable),
-  getKeepScreenActive: () => invoke("AppGetKeepScreenActive"),
-  setKeepScreenActive: (enabled) => invoke("AppSetKeepScreenActive", { enabled }),
 }
@@ -79,8 +79,6 @@ export function createDesktopPlatform(
    windowFullscreen,
    getPinchZoomEnabled: () => api.getPinchZoomEnabled(),
    setPinchZoomEnabled,
-    getKeepScreenActive: () => api.getKeepScreenActive(),
-    setKeepScreenActive: (enabled) => api.setKeepScreenActive(enabled),
    onDragCancel: (callback) => {
      window.addEventListener(DragCancelEvent, callback)
      return () => window.removeEventListener(DragCancelEvent, callback)
@@ -89,9 +87,6 @@ export function createDesktopPlatform(
    checkAppExists: async (appName) => {
      return api.checkAppExists(appName)
    },
-    pair: {
-      info: () => api.pairInfo(),
-    },
  }
 }

@@ -5,12 +5,6 @@ const ServerReadyData = Schema.Struct({
  url: Schema.String,
 })

-export const PairingInfo = Schema.Struct({
-  urls: Schema.Array(Schema.String),
-  username: Schema.Literal("opencode"),
-  password: Schema.String,
-})
-
 export const AppAwaitInitialization = Rpc.make("AppAwaitInitialization", { success: ServerReadyData })
 export const AppReconnectService = Rpc.make("AppReconnectService", { success: ServerReadyData })
 export const AppConsumeInitialDeepLinks = Rpc.make("AppConsumeInitialDeepLinks", {
@@ -59,12 +53,6 @@ export const AppSetNativeTranslations = Rpc.make("AppSetNativeTranslations", {
  payload: { value: Schema.Unknown },
 })
 export const AppRelaunch = Rpc.make("AppRelaunch")
-export const AppPairInfo = Rpc.make("AppPairInfo", { success: PairingInfo, error: Schema.String })
-export const AppGetKeepScreenActive = Rpc.make("AppGetKeepScreenActive", { success: Schema.Boolean })
-export const AppSetKeepScreenActive = Rpc.make("AppSetKeepScreenActive", {
-  payload: { enabled: Schema.Boolean },
-  error: Schema.String,
-})
 export const AppRpcs = RpcGroup.make(
  AppAwaitInitialization,
  AppReconnectService,
@@ -81,7 +69,4 @@ export const AppRpcs = RpcGroup.make(
  AppRecordFatalRendererError,
  AppSetNativeTranslations,
  AppRelaunch,
-  AppPairInfo,
-  AppGetKeepScreenActive,
-  AppSetKeepScreenActive,
 )
@@ -17320,7 +17320,7 @@
          "rawFinish": {
            "type": "string"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_4"
          },
          "cost": {
@@ -17349,7 +17349,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_1"
          },
          "time": {
@@ -17396,7 +17396,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState"
          }
        },
@@ -17509,7 +17509,7 @@
          "model": {
            "$ref": "#/components/schemas/Model.Ref"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_5"
          },
          "summary": {
@@ -601,7 +601,7 @@ export namespace Compaction {
      ...Base,
      reason: Started.data.fields.reason,
      model: SessionMessage.CompactionCompleted.fields.model,
-      providerState: SessionMessage.CompactionCompleted.fields.providerState,
+      providerState: SessionMessage.CompactionCompleted.fields.native,
      providerContext: SessionMessage.CompactionCompleted.fields.providerContext,
      text: Schema.String,
      recent: Schema.String,
@@ -1,6 +1,6 @@
 export * as SessionMessage from "./session-message.js"

-import { Schema } from "effect"
+import { Predicate, Schema, Struct } from "effect"
 import { SessionProviderContext } from "./session-provider-context.js"
 import { optional } from "./schema.js"
 import { Content } from "./tool.js"
@@ -177,14 +177,14 @@ export interface AssistantText extends Schema.Schema.Type<typeof AssistantText>
 export const AssistantText = Schema.Struct({
  type: Schema.tag("text"),
  text: Schema.String,
-  state: ProviderState.pipe(optional),
+  native: ProviderState.pipe(optional),
 }).annotate({ identifier: "Session.Message.Assistant.Text" })

 export interface AssistantReasoning extends Schema.Schema.Type<typeof AssistantReasoning> {}
 export const AssistantReasoning = Schema.Struct({
  type: Schema.tag("reasoning"),
  text: Schema.String,
-  state: ProviderState.pipe(optional),
+  native: ProviderState.pipe(optional),
  time: Schema.Struct({
    created: DateTimeUtcFromMillis,
    completed: DateTimeUtcFromMillis.pipe(optional),
@@ -196,7 +196,18 @@ export const AssistantContent = Schema.Union([AssistantText, AssistantReasoning,
 )
 export type AssistantContent = AssistantText | AssistantReasoning | AssistantTool

-export const AssistantContentEncoded = Schema.toEncoded(AssistantContent).annotate({
+/**
+ * Frozen at the shape older releases stored: text and reasoning carried their
+ * provider blob as `state`. Only replayed durable events still use it; read it
+ * through `persistedContent` before decoding as `AssistantContent`.
+ */
+export const AssistantContentEncoded = Schema.toEncoded(
+  Schema.Union([
+    Schema.Struct({ ...Struct.omit(AssistantText.fields, ["native"]), state: ProviderState.pipe(optional) }),
+    Schema.Struct({ ...Struct.omit(AssistantReasoning.fields, ["native"]), state: ProviderState.pipe(optional) }),
+    AssistantTool,
+  ]).pipe(Schema.toTaggedUnion("type")),
+).annotate({
  identifier: "Session.Message.AssistantContent.Encoded",
 })
 export type AssistantContentEncoded = typeof AssistantContentEncoded.Type
@@ -222,7 +233,7 @@ export const Assistant = Schema.Struct({
  }).pipe(optional),
  finish: FinishReason.pipe(optional),
  rawFinish: Schema.String.pipe(optional),
-  providerState: ProviderState.pipe(optional),
+  native: ProviderState.pipe(optional),
  cost: Money.USD.pipe(optional),
  tokens: TokenUsage.Info.pipe(optional),
  error: SessionError.Error.pipe(optional),
@@ -258,7 +269,7 @@ export const CompactionCompleted = Schema.Struct({
  status: Schema.tag("completed"),
  reason: Schema.Literals(["auto", "manual"]),
  model: Model.Ref.pipe(optional),
-  providerState: ProviderState.pipe(optional),
+  native: ProviderState.pipe(optional),
  summary: Schema.String,
  recent: Schema.String,
  providerContext: SessionProviderContext.Info.pipe(optional),
@@ -318,3 +329,29 @@ export type Info =
  | Compaction
  | Idle
 export type Type = Info["type"]
+
+/** Reads messages stored before provider blobs were renamed to `native`. Tool parts are unchanged. */
+export function persisted(input: unknown) {
+  if (!Predicate.isObject(input)) return input
+  const message =
+    input.type === "assistant" || input.type === "compaction" ? rename(input, "providerState", "native") : input
+  if (message.type !== "assistant" || !Array.isArray(message.content)) return message
+  const content = persistedContent(message.content)
+  return content === message.content ? message : { ...message, content }
+}
+
+/** Reads assistant content stored before text and reasoning blobs were renamed to `native`. */
+export function persistedContent(content: ReadonlyArray<unknown>) {
+  const next = content.map((part) => {
+    if (!Predicate.isObject(part) || (part.type !== "text" && part.type !== "reasoning")) return part
+    return rename(part, "state", "native")
+  })
+  return next.every((part, index) => part === content[index]) ? content : next
+}
+
+function rename(record: Record<string, unknown>, from: string, to: string) {
+  if (record[from] === undefined || record[to] !== undefined) return record
+  const value = record[from]
+  const rest = Object.fromEntries(Object.entries(record).filter(([key]) => key !== from))
+  return { ...rest, [to]: value }
+}
@@ -257,8 +257,8 @@ describe("contract hygiene", () => {
      text: "hello",
    })
    expect(
-      SessionMessage.AssistantReasoning.make({ type: "reasoning", text: "thinking", state: { id: "opaque" } }),
-    ).toEqual({ type: "reasoning", text: "thinking", state: { id: "opaque" } })
+      SessionMessage.AssistantReasoning.make({ type: "reasoning", text: "thinking", native: { id: "opaque" } }),
+    ).toEqual({ type: "reasoning", text: "thinking", native: { id: "opaque" } })
    expect(
      SessionMessage.AssistantTool.make({
        type: "tool",
@@ -23,14 +23,48 @@ test("assistant terminal diagnostics remain optional and round trip", () => {
        ...assistant,
        finish: "content-filter",
        rawFinish: "SAFETY",
-        providerState: { promptFeedback: { blockReason: "SAFETY" } },
+        native: { promptFeedback: { blockReason: "SAFETY" } },
      }),
    ),
  ).toMatchObject({
    finish: "content-filter",
    rawFinish: "SAFETY",
-    providerState: { promptFeedback: { blockReason: "SAFETY" } },
+    native: { promptFeedback: { blockReason: "SAFETY" } },
  })
+  const legacy = SessionMessage.persisted({
+    ...assistant,
+    providerState: { promptFeedback: { blockReason: "SAFETY" } },
+    content: [{ type: "text", text: "hello", state: { signature: "sig" } }],
+  })
+  expect(decode(legacy)).toMatchObject({
+    native: { promptFeedback: { blockReason: "SAFETY" } },
+    content: [{ type: "text", native: { signature: "sig" } }],
+  })
+  expect(encode(decode(legacy))).not.toHaveProperty("providerState")
+  expect(SessionMessage.persisted(assistant)).toBe(assistant)
+})
+
+test("replayed content updates keep the stored provider blob shape", () => {
+  const content = [
+    { type: "text", text: "hello", state: { signature: "sig" } },
+    { type: "reasoning", text: "think", state: { id: "rs_1" }, time: { created: 1 } },
+    { type: "tool", id: "call", name: "read", state: { status: "streaming", input: "" }, time: { created: 1 } },
+  ] as const
+  const decoded = Schema.decodeUnknownSync(SessionEvent.MessageContentUpdated.data)({
+    sessionID: "ses_terminal",
+    messageID: "msg_terminal",
+    content,
+  })
+  expect(decoded.content).toEqual(content)
+  expect(
+    Schema.decodeUnknownSync(Schema.Array(SessionMessage.AssistantContent))(
+      SessionMessage.persistedContent(decoded.content),
+    ),
+  ).toMatchObject([
+    { type: "text", native: { signature: "sig" } },
+    { type: "reasoning", native: { id: "rs_1" } },
+    { type: "tool", state: { status: "streaming" } },
+  ])
 })

 test("failed steps only override the assistant finish for content filters", () => {
@@ -8,7 +8,14 @@ import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty"
 import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty"
 import { Global } from "@opencode/util/global"
 import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect"
-import { HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import {
+  HttpMiddleware,
+  HttpPlatform,
+  HttpRouter,
+  HttpServer,
+  HttpServerRequest,
+  HttpServerResponse,
+} from "effect/unstable/http"
 import { createServer } from "node:http"
 import { ServerAuth } from "./auth"
 import { isAllowedCorsOrigin } from "./cors"
@@ -61,17 +68,15 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
    return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname)
  }
  const application = yield* Ref.make(Option.none<App>())
-  const app = dispatch(password, status, application, options.app?.version ?? "unknown", urls, Global.Path.tmp)
  // Request fibers may continue inbound trace context, but must not inherit the server startup parent.
  yield* bound.http
    .serve(
-      (transform ? transform(app) : app).pipe(
-        HttpMiddleware.compression(),
+      dispatch(password, status, application, options.app?.version ?? "unknown", urls, Global.Path.tmp).pipe(
        HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86_400 }),
      ),
      errorResponseLogger,
    )
-    .pipe(Effect.provide(NodeHttpServer.layerHttpServices), withoutParentSpan)
+    .pipe(withoutParentSpan)
  if (lifecycle)
    yield* lifecycle.onListen(bound.http.address, shutdown.open.pipe(Effect.asVoid)).pipe(
      Effect.flatMap((cleanup) =>
@@ -105,7 +110,13 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
        Effect.provideService(Scope.Scope, applicationScope),
      )
    }
-    yield* Ref.set(application, Option.some(Context.get(context, HttpRouter.HttpRouter).asHttpEffect()))
+    const app = Context.get(context, HttpRouter.HttpRouter)
+      .asHttpEffect()
+      .pipe(
+        HttpMiddleware.compression(),
+        Effect.provideService(HttpPlatform.HttpPlatform, Context.get(context, HttpPlatform.HttpPlatform)),
+      )
+    yield* Ref.set(application, Option.some(transform ? transform(app) : app))
    yield* status.ready
    const bus = Context.get(context, Bus.Service)
    return {
@@ -1,10 +1,10 @@
 import { expect } from "bun:test"
 import { Effect } from "effect"
-import { HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import { HttpServer, HttpServerError, HttpServerResponse } from "effect/unstable/http"
 import { it } from "../../core/test/lib/effect"
 import { ServerProcess } from "../src/process"

-it.live("authenticates API requests behind the frontend transform while allowing browser preflight", () =>
+it.live("authenticates API and frontend requests while allowing browser preflight", () =>
  Effect.gen(function* () {
    const fallback = "fallback".repeat(256)
    const server = yield* ServerProcess.start<never, never>(
@@ -18,13 +18,12 @@ it.live("authenticates API requests behind the frontend transform while allowing
      },
      undefined,
      (api) =>
-        Effect.gen(function* () {
-          const request = yield* HttpServerRequest.HttpServerRequest
-          const url = new URL(request.url, "http://localhost")
-          if (url.pathname === "/api" || url.pathname.startsWith("/api/") || url.pathname === "/openapi.json")
-            return yield* api
-          return HttpServerResponse.raw(fallback, { contentType: "text/plain" })
-        }),
+        api.pipe(
+          Effect.catchIf(
+            (error) => error instanceof HttpServerError.HttpServerError && error.reason._tag === "RouteNotFound",
+            () => Effect.succeed(HttpServerResponse.raw(fallback, { contentType: "text/plain" })),
+          ),
+        ),
    )
    const response = yield* Effect.promise(() =>
      fetch(new URL("/api/info", HttpServer.formatAddress(server.address)), {
@@ -144,9 +143,9 @@ it.live("authenticates API requests behind the frontend transform while allowing
                    headers: authorization ? { authorization } : undefined,
                  }),
                )
-                expect(response.status).toBe(200)
-                expect(response.headers.get("www-authenticate")).toBeNull()
-                expect(yield* Effect.promise(() => response.text())).toBe(method === "HEAD" ? "" : fallback)
+                expect(response.status).toBe(401)
+                expect(response.headers.get("www-authenticate")).toBe('Basic realm="Secure Area"')
+                expect(yield* Effect.promise(() => response.text())).toBe("")
              }),
            )
            const response = yield* Effect.promise(() =>
@@ -190,13 +190,13 @@ export const streamingDocument = document(
        {
          type: "reasoning",
          text: "## Checking the current contract\n\nThe assistant content is nested on each current Session message.",
-          state: { phase: "streaming" },
+          native: { phase: "streaming" },
          time: { created: STORY_TIME + 11_100 },
        },
        {
          type: "text",
          text: "I have the typed rows in place. Next I am checking the streaming presentation",
-          state: { phase: "streaming" },
+          native: { phase: "streaming" },
        },
      ],
    }),
@@ -47,7 +47,7 @@ function MermaidTimeline(props: { streaming: boolean }) {
                "```mermaid\nsequenceDiagram\n Client->>Server: Send prompt\n Server->>Model: Generate response\n Model-->>Client: Response\n" +
                  (completed() ? "```" : ""),
              ].join("\n\n"),
-              ...(completed() ? {} : { state: { phase: "streaming" } }),
+              ...(completed() ? {} : { native: { phase: "streaming" } }),
            },
          ],
        },
@@ -727,7 +727,7 @@ function App(props: { pair?: DialogPairCredentials }) {
        title: "New session",
        suggested: route.data.type === "session",
        category: "Session",
-        slash: { name: "new" },
+        slash: { name: "new", aliases: ["clear"] },
        run: () => {
          const model = local.model.current()
          const agent = local.agent.current()
@@ -749,33 +749,6 @@ function App(props: { pair?: DialogPairCredentials }) {
          dialog.clear()
        },
      },
-      {
-        name: "session.clear",
-        title: "Clear session",
-        category: "Session",
-        slash: { name: "clear" },
-        run: () => {
-          const model = local.model.current()
-          const agent = local.agent.current()
-          const current =
-            route.data.type === "session"
-              ? (data.session.get(route.data.sessionID)?.location ?? location.ref)
-              : undefined
-          sessionTabs.close()
-          route.navigate({
-            type: "home",
-            location: newSessionLocation(
-              config.data.session.new_location,
-              data.location.default().directory,
-              current,
-              location.error?.location,
-            ),
-          })
-          if (agent) local.agent.set(agent.id)
-          if (model) local.model.set(model)
-          dialog.clear()
-        },
-      },
      {
        name: "open.menu",
        title: "Open session or project",
@@ -1,67 +0,0 @@
-import { expect, test } from "bun:test"
-import { createAppFixture } from "./fixture/app"
-import { directory, json } from "./fixture/tui-client"
-import { tmpdir } from "./fixture/fixture"
-
-const location = { directory, project: { id: "project", directory, canonical: directory } }
-const session = {
-  id: "ses_clear",
-  title: "Session to clear",
-  projectID: "project",
-  location: { directory },
-  agent: "build",
-  model: { providerID: "provider", id: "model" },
-  cost: 0,
-  tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-  time: { created: 0, updated: 0 },
-}
-
-function render(state: string) {
-  return createAppFixture({
-    state,
-    args: { sessionID: session.id },
-    config: { animations: false, tabs: { mode: "on" } },
-    fetch: (url) => {
-      if (url.pathname === "/api/fs/list") return json({ location, data: [] })
-      if (url.pathname === "/api/location") return json(location)
-      if (url.pathname === "/api/session") return json({ data: [session], cursor: {} })
-      if (url.pathname === `/api/session/${session.id}`) return json({ data: session })
-      if (/^\/api\/session\/[^/]+\/(message|inbox|permission)$/.test(url.pathname))
-        return json({ data: [], cursor: {} })
-      if (url.pathname === "/api/agent")
-        return json({ location, data: [{ id: "build", mode: "primary", hidden: false, permissions: [] }] })
-      if (url.pathname === "/api/provider") return json({ location, data: [{ id: "provider", name: "Provider" }] })
-      if (url.pathname === "/api/model")
-        return json({
-          location,
-          data: [{ id: "model", providerID: "provider", name: "Model", variants: [] }],
-        })
-    },
-  })
-}
-
-test("/clear replaces the active session tab", async () => {
-  await using state = await tmpdir()
-  await using setup = await render(state.path)
-
-  await setup.waitForFrame((frame) => frame.includes("Session to clear"))
-  await setup.mockInput.typeText("/clear")
-  setup.mockInput.pressEnter()
-  const frame = await setup.waitForFrame((frame) => !frame.includes("Session to clear"))
-
-  expect(frame).not.toContain("Session to clear")
-})
-
-test("/new keeps the active session tab", async () => {
-  await using state = await tmpdir()
-  await using setup = await render(state.path)
-
-  await setup.waitForFrame((frame) => frame.includes("Session to clear"))
-  await setup.mockInput.typeText("/new")
-  setup.mockInput.pressEnter()
-  const frame = await setup.waitForFrame(
-    (frame) => frame.includes("New session") && frame.includes("Session to clear"),
-  )
-
-  expect(frame).toContain("Session to clear")
-})
@@ -1,5 +1,5 @@
 diff --git a/dist/index.cjs b/dist/index.cjs
-index 635f1c0134274c89e7efbcae2adf3d9ecba575ee..5eaa7b451c8c7e12e51f61c2a835ff6f7a8ea0ae 100644
+index 635f1c0134274c89e7efbcae2adf3d9ecba575ee..0054b779ff7b550ecf6d4008e177a888003f9c92 100644
 --- a/dist/index.cjs
 +++ b/dist/index.cjs
@@ -977,7 +977,6 @@ async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, o
@@ -10,16 +10,8 @@ index 635f1c0134274c89e7efbcae2adf3d9ecba575ee..5eaa7b451c8c7e12e51f61c2a835ff6f
 	}
 	let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
 	if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
-@@ -1158,7 +1157,6 @@ async function startAuthorization(authorizationServerUrl, { metadata, clientInfo
- 	authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
- 	if (state) authorizationUrl.searchParams.set("state", state);
- 	if (scope) authorizationUrl.searchParams.set("scope", scope);
-	if (scope?.split(" ").includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
- 	if (resource) authorizationUrl.searchParams.set("resource", resource.href);
- 	return {
- 		authorizationUrl,
 diff --git a/dist/index.mjs b/dist/index.mjs
-index f02ce3ca394e826fc27c9848dbe9a214bf6ba7a9..73a93a066c3540e131fa0770a74b4a7e8d9343a0 100644
+index f02ce3ca394e826fc27c9848dbe9a214bf6ba7a9..8e27c9320e14ba8816fda752f250f6ddb1cc7ed0 100644
 --- a/dist/index.mjs
 +++ b/dist/index.mjs
@@ -974,7 +974,6 @@ async function discoverMetadataWithFallback(serverUrl, wellKnownType, fetchFn, o
@@ -30,11 +22,3 @@ index f02ce3ca394e826fc27c9848dbe9a214bf6ba7a9..73a93a066c3540e131fa0770a74b4a7e
 	}
 	let response = await tryMetadataDiscovery(url, protocolVersion, fetchFn);
 	if (!opts?.metadataUrl && shouldAttemptFallback(response, issuer.pathname)) response = await tryMetadataDiscovery(new URL(`/.well-known/${wellKnownType}`, issuer), protocolVersion, fetchFn);
-@@ -1155,7 +1154,6 @@ async function startAuthorization(authorizationServerUrl, { metadata, clientInfo
- 	authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
- 	if (state) authorizationUrl.searchParams.set("state", state);
- 	if (scope) authorizationUrl.searchParams.set("scope", scope);
-	if (scope?.split(" ").includes("offline_access")) authorizationUrl.searchParams.append("prompt", "consent");
- 	if (resource) authorizationUrl.searchParams.set("resource", resource.href);
- 	return {
- 		authorizationUrl,
@@ -17320,7 +17320,7 @@
          "rawFinish": {
            "type": "string"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_4"
          },
          "cost": {
@@ -17349,7 +17349,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_1"
          },
          "time": {
@@ -17396,7 +17396,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState"
          }
        },
@@ -17509,7 +17509,7 @@
          "model": {
            "$ref": "#/components/schemas/Model.Ref"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_5"
          },
          "summary": {
@@ -17320,7 +17320,7 @@
          "rawFinish": {
            "type": "string"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_4"
          },
          "cost": {
@@ -17349,7 +17349,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_1"
          },
          "time": {
@@ -17396,7 +17396,7 @@
          "text": {
            "type": "string"
          },
-          "state": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState"
          }
        },
@@ -17509,7 +17509,7 @@
          "model": {
            "$ref": "#/components/schemas/Model.Ref"
          },
-          "providerState": {
+          "native": {
            "$ref": "#/components/schemas/Session.Message.ProviderState_5"
          },
          "summary": {
Author	SHA1	Message	Date
Aiden Cline	8997d8662f	fix(schema): keep legacy blobs on replay, import, and V1 migration Freeze session.message.content.updated at the stored shape and translate on replay, run persisted() on CLI session import, write native from the V1 migration, regenerate the OpenAPI docs, and mirror text.ended state in the client fold.	2026-09-22 00:37:59 -05:00
Aiden Cline	e4dd41b033	test(core): use native for text and reasoning provider blobs	2026-09-21 23:39:41 -05:00
Aiden Cline	347bf1d749	Merge remote-tracking branch 'origin/v2' into message-native	2026-09-21 23:37:54 -05:00
Aiden Cline	e7c4bffd38	refactor(schema): drop native migration and fix fixtures	2026-09-21 23:27:12 -05:00
Aiden Cline	85962e49b7	refactor(schema): rename message provider blobs to native	2026-09-20 21:41:03 -05:00