Merge remote-tracking branch 'origin/v2' into session-diff

# Conflicts:
#	packages/client/src/effect/api/api.ts
#	packages/core/src/session.ts
#	packages/core/test/git.test.ts
#	packages/protocol/src/groups/session.ts
#	packages/server/src/handlers/session-error.ts
#	packages/server/src/handlers/session.ts

bun.lock

@@ -86,6 +86,7 @@
         "fuzzysort": "catalog:",
         "ghostty-web": "github:anomalyco/ghostty-web#83c0a07b8628b748aed073b232cb4b52a6ca11c1",
         "luxon": "catalog:",
+        "qr-scanner": "1.4.2",
         "remeda": "catalog:",
         "solid-js": "catalog:",
         "solid-presence": "0.2.0",
@@ -3228,6 +3229,8 @@
 
     "@types/npmlog": ["@types/npmlog@7.0.0", "", { "dependencies": { "@types/node": "*" } }, "sha512-hJWbrKFvxKyWwSUXjZMYTINsSOY6IclhvGOZ97M8ac2tmR9hMwmTnYaMdpGhvju9ctWLTPhCS+eLfQNluiEjQQ=="],
 
+    "@types/offscreencanvas": ["@types/offscreencanvas@2019.7.3", "", {}, "sha512-ieXiYmgSRXUDeOntE1InxjWyvEelZGP63M+cGuquuRLuIKKT1osnkXjxev9B7d1nXSug5vpunx+gNlbVxMlC9A=="],
+
     "@types/pacote": ["@types/pacote@11.1.8", "", { "dependencies": { "@types/node": "*", "@types/npm-registry-fetch": "*", "@types/npmlog": "*", "@types/ssri": "*" } }, "sha512-/XLR0VoTh2JEO0jJg1q/e6Rh9bxjBq9vorJuQmtT7rRrXSiWz7e7NsvXVYJQ0i8JxMlBMPPYDTnrRe7MZRFA8Q=="],
 
     "@types/prop-types": ["@types/prop-types@15.7.15", "", {}, "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw=="],
@@ -5160,6 +5163,8 @@
 
     "pvutils": ["pvutils@1.2.0", "", {}, "sha512-BbubeCEyTuQjVMakvJQ/Sxbc93F2pwmbsxONT/ZRrwU7Ua38d8unYTwXpTVLAKJ4BDuH9IGztCjQcd/N/39Dvg=="],
 
+    "qr-scanner": ["qr-scanner@1.4.2", "", { "dependencies": { "@types/offscreencanvas": "^2019.6.4" } }, "sha512-kV1yQUe2FENvn59tMZW6mOVfpq9mGxGf8l6+EGaXUOd4RBOLg7tRC83OrirM5AtDvZRpdjdlXURsHreAOSPOUw=="],
+
     "qs": ["qs@6.15.3", "", { "dependencies": { "es-define-property": "^1.0.1", "side-channel": "^1.1.1" } }, "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A=="],
 
     "quansync": ["quansync@0.2.11", "", {}, "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA=="],

infra/webapp.ts

@@ -6,6 +6,7 @@ export function createWebApp(domain: string) {
       $app.stage === "beta"
         ? {
             OPENCODE_CHANNEL: "beta",
+            VITE_OPENCODE_SERVER_MODE: "none",
             VITE_SENTRY_ENVIRONMENT: "beta",
           }
         : undefined,

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-gW+1JbPQnt+PZzHfGijjnwch6X6pyaBnPTxAc47yiQw=",
-    "aarch64-linux": "sha256-qI6CtJkmh20ouWeiQRR1zp+YjHootkN23VFJCwqnf0A=",
-    "aarch64-darwin": "sha256-oyEhVcjbKq3+BCCxVBl0TZYmKJv1BBLWPVs0Vw6Fbac=",
-    "x86_64-darwin": "sha256-UhLZjG3NlkoXRWNn8SK/pLm5eDR3saU+TgEgfX592vQ="
+    "x86_64-linux": "sha256-EKhY3iZDrbNrBhntWpSdtLcmNLte6yVBxpIrCxr1uNM=",
+    "aarch64-linux": "sha256-0OjDGZHgcnnk6IxkfK6ogeeqsGTqY/dcaZ/XzT23sgA=",
+    "aarch64-darwin": "sha256-Zk51gnOicaLtPuqCYfgARhm2TjL222w1Y0Em288o0YY=",
+    "x86_64-darwin": "sha256-hvDZ9zCV6zOSx6i7JZ1kVUMht+JI/jc8/y+aYrNHQ1E="
   }
 }

packages/ai/src/protocols/anthropic-messages.ts

@@ -50,15 +50,24 @@ const SSE_EVENTS = new Set([
 ])
 export const framing = Framing.sseEvents(SSE_EVENTS)
 
+export type ThinkingBlockBinding = {
+  readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {})
+}
+
 export type ThinkingInput =
   | {
       readonly type: "adaptive"
       readonly display?: "summarized" | "omitted"
+      readonly block_binding?: ThinkingBlockBinding
     }
   | {
       readonly type: "disabled"
     }
-  | ({ readonly type: "enabled"; readonly display?: "summarized" | "omitted" } & (
+  | ({
+      readonly type: "enabled"
+      readonly display?: "summarized" | "omitted"
+      readonly block_binding?: ThinkingBlockBinding
+    } & (
       | { readonly budgetTokens: number; readonly budget_tokens?: number }
       | { readonly budgetTokens?: number; readonly budget_tokens: number }
     ))
@@ -301,20 +310,27 @@ const AnthropicToolChoice = Schema.Union([
   }),
 ])
 
+const AnthropicThinkingBlockBinding = Schema.Struct({
+  prefix_mismatch_behavior: Schema.optional(Schema.String),
+})
+
 const AnthropicThinking = Schema.Union([
   Schema.Struct({
     type: Schema.tag("enabled"),
     budget_tokens: Schema.Number,
     display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+    block_binding: Schema.optional(AnthropicThinkingBlockBinding),
   }),
   Schema.Struct({
     type: Schema.tag("adaptive"),
     display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
+    block_binding: Schema.optional(AnthropicThinkingBlockBinding),
   }),
   Schema.Struct({
     type: Schema.tag("disabled"),
   }),
 ])
+type AnthropicThinking = typeof AnthropicThinking.Type
 
 // SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
 const AnthropicJsonOutputFormat = Schema.Struct({
@@ -1025,8 +1041,9 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
           ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
           ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
         }
+  const thinking = yield* resolveThinking(input?.thinking)
   return {
-    thinking: yield* resolveThinking(input?.thinking),
+    thinking: applyThinkingBindingDefault(request.model, thinking),
     effort: outputConfigEffort,
     output_config,
     service_tier,
@@ -1037,15 +1054,41 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
   }
 })
 
+const supportsThinkingBlockBinding = (model: LLMRequest["model"]) => {
+  const override = model.compatibility?.supportsThinkingBlockBinding
+  if (override !== undefined) return override
+  // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
+  const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups
+  if (!version) return false
+  const major = Number(version.major)
+  const minor = Number(version.minor ?? 0)
+  return major > 5 || (major === 5 && minor >= 1)
+}
+
+const applyThinkingBindingDefault = (model: LLMRequest["model"], thinking: AnthropicThinking | undefined) => {
+  if (thinking?.type === "disabled") return thinking
+  if (!supportsThinkingBlockBinding(model)) return thinking
+  return {
+    ...(thinking ?? { type: "adaptive" as const }),
+    block_binding: {
+      prefix_mismatch_behavior: "drop_block",
+      ...thinking?.block_binding,
+    },
+  }
+}
+
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input: unknown) {
   if (!ProviderShared.isRecord(input)) return undefined
+  if (input.type === "disabled") return { type: "disabled" as const }
+  if (input.type !== "adaptive" && input.type !== "enabled") return undefined
+  const block_binding = yield* ProviderShared.validateWith(
+    Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)),
+  )(input.block_binding)
   const display =
     input.display === "summarized" || input.display === "omitted"
       ? (input.display as "summarized" | "omitted")
       : undefined
-  if (input.type === "adaptive") return { type: "adaptive" as const, ...(display === undefined ? {} : { display }) }
-  if (input.type === "disabled") return { type: "disabled" as const }
-  if (input.type !== "enabled") return undefined
+  if (input.type === "adaptive") return { type: "adaptive" as const, display, block_binding }
   const budget =
     typeof input.budgetTokens === "number"
       ? input.budgetTokens
@@ -1054,7 +1097,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
         : undefined
   if (budget === undefined)
     return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens")
-  return { type: "enabled" as const, budget_tokens: budget, ...(display === undefined ? {} : { display }) }
+  return { type: "enabled" as const, budget_tokens: budget, display, block_binding }
 })
 
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request: LLMRequest) {
@@ -1636,24 +1679,21 @@ export const protocol = Protocol.make({
   },
 })
 
-export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
+export const transport = <
+  Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">,
+>() => {
   const http = HttpTransport.httpJson<Body, string>({ framing })
   return {
     ...http,
     prepare: (input: Parameters<typeof http.prepare>[0]) => {
-      if (
-        !input.body.context_management?.edits.length &&
-        !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction"))
-      )
-        return http.prepare(input)
+      const requiredBetas = requiredBetaHeaders(input.body)
+      if (requiredBetas.length === 0) return http.prepare(input)
       const headers = Headers.fromInput(input.request.http?.headers)
-      const betas = new Set(
-        (headers["anthropic-beta"] ?? "")
-          .split(",")
-          .map((item) => item.trim())
-          .filter(Boolean),
-      )
-      betas.add("compact-2026-01-12")
+      const existingBetas = (headers["anthropic-beta"] ?? "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+      const betas = new Set([...existingBetas, ...requiredBetas])
       return http.prepare({
         ...input,
         request: LLMRequest.update(input.request, {
@@ -1667,6 +1707,20 @@ export const transport = <Body extends Pick<AnthropicMessagesBody, "messages" |
   }
 }
 
+function requiredBetaHeaders(body: Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">) {
+  const betas: string[] = []
+  const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0
+  const replaysCompaction = body.messages.some((message) =>
+    message.content.some((block) => block.type === "compaction"),
+  )
+  if (requestsCompaction || replaysCompaction) betas.push("compact-2026-01-12")
+
+  const thinking = body.thinking
+  if (thinking && thinking.type !== "disabled" && thinking.block_binding)
+    betas.push("thinking-binding-controls-2026-08-01")
+  return betas
+}
+
 export const route = Route.make({
   id: ADAPTER,
   provider: "anthropic",

packages/ai/src/schema/options.ts

@@ -163,6 +163,8 @@ export class LanguageModelCompatibility extends Schema.Class<LanguageModelCompat
   supportsStrictMode: Schema.optional(Schema.Boolean),
   zaiToolStream: Schema.optional(Schema.Boolean),
   requireSignature: Schema.optional(Schema.Boolean),
+  /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+  supportsThinkingBlockBinding: Schema.optional(Schema.Boolean),
 }) {}
 
 export namespace LanguageModelCompatibility {

packages/ai/test/provider/anthropic-thinking-binding.test.ts

@@ -0,0 +1,60 @@
+import { expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM } from "../../src/index.js"
+import { AnthropicMessages } from "../../src/protocols/anthropic-messages.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+
+for (const [id, enabled] of [
+  ["claude-fable-5-1", true],
+  ["claude-mythos-5-1", true],
+  ["claude-fable-5.1", true],
+  ["anthropic/claude-fable-5.1", true],
+  ["claude-fable-5-1@default", true],
+  ["claude-fable-5-1@20260901", true],
+  ["claude-sonnet-6", true],
+  ["claude-opus-5-20260901", false],
+  ["claude-opus-4-8", false],
+  ["anthropic/claude-opus-4.8", false],
+  ["claude-fable-5@default", false],
+  ["kimi-k2.5", false],
+] as const) {
+  it.effect(`thinking-binding defaults for ${id}`, () =>
+    Effect.gen(function* () {
+      const request = LLM.request({
+        model: AnthropicMessages.route.model({ id }),
+        prompt: "Hello",
+        http: { headers: { "anthropic-beta": "existing-beta" } },
+      })
+      const compiled = yield* compileRequest(request)
+      const prepared = yield* AnthropicMessages.route.prepareTransport(compiled.body, request)
+      expect(compiled.body.thinking).toEqual(
+        enabled ? { type: "adaptive", block_binding: { prefix_mismatch_behavior: "drop_block" } } : undefined,
+      )
+      expect(prepared.request.headers["anthropic-beta"]).toBe(
+        enabled ? "existing-beta,thinking-binding-controls-2026-08-01" : "existing-beta",
+      )
+    }),
+  )
+}
+
+it.effect("preserves explicit thinking settings and combines required beta headers", () =>
+  Effect.gen(function* () {
+    for (const thinking of [
+      { type: "disabled" },
+      { type: "adaptive", block_binding: { prefix_mismatch_behavior: "error" } },
+    ] as const) {
+      const request = LLM.request({
+        model: AnthropicMessages.route.model({ id: "claude-fable-5-1" }),
+        prompt: "Hello",
+        providerOptions: { thinking, contextManagement: { edits: [{ type: "compact_20260112" }] } },
+      })
+      const compiled = yield* compileRequest(request)
+      const prepared = yield* AnthropicMessages.route.prepareTransport(compiled.body, request)
+      expect(compiled.body.thinking).toEqual(thinking)
+      expect(prepared.request.headers["anthropic-beta"]).toBe(
+        thinking.type === "disabled" ? "compact-2026-01-12" : "compact-2026-01-12,thinking-binding-controls-2026-08-01",
+      )
+    }
+  }),
+)

packages/app/README.md

@@ -83,8 +83,39 @@ Changes merged into `v2` reach the beta site when they are promoted to `beta`. T
 only the web app, using the same `WebApp` StaticSite definition as production. It sets the build channel
 and Sentry environment to `beta` without deploying the API, console, database, or billing infrastructure.
 
-The hosted app defaults to `http://localhost:49374`, matching the managed V2 service. Saved server selections
-override this default. Connecting still requires the service's credentials.
+`VITE_OPENCODE_SERVER_MODE` controls which server the web build provides at startup:
+
+| Mode               | Initial server                                                                       |
+| ------------------ | ------------------------------------------------------------------------------------ |
+| `none`             | No initial server. The beta deployment uses this mode.                               |
+| `origin` (default) | The current page's origin. CLI builds explicitly use this mode for `opencode serve`. |
+
+In Vite development mode, `origin` uses `VITE_OPENCODE_SERVER_HOST` / `VITE_OPENCODE_SERVER_PORT`
+(default: `http://localhost:4096`) instead of the frontend origin. Both modes restore user-added servers
+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 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.
+
+When the service is exposed through an HTTPS reverse proxy, advertise its external address at runtime:
+
+```bash
+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.
+The proxy URL must reach the OpenCode API, not just the frontend. For separate frontend and API processes,
+route `/api` to the service while preserving the `/api` prefix. No machine-specific app or CLI build is required.
+
+When an HTTPS page fails to connect to a non-loopback HTTP server, the connection forms show a specific
+HTTPS-to-HTTP error instead of the generic connection failure. HTTP servers on `localhost`, `*.localhost`,
+`127.0.0.0/8`, or `::1` are treated as trustworthy loopback targets. Connection attempts still run, since
+browser local-network permissions can allow some HTTP LAN connections.
+QR scanning is enabled only in a browser-reported secure context with camera support and an available
+video input; insecure pages and unavailable cameras show an explanation beside the disabled action.
 
 The workflow reuses the repository's `CLOUDFLARE_API_TOKEN` and web Sentry settings. The Cloudflare token
 must cover SST's R2 state storage, KV assets, Workers, and custom-domain management in the account that

packages/app/e2e/performance/unit/mock-server.test.ts

@@ -1,6 +1,25 @@
 import { expect, test } from "bun:test"
 import type { Page, Route } from "@playwright/test"
-import { mockOpenCodeServer } from "../../utils/mock-server"
+import { createMockServerHandler, mockOpenCodeServer } from "../../utils/mock-server"
+
+test("serves an empty config document list for composer defaults", async () => {
+  const server = createMockServerHandler({
+    provider: {},
+    directory: "C:/OpenCode",
+    project: {},
+    sessions: [],
+    pageMessages: () => ({ items: [] }),
+  })
+  try {
+    const response = await server.handler(
+      new Request("http://localhost/api/config?location%5Bdirectory%5D=C%3A%2FOpenCode"),
+    )
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual([])
+  } finally {
+    await server.dispose()
+  }
+})
 
 test("applies message latency after a list response gate is released", async () => {
   const events: string[] = []

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

@@ -342,6 +342,7 @@ async function mockServers(
     if (route.request().method() === "GET" && sessionPermission)
       return json(route, { data: options.sessionPending?.[sessionPermission[1]!] ?? [] })
     if (requestDirectory && requestDirectory !== directory) return json(route, { name: "InvalidDirectory" }, 500)
+    if (url.pathname === "/api/config") return json(route, [])
     if (url.pathname === "/api/provider")
       return json(route, {
         location: { directory },

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

@@ -602,6 +602,7 @@ async function mockServer(page: Page) {
     if (url.origin !== server) return route.fallback()
     if (url.pathname === `/api/session/${unresolvedSessionID}`) return new Promise(() => {})
     if (url.pathname === "/api/event") return sse(route)
+    if (url.pathname === "/api/config") return json(route, [])
     if (url.pathname === "/api/session")
       return json(route, { data: sessions.map((session) => currentSession(session)), cursor: {} })
     if (url.pathname === "/api/session/active") return json(route, { data: {} })

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

@@ -39,6 +39,7 @@ const Group = HttpApiGroup.make("mock")
     }),
   )
   .add(HttpApiEndpoint.get("reference", "/api/reference", { success: Json }))
+  .add(HttpApiEndpoint.get("config", "/api/config", { success: Json }))
   .add(HttpApiEndpoint.get("agent", "/api/agent", { success: Json }))
   .add(HttpApiEndpoint.get("provider", "/api/provider", { success: Json }))
   .add(HttpApiEndpoint.get("model", "/api/model", { success: Json }))

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

@@ -207,6 +207,7 @@ function mockHandlers(config: MockServerConfig, state: { cursors: Map<string, st
       )
       .handleAll({
         health: () => Effect.succeed({ healthy: true, version: "2.0.0", pid: 1 }),
+        config: () => Effect.succeed([]),
         reference: () =>
           Effect.succeed({
             location: {

packages/app/package.json

@@ -87,6 +87,7 @@
     "fuzzysort": "catalog:",
     "ghostty-web": "github:anomalyco/ghostty-web#83c0a07b8628b748aed073b232cb4b52a6ca11c1",
     "luxon": "catalog:",
+    "qr-scanner": "1.4.2",
     "remeda": "catalog:",
     "solid-js": "catalog:",
     "solid-presence": "0.2.0",

packages/app/src/app.tsx

@@ -95,7 +95,7 @@ export function AppBaseProviders(
 
 export function AppInterface(props: {
   children?: JSX.Element
-  defaultServer: ServerConnection.Key
+  defaultServer?: ServerConnection.Key
   canonicalLocalServer?: ServerConnection.Key
   servers?: Array<ServerConnection.Any>
   router?: Component<BaseRouterProps>

packages/app/src/composer/attachments/attachments.ts

@@ -1,5 +1,7 @@
 import { onCleanup, onMount } from "solid-js"
 import { makeEventListener } from "@solid-primitives/event-listener"
+import { createBlobReference } from "@/runtime/persistence/drafts"
+import { uuid } from "@/runtime/persistence/uuid"
 import type { ComposerAttachment, ComposerPrompt } from "../types"
 
 const accepted = [
@@ -107,7 +109,7 @@ export function createComposerAttachments(
       if (toast) input.warn()
       return false
     }
-    const blob = input.store ? await input.store(file) : await blobReference(file)
+    const blob = input.store ? await input.store(file) : await createBlobReference(file)
     const sourcePath = input.getPathForFile?.(file) || undefined
     // Native clipboard images arrive with a fresh timestamped filename on every paste, so identical
     // clipboard content is matched on bytes alone.
@@ -127,7 +129,7 @@ export function createComposerAttachments(
     }
     const attachment: ComposerAttachment = {
       type: "image",
-      id: crypto.randomUUID(),
+      id: uuid(),
       filename: file.name,
       sourcePath,
       mime,
@@ -230,12 +232,6 @@ export function createComposerAttachments(
 
 const imageMimes = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"])
 
-async function blobReference(file: File) {
-  const id = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", await file.arrayBuffer())))
-    .map((byte) => byte.toString(16).padStart(2, "0"))
-    .join("")
-  return { id, url: URL.createObjectURL(file) }
-}
 const imageExtensions = new Map([
   ["gif", "image/gif"],
   ["jpeg", "image/jpeg"],

packages/app/src/composer/selection.ts

@@ -1,4 +1,5 @@
-import { batch, type Accessor, createMemo, startTransition } from "solid-js"
+import { batch, type Accessor, createEffect, createMemo, on } from "solid-js"
+import { createStore } from "solid-js/store"
 import type { ComposerControls } from "./adapter"
 import { useLayout } from "@/shell/state/layout"
 import { useLocal, type ModelKey, type ModelSelection } from "@/providers/models/selection"
@@ -9,6 +10,7 @@ import { normalizeAgentList } from "@/runtime/server/global-sync/utils"
 import { useModels } from "@/providers/models/models"
 import { cycleModelVariant, getConfiguredAgentVariant, resolveModelVariant } from "@/providers/models/variant"
 import { useComposerState } from "./persistence"
+import { useConfiguredModel } from "@/providers/models/configured"
 
 export function createComposerControls(input: { sessionKey: Accessor<string>; model?: ModelSelection }) {
   const layout = useLayout()
@@ -31,6 +33,7 @@ export function createComposerControls(input: { sessionKey: Accessor<string>; mo
         selection: input.model ?? local.model,
         paid: providers.paid().length > 0,
         loading:
+          !(input.model ?? local.model).ready() ||
           (local.agent.visible() && data.location.agent.list({ directory: sdk().directory }) === undefined) ||
           !providers.ready(),
       },
@@ -43,15 +46,31 @@ export function createComposerControls(input: { sessionKey: Accessor<string>; mo
 }
 
 export function createComposerModelSelection(input: {
-  agent: () => { model?: ModelKey; variant?: string } | undefined
+  agent: () => { name: string; model?: ModelKey; variant?: string } | undefined
 }) {
   const sdk = useWorkspaceLocation()
   const models = useModels()
+  const local = useLocal()
   const prompt = useComposerState()
+  const configuredModel = useConfiguredModel()
+  const [remembered, setRemembered] = createStore<Record<string, ModelKey | undefined>>({})
+  createEffect(
+    on(
+      () => input.agent()?.name,
+      (name, previous) => {
+        if (!name || !previous || name === previous) return
+        batch(() => {
+          const model = prompt.model.current()
+          setRemembered(previous, model ? { providerID: model.providerID, modelID: model.modelID } : undefined)
+          prompt.model.set(remembered[name] ? { ...remembered[name] } : undefined)
+        })
+      },
+    ),
+  )
   const providers = useProviders(() => sdk().directory)
   const connected = createMemo(() => new Set(providers.connected().map((item) => item.id)))
 
-  const valid = (model: ModelKey) => {
+  const valid = (model: Pick<ModelKey, "providerID" | "modelID">) => {
     const provider = providers.all().get(model.providerID)
     return !!provider?.models[model.modelID] && connected().has(model.providerID)
   }
@@ -62,7 +81,8 @@ export function createComposerModelSelection(input: {
       return modelID ? [{ providerID: provider.id, modelID }] : []
     })[0]
   const current = () => {
-    const key = [prompt.model.current(), input.agent()?.model, recent(), fallback()].find(
+    if (!configuredModel.ready()) return
+    const key = [prompt.model.current(), input.agent()?.model, configuredModel(), recent(), fallback()].find(
       (item): item is ModelKey => !!item && valid(item),
     )
     return key ? models.find(key) : undefined
@@ -74,7 +94,9 @@ export function createComposerModelSelection(input: {
       .filter((item): item is NonNullable<typeof item> => !!item),
   )
   const selection = {
-    ready: models.ready,
+    trackSessionCommit: local.model.trackSessionCommit,
+    remembered: () => Object.fromEntries(Object.entries(remembered).map(([name, model]) => [name, { model }])),
+    ready: Object.assign(() => models.ready() && configuredModel.ready(), { promise: models.ready.promise }),
     current,
     recent: recentModels,
     list: models.list,
@@ -83,19 +105,24 @@ export function createComposerModelSelection(input: {
       const item = current()
       if (!item) return
       const index = items.findIndex((entry) => entry.provider.id === item.provider.id && entry.id === item.id)
-      if (index === -1) return
-      const next = items[(index + direction + items.length) % items.length]
+      const next =
+        items[
+          index === -1 ? (direction === 1 ? 0 : items.length - 1) : (index + direction + items.length) % items.length
+        ]
       if (next) selection.set({ providerID: next.provider.id, modelID: next.id })
     },
     set(item: ModelKey | undefined, options?: { recent?: boolean }) {
-      void startTransition(() =>
-        batch(() => {
-          prompt.model.set(item ? { ...item, variant: prompt.model.current()?.variant } : undefined)
-          if (!item) return
-          models.setVisibility(item, true)
-          if (options?.recent) models.recent.push(item)
-        }),
-      )
+      batch(() => {
+        if (item && !valid(item)) return
+        const previous = current()
+        const same = item && previous?.provider.id === item.providerID && previous.id === item.modelID
+        prompt.model.set(
+          item ? { ...item, variant: same ? (selection.variant.current() ?? null) : undefined } : undefined,
+        )
+        if (!item) return
+        models.setVisibility(item, true)
+        if (options?.recent) models.recent.push(item)
+      })
     },
     visible: models.visible,
     setVisibility: models.setVisibility,
@@ -104,38 +131,41 @@ export function createComposerModelSelection(input: {
         const item = input.agent()
         const model = current()
         if (!item || !model) return
-        return getConfiguredAgentVariant({
-          agent: { model: item.model, variant: item.variant },
-          model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
-        })
+        const global = configuredModel()
+        return (
+          getConfiguredAgentVariant({
+            agent: { model: item.model, variant: item.variant },
+            model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
+          }) ??
+          getConfiguredAgentVariant({
+            agent: { model: global, variant: global?.variant },
+            model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
+          })
+        )
       },
       selected() {
-        return prompt.model.current()?.variant
+        const model = prompt.model.current()
+        return model && valid(model) ? model.variant : undefined
       },
       current() {
-        const resolved = resolveModelVariant({
+        const model = current()
+        return resolveModelVariant({
           variants: this.list(),
           selected: this.selected(),
           configured: this.configured(),
+          preferred: model ? models.variant.get({ providerID: model.provider.id, modelID: model.id }) : undefined,
         })
-        if (resolved) return resolved
-        const model = current()
-        if (!model) return
-        const saved = models.variant.get({ providerID: model.provider.id, modelID: model.id })
-        if (saved && this.list().includes(saved)) return saved
       },
       list() {
         return Object.keys(current()?.variants ?? {})
       },
       set(value: string | undefined) {
-        void startTransition(() =>
-          batch(() => {
-            const model = current()
-            if (!model) return
-            prompt.model.set({ providerID: model.provider.id, modelID: model.id, variant: value ?? null })
-            models.variant.set({ providerID: model.provider.id, modelID: model.id }, value)
-          }),
-        )
+        batch(() => {
+          const model = current()
+          if (!model) return
+          prompt.model.set({ providerID: model.provider.id, modelID: model.id, variant: value ?? null })
+          models.variant.set({ providerID: model.provider.id, modelID: model.id }, value)
+        })
       },
       cycle() {
         const variants = this.list()
@@ -143,13 +173,13 @@ export function createComposerModelSelection(input: {
         this.set(
           cycleModelVariant({
             variants,
-            selected: this.selected(),
-            configured: this.configured(),
+            selected: this.current() ?? null,
+            configured: undefined,
           }),
         )
       },
     },
-  } satisfies ModelSelection
+  }
 
-  return selection
+  return selection satisfies ModelSelection
 }

packages/app/src/composer/submit.test.ts

@@ -91,6 +91,8 @@ function session(input: {
   admitted?: (messageID: string) => boolean
   shell?: () => Promise<unknown>
   command?: ComposerSession["api"]["command"]
+  switchAgent?: ComposerSession["api"]["switchAgent"]
+  switchModel?: ComposerSession["api"]["switchModel"]
 }): ComposerSession {
   return {
     id: "session-1",
@@ -99,12 +101,16 @@ function session(input: {
     current: input.current ?? (() => undefined),
     admitted: input.admitted ?? (() => false),
     api: {
-      switchAgent: async () => {
-        input.calls.push("switch-agent")
-      },
-      switchModel: async () => {
-        input.calls.push("switch-model")
-      },
+      switchAgent:
+        input.switchAgent ??
+        (async () => {
+          input.calls.push("switch-agent")
+        }),
+      switchModel:
+        input.switchModel ??
+        (async () => {
+          input.calls.push("switch-model")
+        }),
       shell: input.shell ?? (async () => undefined),
       command: input.command ?? (async () => undefined),
     },
@@ -122,6 +128,146 @@ function session(input: {
 }
 
 describe("Composer submission", () => {
+  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[] = []
+    const selected = controls()
+    const agent = Promise.withResolvers<void>()
+    const started = Promise.withResolvers<void>()
+    const committed = Promise.withResolvers<void>()
+    const completed = Promise.withResolvers<void>()
+    const target = session({
+      calls,
+      prompt: async () => {
+        throw new Error("command must not call prompt")
+      },
+      switchAgent: async (request) => {
+        expect(request.agent).toBe("build")
+        calls.push("agent")
+        started.resolve()
+        await agent.promise
+      },
+      switchModel: async (request) => {
+        expect(request.model).toEqual({ providerID: "provider-1", id: "model-1", variant: "balanced" })
+        calls.push("model")
+        await committed.promise
+      },
+      command: async (request) => {
+        expect(request).toMatchObject({ command: "review", text: "changes", delivery: "steer" })
+        expect(request).not.toHaveProperty("model")
+        expect(request).not.toHaveProperty("agent")
+        calls.push("command")
+        completed.resolve()
+      },
+    })
+    selected.model.selection = {
+      ...selection,
+      trackSessionCommit: (_id, value) => {
+        expect(value).toEqual({
+          agent: "build",
+          model: { providerID: "provider-1", modelID: "model-1" },
+          variant: "balanced",
+        })
+        calls.push("track")
+        return () => calls.push("cancel")
+      },
+    }
+    const adapter: ActiveComposerAdapter = {
+      kind: "active-session",
+      state,
+      ready: () => true,
+      controls: () => selected,
+      working: () => false,
+      session: () => target,
+      interrupt: async () => undefined,
+      submitted() {},
+      setEditor() {},
+    }
+    await submitInput(adapter, undefined, "normal", () => [{ name: "review" }]).submit(new Event("submit"))
+    await started.promise
+    expect(calls).toEqual(["track", "agent"])
+    selected.agents.current = "plan"
+    selected.model.selection = { ...selection, variant: { ...selection.variant, current: () => "high" } }
+    agent.resolve()
+    committed.resolve()
+    await completed.promise
+    expect(calls).toEqual(["track", "agent", "model", "command"])
+  })
+
+  test("commits the model even when cached session state already matches", async () => {
+    const state = createMemoryComposerState({ prompt: "continue" }).capture()
+    const calls: string[] = []
+    const done = Promise.withResolvers<void>()
+    const target = session({
+      calls,
+      current: () => ({ agent: "build", model: { providerID: "provider-1", id: "model-1", variant: "balanced" } }),
+      prompt: async () => done.resolve(),
+    })
+    const adapter: ActiveComposerAdapter = {
+      kind: "active-session",
+      state,
+      ready: () => true,
+      controls,
+      working: () => false,
+      session: () => target,
+      interrupt: async () => undefined,
+      submitted() {},
+      setEditor() {},
+    }
+    await submitInput(adapter).submit(new Event("submit"))
+    await done.promise
+    expect(calls).toEqual(["switch-model", "prompt"])
+  })
+
+  test("cancels selection tracking and does not execute a command when selection fails", async () => {
+    const state = createMemoryComposerState({ prompt: "/review changes" }).capture()
+    const calls: string[] = []
+    const selected = controls()
+    const failed = Promise.withResolvers<unknown>()
+    const error = new Error("model unavailable")
+    const target = session({
+      calls,
+      prompt: async () => {
+        calls.push("prompt")
+      },
+      switchModel: async () => {
+        throw error
+      },
+      command: async () => {
+        calls.push("command")
+      },
+    })
+    selected.model.selection = {
+      ...selection,
+      trackSessionCommit: () => {
+        calls.push("track")
+        return () => {
+          calls.push("cancel")
+        }
+      },
+    }
+    const adapter: ActiveComposerAdapter = {
+      kind: "active-session",
+      state,
+      ready: () => true,
+      controls: () => selected,
+      working: () => false,
+      session: () => target,
+      interrupt: async () => undefined,
+      submitted() {},
+      setEditor() {},
+    }
+    await submitInput(
+      adapter,
+      { missingSelection() {}, failed: (_kind, error) => failed.resolve(error) },
+      "normal",
+      () => [{ name: "review" }],
+    ).submit(new Event("submit"))
+    expect(await failed.promise).toBe(error)
+    expect(calls).toEqual(["track", "switch-agent", "cancel"])
+    expect(state.current()[0]).toMatchObject({ content: "/review changes" })
+  })
+
   test("submits a slash skill with its trailing text and attachments", async () => {
     const state = createMemoryComposerState({ prompt: "/show-me explain " }).capture()
     state.set([

packages/app/src/composer/submit.ts

@@ -11,6 +11,7 @@ import { createComposerSubmission } from "./submission-state"
 import { buildPromptRequest } from "./request"
 import { setCursorPosition } from "./editor/dom"
 import { blobDataUrl } from "@/runtime/persistence/drafts"
+import type { ModelSelection } from "@/providers/models/selection"
 
 const submitting = new WeakSet<object>()
 
@@ -88,7 +89,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
         session.handoff?.set(handoffMessage(value))
         const optimisticBusy = !input.adapter.working()
         if (optimisticBusy) session.data.session.setStatus(session.id, "running")
-        const sending = sendPrompt(session, value).then(
+        const sending = sendPrompt(session, value, input.adapter.controls().model.selection.trackSessionCommit).then(
           () => ({ ok: true as const }),
           (error) => ({ ok: false as const, error }),
         )
@@ -124,9 +125,12 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
         // Commands always steer: the server applies a command's configured
         // agent and model immediately at admission, so queueing one would
         // reconfigure the turn it is supposed to wait behind.
-        void sendCommand(session, { ...value, delivery: "steer" }, command).catch((error) =>
-          failSubmission(input, session, "command", error, restore, value.id),
-        )
+        void sendCommand(
+          session,
+          { ...value, delivery: "steer" },
+          command,
+          input.adapter.controls().model.selection.trackSessionCommit,
+        ).catch((error) => failSubmission(input, session, "command", error, restore, value.id))
         return
       }
     } finally {
@@ -315,8 +319,10 @@ async function sendCommand(
   session: ComposerSession,
   value: ComposerSubmission,
   command: { command: string; arguments: string },
+  track?: ModelSelection["trackSessionCommit"],
 ) {
   const request = await buildSubmissionRequest(session, value)
+  await applySelection(session, value.selection, track)
   await session.api.command({
     sessionID: session.id,
     command: command.command,
@@ -328,7 +334,33 @@ async function sendCommand(
   })
 }
 
-async function sendPrompt(session: ComposerSession, value: ComposerSubmission) {
+async function applySelection(
+  session: ComposerSession,
+  selection: ComposerSelection,
+  track?: ModelSelection["trackSessionCommit"],
+) {
+  const cancel = track?.(session.id, selection)
+  try {
+    const current = session.current()
+    if (current?.agent !== selection.agent) {
+      await session.api.switchAgent({ sessionID: session.id, agent: selection.agent })
+    }
+    // The server deduplicates unchanged selections; cached SSE state may still be behind an earlier switch.
+    await session.api.switchModel({
+      sessionID: session.id,
+      model: { id: selection.model.modelID, providerID: selection.model.providerID, variant: selection.variant },
+    })
+  } catch (error) {
+    cancel?.()
+    throw error
+  }
+}
+
+async function sendPrompt(
+  session: ComposerSession,
+  value: ComposerSubmission,
+  track?: ModelSelection["trackSessionCommit"],
+) {
   const request = await buildSubmissionRequest(session, value)
   // Switching agent or model reconfigures the session immediately, and with it
   // the remainder of a running turn. A steer targets that turn, so its
@@ -336,24 +368,7 @@ async function sendPrompt(session: ComposerSession, value: ComposerSubmission) {
   // waits behind, so it runs with the session selection at delivery time (the
   // intended selection stays recorded in its metadata).
   if (value.delivery === "steer") {
-    const current = session.current()
-    if (current?.agent !== value.selection.agent) {
-      await session.api.switchAgent({ sessionID: session.id, agent: value.selection.agent })
-    }
-    if (
-      current?.model?.providerID !== value.selection.model.providerID ||
-      current.model.id !== value.selection.model.modelID ||
-      (current.model.variant ?? "default") !== (value.selection.variant ?? "default")
-    ) {
-      await session.api.switchModel({
-        sessionID: session.id,
-        model: {
-          id: value.selection.model.modelID,
-          providerID: value.selection.model.providerID,
-          variant: value.selection.variant,
-        },
-      })
-    }
+    await applySelection(session, value.selection, track)
   }
 
   const admission = {

packages/app/src/entry.tsx

@@ -76,22 +76,24 @@ if (root instanceof HTMLElement && root.dataset.opencodeMounted === undefined) {
     const standalone = isStandalone()
     root.dataset.standalone = String(standalone)
     if (standalone) restorePwaRoute()
-    const server: ServerConnection.Http = {
-      type: "http",
-      authToken: !!auth,
-      http: {
-        url: web.currentServerUrl,
-        ...auth,
-      },
-    }
+    const server: ServerConnection.Http | undefined = web.currentServerUrl
+      ? {
+          type: "http",
+          authToken: !!auth,
+          http: {
+            url: web.currentServerUrl,
+            ...auth,
+          },
+        }
+      : undefined
     render(
       () => (
         <PlatformProvider value={web.platform}>
           <AppBaseProviders locale={locale}>
             <AppInterface
-              defaultServer={ServerConnection.Key.make(web.defaultServerUrl)}
-              canonicalLocalServer={ServerConnection.key(server)}
-              servers={[server]}
+              defaultServer={web.defaultServerUrl ? ServerConnection.Key.make(web.defaultServerUrl) : undefined}
+              canonicalLocalServer={server ? ServerConnection.key(server) : undefined}
+              servers={server ? [server] : []}
             >
               <KeyboardInsets />
               {standalone && <PwaRoutePersistence />}

packages/app/src/env.d.ts

@@ -1,4 +1,5 @@
 interface ImportMetaEnv {
+  readonly VITE_OPENCODE_SERVER_MODE?: "none" | "origin"
   readonly VITE_OPENCODE_SERVER_HOST: string
   readonly VITE_OPENCODE_SERVER_PORT: string
   readonly VITE_OPENCODE_CHANNEL?: "local" | "dev" | "beta" | "prod"

packages/app/src/home/projects/view.tsx

@@ -198,26 +198,30 @@ function HomeProjectsPanel(props: HomeProjectsViewProps) {
         <Show
           when={props.servers.length > 1}
           fallback={
-            <div class={props.dropdown ? "" : "pr-3"}>
-              <Show
-                when={props.projects.length > 0}
-                fallback={<HomeProjectEmpty {...props} server={props.servers[0]} items={props.recentlyClosed} />}
-              >
-                <HomeProjectList {...props} {...contextMenuProps} server={props.servers[0]} items={props.projects} />
-                <Show when={props.dropdown}>
-                  <HomeProjectNavButton
-                    type="button"
-                    data-action="home-add-project-row"
-                    class="mt-1 disabled:opacity-60"
-                    disabled={props.serverHealth(props.servers[0])?.healthy === false}
-                    onClick={() => props.onChooseProject(props.servers[0])}
+            <Show when={props.servers[0]}>
+              {(server) => (
+                <div class={props.dropdown ? "" : "pr-3"}>
+                  <Show
+                    when={props.projects.length > 0}
+                    fallback={<HomeProjectEmpty {...props} server={server()} items={props.recentlyClosed} />}
                   >
-                    <Icon name="folder-add-left" size="small" />
-                    <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("home.project.add")}</span>
-                  </HomeProjectNavButton>
-                </Show>
-              </Show>
-            </div>
+                    <HomeProjectList {...props} {...contextMenuProps} server={server()} items={props.projects} />
+                    <Show when={props.dropdown}>
+                      <HomeProjectNavButton
+                        type="button"
+                        data-action="home-add-project-row"
+                        class="mt-1 disabled:opacity-60"
+                        disabled={props.serverHealth(server())?.healthy === false}
+                        onClick={() => props.onChooseProject(server())}
+                      >
+                        <Icon name="folder-add-left" size="small" />
+                        <span class={HOME_PROJECT_NAV_LABEL}>{props.language.t("home.project.add")}</span>
+                      </HomeProjectNavButton>
+                    </Show>
+                  </Show>
+                </div>
+              )}
+            </Show>
           }
         >
           <div class={`flex min-w-0 flex-col ${props.dropdown ? "gap-1" : "gap-4 pr-3"}`}>

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

@@ -311,8 +311,10 @@ export function createHomeSessionsController(home: HomeController) {
         dialog.show(() => <DeleteDialog server={server} session={session} />),
     },
     tab: {
-      isOpen: (record: HomeSessionRecord) =>
-        sessionHasOpenTab(tabs.store, home.selection.value().server, record.session),
+      isOpen: (record: HomeSessionRecord) => {
+        const server = home.selection.value().server
+        return !!server && sessionHasOpenTab(tabs.store, server, record.session)
+      },
     },
   }
 }

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

@@ -2,6 +2,7 @@ import type { HomeScrollController } from "../scroll"
 import type { HomeSessionSearchController } from "./search"
 import type { HomeSessionsController } from "./controller"
 import { HomeSessionsView } from "./view"
+import { Show } from "solid-js"
 
 export function HomeSessions(props: {
   sessions: HomeSessionsController
@@ -9,43 +10,47 @@ export function HomeSessions(props: {
   scroll: HomeScrollController
 }) {
   return (
-    <HomeSessionsView
-      language={props.sessions.copy.language}
-      groups={props.sessions.data.groups()}
-      loading={props.sessions.data.loading()}
-      showProjectName={props.sessions.session.showProjectName()}
-      server={props.sessions.session.server()}
-      canCreateSession={props.sessions.session.canCreate()}
-      searchValue={props.search.query.value()}
-      searchPlaceholder={props.search.query.placeholder()}
-      searchOpen={props.search.query.open()}
-      searchLoading={props.search.result.loading()}
-      searchResults={props.search.result.list()}
-      searchActive={props.search.result.active()}
-      searchNoResultsLabel={props.search.result.noResultsLabel()}
-      titleOpacity={props.scroll.header.titleOpacity}
-      isOpenTab={props.sessions.tab.isOpen}
-      onCreateSession={props.sessions.session.create}
-      onOpenSession={props.sessions.session.open}
-      onArchiveSession={props.sessions.session.archive}
-      onRenameSession={props.sessions.session.rename}
-      onExportSession={props.sessions.session.export}
-      onDeleteSession={props.sessions.session.showDelete}
-      onSetHoverTarget={props.scroll.viewport.setHoverTarget}
-      onSetThumbTrack={props.scroll.viewport.setThumbTrack}
-      onSetContent={props.scroll.header.setContent}
-      onSetHeader={props.scroll.header.setHeader}
-      onWheel={props.scroll.viewport.containWheel}
-      onSetSearchRoot={props.search.element.setRoot}
-      onSetSearchInput={props.search.element.setInput}
-      onSetSearchList={props.search.element.setList}
-      onSearchFocus={props.search.query.focus}
-      onSearchInput={props.search.query.input}
-      onSearchClose={props.search.query.close}
-      onSearchMove={props.search.result.move}
-      onSearchSelectActive={props.search.result.selectActive}
-      onSearchHighlight={props.search.result.highlight}
-      onSearchSelect={props.search.result.select}
-    />
+    <Show when={props.sessions.session.server()}>
+      {(server) => (
+        <HomeSessionsView
+          language={props.sessions.copy.language}
+          groups={props.sessions.data.groups()}
+          loading={props.sessions.data.loading()}
+          showProjectName={props.sessions.session.showProjectName()}
+          server={server()}
+          canCreateSession={props.sessions.session.canCreate()}
+          searchValue={props.search.query.value()}
+          searchPlaceholder={props.search.query.placeholder()}
+          searchOpen={props.search.query.open()}
+          searchLoading={props.search.result.loading()}
+          searchResults={props.search.result.list()}
+          searchActive={props.search.result.active()}
+          searchNoResultsLabel={props.search.result.noResultsLabel()}
+          titleOpacity={props.scroll.header.titleOpacity}
+          isOpenTab={props.sessions.tab.isOpen}
+          onCreateSession={props.sessions.session.create}
+          onOpenSession={props.sessions.session.open}
+          onArchiveSession={props.sessions.session.archive}
+          onRenameSession={props.sessions.session.rename}
+          onExportSession={props.sessions.session.export}
+          onDeleteSession={props.sessions.session.showDelete}
+          onSetHoverTarget={props.scroll.viewport.setHoverTarget}
+          onSetThumbTrack={props.scroll.viewport.setThumbTrack}
+          onSetContent={props.scroll.header.setContent}
+          onSetHeader={props.scroll.header.setHeader}
+          onWheel={props.scroll.viewport.containWheel}
+          onSetSearchRoot={props.search.element.setRoot}
+          onSetSearchInput={props.search.element.setInput}
+          onSetSearchList={props.search.element.setList}
+          onSearchFocus={props.search.query.focus}
+          onSearchInput={props.search.query.input}
+          onSearchClose={props.search.query.close}
+          onSearchMove={props.search.result.move}
+          onSearchSelectActive={props.search.result.selectActive}
+          onSearchHighlight={props.search.result.highlight}
+          onSearchSelect={props.search.result.select}
+        />
+      )}
+    </Show>
   )
 }

packages/app/src/new-session/composer-adapter.ts

@@ -110,6 +110,7 @@ export function createNewSessionComposerAdapter(props: {
           agent: selection.agent,
           model: selection.model,
           variant: selection.variant ?? null,
+          choices: model.remembered(),
         })
         if (!pending) tabs.promoteDraft(draftID, { server: server.key, sessionId: created.id })
         submission.retarget(

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

@@ -177,7 +177,7 @@ export function PromptWorkspaceSelector(props: {
                     </span>
                   </Menu.SubTrigger>
                   <Menu.Portal>
-                    <Menu.SubContent class="max-h-[calc(100dvh-16px)] w-[200px] overflow-y-auto">
+                    <Menu.SubContent class="max-h-[224px] w-[200px] overflow-y-auto">
                       <Show when={props.workspaces.length >= 10}>
                         <div class="flex h-7 items-center gap-2 rounded-sm ps-3 pe-2 text-v2-icon-icon-muted">
                           <Icon name="magnifying-glass" size="small" class="shrink-0" />

packages/app/src/providers/models/configured.ts

@@ -0,0 +1,28 @@
+import { createEffect, createMemo, on } from "solid-js"
+import { useData } from "@/runtime/server/current"
+import { useWorkspaceLocation } from "@/workspaces/location"
+import { useServerSDK } from "@/runtime/server/client"
+
+export function useConfiguredModel() {
+  const data = useData()
+  const location = useWorkspaceLocation()
+  const server = useServerSDK()
+  createEffect(
+    on(
+      () => [location().directory, server.connection.status()] as const,
+      ([directory]) => {
+        void data.location.config.sync({ directory }).catch(() => undefined)
+      },
+    ),
+  )
+  const documents = () => data.location.config.list({ directory: location().directory })
+  const model = createMemo(() => {
+    const entry = documents()?.findLast((entry) => entry.type === "document" && entry.info.model !== undefined)
+    const model = entry?.type === "document" ? entry.info.model : undefined
+    if (!model) return
+    if (typeof model !== "string") return { providerID: model.providerID, modelID: model.model, variant: model.variant }
+    const [providerID, ...parts] = model.split("/")
+    return { providerID, modelID: parts.join("/"), variant: undefined }
+  })
+  return Object.assign(model, { ready: () => documents() !== undefined })
+}

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

@@ -122,10 +122,10 @@ const createModelsController = (directory: Accessor<string | undefined>) => {
   const setVariant = (model: ModelKey, value: string | undefined) => {
     const key = variantKey(model)
     if (!store.variant) {
-      setStore("variant", { [key]: value })
+      setStore("variant", { [key]: value ?? "default" })
       return
     }
-    setStore("variant", key, value)
+    setStore("variant", key, value ?? "default")
   }
 
   return {

packages/app/src/providers/models/select-dialog.tsx

@@ -1,7 +1,7 @@
 import { Popover } from "@kobalte/core/popover"
 import { Component, ComponentProps, createEffect, createMemo, For, JSX, Show } from "solid-js"
 import { createStore } from "solid-js/store"
-import { useLocal } from "@/providers/models/selection"
+import { useLocal, type ModelSelection } from "@/providers/models/selection"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { popularProviders } from "@/providers/catalog/providers"
 import { Button } from "@opencode/ui/button"
@@ -27,7 +27,7 @@ import "@/settings/settings.css"
 const isFree = (provider: string, cost: { input: number } | undefined) =>
   provider === "opencode" && (!cost || cost.input === 0)
 
-type ModelState = ReturnType<typeof useLocal>["model"]
+type ModelState = ModelSelection
 type ModelItem = ReturnType<ModelState["list"]>[number]
 
 const modelKey = (model: ModelItem) => `${model.provider.id}:${model.id}`

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

@@ -1,7 +1,7 @@
 import { createSimpleContext } from "@opencode/ui/context"
 import { base64Encode } from "@opencode/util/encode"
 import { useParams } from "@solidjs/router"
-import { batch, createEffect, createMemo, startTransition } from "solid-js"
+import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Schema, SchemaGetter } from "effect"
 import { useModels } from "@/providers/models/models"
@@ -16,6 +16,7 @@ import { useData } from "@/runtime/server/current"
 import { normalizeAgentList } from "@/runtime/server/global-sync/utils"
 import { useServerSDK } from "@/runtime/server/client"
 import { ScopedKey, type ServerScope } from "@/runtime/server/scope"
+import { useConfiguredModel } from "./configured"
 
 const ModelKeySchema = Schema.Struct({
   providerID: Schema.String,
@@ -24,11 +25,15 @@ const ModelKeySchema = Schema.Struct({
 })
 export type ModelKey = typeof ModelKeySchema.Type
 
-const StateSchema = Schema.Struct({
-  agent: Persistence.optional(Schema.String),
+const ChoiceSchema = Schema.Struct({
   model: Persistence.optional(ModelKeySchema),
   variant: Persistence.optional(Schema.NullOr(Schema.String)),
 })
+const StateSchema = Schema.Struct({
+  ...ChoiceSchema.fields,
+  agent: Persistence.optional(Schema.String),
+  choices: Persistence.optional(Schema.Record(Schema.String, ChoiceSchema)),
+})
 type State = typeof StateSchema.Type
 
 const SessionsSchema = Schema.Record(
@@ -78,6 +83,7 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     const providers = useProviders(() => sdk().directory)
     const models = useModels()
     const settings = useSettings()
+    const configuredModel = useConfiguredModel()
 
     const id = createMemo(() => params.id || undefined)
     const list = createMemo(() =>
@@ -98,16 +104,9 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       current?: string
       draft?: State
       promoting?: State
-      last?: {
-        type: "agent" | "model" | "variant"
-        agent?: string
-        model?: ModelKey | null
-        variant?: string | null
-      }
     }>({
       current: list()[0]?.name,
       draft: undefined,
-      last: undefined,
     })
 
     const validModel = (model: ModelKey) => {
@@ -176,13 +175,17 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       }
     }
 
-    const fallback = createMemo<ModelKey | undefined>(() => recentModel() ?? defaultModel())
+    const fallback = createMemo(() => firstModel(configuredModel, recentModel, defaultModel))
+    const durable = () => {
+      const session = id()
+      return session ? data.session.get(session) : undefined
+    }
 
     const agent = {
       list,
       visible: agentsVisible,
       current() {
-        return pickAgent(agentsVisible() ? (scope()?.agent ?? store.current) : "build")
+        return pickAgent(scope()?.agent ?? durable()?.agent ?? (agentsVisible() ? store.current : "build"))
       },
       set(name: string | undefined) {
         const item = pickAgent(name)
@@ -192,25 +195,24 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         }
 
         batch(() => {
-          setStore("current", item.name)
-          setStore("last", {
-            type: "agent",
-            agent: item.name,
-            model: item.model,
-            variant: item.variant ?? null,
-          })
+          const previous = snapshot()
+          if (previous.agent === item.name) return
           const prev = scope()
+          const choices = {
+            ...prev?.choices,
+            ...(previous.agent ? { [previous.agent]: { model: previous.model, variant: previous.variant } } : {}),
+          }
+          setStore("current", item.name)
           const next = {
             agent: item.name,
-            model: item.model ?? prev?.model,
-            variant: item.variant ?? prev?.variant,
+            model: choices[item.name]?.model,
+            variant: choices[item.name]?.variant,
+            choices,
           } satisfies State
-          const session = id()
-          if (session) {
-            setSaved("session", session, next)
-            return
-          }
-          setStore("draft", next)
+          write(next)
+          // Pin both choices while the agent and model acknowledgments arrive separately.
+          const selected = current()
+          if (selected) model.set({ providerID: selected.provider.id, modelID: selected.id })
         })
       },
       move(direction: 1 | -1) {
@@ -230,8 +232,15 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
     }
 
     const current = createMemo(() => {
+      if (!configuredModel.ready()) return
       const item = firstModel(
         () => scope()?.model,
+        () => {
+          const session = durable()
+          if (session?.agent && session.agent !== agent.current()?.name) return
+          const model = session?.model
+          return model && { providerID: model.providerID, modelID: model.id }
+        },
         () => agent.current()?.model,
         fallback,
       )
@@ -243,26 +252,41 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       const item = agent.current()
       const model = current()
       if (!item || !model) return
-      return getConfiguredAgentVariant({
-        agent: { model: item.model, variant: item.variant },
-        model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
-      })
+      const global = configuredModel()
+      return (
+        getConfiguredAgentVariant({
+          agent: { model: item.model, variant: item.variant },
+          model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
+        }) ??
+        getConfiguredAgentVariant({
+          agent: { model: global, variant: global?.variant },
+          model: { providerID: model.provider.id, modelID: model.id, variants: model.variants },
+        })
+      )
     }
 
-    const selected = () => scope()?.variant
+    const selected = () => {
+      const draft = scope()
+      if (draft?.model && validModel(draft.model)) return draft.variant
+      const session = durable()
+      if (session?.agent && session.agent !== agent.current()?.name) return
+      const value = session?.model
+      if (value && validModel({ providerID: value.providerID, modelID: value.id })) return value.variant ?? null
+    }
 
     const snapshot = () => {
-      const model = current()
+      const selected = current()
       return {
         agent: agent.current()?.name,
-        model: model ? { providerID: model.provider.id, modelID: model.id } : undefined,
-        variant: selected(),
+        model: selected ? { providerID: selected.provider.id, modelID: selected.id } : undefined,
+        variant: selected ? (model.variant.current() ?? null) : undefined,
       } satisfies State
     }
 
     const write = (next: Partial<State>) => {
       const state = {
-        ...(scope() ?? { agent: agent.current()?.name }),
+        ...scope(),
+        agent: agent.current()?.name,
         ...next,
       } satisfies State
 
@@ -274,22 +298,59 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
       setStore("draft", state)
     }
 
-    const recent = createMemo(() => models.recent.list().map(models.find).filter(Boolean))
+    const recent = createMemo(() => models.recent.list().filter(validModel).map(models.find).filter(Boolean))
+    const pending = new Map<string, State>()
+    const sameSelection = (a: State, b: State) =>
+      a.agent === b.agent &&
+      a.model?.providerID === b.model?.providerID &&
+      a.model?.modelID === b.model?.modelID &&
+      (a.variant ?? "default") === (b.variant ?? "default")
+
+    const reconcile = (sessionID: string) => {
+      const expected = pending.get(sessionID)
+      const session = data.session.get(sessionID)
+      if (!expected || !session?.model) return
+      if (
+        !sameSelection(expected, {
+          agent: session.agent,
+          model: { providerID: session.model.providerID, modelID: session.model.id },
+          variant: session.model.variant,
+        })
+      )
+        return
+      pending.delete(sessionID)
+      const draft = saved.session[sessionID]
+      if (id() !== sessionID || !draft || !sameSelection(draft, expected)) return
+      setSaved("session", sessionID, { agent: undefined, model: undefined, variant: undefined })
+    }
+    onCleanup(serverSDK.event.on("session.model.selected", (event) => reconcile(event.data.sessionID)))
+    onCleanup(serverSDK.event.on("session.agent.selected", (event) => reconcile(event.data.sessionID)))
+    onCleanup(
+      serverSDK.event.on("session.deleted", (event) => {
+        pending.delete(event.data.sessionID)
+        setSaved("session", event.data.sessionID, undefined)
+      }),
+    )
 
     const model = {
-      ready: models.ready,
+      ready: Object.assign(() => models.ready() && configuredModel.ready(), { promise: models.ready.promise }),
       current,
       recent,
       list: models.list,
+      trackSessionCommit(sessionID: string, selection: { agent: string; model: ModelKey; variant?: string }) {
+        pending.set(sessionID, selection)
+        reconcile(sessionID)
+        return () => {
+          if (pending.get(sessionID) === selection) pending.delete(sessionID)
+        }
+      },
       cycle(direction: 1 | -1) {
         const items = recent()
         const item = current()
         if (!item) return
 
         const index = items.findIndex((entry) => entry?.provider.id === item.provider.id && entry?.id === item.id)
-        if (index === -1) return
-
-        let next = index + direction
+        let next = index === -1 ? (direction === 1 ? 0 : items.length - 1) : index + direction
         if (next < 0) next = items.length - 1
         if (next >= items.length) next = 0
 
@@ -298,21 +359,18 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         model.set({ providerID: entry.provider.id, modelID: entry.id })
       },
       set(item: ModelKey | undefined, options?: { recent?: boolean }) {
-        startTransition(() =>
-          batch(() => {
-            setStore("last", {
-              type: "model",
-              agent: agent.current()?.name,
-              model: item ?? null,
-              variant: selected(),
-            })
-            write({ model: item })
-            if (!item) return
-            models.setVisibility(item, true)
-            if (!options?.recent) return
-            models.recent.push(item)
-          }),
-        )
+        batch(() => {
+          if (item && !validModel(item)) return
+          const previous = current()
+          const same = item && previous?.provider.id === item.providerID && previous.id === item.modelID
+          write({ model: item, variant: same ? (model.variant.current() ?? null) : undefined })
+          if (!item) return
+          // A session draft owns its variant even when preferences change in another session.
+          if (id() && !same) write({ variant: model.variant.current() ?? null })
+          models.setVisibility(item, true)
+          if (!options?.recent) return
+          models.recent.push(item)
+        })
       },
       visible(item: ModelKey) {
         return models.visible(item)
@@ -324,16 +382,13 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         configured,
         selected,
         current() {
-          const resolved = resolveModelVariant({
+          const model = current()
+          return resolveModelVariant({
             variants: this.list(),
             selected: this.selected(),
             configured: this.configured(),
+            preferred: model ? models.variant.get({ providerID: model.provider.id, modelID: model.id }) : undefined,
           })
-          if (resolved) return resolved
-          const model = current()
-          if (!model) return
-          const saved = models.variant.get({ providerID: model.provider.id, modelID: model.id })
-          if (saved && this.list().includes(saved)) return saved
         },
         list() {
           const item = current()
@@ -341,21 +396,12 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           return Object.keys(item.variants)
         },
         set(value: string | undefined) {
-          startTransition(() =>
-            batch(() => {
-              const model = current()
-              setStore("last", {
-                type: "variant",
-                agent: agent.current()?.name,
-                model: model ? { providerID: model.provider.id, modelID: model.id } : null,
-                variant: value ?? null,
-              })
-              write({ variant: value ?? null })
-              if (model) {
-                models.variant.set({ providerID: model.provider.id, modelID: model.id }, value ?? undefined)
-              }
-            }),
-          )
+          batch(() => {
+            const model = current()
+            if (!model) return
+            write({ model: { providerID: model.provider.id, modelID: model.id }, variant: value ?? null })
+            models.variant.set({ providerID: model.provider.id, modelID: model.id }, value)
+          })
         },
         cycle() {
           const items = this.list()
@@ -363,8 +409,8 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
           this.set(
             cycleModelVariant({
               variants: items,
-              selected: this.selected(),
-              configured: this.configured(),
+              selected: this.current() ?? null,
+              configured: undefined,
             }),
           )
         },
@@ -383,20 +429,34 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
         promote(dir: string, session: string, state?: State) {
           const next = clone(state ?? snapshot())
           if (!next) return
+          // Creation already owns the active selection; keep only agent memory once it is in the read model.
+          // Otherwise a first-message command's configured overrides would stay hidden behind this handoff.
+          const created = data.session.get(session)
+          const selection = created?.model
+          const committed =
+            selection &&
+            sameSelection(next, {
+              agent: created.agent,
+              model: { providerID: selection.providerID, modelID: selection.id },
+              variant: selection.variant,
+            })
+              ? { choices: next.choices }
+              : next
           const key = handoffKey(serverSDK.scope, dir, session)
-          handoff.set(key, next)
+          handoff.set(key, committed)
 
           if (dir === sdk().directory) {
-            setSaved("session", session, next)
+            setSaved("session", session, committed)
           }
 
-          setStore("promoting", next)
+          setStore("promoting", committed)
           setStore("draft", undefined)
         },
         restore(msg: { sessionID: string; agent: string; model: ModelKey }) {
           const session = id()
           if (!session) return
           if (msg.sessionID !== session) return
+          if (durable()?.model) return
           if (saved.session[session] !== undefined) return
           if (handoff.has(handoffKey(serverSDK.scope, sdk().directory, session))) return
 
@@ -412,4 +472,5 @@ export const { use: useLocal, provider: LocalProvider } = createSimpleContext({
   },
 })
 
-export type ModelSelection = ReturnType<typeof useLocal>["model"]
+export type ModelSelection = Omit<ReturnType<typeof useLocal>["model"], "trackSessionCommit"> &
+  Partial<Pick<ReturnType<typeof useLocal>["model"], "trackSessionCommit">>

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

@@ -6,13 +6,13 @@ import { Tooltip } from "@opencode/ui/tooltip"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { useTheme } from "@opencode/ui/theme"
 import { createMemo, onCleanup, onMount, type Component, For, Show } from "solid-js"
-import { useLocal } from "@/providers/models/selection"
+import { useLocal, type ModelSelection } from "@/providers/models/selection"
 import { useIntegrations } from "@/providers/catalog/integrations"
 import { decode64 } from "@/runtime/persistence/base64"
 import { useLanguage } from "@/runtime/i18n/language"
 import { ModelTooltip } from "./tooltip"
 
-type ModelState = ReturnType<typeof useLocal>["model"]
+type ModelState = ModelSelection
 const featuredProviders = ["opencode-go", "opencode", "openai", "anthropic", "google", "github-copilot"]
 const displayModelName = (name: string) => name.replace(/\s+(?:\(free\)|free)$/i, "")
 

packages/app/src/providers/models/variant.test.ts

@@ -64,14 +64,14 @@ describe("model variant", () => {
     expect(value).toBe("xhigh")
   })
 
-  test("wraps from configured last variant to first", () => {
+  test("cycles from configured last variant to default", () => {
     const value = cycleModelVariant({
       variants: ["low", "high", "xhigh"],
       selected: undefined,
       configured: "xhigh",
     })
 
-    expect(value).toBe("low")
+    expect(value).toBeUndefined()
   })
 
   test("cycles from an explicit default to the first variant", () => {
@@ -83,4 +83,22 @@ describe("model variant", () => {
 
     expect(value).toBe("low")
   })
+
+  test("prefers a saved variant to configuration, including explicit Default", () => {
+    const input = { variants: ["low", "high"], selected: undefined, configured: "high" }
+    expect(resolveModelVariant({ ...input, preferred: "low" })).toBe("low")
+    expect(resolveModelVariant({ ...input, preferred: "default" })).toBeUndefined()
+    expect(resolveModelVariant({ ...input, preferred: "low", selected: null })).toBeUndefined()
+    expect(resolveModelVariant({ ...input, preferred: "low", selected: "high" })).toBe("high")
+    expect(cycleModelVariant({ ...input, preferred: "high" })).toBeUndefined()
+    expect(cycleModelVariant({ ...input, preferred: "default" })).toBe("low")
+  })
+
+  test("normalizes unavailable selections instead of silently applying another variant", () => {
+    expect(resolveModelVariant({ variants: ["low"], selected: "high", configured: "low" })).toBeUndefined()
+    expect(
+      resolveModelVariant({ variants: ["low"], selected: undefined, preferred: "high", configured: "low" }),
+    ).toBeUndefined()
+    expect(cycleModelVariant({ variants: [], selected: undefined, configured: undefined })).toBeUndefined()
+  })
 })

packages/app/src/providers/models/variant.ts

@@ -16,6 +16,7 @@ type VariantInput = {
   variants: string[]
   selected: string | null | undefined
   configured: string | undefined
+  preferred?: string
 }
 
 export function getConfiguredAgentVariant(input: { agent: Agent | undefined; model: Model | undefined }) {
@@ -24,29 +25,16 @@ export function getConfiguredAgentVariant(input: { agent: Agent | undefined; mod
   if (!input.model?.variants) return undefined
   if (input.agent.model.providerID !== input.model.providerID) return undefined
   if (input.agent.model.modelID !== input.model.modelID) return undefined
-  if (!(input.agent.variant in input.model.variants)) return undefined
   return input.agent.variant
 }
 
 export function resolveModelVariant(input: VariantInput) {
   if (input.selected === null) return undefined
-  if (input.selected && input.variants.includes(input.selected)) return input.selected
-  if (input.configured && input.variants.includes(input.configured)) return input.configured
-  return undefined
+  const value = input.selected ?? input.preferred ?? input.configured
+  return value && value !== "default" && input.variants.includes(value) ? value : undefined
 }
 
 export function cycleModelVariant(input: VariantInput) {
-  if (input.variants.length === 0) return undefined
-  if (input.selected === null) return input.variants[0]
-  if (input.selected && input.variants.includes(input.selected)) {
-    const index = input.variants.indexOf(input.selected)
-    if (index === input.variants.length - 1) return undefined
-    return input.variants[index + 1]
-  }
-  if (input.configured && input.variants.includes(input.configured)) {
-    const index = input.variants.indexOf(input.configured)
-    if (index === input.variants.length - 1) return input.variants[0]
-    return input.variants[index + 1]
-  }
-  return input.variants[0]
+  const current = resolveModelVariant(input)
+  return input.variants[current ? input.variants.indexOf(current) + 1 : 0]
 }

packages/app/src/runtime/i18n/en.ts

@@ -366,6 +366,25 @@ export const dict = {
   "dialog.server.add.namePlaceholder": "Localhost",
   "dialog.server.add.password": "Password",
   "dialog.server.add.passwordPlaceholder": "password",
+
+  "server.connect.title": "Connect to a server",
+  "server.connect.description": "Enter your server address and password to get started.",
+  "server.connect.button": "Connect",
+  "server.connect.address.invalid": "Enter a valid HTTP or HTTPS server address.",
+  "server.connect.failed": "Could not connect. Check the server address and password, then try again.",
+  "server.connect.pair.description": "Run this command on your computer to get your connection details.",
+  "server.connect.scan": "Scan QR code",
+  "server.connect.scan.description": "Point your camera at the QR code shown by opencode pair.",
+  "server.connect.scan.invalid": "This is not an OpenCode pairing code. Scan the code shown by opencode pair.",
+  "server.connect.camera": "Pairing camera",
+  "server.connect.camera.starting": "Opening camera…",
+  "server.connect.mixedContent":
+    "Could not connect to this HTTP server from an HTTPS page. Use an HTTPS server address instead.",
+  "server.connect.camera.insecure": "QR scanning requires opening this page over HTTPS or on localhost.",
+  "server.connect.camera.unavailable":
+    "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.",
   "dialog.server.edit.title": "Edit server",
   "dialog.server.default.title": "Default server",
   "dialog.server.default.description":

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

@@ -230,3 +230,72 @@ describe("draft store text externalization", () => {
     expect(JSON.parse(memory.documents.get("doc")!).prompt[0].content.blob.ids).toHaveLength(1)
   })
 })
+
+describe("draft store image retention", () => {
+  const image = (byte: number) => new Blob([new Uint8Array(6).fill(byte)], { type: "image/png" })
+  const fresh = (grace = 0) => {
+    const memory = memoryDriver()
+    return { memory, store: createDraftStore(memory.driver, { grace }) }
+  }
+  // Release timers fire on the macrotask queue; a zero grace has fired after one tick.
+  const tick = () => new Promise((resolve) => setTimeout(resolve, 5))
+  // An image with no object URL left gets a new one when its bytes are uploaded again.
+  const released = async (store: ReturnType<typeof createDraftStore>, byte: number, url: string) =>
+    (await store.putBlob(image(byte))).url !== url
+
+  test("an uploaded image no document references is released after the grace", async () => {
+    const { store } = fresh()
+    const orphan = await store.putBlob(image(1))
+    await tick()
+    expect(await released(store, 1, orphan.url)).toBe(true)
+  })
+
+  test("an image referenced within the grace is kept", async () => {
+    const { store } = fresh(50)
+    const pasted = await store.putBlob(image(2))
+    await store.setDocument("pinned", { prompt: [{ type: "image", blob: pasted }] })
+    await new Promise((resolve) => setTimeout(resolve, 80))
+    expect(await released(store, 2, pasted.url)).toBe(false)
+  })
+
+  test("saving a document without an image or removing the document releases it", async () => {
+    const { store } = fresh()
+    const dropped = await store.putBlob(image(3))
+    const removed = await store.putBlob(image(4))
+    await store.setDocument("edited", { prompt: [{ type: "image", blob: dropped }] })
+    await store.setDocument("closed", { prompt: [{ type: "image", blob: removed }] })
+    await tick()
+    expect(await released(store, 3, dropped.url)).toBe(false)
+    expect(await released(store, 4, removed.url)).toBe(false)
+    await store.setDocument("edited", { prompt: [{ type: "text", content: "typed over it" }] })
+    await store.removeItem("closed")
+    await tick()
+    expect(await released(store, 3, dropped.url)).toBe(true)
+    expect(await released(store, 4, removed.url)).toBe(true)
+  })
+
+  test("an image referenced by two documents survives until both drop it", async () => {
+    const { store } = fresh()
+    const shared = await store.putBlob(image(5))
+    await store.setDocument("composer", { prompt: [{ type: "image", blob: shared }] })
+    await store.setDocument("history", { entries: [{ prompt: [{ type: "image", blob: shared }] }] })
+    await store.setDocument("composer", { prompt: [] })
+    await tick()
+    expect(await released(store, 5, shared.url)).toBe(false)
+    await store.setDocument("history", { entries: [] })
+    await tick()
+    expect(await released(store, 5, shared.url)).toBe(true)
+  })
+
+  test("loading a document pins the images it references", async () => {
+    const { memory, store } = fresh()
+    const id = await memory.driver.putBlob(image(6))
+    memory.documents.set("loaded", JSON.stringify({ prompt: [{ type: "image", blob: { id } }] }))
+    const url = JSON.parse((await store.getItem("loaded"))!).prompt[0].blob.url
+    await tick()
+    expect(await released(store, 6, url)).toBe(false)
+    await store.removeItem("loaded")
+    await tick()
+    expect(await released(store, 6, url)).toBe(true)
+  })
+})

packages/app/src/runtime/persistence/drafts.ts

@@ -28,23 +28,77 @@ export const draftTextThreshold = 16 * 1024
 export const draftTextChunk = 64 * 1024
 const textCacheLimit = 64
 
-const urls = new Map<string, string>()
-// The object URL already pins the Blob for the page's lifetime; keeping the Blob itself lets a
-// collected image be uploaded again without fetching the URL.
-const held = new Map<string, Blob>()
+// Decoded image bytes the renderer pins through object URLs. Every consumer of a `blob.url` is a
+// persisted draft document (composer prompt, prompt history), so an image is pinned exactly while a
+// stored document references it. Once the last reference disappears (removed from a draft, sent, or
+// a discarded duplicate paste) the URL is revoked after this grace, which covers the persist delay
+// between a paste and the save that references it, and the submit → history handoff.
+export const retainedBlobGrace = 30_000
+
+type Retained = { blob: Blob; url: string; release: ReturnType<typeof setTimeout> | undefined }
+const retained = new Map<string, Retained>()
+// Document keys that reference each image id; an id with no keys is released after the grace.
+const refs = new Map<string, Set<string>>()
 // Image ids that were restored under a different id (a store without WebCrypto assigns fresh
 // ones); live references still carry the original.
 const aliases = new Map<string, string>()
 
-function blobUrl(id: string, blob: Blob) {
-  const existing = urls.get(id)
-  if (existing) return existing
+function blobUrl(id: string, blob: Blob, grace?: number) {
+  const existing = retained.get(id)
+  if (existing) return existing.url
   const url = URL.createObjectURL(blob)
-  urls.set(id, url)
-  held.set(id, blob)
+  // Without a grace the image has no store to reference it from and stays for the page's lifetime.
+  const release = grace === undefined || refs.get(id)?.size ? undefined : setTimeout(() => revoke(id), grace)
+  retained.set(id, { blob, url, release })
   return url
 }
 
+// Record which image ids `key` now references; ids it dropped are released once no other document
+// references them, ids it gained stay pinned.
+function retain(key: string, ids: ReadonlySet<string>, grace: number) {
+  for (const [id, keys] of refs) {
+    if (ids.has(id) || !keys.delete(key) || keys.size) continue
+    refs.delete(id)
+    const entry = retained.get(id)
+    if (entry) entry.release = setTimeout(() => revoke(id), grace)
+  }
+  for (const id of ids) {
+    const keys = refs.get(id) ?? new Set<string>()
+    keys.add(key)
+    refs.set(id, keys)
+    const entry = retained.get(id)
+    if (!entry) continue
+    clearTimeout(entry.release)
+    entry.release = undefined
+  }
+}
+
+function revoke(id: string) {
+  const entry = retained.get(id)
+  if (!entry) return
+  URL.revokeObjectURL(entry.url)
+  retained.delete(id)
+  for (const [from, to] of aliases) if (to === id) aliases.delete(from)
+}
+
+// Image ids a document references: `{ blob: { id } }` parts, not text chunk lists.
+function imageIDs(value: unknown, into = new Set<string>()): Set<string> {
+  if (Array.isArray(value)) {
+    value.forEach((entry) => imageIDs(entry, into))
+    return into
+  }
+  if (!value || typeof value !== "object") return into
+  const item = value as Record<string, unknown>
+  const blob = item.blob
+  if (blob && typeof blob === "object" && !("kind" in blob)) {
+    const id = (blob as Record<string, unknown>).id
+    if (typeof id === "string") into.add(id)
+    return into
+  }
+  Object.values(item).forEach((entry) => imageIDs(entry, into))
+  return into
+}
+
 async function blobID(blob: Blob) {
   const bytes = crypto.subtle
     ? new Uint8Array(await crypto.subtle.digest("SHA-256", await blob.arrayBuffer()))
@@ -60,24 +114,25 @@ export async function createBlobReference(blob: Blob): Promise<BlobReference> {
   return { id, url: blobUrl(id, blob) }
 }
 
-export function createDraftStore(driver: Driver): DraftStore {
+export function createDraftStore(driver: Driver, options: { grace?: number } = {}): DraftStore {
+  const grace = options.grace ?? retainedBlobGrace
   const versions = new Map<string, number>()
   const loading = new Map<string, Promise<string | undefined>>()
   const loadBlobUrl = (id: string) => {
-    const existing = urls.get(id)
-    if (existing) return existing
+    const existing = retained.get(id)
+    if (existing) return existing.url
     const pending = loading.get(id)
     if (pending) return pending
     const next = driver
       .getBlob(id)
-      .then((blob) => (blob ? blobUrl(id, blob) : undefined))
+      .then((blob) => (blob ? blobUrl(id, blob, grace) : undefined))
       .finally(() => loading.delete(id))
     loading.set(id, next)
     return next
   }
   const putBlob = async (blob: Blob) => {
     const id = await driver.putBlob(blob)
-    return { id, url: blobUrl(id, blob) }
+    return { id, url: blobUrl(id, blob, grace) }
   }
   // Keyed by chunk content so unchanged chunks are never hashed or sent again while the draft is
   // edited. Bounded because each entry pins up to draftTextChunk characters. A hit is safe even if
@@ -145,8 +200,8 @@ export function createDraftStore(driver: Driver): DraftStore {
       if (typeof blob.id === "string") {
         // A live reference keeps the id it was created with; publish the id its bytes now live under.
         const id = aliases.get(blob.id) ?? blob.id
-        const kept = held.get(id)
-        const url = typeof blob.url === "string" ? blob.url : urls.get(id)
+        const kept = retained.get(id)?.blob
+        const url = typeof blob.url === "string" ? blob.url : retained.get(id)?.url
         if (kept) sources.set(id, { blob: async () => kept })
         else if (url) sources.set(id, { blob: () => fetch(url).then((response) => response.blob()) })
         return { ...item, blob: { id } }
@@ -192,8 +247,7 @@ export function createDraftStore(driver: Driver): DraftStore {
           remember(chunks, next, source.chunk)
           return
         }
-        held.set(next, blob)
-        blobUrl(next, blob)
+        blobUrl(next, blob, grace)
         if (next === id) return
         // Later encodes of the still-live reference resolve straight to the new id. Re-point any
         // earlier alias chain so lookups stay one step.
@@ -225,14 +279,19 @@ export function createDraftStore(driver: Driver): DraftStore {
     // stays visible until the bytes are back. Covers a blob collected while a cache, another tab,
     // or the composer's history still held its id.
     const missing = await driver.set(key, JSON.stringify(encoded), true)
-    if (missing.length === 0) return
+    if (missing.length === 0) {
+      retain(key, imageIDs(encoded), grace)
+      return
+    }
     const renamed = await restore(missing, sources)
     if (versions.get(key) !== version) return
     const unrestored = missing.filter((id) => !renamed.has(id))
     if (unrestored.length)
       console.error(`[persistence] draft ${key} references blobs with no bytes to restore`, unrestored)
     // Anything still missing has no bytes anywhere; the owning codec drops such references on read.
-    await driver.set(key, JSON.stringify(rename(encoded, renamed)), false)
+    const final = rename(encoded, renamed)
+    await driver.set(key, JSON.stringify(final), false)
+    retain(key, imageIDs(final), grace)
   }
   return {
     getItem: async (key) => {
@@ -241,6 +300,8 @@ export function createDraftStore(driver: Driver): DraftStore {
       const parsed = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))(value)
       // Let the owning persistence codec apply its invalid-document policy.
       if (Option.isNone(parsed)) return value
+      // A loaded document is live in the composer: pin its images before decode mints their URLs.
+      retain(key, imageIDs(parsed.value), grace)
       return JSON.stringify(await decode(parsed.value))
     },
     setItem: (key, value) => setDocument(key, JSON.parse(value)),
@@ -248,6 +309,7 @@ export function createDraftStore(driver: Driver): DraftStore {
     removeItem: async (key) => {
       versions.set(key, (versions.get(key) ?? 0) + 1)
       await driver.remove(key)
+      retain(key, new Set(), grace)
     },
     putBlob,
   }
@@ -360,7 +422,8 @@ function referenced(json: string) {
 }
 
 export async function blobDataUrl(blob: BlobReference, mime: string) {
-  const data = await fetch(blob.url).then((response) => response.blob())
+  const kept = retained.get(aliases.get(blob.id) ?? blob.id)
+  const data = kept ? kept.blob : await fetch(blob.url).then((response) => response.blob())
   return new Promise<string>((resolve, reject) => {
     const reader = new FileReader()
     reader.addEventListener("error", () => reject(reader.error))

packages/app/src/runtime/platform/web.ts

@@ -53,7 +53,7 @@ export function createWebPlatform(version: string) {
 }
 
 function getCurrentServerUrl() {
-  if (location.hostname.includes("opencode.ai")) return "http://localhost:49374"
+  if (import.meta.env.VITE_OPENCODE_SERVER_MODE === "none") return undefined
   if (import.meta.env.DEV)
     return `http://${import.meta.env.VITE_OPENCODE_SERVER_HOST ?? "localhost"}:${import.meta.env.VITE_OPENCODE_SERVER_PORT ?? "4096"}`
   return location.origin

packages/app/src/runtime/server/data.ts

@@ -2,6 +2,7 @@ import type { Data } from "@opencode/client/solid"
 import type { SessionInfo } from "@opencode/client/promise"
 import { onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
+import { uuid } from "@/runtime/persistence/uuid"
 
 type SessionMutation = { readonly id: string; readonly type: "remove"; readonly sessionID: string }
 
@@ -35,7 +36,7 @@ export function createSessionMutations(remove: (sessionID: string) => Promise<vo
       return removed.size === 0 ? [...sessions] : sessions.filter((session) => !removed.has(session.id))
     },
     remove(sessionID: string) {
-      const mutation = { id: crypto.randomUUID(), type: "remove" as const, sessionID }
+      const mutation = { id: uuid(), type: "remove" as const, sessionID }
       setStore("session", (current) => [...current, mutation])
       return Promise.resolve()
         .then(() => remove(sessionID))

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

@@ -194,7 +194,7 @@ export const { use: useServers, provider: ServersProvider } = createSimpleContex
   name: "Server",
   gate: true,
   init: (props: {
-    defaultServer: ServerConnection.Key
+    defaultServer?: ServerConnection.Key
     canonicalLocalServer?: ServerConnection.Key
     servers?: Array<ServerConnection.Any>
   }) => {

packages/app/src/servers/connect/browser.ts

@@ -0,0 +1,12 @@
+import { serverAddress } from "./pairing"
+
+export function isMixedContent(page: string, address: string) {
+  if (new URL(page).protocol !== "https:") return false
+  const normalized = serverAddress(address)
+  if (!normalized) return false
+  const url = new URL(normalized)
+  if (url.protocol !== "http:") return false
+  // Secure Contexts treats loopback HTTP origins as potentially trustworthy.
+  const host = url.hostname.replace(/\.$/, "")
+  return !(host === "localhost" || host.endsWith(".localhost") || host === "[::1]" || /^127(?:\.\d+){3}$/.test(host))
+}

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

@@ -16,6 +16,8 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { normalizeServerUrl, ServerConnection, useServers } from "@/runtime/server/registry"
 import { useTabs } from "@/shell/tabs/tabs"
 import { useCheckServerHealth } from "@/runtime/server/health"
+import { usePlatform } from "@/runtime/platform/platform"
+import { isMixedContent } from "./browser"
 import "@/settings/settings.css"
 
 type FormMode = "list" | "add" | "edit"
@@ -81,11 +83,14 @@ export const DialogServer: Component<{
               invalid={!!form.state.error()}
               disabled={form.state.busy()}
               autofocus
+              aria-describedby={form.state.error() ? "dialog-server-error" : undefined}
               onInput={(event) => form.change.value(event.currentTarget.value)}
               onKeyDown={keyDown}
             />
             <Show when={form.state.error()}>
-              <span class="settings-server-dialog-error">{form.state.error()}</span>
+              <span id="dialog-server-error" class="settings-server-dialog-error" role="alert">
+                {form.state.error()}
+              </span>
             </Show>
           </div>
           <div class="flex w-full min-w-0 flex-col gap-2">
@@ -129,6 +134,7 @@ export const DialogServer: Component<{
 }
 
 function createFormController(options: { onSelect?: () => void } = {}) {
+  const platform = usePlatform()
   const server = useServers()
   const tabs = useTabs()
   const global = useGlobal()
@@ -201,7 +207,14 @@ function createFormController(options: { onSelect?: () => void } = {}) {
       }
       const result = await checkServerHealth(connection.http)
       if (!result.healthy) {
-        setStore("error", language.t("dialog.server.add.error"))
+        setStore(
+          "error",
+          language.t(
+            platform.platform === "web" && isMixedContent(location.href, normalized)
+              ? "server.connect.mixedContent"
+              : "dialog.server.add.error",
+          ),
+        )
         return
       }
       if (original?.type === "http") {

packages/app/src/servers/connect/pairing.ts

@@ -0,0 +1,28 @@
+import { Option, Schema } from "effect"
+import { normalizeServerUrl } from "@/runtime/server/registry"
+
+const pairing = Schema.fromJsonString(
+  Schema.Struct({
+    urls: Schema.Array(Schema.String),
+    username: Schema.Literal("opencode"),
+    password: Schema.String,
+  }),
+)
+
+export function serverAddress(value: string) {
+  if (value.includes("://") && !/^https?:\/\//.test(value.trim())) return
+  const normalized = normalizeServerUrl(value)
+  if (!normalized || !URL.canParse(normalized)) return
+  const url = new URL(normalized)
+  if (url.protocol !== "http:" && url.protocol !== "https:") return
+  if (url.username || url.password || url.search || url.hash) return
+  return normalized
+}
+
+export function decodePairingCode(value: string) {
+  const result = Schema.decodeUnknownOption(pairing)(value)
+  if (Option.isNone(result)) return
+  const urls = [...new Set(result.value.urls.map(serverAddress).filter((url) => url !== undefined))]
+  if (!urls.length) return
+  return { urls, password: result.value.password }
+}

packages/app/src/servers/connect/scanner.tsx

@@ -0,0 +1,62 @@
+import QrScanner from "qr-scanner"
+import { onCleanup, onMount, Show } from "solid-js"
+import { createStore } from "solid-js/store"
+import { Button } from "@opencode/ui/button"
+import { useLanguage } from "@/runtime/i18n/language"
+import { decodePairingCode } from "./pairing"
+
+export function PairingScanner(props: {
+  onScan: (value: NonNullable<ReturnType<typeof decodePairingCode>>) => void
+  onCancel: () => void
+}) {
+  const language = useLanguage()
+  const [state, setState] = createStore({ error: "", ready: false })
+  const video = document.createElement("video")
+  video.setAttribute("aria-label", language.t("server.connect.camera"))
+  video.setAttribute("playsinline", "")
+  video.muted = true
+
+  onMount(() => {
+    // QrScanner hides detached videos, so initialize only after this preview is mounted.
+    const scanner = new QrScanner(
+      video,
+      (result) => {
+        const pairing = decodePairingCode(result.data)
+        if (!pairing) {
+          setState("error", language.t("server.connect.scan.invalid"))
+          return
+        }
+        scanner.stop()
+        props.onScan(pairing)
+      },
+      { preferredCamera: "environment", maxScansPerSecond: 10, returnDetailedScanResult: true },
+    )
+    // Terminal QR codes can be light-on-dark depending on the terminal theme.
+    scanner.setInversionMode("both")
+    onCleanup(() => scanner.destroy())
+    void scanner.start().then(
+      () => setState("ready", true),
+      () => setState("error", language.t("server.connect.camera.error")),
+    )
+  })
+
+  return (
+    <section class="server-connect-scanner" aria-label={language.t("server.connect.scan")}>
+      <p>{language.t("server.connect.scan.description")}</p>
+      <div class="server-connect-video">
+        {video}
+        <Show when={!state.ready && !state.error}>
+          <span role="status">{language.t("server.connect.camera.starting")}</span>
+        </Show>
+      </div>
+      <Show when={state.error}>
+        <p class="server-connect-error" role="alert">
+          {state.error}
+        </p>
+      </Show>
+      <Button variant="neutral" size="large" onClick={props.onCancel}>
+        {language.t("common.cancel")}
+      </Button>
+    </section>
+  )
+}

packages/app/src/servers/connect/screen.css

@@ -0,0 +1,119 @@
+[data-component="connect-server"] {
+  display: flex;
+  flex: 1;
+  min-height: 0;
+  width: 100%;
+  overflow: auto;
+  padding: max(48px, env(safe-area-inset-top)) max(24px, env(safe-area-inset-right))
+    max(32px, env(safe-area-inset-bottom)) max(24px, env(safe-area-inset-left));
+  background: var(--v2-background-bg-base);
+  color: var(--v2-text-text-base);
+
+  .server-connect-content {
+    display: flex;
+    flex-direction: column;
+    width: min(100%, 360px);
+    margin: auto;
+    gap: 16px;
+  }
+
+  .server-connect-brand {
+    width: 160px;
+    margin-inline: auto;
+    margin-block-end: 16px;
+  }
+
+  header {
+    text-align: center;
+    margin-block-end: 16px;
+  }
+
+  h1 {
+    font-size: 20px;
+    line-height: 28px;
+    font-weight: 530;
+    margin-block-end: 8px;
+  }
+
+  p {
+    font-size: 13px;
+    line-height: var(--line-height-base);
+    color: var(--v2-text-text-muted);
+  }
+
+  form,
+  .server-connect-scanner {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+  }
+
+  .server-connect-field {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+  }
+
+  label {
+    font-size: 13px;
+    line-height: var(--line-height-compact);
+    font-weight: 530;
+  }
+
+  [data-component="text-input-v2"] {
+    width: 100%;
+    height: 44px;
+  }
+
+  [data-slot="text-input-v2-input"] {
+    font-size: 16px;
+    line-height: 24px;
+  }
+
+  button {
+    min-height: 44px;
+    width: 100%;
+  }
+
+  .server-connect-error {
+    color: var(--v2-state-fg-danger);
+  }
+
+  footer {
+    text-align: center;
+    margin-block-start: 16px;
+  }
+
+  code {
+    display: inline-block;
+    margin-block-start: 12px;
+    border: 1px solid var(--v2-border-border-base);
+    border-radius: 6px;
+    padding: 8px 16px;
+    font-size: 13px;
+    line-height: var(--line-height-base);
+    background: var(--v2-background-bg-layer-01);
+    user-select: all;
+  }
+
+  .server-connect-video {
+    position: relative;
+    aspect-ratio: 1;
+    overflow: hidden;
+    border-radius: 12px;
+    background: var(--v2-background-bg-deep);
+  }
+
+  video {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+  }
+
+  .server-connect-video [role="status"] {
+    position: absolute;
+    inset: 0;
+    display: grid;
+    place-items: center;
+  }
+}

packages/app/src/servers/connect/screen.tsx

@@ -0,0 +1,179 @@
+import { createResource, lazy, Show, Suspense } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useMutation } from "@tanstack/solid-query"
+import { Button } from "@opencode/ui/button"
+import { TextInput } from "@opencode/ui/text-input"
+import { Wordmark } from "@opencode/ui/wordmark"
+import { useLanguage } from "@/runtime/i18n/language"
+import { usePlatform } from "@/runtime/platform/platform"
+import { useCheckServerHealth } from "@/runtime/server/health"
+import { useServers } from "@/runtime/server/registry"
+import { serverAddress } from "./pairing"
+import { isMixedContent } from "./browser"
+import "./screen.css"
+
+const PairingScanner = lazy(() => import("./scanner").then((module) => ({ default: module.PairingScanner })))
+
+export function ConnectServerScreen() {
+  const language = useLanguage()
+  const platform = usePlatform()
+  const servers = useServers()
+  const check = useCheckServerHealth()
+  const cameraSupported =
+    platform.platform === "web" && window.isSecureContext && !!navigator.mediaDevices?.getUserMedia
+  const [camera, cameraActions] = createResource(
+    async () => {
+      if (!cameraSupported || !navigator.mediaDevices.enumerateDevices) return false
+      const denied = await navigator.permissions?.query({ name: "camera" }).then(
+        (permission) => permission.state === "denied",
+        () => false,
+      )
+      if (denied) return false
+      return navigator.mediaDevices.enumerateDevices().then(
+        (devices) => devices.some((device) => device.kind === "videoinput"),
+        () => false,
+      )
+    },
+    { initialValue: 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)
+        ? "server.connect.mixedContent"
+        : "server.connect.failed",
+    )
+  const request = useMutation(() => ({
+    mutationFn: async () => {
+      const url = serverAddress(state.url)
+      if (!url) {
+        setState("error", language.t("server.connect.address.invalid"))
+        return
+      }
+      const http = { url, password: state.password || undefined }
+      const result = await check(http)
+      if (!result.healthy) {
+        setState("error", connectionError())
+        return
+      }
+      servers.add({ type: "http", http })
+    },
+    onError: () => setState("error", connectionError()),
+  }))
+
+  return (
+    <main data-component="connect-server" aria-labelledby="server-connect-title">
+      <div class="server-connect-content">
+        <div class="server-connect-brand" role="img" aria-label="OpenCode">
+          <Wordmark />
+        </div>
+        <header>
+          <h1 id="server-connect-title">{language.t("server.connect.title")}</h1>
+          <p>{language.t("server.connect.description")}</p>
+        </header>
+        <Show
+          when={!state.scanning}
+          fallback={
+            <Suspense fallback={<p role="status">{language.t("server.connect.camera.starting")}</p>}>
+              <PairingScanner
+                onCancel={() => {
+                  setState("scanning", false)
+                  void cameraActions.refetch()
+                }}
+                onScan={(pairing) => {
+                  setState({
+                    url: pairing.urls[0],
+                    urls: pairing.urls,
+                    password: pairing.password,
+                    error: "",
+                    scanning: false,
+                  })
+                  request.mutate()
+                }}
+              />
+            </Suspense>
+          }
+        >
+          <form
+            onSubmit={(event) => {
+              event.preventDefault()
+              if (request.isPending) return
+              setState("error", "")
+              request.mutate()
+            }}
+          >
+            <div class="server-connect-field">
+              <label for="server-connect-url">{language.t("dialog.server.add.url")}</label>
+              <TextInput
+                id="server-connect-url"
+                name="server"
+                dir="ltr"
+                type="text"
+                inputMode="url"
+                autocomplete="url"
+                autocapitalize="off"
+                spellcheck={false}
+                required
+                appearance="large"
+                list="server-connect-addresses"
+                placeholder={language.t("dialog.server.add.placeholder")}
+                value={state.url}
+                disabled={request.isPending}
+                aria-describedby={state.error ? "server-connect-error" : undefined}
+                onInput={(event) => setState({ url: event.currentTarget.value, error: "" })}
+              />
+              <datalist id="server-connect-addresses">
+                {state.urls.map((url) => (
+                  <option value={url} />
+                ))}
+              </datalist>
+            </div>
+            <div class="server-connect-field">
+              <label for="server-connect-password">{language.t("dialog.server.add.password")}</label>
+              <TextInput
+                id="server-connect-password"
+                name="password"
+                type="password"
+                autocomplete="current-password"
+                appearance="large"
+                value={state.password}
+                disabled={request.isPending}
+                onInput={(event) => setState({ password: event.currentTarget.value, error: "" })}
+              />
+            </div>
+            <Show when={state.error}>
+              <p id="server-connect-error" class="server-connect-error" role="alert">
+                {state.error}
+              </p>
+            </Show>
+            <Button type="submit" variant="contrast" size="large" disabled={request.isPending || !state.url.trim()}>
+              {language.t(request.isPending ? "dialog.server.add.checking" : "server.connect.button")}
+            </Button>
+          </form>
+          <Show when={platform.platform === "web"}>
+            <Button
+              variant="neutral"
+              size="large"
+              disabled={request.isPending || !camera.latest}
+              aria-describedby={!camera.latest && !camera.loading ? "server-connect-camera-unavailable" : undefined}
+              onClick={() => setState("scanning", true)}
+            >
+              {language.t("server.connect.scan")}
+            </Button>
+            <Show when={!camera.latest && !camera.loading}>
+              <p id="server-connect-camera-unavailable">
+                {language.t(
+                  window.isSecureContext ? "server.connect.camera.unavailable" : "server.connect.camera.insecure",
+                )}
+              </p>
+            </Show>
+          </Show>
+          <footer>
+            <p>{language.t("server.connect.pair.description")}</p>
+            <code dir="ltr">opencode pair</code>
+          </footer>
+        </Show>
+      </div>
+    </main>
+  )
+}

packages/app/src/session/commands/use-session-commands.tsx

@@ -194,7 +194,7 @@ export const useSessionCommands = (actions: SessionCommandContext) => {
 
   const openTerminal = () => {
     actions.session.layout.view().terminal.open()
-    if (terminal.all().length > 0) terminal.new({ focus: true })
+    if (terminal.all().length > 0) terminal.new()
     if (terminal.all().length === 0) terminal.requestFocus()
   }
 

packages/app/src/session/composer/region.tsx

@@ -20,7 +20,7 @@ import { useComposerCommands } from "@/composer/commands"
 import { useSessionCommands } from "../commands/use-session-commands"
 import type { SessionModel } from "../model"
 import type { SessionScreenLayout } from "../screen-layout"
-import { restorePromptModel, syncPromptModel, syncSessionModel } from "../session-model-helpers"
+import { syncPromptModel, syncSessionModel } from "../session-model-helpers"
 import type { SessionTimelineInteraction } from "../timeline/interaction"
 import { createSessionRevert } from "../revert"
 import { SessionComposerRegion } from "./session-composer-region"
@@ -62,14 +62,10 @@ export function createActiveSessionRegion(input: {
       },
     ),
   )
-  let restoredModelSession: string | undefined
   createEffect(() => {
     const id = input.session.identity.params.id
     if (!id || !prompt.ready() || !local.session.ready()) return
-    if (restoredModelSession !== id) {
-      restoredModelSession = id
-      if (restorePromptModel(local, prompt)) return
-    }
+    // Prompt model is a submission mirror. Local drafts and durable session state own selection.
     syncPromptModel(local, prompt)
   })
   createEffect(

packages/app/src/session/session-model-helpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { resetSessionModel, restorePromptModel, syncPromptModel, syncSessionModel } from "./session-model-helpers"
+import { resetSessionModel, syncPromptModel, syncSessionModel } from "./session-model-helpers"
 
 const message = (input?: { agent?: string; model?: { providerID: string; modelID: string; variant?: string } }) => ({
   sessionID: "session",
@@ -54,8 +54,7 @@ describe("syncPromptModel", () => {
       {
         model: {
           current: () => ({ id: "claude-sonnet-4", provider: { id: "anthropic" } }),
-          set() {},
-          variant: { current: () => "high", set() {} },
+          variant: { current: () => "high" },
         },
       },
       {
@@ -77,8 +76,7 @@ describe("syncPromptModel", () => {
       {
         model: {
           current: () => ({ id: model.modelID, provider: { id: model.providerID } }),
-          set() {},
-          variant: { current: () => model.variant, set() {} },
+          variant: { current: () => model.variant },
         },
       },
       {
@@ -93,54 +91,26 @@ describe("syncPromptModel", () => {
   })
 })
 
-describe("restorePromptModel", () => {
-  test("restores the persisted prompt model into session selection", () => {
+describe("stale prompt model", () => {
+  test("replaces the submission mirror without changing the effective selection", () => {
     const calls: unknown[] = []
-    const restored = restorePromptModel(
+    syncPromptModel(
       {
         model: {
           current: () => ({ id: "gpt", provider: { id: "openai" } }),
-          set: (model) => calls.push(model),
           variant: {
             current: () => undefined,
-            set: (variant) => calls.push(variant),
           },
         },
       },
       {
         model: {
           current: () => ({ providerID: "anthropic", modelID: "claude", variant: "high" }),
-          set() {},
+          set: (value) => calls.push(value),
         },
       },
     )
 
-    expect(restored).toBe(true)
-    expect(calls).toEqual([{ providerID: "anthropic", modelID: "claude" }, "high"])
-  })
-
-  test("does nothing without a persisted prompt model", () => {
-    const calls: unknown[] = []
-    const restored = restorePromptModel(
-      {
-        model: {
-          current: () => ({ id: "gpt", provider: { id: "openai" } }),
-          set: (model) => calls.push(model),
-          variant: {
-            current: () => undefined,
-            set: (variant) => calls.push(variant),
-          },
-        },
-      },
-      {
-        model: {
-          current: () => undefined,
-          set() {},
-        },
-      },
-    )
-
-    expect(restored).toBe(false)
-    expect(calls).toEqual([])
+    expect(calls).toEqual([{ providerID: "openai", modelID: "gpt", variant: undefined }])
   })
 })

packages/app/src/session/session-model-helpers.ts

@@ -12,10 +12,8 @@ type Local = {
 type ModelSelection = {
   model: {
     current(): { id: string; provider: { id: string } } | undefined
-    set(model: { providerID: string; modelID: string }): void
     variant: {
       current(): string | undefined
-      set(variant: string | undefined): void
     }
   }
 }
@@ -51,18 +49,3 @@ export const syncPromptModel = (local: ModelSelection, prompt: PromptState) => {
     return
   prompt.model.set(next)
 }
-
-export const restorePromptModel = (local: ModelSelection, prompt: PromptState) => {
-  const model = prompt.model.current()
-  if (!model) return false
-  const current = local.model.current()
-  if (
-    current?.provider.id === model.providerID &&
-    current.id === model.modelID &&
-    local.model.variant.current() === (model.variant ?? undefined)
-  )
-    return true
-  local.model.set({ providerID: model.providerID, modelID: model.modelID })
-  local.model.variant.set(model.variant ?? undefined)
-  return true
-}

packages/app/src/session/terminal/context.tsx

@@ -244,9 +244,9 @@ function createWorkspaceTerminalSession(
         setStore("all", [])
       })
     },
-    new(options?: { focus?: boolean }) {
+    new() {
       const nextNumber = pickNextTerminalNumber()
-      const focusRequest = options?.focus ? requestFocus(undefined, true) : undefined
+      const focusRequest = requestFocus(undefined, true)
 
       const doCreate = async () => {
         return serverSDK.api.pty.create({ location, title: defaultTitle(nextNumber) }).then((result) => result.data)
@@ -255,7 +255,7 @@ function createWorkspaceTerminalSession(
         .then((data) => {
           const id = data?.id
           if (!id) {
-            if (focusRequest !== undefined) cancelFocus(focusRequest)
+            cancelFocus(focusRequest)
             return
           }
           const newTerminal = {
@@ -266,13 +266,13 @@ function createWorkspaceTerminalSession(
           batch(() => {
             setStore("all", store.all.length, newTerminal)
             setStore("active", id)
-            if (focusRequest !== undefined && ui.focus?.request === focusRequest) {
+            if (ui.focus?.request === focusRequest) {
               setUi("focus", { request: focusRequest, id, pending: false })
             }
           })
         })
         .catch((error: unknown) => {
-          if (focusRequest !== undefined) cancelFocus(focusRequest)
+          cancelFocus(focusRequest)
           console.error("Failed to create terminal", error)
         })
     },
@@ -440,7 +440,7 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
       ready: () => workspace().ready(),
       all: () => workspace().all(),
       active: () => workspace().active(),
-      new: (options?: { focus?: boolean }) => workspace().new(options),
+      new: () => workspace().new(),
       update: (pty: Partial<LocalPTY> & { id: string }) => workspace().update(pty),
       trim: (id: string) => workspace().trim(id),
       trimAll: () => workspace().trimAll(),

packages/app/src/session/terminal/panel.tsx

@@ -330,7 +330,7 @@ export function TerminalPanel(
                       <IconButton
                         icon={<Icon name="plus-small" size="large" />}
                         variant="ghost"
-                        onClick={() => terminal.new({ focus: true })}
+                        onClick={() => terminal.new()}
                         aria-label={language.t("command.terminal.new")}
                       />
                     </Tooltip>

packages/app/src/session/terminal/serialize.test.ts

@@ -63,6 +63,36 @@ describe("SerializeAddon", () => {
     }
   })
 
+  describe("scrollback option", () => {
+    test("reads only the requested tail and restores the cursor on its screen row", async () => {
+      const { term, addon } = createTerminal(20, 5)
+      await writeAndWait(term, Array.from({ length: 30 }, (_, i) => `line ${i}`).join("\r\n"))
+      await writeAndWait(term, "\x1b[2A\x1b[3G")
+      expect(term.buffer.normal.length).toBe(30)
+      expect([term.buffer.normal.cursorX, term.buffer.normal.cursorY]).toEqual([2, 2])
+
+      const reads = spyOn(term.buffer.normal, "getLine")
+      const serialized = addon.serialize({ scrollback: 3 })
+      expect(new Set(reads.mock.calls.map((args) => args[0]))).toEqual(new Set([22, 23, 24, 25, 26, 27, 28, 29]))
+      reads.mockRestore()
+
+      const restored = createTerminal(20, 5)
+      await writeAndWait(restored.term, serialized)
+      expect(restored.term.getScrollbackLength()).toBe(3)
+      for (let row = 0; row < 8; row++) {
+        expect(restored.term.buffer.normal.getLine(row)?.translateToString(true)).toBe(`line ${22 + row}`)
+      }
+      expect([restored.term.buffer.normal.cursorX, restored.term.buffer.normal.cursorY]).toEqual([2, 2])
+    })
+
+    test("serializes the whole buffer when it has fewer rows than requested", async () => {
+      const { term, addon } = createTerminal(20, 5)
+      await writeAndWait(term, Array.from({ length: 30 }, (_, i) => `line ${i}`).join("\r\n"))
+
+      expect(addon.serialize({ scrollback: 100 })).toBe(addon.serialize())
+    })
+  })
+
   test("preserves color scheme reporting mode", async () => {
     const { term, addon } = createTerminal()
     await writeAndWait(term, "\x1b[?2031h")

packages/app/src/session/terminal/serialize.ts

@@ -481,12 +481,12 @@ class StringSerializeHandler extends BaseSerializeHandler {
 
     if (excludeFinalCursorPosition) return content
 
-    const absoluteCursorRow = (this._buffer.baseY ?? 0) + this._buffer.cursorY
-    const cursorRow = constrain(absoluteCursorRow - this._firstRow + 1, 1, Number.MAX_SAFE_INTEGER)
-    const cursorCol = this._buffer.cursorX + 1
-    content += `\u001b[${cursorRow};${cursorCol}H`
+    // CUP addresses the screen and ghostty-web reports cursorY relative to the screen, so the
+    // serialized range start must not shift the row. The cursor line sits in the screen region
+    // at the bottom of the buffer, after any scrollback rows.
+    content += `\u001b[${this._buffer.cursorY + 1};${this._buffer.cursorX + 1}H`
 
-    const line = this._buffer.getLine(absoluteCursorRow)
+    const line = this._buffer.getLine(this._buffer.length - this._terminal.rows + this._buffer.cursorY)
     const cell = line?.getCell(this._buffer.cursorX)
     const style = (() => {
       if (!cell) return this._buffer.getNullCell()

packages/app/src/session/terminal/terminal.tsx

@@ -20,6 +20,12 @@ import { terminalWriter } from "@/session/terminal/writer"
 
 const TOGGLE_TERMINAL_ID = "terminal.toggle"
 const DEFAULT_TOGGLE_TERMINAL_KEYBIND = "ctrl+`"
+// Serialization on unmount is a synchronous O(rows x cols) walk on the main thread and the
+// result is written to localStorage or desktop state for every terminal in the workspace.
+// Persisting the most recent 2k scrollback rows keeps restore fidelity for the history users
+// actually scroll back through while capping teardown cost and snapshot size; the live
+// terminal keeps its full 10k scrollback while mounted.
+const persistedScrollbackRows = 2_000
 export interface TerminalProps extends ComponentProps<"div"> {
   pty: LocalPTY
   autoFocus?: boolean
@@ -152,7 +158,7 @@ const persistTerminal = (input: {
   if (!input.addon || !input.onCleanup || !input.term) return
   const buffer = (() => {
     try {
-      return input.addon.serialize()
+      return input.addon.serialize({ scrollback: persistedScrollbackRows })
     } catch {
       debugTerminal("failed to serialize terminal buffer")
       return ""

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

@@ -3,7 +3,7 @@ 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"
-import { ServerConnection } from "@/runtime/server/registry"
+import { ServerConnection, useServers } from "@/runtime/server/registry"
 import { BrowserAttachmentsProvider } from "@/session/browser/attachments"
 import { SessionPanelFrame, SessionRouteFrame } from "@/session/session-frame"
 import { LayoutProvider } from "@/shell/state/layout"
@@ -15,6 +15,9 @@ export const File = lazy(() => import("@opencode/session-ui/file").then((module)
 const loadSessionRoute = () => Promise.all([import("@/session/route"), File.preload()]).then(([module]) => module)
 const DraftRoute = lazy(() => import("@/new-session/route").then((module) => ({ default: module.DraftRoute })))
 const SettingsScreen = lazy(() => import("@/settings/shell").then((module) => ({ default: module.SettingsScreen })))
+const ConnectServerScreen = lazy(() =>
+  import("@/servers/connect/screen").then((module) => ({ default: module.ConnectServerScreen })),
+)
 const TargetSessionRouteContent = lazy(() =>
   loadSessionRoute().then((module) => ({ default: module.TargetSessionRouteContent })),
 )
@@ -71,13 +74,16 @@ function TargetServerRoute(props: ParentProps) {
 }
 
 function AppLayout(props: ParentProps) {
+  const servers = useServers()
   return (
-    <LayoutProvider>
-      <SettingsSurfaceProvider>
-        <BrowserAttachmentsProvider>
-          <Shell>{props.children}</Shell>
-        </BrowserAttachmentsProvider>
-      </SettingsSurfaceProvider>
-    </LayoutProvider>
+    <Show when={servers.list.length > 0} fallback={<ConnectServerScreen />}>
+      <LayoutProvider>
+        <SettingsSurfaceProvider>
+          <BrowserAttachmentsProvider>
+            <Shell>{props.children}</Shell>
+          </BrowserAttachmentsProvider>
+        </SettingsSurfaceProvider>
+      </LayoutProvider>
+    </Show>
   )
 }

packages/app/src/shell/state/layout.tsx

@@ -165,7 +165,7 @@ export const layoutSchema = Persistence.struct({
   sessionView: Persistence.record(Persistence.fallback(sessionViewSchema, () => ({ scroll: {} }))),
   home: Persistence.struct({
     selection: Persistence.struct({
-      server: TabStorage.ServerKey,
+      server: Schema.optional(TabStorage.ServerKey),
       directory: Schema.optional(Schema.String),
     }),
   }),
@@ -223,7 +223,7 @@ export const layoutPersistence = Persistence.migrate(
   ),
 )
 
-export function initialLayout(server: ServerConnection.Key): typeof layoutSchema.Type {
+export function initialLayout(server?: ServerConnection.Key): typeof layoutSchema.Type {
   return {
     sidebar: { opened: false, width: DEFAULT_SIDEBAR_WIDTH, workspaces: {}, workspacesDefault: false },
     terminal: { height: DEFAULT_TERMINAL_HEIGHT, opened: false },
@@ -233,7 +233,7 @@ export function initialLayout(server: ServerConnection.Key): typeof layoutSchema
     mobileSidebar: { opened: false },
     sessionTabs: {},
     sessionView: {},
-    home: { selection: { server } },
+    home: { selection: server ? { server } : {} },
   }
 }
 
@@ -247,7 +247,7 @@ export const { use: useLayout, provider: LayoutProvider } = createSimpleContext(
     const [store, setStore, _, ready] = persisted(
       { ...Persist.global("layout"), previousKey: "layout.v6" },
       layoutPersistence,
-      initialLayout(ServerConnection.key(servers.list[0])),
+      initialLayout(servers.list[0] ? ServerConnection.key(servers.list[0]) : undefined),
     )
     const [ephemeral, setEphemeral] = createStore({
       reviewPanelSource: "other" as ReviewPanelSource,

packages/app/test-browser/fixtures/model-selection.ts

@@ -0,0 +1,459 @@
+import { afterEach, expect, mock, test } from "bun:test"
+import { createRequire } from "node:module"
+import { createComponent, createRoot } from "solid-js"
+import { createStore } from "solid-js/store"
+import type { Agent } from "@/runtime/server/types"
+import type { ModelKey } from "@/providers/models/selection"
+import { ServerScope } from "@/runtime/server/scope"
+
+// Bun does not compile Solid JSX. Compile the real context provider with the
+// same presets as Vite instead of replacing LocalProvider's implementation.
+const require = createRequire(import.meta.url)
+const solid = createRequire(require.resolve("vite-plugin-solid"))
+const { transformSync } = solid("@babel/core")
+Bun.plugin({
+  name: "selection-solid-context",
+  setup(build) {
+    build.onLoad({ filter: /[\\/]ui[\\/]src[\\/]context[\\/]helper\.tsx$/ }, async (args) => ({
+      contents: transformSync(await Bun.file(args.path).text(), {
+        filename: args.path,
+        presets: [solid.resolve("babel-preset-solid"), solid.resolve("@babel/preset-typescript")],
+      }).code,
+      loader: "js",
+    }))
+  },
+})
+
+type Commit = { agent?: string; model?: { providerID: string; id: string; variant?: string } }
+type Event = { data: { sessionID: string } }
+type ConfigModel = string | { providerID: string; model: string; variant?: string }
+const key = (modelID: string): ModelKey => ({ providerID: "provider", modelID })
+const durable = (modelID: string, variant?: string, agent = "build"): Commit => ({
+  agent,
+  model: { providerID: "provider", id: modelID, variant },
+})
+const agent = (name: string, model?: ModelKey, variant?: string): Agent => ({
+  name,
+  mode: "primary",
+  permission: [],
+  options: {},
+  model,
+  variant,
+})
+
+let active: ReturnType<typeof fixture>
+mock.module("@solidjs/router", () => ({ useParams: () => active.state.route }))
+mock.module("@/runtime/server/current", () => ({ useData: () => active.data }))
+mock.module("@/runtime/server/client", () => ({ useServerSDK: () => active.sdk }))
+mock.module("@/runtime/server/runtime", () => ({ useGlobal: () => ({ models: active.preferences }) }))
+mock.module("@/workspaces/location", () => ({ useWorkspaceLocation: () => () => ({ directory: active.directory }) }))
+mock.module("@/settings/model", () => ({
+  useSettings: () => ({ visibility: { customAgents: () => active.state.visible } }),
+}))
+mock.module("@/composer/persistence", () => ({ useComposerState: () => active.prompt }))
+mock.module("@/shell/state/layout", () => ({ useLayout: () => undefined }))
+mock.module("@/runtime/platform/platform", () => ({
+  usePlatform: () => ({
+    platform: "web",
+    openExternal() {},
+    restart: async () => {},
+    notify: async () => {},
+  }),
+}))
+
+const { LocalProvider, useLocal } = await import("@/providers/models/selection")
+const { ModelsProvider } = await import("@/providers/models/models")
+const { Persist } = await import("@/runtime/persistence/storage")
+const { createMemoryComposerState } = await import("@/composer/state")
+const { createComposerModelSelection } = await import("@/composer/selection")
+
+const cleanups: Array<() => void> = []
+afterEach(() =>
+  cleanups
+    .splice(0)
+    .reverse()
+    .forEach((dispose) => dispose()),
+)
+
+function fixture(input: { session?: Commit; agents?: Agent[]; config?: ConfigModel; preferred?: string } = {}) {
+  const directory = `/selection-test/${crypto.randomUUID()}`
+  const [state, set] = createStore({
+    visible: true,
+    configLoaded: true,
+    connection: "connected",
+    route: { id: "ses_a" as string | undefined },
+    agents: input.agents ?? [agent("build"), agent("plan")],
+    config: input.config as ConfigModel | undefined,
+    sessions: { ses_a: input.session } as Record<string, Commit | undefined>,
+    providers: [{ id: "provider", name: "Provider", package: "@ai-sdk/test", activation: "enabled" }],
+    models: ["a", "b", "c"].map((id) => ({
+      id,
+      modelID: id,
+      providerID: "provider",
+      name: `Model ${id}`,
+      settings: {},
+      headers: {},
+      capabilities: { tools: true, input: ["text"], output: ["text"] },
+      variants: ["low", "high"].map((id) => ({ id, settings: {} })),
+      time: { released: 1 },
+      cost: [],
+      status: "active",
+      enabled: true,
+      limit: { context: 128_000, output: 8192 },
+    })),
+  })
+  const [preferences, setPreferences] = createStore({
+    user: [] as Array<ModelKey & { visibility: "show" | "hide" }>,
+    recent: [] as ModelKey[],
+    variant: (input.preferred ? { "provider/a": input.preferred } : {}) as Record<string, string>,
+  })
+  const events = new Map<string, Set<(event: Event) => void>>()
+  const configLoads: string[] = []
+  const result = {
+    prompt: createMemoryComposerState(),
+    directory,
+    state,
+    set,
+    setPreferences,
+    preferences: { store: preferences, set: setPreferences, ready: () => true, recent: () => preferences.recent },
+    data: {
+      session: { get: (id: string) => state.sessions[id] },
+      location: {
+        agent: { list: () => state.agents },
+        config: {
+          list: () => (state.configLoaded ? [{ type: "document", info: { model: state.config } }] : undefined),
+          sync: async () => {
+            configLoads.push(state.connection)
+          },
+        },
+        provider: { list: () => state.providers },
+        model: { list: () => state.models },
+        integration: { list: () => [] },
+      },
+    },
+    sdk: {
+      scope: ServerScope.local,
+      connection: { status: () => state.connection },
+      event: {
+        on(type: string, handler: (event: Event) => void) {
+          const handlers = events.get(type) ?? new Set()
+          events.set(type, handlers)
+          handlers.add(handler)
+          return () => handlers.delete(handler)
+        },
+      },
+    },
+    emit(type: string, sessionID = "ses_a") {
+      events.get(type)?.forEach((handler) => handler({ data: { sessionID } }))
+    },
+    configLoads,
+    mount(draft = false) {
+      active = result
+      let local!: ReturnType<typeof useLocal>
+      let composer: ReturnType<typeof createComposerModelSelection> | undefined
+      const dispose = createRoot((dispose) => {
+        createComponent(ModelsProvider, {
+          directory,
+          get children() {
+            return createComponent(LocalProvider, {
+              get children() {
+                local = useLocal()
+                if (draft) composer = createComposerModelSelection({ agent: local.agent.current })
+                return null
+              },
+            })
+          },
+        })
+        return dispose
+      })
+      cleanups.push(dispose)
+      return { local, composer, dispose }
+    },
+  }
+  const target = Persist.serverWorkspace(ServerScope.local, directory, "model-selection")
+  cleanups.push(() => localStorage.removeItem(`${target.storage}:${target.key}`))
+  return result
+}
+
+function selection(local: ReturnType<typeof useLocal>) {
+  return {
+    agent: local.agent.current()?.name,
+    model: local.model.current()?.id,
+    variant: local.model.variant.current(),
+  }
+}
+
+test("restores durable agents even when the agent selector is hidden", () => {
+  const f = fixture({ session: durable("b", "high", "plan") })
+  f.set("visible", false)
+  const { local } = f.mount()
+  expect(local.agent.visible()).toBe(false)
+  expect(selection(local)).toEqual({ agent: "plan", model: "b", variant: "high" })
+})
+
+test("waits for initial configuration and reloads it after reconnecting", () => {
+  const f = fixture({ config: "provider/b" })
+  f.set("configLoaded", false)
+  const { local } = f.mount()
+  expect(local.model.ready()).toBe(false)
+  expect(local.model.current()).toBeUndefined()
+  f.set("connection", "reconnecting")
+  f.set("connection", "connected")
+  expect(f.configLoads).toEqual(["connected", "reconnecting", "connected"])
+  f.set("configLoaded", true)
+  expect(local.model.ready()).toBe(true)
+  expect(local.model.current()?.id).toBe("b")
+})
+
+test("new-session promotion does not mask a command's durable overrides", () => {
+  const f = fixture({ session: durable("a", "low") })
+  const { local } = f.mount()
+  local.session.promote(f.directory, "ses_a", { agent: "build", model: key("a"), variant: "low" })
+  f.set("sessions", "ses_a", durable("b", "high", "plan"))
+  expect(selection(local)).toEqual({ agent: "plan", model: "b", variant: "high" })
+})
+
+test("new-session drafts remember each agent's model and hand off inactive choices", () => {
+  const f = fixture({ agents: [agent("build", key("a")), agent("plan", key("b"))] })
+  f.set("route", "id", undefined)
+  const { local, composer } = f.mount(true)
+  if (!composer) throw new Error("missing draft composer")
+  composer.set(key("c"))
+  composer.variant.set("high")
+  local.agent.set("plan")
+  expect(composer.current()?.id).toBe("b")
+  expect(composer.variant.current()).toBeUndefined()
+  local.agent.set("build")
+  expect(composer.current()?.id).toBe("c")
+  expect(composer.variant.current()).toBe("high")
+  local.agent.set("plan")
+  const choices = composer.remembered()
+  f.set("sessions", "ses_a", durable("b", undefined, "plan"))
+  local.session.promote(f.directory, "ses_a", { agent: "plan", model: key("b"), choices })
+  f.set("route", "id", "ses_a")
+  local.agent.set("build")
+  expect(local.model.current()?.id).toBe("c")
+})
+
+test("session model picks snapshot the variant rather than following another session's preferences", () => {
+  const f = fixture({ session: durable("a") })
+  const { local } = f.mount()
+  f.setPreferences("variant", "provider/b", "low")
+  local.model.set(key("b"))
+  f.setPreferences("variant", "provider/b", "high")
+  expect(local.model.variant.current()).toBe("low")
+})
+
+test("remembers distinct variants for agents using the same model, scoped to the session", () => {
+  const f = fixture({ session: durable("a", "low"), agents: [agent("build", key("a")), agent("plan", key("a"))] })
+  const { local } = f.mount()
+  local.model.variant.set("high")
+  local.agent.set("plan")
+  local.model.variant.set("low")
+  local.agent.set("build")
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: "high" })
+  local.agent.set("plan")
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "low" })
+
+  f.set("sessions", "ses_b", durable("b", "high"))
+  f.set("route", "id", "ses_b")
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: "high" })
+  f.set("route", "id", "ses_a")
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "low" })
+})
+
+test("restores each agent's model and variant after provider remount", () => {
+  const f = fixture({ agents: [agent("build", key("a")), agent("plan", key("b"))] })
+  const first = f.mount()
+  first.local.model.variant.set("high")
+  first.local.agent.set("plan")
+  first.local.model.set(key("c"))
+  first.local.model.variant.set("low")
+  first.dispose()
+  const { local } = f.mount()
+  expect(selection(local)).toEqual({ agent: "plan", model: "c", variant: "low" })
+  local.agent.set("build")
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: "high" })
+  local.agent.set("plan")
+  expect(selection(local)).toEqual({ agent: "plan", model: "c", variant: "low" })
+})
+
+test("changing models drops the old variant even when both models support it", () => {
+  const f = fixture({ session: durable("a", "high") })
+  const { local } = f.mount()
+  local.model.set(key("b"))
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: undefined })
+  f.setPreferences("variant", "provider/c", "low")
+  local.model.set(key("c"))
+  expect(local.model.variant.current()).toBe("low")
+})
+
+test("restores durable selection ahead of agent, global, and saved variant defaults", () => {
+  const f = fixture({
+    session: durable("a", "low", "plan"),
+    agents: [agent("build"), agent("plan", key("b"), "high")],
+    config: { providerID: "provider", model: "c", variant: "high" },
+    preferred: "high",
+  })
+  const { local } = f.mount()
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "low" })
+  local.session.restore({ sessionID: "ses_a", agent: "build", model: key("c") })
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "low" })
+})
+
+test("uses historical message selection only when durable and local selection are absent", () => {
+  const f = fixture()
+  const { local } = f.mount()
+  local.session.restore({ sessionID: "ses_b", agent: "plan", model: key("b") })
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: undefined })
+  local.session.restore({ sessionID: "ses_a", agent: "plan", model: { ...key("b"), variant: "low" } })
+  expect(selection(local)).toEqual({ agent: "plan", model: "b", variant: "low" })
+  local.model.variant.set("high")
+  local.session.restore({ sessionID: "ses_a", agent: "build", model: key("c") })
+  expect(selection(local)).toEqual({ agent: "plan", model: "b", variant: "high" })
+})
+
+test("invalid durable models fall through agent, global, recent, and connected defaults", () => {
+  const f = fixture({
+    session: durable("removed", "high"),
+    agents: [agent("build", key("b"), "low")],
+    config: "provider/c",
+  })
+  const { local } = f.mount()
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: "low" })
+  f.set("agents", [agent("build", key("removed"))])
+  expect(local.model.current()?.id).toBe("c")
+  f.setPreferences("recent", [key("removed"), key("b")])
+  f.set("config", "provider/removed")
+  expect(local.model.current()?.id).toBe("b")
+  f.setPreferences("recent", [key("removed")])
+  expect(local.model.current()?.id).toBe("a")
+  f.set("providers", [])
+  expect(local.model.current()).toBeUndefined()
+})
+
+test("global and agent model/variant defaults react to configuration replacement", () => {
+  const f = fixture({ config: { providerID: "provider", model: "a", variant: "low" } })
+  const { local } = f.mount()
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: "low" })
+  f.set("config", { providerID: "provider", model: "b", variant: "high" })
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: "high" })
+  f.set("agents", [agent("build", key("a"), "low")])
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: "low" })
+  f.set("agents", [agent("build", key("c"), "high")])
+  expect(selection(local)).toEqual({ agent: "build", model: "c", variant: "high" })
+  f.set("agents", [agent("build")])
+  f.set("config", "provider/b")
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: undefined })
+})
+
+test("durable and explicitly selected Default override a saved variant preference", () => {
+  const f = fixture({
+    session: durable("a"),
+    preferred: "high",
+    config: { providerID: "provider", model: "a", variant: "low" },
+  })
+  const { local } = f.mount()
+  expect(local.model.variant.current()).toBeUndefined()
+  local.model.variant.set(undefined)
+  expect(f.preferences.store.variant["provider/a"]).toBe("default")
+  f.set("route", "id", "ses_b")
+  expect(local.model.variant.current()).toBeUndefined()
+  f.set("route", "id", "ses_a")
+  f.setPreferences("variant", "provider/a", "high")
+  expect(local.model.variant.current()).toBeUndefined()
+  f.set("route", "id", "ses_b")
+  expect(local.model.variant.current()).toBe("high")
+  f.set("route", "id", "ses_a")
+  expect(local.model.variant.current()).toBeUndefined()
+})
+
+test("waits for both commit acknowledgments, then releases only the matching draft", () => {
+  const f = fixture({ session: durable("b", "low") })
+  const { local } = f.mount()
+  local.agent.set("plan")
+  local.model.set(key("a"))
+  local.model.variant.set("high")
+  local.model.trackSessionCommit("ses_a", { agent: "plan", model: key("a"), variant: "high" })
+  f.set("sessions", "ses_a", durable("b", "low", "plan"))
+  f.emit("session.agent.selected")
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "high" })
+  f.set("sessions", "ses_a", durable("a", "high", "plan"))
+  f.emit("session.model.selected")
+  f.set("sessions", "ses_a", durable("c", "low", "plan"))
+  expect(selection(local)).toEqual({ agent: "plan", model: "c", variant: "low" })
+})
+
+test.each(["a", "b"])("a delayed commit preserves the newer %s/low selection", (model) => {
+  const f = fixture()
+  const { local } = f.mount()
+  local.model.set(key("a"))
+  local.model.variant.set("high")
+  local.model.trackSessionCommit("ses_a", { agent: "build", model: key("a"), variant: "high" })
+  local.model.set(key(model))
+  local.model.variant.set("low")
+  f.set("sessions", "ses_a", durable("a", "high"))
+  f.emit("session.model.selected")
+  expect(selection(local)).toEqual({ agent: "build", model, variant: "low" })
+})
+
+test("a delayed commit preserves a newer agent even when model and variant match", () => {
+  const f = fixture({ agents: [agent("build", key("a")), agent("plan", key("a"))] })
+  const { local } = f.mount()
+  local.model.variant.set("high")
+  local.model.trackSessionCommit("ses_a", { agent: "build", model: key("a"), variant: "high" })
+  local.agent.set("plan")
+  f.set("sessions", "ses_a", durable("a", "high"))
+  f.emit("session.model.selected")
+  expect(selection(local)).toEqual({ agent: "plan", model: "a", variant: "high" })
+})
+
+test("a commit received while its session is inactive does not discard its local selection", () => {
+  const f = fixture()
+  const { local } = f.mount()
+  local.model.set(key("a"))
+  local.model.variant.set("high")
+  local.model.trackSessionCommit("ses_a", { agent: "build", model: key("a"), variant: "high" })
+  f.set("sessions", "ses_b", durable("b", "low"))
+  f.set("route", "id", "ses_b")
+  f.set("sessions", "ses_a", durable("a", "high"))
+  f.emit("session.model.selected")
+  expect(selection(local)).toEqual({ agent: "build", model: "b", variant: "low" })
+  f.set("sessions", "ses_a", durable("c", "low"))
+  f.set("route", "id", "ses_a")
+  expect(selection(local)).toEqual({ agent: "build", model: "a", variant: "high" })
+})
+
+test("cancelling a failed commit retains the draft and does not cancel a newer commit", () => {
+  const f = fixture()
+  const { local } = f.mount()
+  local.model.set(key("a"))
+  local.model.variant.set("high")
+  const cancel = local.model.trackSessionCommit("ses_a", { agent: "build", model: key("a"), variant: "high" })
+  cancel()
+  f.set("sessions", "ses_a", durable("a", "high"))
+  f.emit("session.model.selected")
+  f.set("sessions", "ses_a", durable("c", "low"))
+  expect(local.model.current()?.id).toBe("a")
+
+  local.model.set(key("b"))
+  local.model.variant.set("low")
+  local.model.trackSessionCommit("ses_a", { agent: "build", model: key("b"), variant: "low" })
+  cancel()
+  f.set("sessions", "ses_a", durable("b", "low"))
+  f.emit("session.model.selected")
+  f.set("sessions", "ses_a", durable("c", "high"))
+  expect(selection(local)).toEqual({ agent: "build", model: "c", variant: "high" })
+})
+
+test.each([1, -1] as const)("cycles %p from outside recents to the correct end and wraps", (direction) => {
+  const f = fixture({ session: durable("a") })
+  f.setPreferences("recent", [key("removed"), key("b"), key("c")])
+  const { local } = f.mount()
+  local.model.cycle(direction)
+  expect(local.model.current()?.id).toBe(direction === 1 ? "b" : "c")
+  local.model.cycle(direction)
+  expect(local.model.current()?.id).toBe(direction === 1 ? "c" : "b")
+  local.model.cycle(direction)
+  expect(local.model.current()?.id).toBe(direction === 1 ? "b" : "c")
+})

packages/app/test-browser/model-selection.test.ts

@@ -0,0 +1,23 @@
+import { expect, test } from "bun:test"
+import { fileURLToPath } from "node:url"
+
+test("LocalProvider selection integration", async () => {
+  // Isolate provider module substitutions from the rest of the browser suite.
+  const child = Bun.spawn(
+    [
+      process.execPath,
+      "test",
+      "--conditions=browser",
+      "--preload",
+      "./happydom.ts",
+      "./test-browser/fixtures/model-selection.ts",
+    ],
+    { cwd: fileURLToPath(new URL("..", import.meta.url)), stdout: "pipe", stderr: "pipe" },
+  )
+  const [status, stdout, stderr] = await Promise.all([
+    child.exited,
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+  ])
+  expect(status, stdout + stderr).toBe(0)
+}, 30_000)

packages/cli/script/app-assets.ts

@@ -6,7 +6,9 @@ import { collectFiles } from "./files"
 export async function buildAppArchive(channel: string, options?: { skipBuild?: boolean }) {
   if (options?.skipBuild) return compress({})
   const root = path.resolve(import.meta.dirname, "../../app")
-  await $`bun run build`.cwd(root).env({ ...process.env, OPENCODE_CHANNEL: channel })
+  await $`bun run build`
+    .cwd(root)
+    .env({ ...process.env, OPENCODE_CHANNEL: channel, VITE_OPENCODE_SERVER_MODE: "origin" })
   const assets = Object.fromEntries(
     await Promise.all(
       (await collectFiles(path.join(root, "dist")))

packages/cli/src/commands/commands.ts

@@ -431,7 +431,24 @@ const Root = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME
         }),
       ],
     }),
-    Spec.make("pair", { description: "Show server pairing information" }),
+    Spec.make("pair", {
+      description: "Show server pairing information",
+      params: {
+        url: Flag.string("url").pipe(
+          Flag.withDescription("Advertise an external HTTP(S) server URL in the pairing QR code"),
+          Flag.mapTryCatch(
+            (value) => {
+              const url = new URL(value)
+              if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+                throw new Error("Invalid pairing URL")
+              return url.href.replace(/\/+$/, "")
+            },
+            () => "Expected an HTTP(S) server URL without credentials, query parameters, or a fragment",
+          ),
+          Flag.optional,
+        ),
+      },
+    }),
     Spec.make("serve", {
       description: "Start the v2 API and web server",
       params: {

packages/cli/src/commands/handlers/pair.ts

@@ -1,5 +1,5 @@
 import { EOL } from "os"
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
 import { Service } from "@opencode/client/effect/service"
 import { OpenCode } from "@opencode/client/promise"
 import { renderUnicodeCompact } from "uqr"
@@ -9,13 +9,15 @@ import { ServiceConfig } from "../../services/service-config"
 
 export default Runtime.handler(
   Commands.commands.pair,
-  Effect.fn("cli.pair")(function* () {
+  Effect.fn("cli.pair")(function* (input: Runtime.Input<typeof Commands.commands.pair>) {
     const endpoint = yield* Service.ensure(yield* ServiceConfig.options())
     const password = yield* ServiceConfig.password()
-    const server = yield* Effect.tryPromise(() =>
-      OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) }).server.get(),
-    )
-    const info = { urls: server.urls, username: "opencode", password }
+    const urls = Option.isSome(input.url)
+      ? [input.url.value]
+      : (yield* Effect.tryPromise(() =>
+          OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) }).server.get(),
+        )).urls
+    const info = { urls, username: "opencode", password }
     process.stdout.write(
       [
         "",
@@ -34,6 +36,7 @@ export default Runtime.handler(
       ].join(EOL) + EOL,
     )
 
+    if (Option.isSome(input.url)) return
     const hostname = new URL(endpoint.url).hostname
     if (!["localhost", "127.0.0.1", "[::1]"].includes(hostname)) return
     process.stderr.write(`  Run \`opencode service set hostname 0.0.0.0\` to access the service remotely.${EOL}${EOL}`)

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

@@ -17,6 +17,7 @@ import type { PromptInput } from "@opencode/schema/prompt-input"
 import type { AgentAttachment } from "@opencode/schema/prompt"
 import type { Skill } from "@opencode/schema/skill"
 import type { Event } from "@opencode/schema/event"
+import type { FileDiff } from "@opencode/schema/file-diff"
 import type { InstructionEntry } from "@opencode/schema/instruction-entry"
 import type { Schema } from "effect"
 import type { EventLog } from "@opencode/schema/event-log"
@@ -36,7 +37,6 @@ import type { PtyTicket } from "@opencode/schema/pty-ticket"
 import type { Reference } from "@opencode/schema/reference"
 import type { Worktree } from "@opencode/schema/worktree"
 import type { Vcs } from "@opencode/schema/vcs"
-import type { FileDiff } from "@opencode/schema/file-diff"
 import type { WebSearch } from "@opencode/schema/websearch"
 import type { Config } from "@opencode/schema/config"
 
@@ -360,6 +360,15 @@ export type SessionContextInput = { readonly sessionID: Session.ID }
 export type SessionContextOutput = ReadonlyArray<SessionMessage.Info>
 export type SessionContextOperation<E = never> = (input: SessionContextInput) => Effect.Effect<SessionContextOutput, E>
 
+export type SessionDiffInput = {
+  readonly sessionID: Session.ID
+  readonly messageID?: SessionMessage.ID | undefined
+  readonly to?: SessionMessage.ID | undefined
+  readonly context?: number | undefined
+}
+export type SessionDiffOutput = ReadonlyArray<FileDiff.Info>
+export type SessionDiffOperation<E = never> = (input: SessionDiffInput) => Effect.Effect<SessionDiffOutput, E>
+
 export type SessionInboxListInput = { readonly sessionID: Session.ID }
 export type SessionInboxListOutput = ReadonlyArray<SessionInbox.Info>
 export type SessionInboxListOperation<E = never> = (
@@ -1133,6 +1142,7 @@ export interface SessionApi<E = never> {
     readonly commit: SessionRevertCommitOperation<E>
   }
   readonly context: SessionContextOperation<E>
+  readonly diff: SessionDiffOperation<E>
   readonly inbox: {
     readonly list: SessionInboxListOperation<E>
     readonly cancel: SessionInboxCancelOperation<E>

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

@@ -68,6 +68,8 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
+  SessionDiffInput,
+  SessionDiffOutput,
   SessionInboxListInput,
   SessionInboxListOutput,
   SessionInboxCancelInput,
@@ -594,6 +596,17 @@ const EndpointSessionContext = (raw: RawClient["server.session"]) => (input: Ses
     ),
   )
 
+const EndpointSessionDiff = (raw: RawClient["server.session"]) => (input: SessionDiffInput) =>
+  preserveEffect<SessionDiffOutput>()(
+    raw["session.diff"]({
+      params: { sessionID: input["sessionID"] },
+      query: { messageID: input["messageID"], to: input["to"], context: input["context"] },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
 const EndpointSessionInboxList = (raw: RawClient["server.session"]) => (input: SessionInboxListInput) =>
   preserveEffect<SessionInboxListOutput>()(
     raw["session.inbox.list"]({ params: { sessionID: input["sessionID"] } }).pipe(
@@ -744,6 +757,7 @@ const adaptGroupSession = (raw: RawClient["server.session"]) => ({
     commit: EndpointSessionRevertCommit(raw),
   },
   context: EndpointSessionContext(raw),
+  diff: EndpointSessionDiff(raw),
   inbox: {
     list: EndpointSessionInboxList(raw),
     cancel: EndpointSessionInboxCancel(raw),

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

@@ -62,6 +62,8 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
+  SessionDiffInput,
+  SessionDiffOutput,
   SessionInboxListInput,
   SessionInboxListOutput,
   SessionInboxCancelInput,
@@ -844,6 +846,18 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
+      diff: (input: SessionDiffInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionDiffOutput }>(
+          {
+            method: "GET",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/diff`,
+            query: { messageID: input["messageID"], to: input["to"], context: input["context"] },
+            successStatus: 200,
+            declaredStatuses: [400, 401, 404, 500],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
       inbox: {
         list: (input: SessionInboxListInput, requestOptions?: RequestOptions) =>
           request<{ readonly data: SessionInboxListOutput }>(

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

@@ -147,6 +147,14 @@ export type SessionProviderContextProvenance = {
   endpoint: string
 }
 
+export type SessionMessageIdle = {
+  id: string
+  metadata?: { [x: string]: JsonValue }
+  time: { created: number }
+  type: "idle"
+  outcome: "succeeded" | "failed" | "interrupted"
+}
+
 export type SessionActive = { type: "running" }
 
 export type SessionInboxDelivery = "steer" | "queue"
@@ -2177,6 +2185,7 @@ export type SessionMessageInfo =
   | SessionMessageShell
   | SessionMessageAssistant
   | SessionMessageCompaction
+  | SessionMessageIdle
 
 export type SessionMessageContentUpdated = {
   id: string
@@ -3122,6 +3131,13 @@ export type SessionImportInput = {
               readonly error: { readonly type: string; readonly message: string; readonly status?: number }
             }
         )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
     >
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["info"]
@@ -3413,6 +3429,13 @@ export type SessionImportInput = {
               readonly error: { readonly type: string; readonly message: string; readonly status?: number }
             }
         )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
     >
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["messages"]
@@ -3704,6 +3727,13 @@ export type SessionImportInput = {
               readonly error: { readonly type: string; readonly message: string; readonly status?: number }
             }
         )
+      | {
+          readonly id: string
+          readonly metadata?: { readonly [x: string]: JsonValue }
+          readonly time: { readonly created: number }
+          readonly type: "idle"
+          readonly outcome: "succeeded" | "failed" | "interrupted"
+        }
     >
     readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
   }["location"]
@@ -4193,6 +4223,27 @@ export type SessionContextInput = { readonly sessionID: { readonly sessionID: st
 
 export type SessionContextOutput = { data: Array<SessionMessageInfo> }["data"]
 
+export type SessionDiffInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly messageID?: {
+    readonly messageID?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["messageID"]
+  readonly to?: {
+    readonly messageID?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["to"]
+  readonly context?: {
+    readonly messageID?: string | undefined
+    readonly to?: string | undefined
+    readonly context?: number | undefined
+  }["context"]
+}
+
+export type SessionDiffOutput = { data: Array<FileDiffInfo> }["data"]
+
 export type SessionInboxListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
 export type SessionInboxListOutput = { data: Array<SessionInboxInfo> }["data"]

packages/client/src/solid/data.ts

@@ -1032,6 +1032,18 @@ export function createData(config: CreateDataInput) {
           if (currentAssistant) currentAssistant.retry = undefined
         })
         if (event.type === "session.execution.interrupted" && event.data.reason === "shutdown") return
+        // Mirror the projected idle marker so turn boundaries match before the next message read.
+        message.insert(event.data.sessionID, {
+          id: messageIDFromEvent(event.id),
+          type: "idle",
+          outcome:
+            event.type === "session.execution.succeeded"
+              ? "succeeded"
+              : event.type === "session.execution.failed"
+                ? "failed"
+                : "interrupted",
+          time: { created: event.created },
+        })
         // An event can overtake the first read; queue a revalidation when that read is still active.
         if (!store.session.info[event.data.sessionID] && !sync.has(`session:${event.data.sessionID}`)) return
         result.session.invalidate(event.data.sessionID)

packages/core/src/git.ts

@@ -9,6 +9,7 @@ import { AppProcess } from "@opencode/util/process"
 import { makeGlobalNode } from "@opencode/util/effect/app-node"
 import { File } from "./file.js"
 import { KeyedMutex } from "./effect/keyed-mutex.js"
+import { VcsPatch } from "./vcs/patch.js"
 
 export class Repository extends Schema.Class<Repository>("Git.Repository")({
   worktree: AbsolutePath,
@@ -308,7 +309,7 @@ const layer = Layer.effect(
       operationName: OperationError["operation"],
       repository: Repository,
       args: string[],
-      options?: { stdin?: string; env?: Record<string, string> },
+      options?: { stdin?: string; env?: Record<string, string>; maxOutputBytes?: number },
     ) {
       const result = yield* proc
         .run(
@@ -317,7 +318,7 @@ const layer = Layer.effect(
             env: options?.env,
             extendEnv: true,
           }),
-          { stdin: options?.stdin },
+          { stdin: options?.stdin, maxOutputBytes: options?.maxOutputBytes },
         )
         .pipe(
           Effect.mapError(
@@ -331,7 +332,8 @@ const layer = Layer.effect(
           ),
         )
       const text = result.stdout.toString("utf8")
-      if (result.exitCode === 0) return { text, stderr: result.stderr.toString("utf8") }
+      if (result.exitCode === 0)
+        return { text, stderr: result.stderr.toString("utf8"), truncated: result.stdoutTruncated }
       return yield* new OperationError({
         operation: operationName,
         directory: repository.worktree,
@@ -385,9 +387,7 @@ const layer = Layer.effect(
       maximumUntrackedFileBytes?: number
     }) {
       const list = (args: string[]) =>
-        repositoryOperation("refresh", input.repository, args).pipe(
-          Effect.map((result) => result.text.split("\0").filter(Boolean)),
-        )
+        repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => nuls(result.text)))
       const [tracked, untracked] = yield* Effect.all(
         [
           list(["diff-files", "--name-only", "-z", "--", input.scope]),
@@ -464,13 +464,7 @@ const layer = Layer.effect(
           directory: input.repository.worktree,
           message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths",
         })
-      return new Set(
-        result.stdout
-          .toString("utf8")
-          .split("\0")
-          .filter(Boolean)
-          .map((file) => RelativePath.make(file)),
-      )
+      return new Set(nuls(result.stdout.toString("utf8")).map((file) => RelativePath.make(file)))
     })
 
     const writeTree = Effect.fn("Git.tree.write")(function* (repository: Repository) {
@@ -499,19 +493,23 @@ const layer = Layer.effect(
       to: TreeID
     }) {
       // Undo needs both paths of a rename, not only its destination.
-      return (yield* repositoryOperation("list_files", input.repository, [
-        "diff",
-        "--name-only",
-        "--no-renames",
-        "-z",
-        input.from,
-        input.to,
-      ])).text
-        .split("\0")
-        .filter(Boolean)
-        .map((file) => RelativePath.make(file))
+      return nuls(
+        (yield* repositoryOperation("list_files", input.repository, [
+          "diff",
+          "--name-only",
+          "--no-renames",
+          "-z",
+          input.from,
+          input.to,
+        ])).text,
+      ).map((file) => RelativePath.make(file))
     })
 
+    /**
+     * Three batched invocations over the tree pair instead of three per file. An
+     * explicit empty selection diffs nothing; an absent one diffs every changed path.
+     * Patch output is capped like VCS diffs: files past the cap get an empty patch.
+     */
     const treeDiff = Effect.fn("Git.tree.diff")(function* (input: {
       repository: Repository
       from: TreeID
@@ -519,49 +517,57 @@ const layer = Layer.effect(
       context?: number
       paths?: readonly RelativePath[]
     }) {
-      const paths = input.paths ?? (yield* treeFiles(input))
-      return yield* Effect.forEach(paths, (file) =>
-        Effect.gen(function* () {
-          const statusText = (yield* repositoryOperation("diff", input.repository, [
+      if (input.paths?.length === 0) return []
+      const args = ["--no-renames", input.from, input.to, "--", ...(input.paths ?? [])]
+      // Patch headers have no -z form: unquoted paths keep chunksByFile matching non-ASCII names.
+      const [names, numbers, patch] = yield* Effect.all(
+        [
+          repositoryOperation("diff", input.repository, ["diff", "--name-status", "-z", ...args]),
+          repositoryOperation("diff", input.repository, ["diff", "--numstat", "-z", ...args]),
+          repositoryOperation(
             "diff",
-            "--name-status",
-            "--no-renames",
-            input.from,
-            input.to,
-            "--",
-            file,
-          ])).text.trim()
-          const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified"
-          const stats = (yield* repositoryOperation("diff", input.repository, [
-            "diff",
-            "--numstat",
-            "--no-renames",
-            input.from,
-            input.to,
-            "--",
-            file,
-          ])).text.split("\t")
-          const binary = stats[0] === "-" || stats[1] === "-"
-          const patch = binary
-            ? ""
-            : (yield* repositoryOperation("diff", input.repository, [
-                "diff",
-                `--unified=${input.context ?? 3}`,
-                "--no-renames",
-                input.from,
-                input.to,
-                "--",
-                file,
-              ])).text
-          return {
-            file,
-            status,
-            additions: binary ? 0 : Number(stats[0] ?? 0),
-            deletions: binary ? 0 : Number(stats[1] ?? 0),
-            patch,
-          } satisfies File.Diff
+            input.repository,
+            ["-c", "core.quotepath=false", "diff", "--no-ext-diff", `--unified=${input.context ?? 3}`, ...args],
+            { maxOutputBytes: VcsPatch.MAX_TOTAL_PATCH_BYTES },
+          ),
+        ],
+        { concurrency: 3 },
+      )
+      const statuses = nuls(names.text)
+      const files = statuses.flatMap((code, index) => {
+        const file = statuses[index + 1]
+        if (index % 2 !== 0 || !file) return []
+        return [
+          {
+            file: RelativePath.make(file),
+            status: code.startsWith("A") ? "added" : code.startsWith("D") ? "deleted" : "modified",
+          } as const,
+        ]
+      })
+      const stats = new Map(
+        nuls(numbers.text).flatMap((line) => {
+          const [additions, deletions, ...file] = line.split("\t")
+          if (!additions || !deletions || file.length === 0) return []
+          return [
+            [
+              file.join("\t"),
+              additions === "-" || deletions === "-"
+                ? { binary: true, additions: 0, deletions: 0 }
+                : { binary: false, additions: Number(additions), deletions: Number(deletions) },
+            ] as const,
+          ]
         }),
       )
+      const patches = VcsPatch.chunksByFile(patch, (index) => files[index]?.file)
+      return files.map((entry) => {
+        const stat = stats.get(entry.file)
+        return {
+          ...entry,
+          additions: stat?.additions ?? 0,
+          deletions: stat?.deletions ?? 0,
+          patch: stat?.binary ? "" : (patches.get(entry.file) ?? VcsPatch.emptyPatch(entry.file)),
+        } satisfies File.Diff
+      })
     })
 
     const hasEntry = Effect.fnUntraced(function* (repository: Repository, tree: TreeID, file: RelativePath) {
@@ -733,6 +739,11 @@ function execute(cwd: string, proc: AppProcess.Interface, args: string[]) {
     )
 }
 
+/** Split NUL-terminated git output into its records. */
+function nuls(text: string) {
+  return text.split("\0").filter(Boolean)
+}
+
 function resolvePath(cwd: string, value: string) {
   const trimmed = value.replace(/[\r\n]+$/, "")
   if (!trimmed) return cwd

packages/core/src/plugin/provider/snowflake-cortex.ts

@@ -1,90 +1,264 @@
-import { Effect } from "effect"
 import { define } from "@opencode/plugin/effect/plugin"
+import { Form } from "@opencode/schema/form"
+import { Clock, Deferred, Effect, Option, Schema, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { App } from "../../app.js"
+import { Bus } from "../../bus.js"
+import { Credential } from "../../credential.js"
+import { Integration } from "../../integration.js"
+import { OauthCallbackPage } from "../../oauth/page.js"
 import { Provider } from "../../provider.js"
+import { configuredSettings } from "./configured.js"
 
-type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>
-
-// Exported for testing: intercepts Cortex-specific request/response quirks.
-export function cortexFetch(upstream: FetchLike = fetch) {
-  return async (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
-    if (init?.body && typeof init.body === "string") {
-      try {
-        const body = JSON.parse(init.body)
-        if ("max_tokens" in body) {
-          body.max_completion_tokens = body.max_tokens
-          delete body.max_tokens
-          init = { ...init, body: JSON.stringify(body) }
-        }
-      } catch {}
-    }
-
-    const response = await upstream(url, init)
-
-    // Cortex returns 400 "conversation complete" as a normal stop condition
-    if (response.status === 400) {
-      try {
-        const errorData = (await response.clone().json()) as Record<string, unknown>
-        if (
-          String(errorData.message || errorData.error || "")
-            .toLowerCase()
-            .includes("conversation complete")
-        ) {
-          return new Response(
-            JSON.stringify({ choices: [{ finish_reason: "stop", message: { content: "", role: "assistant" } }] }),
-            { status: 200, headers: new Headers({ "content-type": "application/json" }) },
-          )
-        }
-      } catch {}
-    }
-
-    // Cortex returns role:"" in streaming deltas; the AI SDK schema requires "assistant"
-    if (response.body && response.headers.get("content-type")?.includes("text/event-stream")) {
-      const reader = response.body.getReader()
-      const encoder = new TextEncoder()
-      const decoder = new TextDecoder()
-      const stream = new ReadableStream({
-        async pull(ctrl) {
-          const { done, value } = await reader.read()
-          if (done) {
-            ctrl.close()
-            return
-          }
-          ctrl.enqueue(
-            encoder.encode(decoder.decode(value, { stream: true }).replace(/"role"\s*:\s*""/g, '"role":"assistant"')),
-          )
-        },
-        cancel() {
-          reader.cancel()
-        },
-      })
-      return new Response(stream, { headers: response.headers, status: response.status })
-    }
-
-    return response
-  }
-}
+const providerID = Provider.ID.make("snowflake-cortex")
+const integrationID = Integration.ID.make(providerID)
+const methodID = Integration.MethodID.make("browser")
+const clientID = "LOCAL_APPLICATION"
+const accountForm = Form.Fields.make([
+  {
+    type: "string",
+    key: "account",
+    title: "Snowflake account",
+    placeholder: "myorg-myaccount",
+    required: true,
+  },
+])
+const Token = Schema.Struct({
+  access_token: Schema.NonEmptyString,
+  refresh_token: Schema.optional(Schema.String),
+  expires_in: Schema.optional(Schema.Number),
+})
+const decodeError = Schema.decodeUnknownOption(
+  Schema.fromJsonString(
+    Schema.Struct({ message: Schema.optional(Schema.Unknown), error: Schema.optional(Schema.Unknown) }),
+  ),
+)
 
 export const SnowflakeCortexPlugin = define({
   id: "opencode.provider.snowflake.cortex",
   effect: Effect.fn(function* (ctx) {
-    yield* ctx.aisdk.hook(
-      "sdk",
-      Effect.fn(function* (evt) {
-        if (evt.model.providerID !== Provider.ID.make("snowflake-cortex")) return
-        const token =
-          process.env.SNOWFLAKE_CORTEX_TOKEN ??
-          process.env.SNOWFLAKE_CORTEX_PAT ??
-          (typeof evt.options.token === "string" ? evt.options.token : undefined) ??
-          (typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined)
-        const upstream = typeof evt.options.fetch === "function" ? (evt.options.fetch as FetchLike) : undefined
-        if (evt.options.includeUsage !== false) evt.options.includeUsage = true
-        const mod = yield* Effect.promise(() => import("@ai-sdk/openai-compatible"))
-        evt.sdk = mod.createOpenAICompatible({
-          ...evt.options,
-          ...(token ? { apiKey: token } : {}),
-          fetch: cortexFetch(upstream) as typeof fetch,
-        } as any)
+    const http = yield* HttpClient.HttpClient
+    const credentials = yield* Credential.Service
+    const integrations = yield* Integration.Service
+    const bus = yield* Bus.Service
+    const configured = yield* configuredSettings(providerID)
+    const account = { value: "" }
+    const saved = Effect.gen(function* () {
+      const connection = yield* integrations.connection.active(integrationID)
+      return connection?.type === "credential" ? yield* credentials.get(connection.id) : undefined
+    })
+    const token = Effect.fn(function* (account: string, form: Record<string, string>) {
+      if (!account) return yield* Effect.fail(new Error("Snowflake account is required"))
+      const response = yield* http.execute(
+        HttpClientRequest.post(`${issuer(account)}/oauth/token-request`).pipe(
+          HttpClientRequest.setHeaders({
+            Accept: "application/json",
+            "User-Agent": App.useragent(ctx.app),
+            // Same built-in OAuth client and Basic header as V1; this is not a user password.
+            Authorization: `Basic ${Buffer.from(`${clientID}:${clientID}`).toString("base64")}`,
+          }),
+          HttpClientRequest.bodyUrlParams({ ...form, client_id: clientID }),
+        ),
+      )
+      if (response.status < 200 || response.status >= 300)
+        return yield* Effect.fail(
+          new Error(`Snowflake token request failed (${response.status}): ${yield* response.text}`),
+        )
+      const tokens = yield* HttpClientResponse.schemaBodyJson(Token)(response)
+      const refresh = tokens.refresh_token || form.refresh_token
+      if (!refresh) return yield* Effect.fail(new Error("Snowflake token response did not include refresh_token"))
+      return Credential.OAuth.make({
+        type: "oauth",
+        methodID,
+        access: tokens.access_token,
+        refresh,
+        expires: (yield* Clock.currentTimeMillis) + (tokens.expires_in ?? 600) * 1000,
+        metadata: { account },
+      })
+    })
+    const refresh = (value: Credential.OAuth) =>
+      token(normalizeAccount(value.metadata?.account), { grant_type: "refresh_token", refresh_token: value.refresh })
+
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID,
+        method: { type: "key", label: "Paste PAT or bearer token", form: accountForm },
+      })
+      // SNOWFLAKE_ACCOUNT configures the endpoint; it is not a token.
+      editor.method.update({
+        integrationID,
+        method: { type: "env", names: ["SNOWFLAKE_CORTEX_TOKEN", "SNOWFLAKE_CORTEX_PAT"] },
+      })
+      editor.method.update({
+        integrationID,
+        method: {
+          id: methodID,
+          type: "oauth",
+          label: "Login with Snowflake (External Browser)",
+          form: [...accountForm, { type: "string", key: "role", title: "Snowflake role (optional)" }],
+        },
+        // An environment-token override must work even when the saved OAuth login has expired.
+        refresh: (value) => (envToken() ? Effect.succeed(value) : refresh(value)),
+        label: (value) => normalizeAccount(value.metadata?.account),
+        authorize: (answer) =>
+          Effect.gen(function* () {
+            const account = normalizeAccount(answer.account)
+            if (!account) return yield* Effect.fail(new Error("Snowflake account is required"))
+            const role = typeof answer.role === "string" ? answer.role.trim() : ""
+            const verifier = Buffer.from(crypto.getRandomValues(new Uint8Array(48))).toString("base64url")
+            const challenge = Buffer.from(
+              yield* Effect.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))),
+            ).toString("base64url")
+            const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("base64url")
+            const code = yield* Deferred.make<string, Error>()
+            const { createServer } = yield* Effect.promise(() => import("node:http"))
+            const { EventEmitter } = yield* Effect.promise(() => import("node:events"))
+            const server = createServer((request, response) => {
+              const url = new URL(request.url ?? "/", "http://127.0.0.1")
+              if (url.pathname !== "/") {
+                response.writeHead(404).end()
+                return
+              }
+              const value = url.searchParams.get("code")
+              const error =
+                url.searchParams.get("state") !== state
+                  ? "Invalid OAuth state"
+                  : url.searchParams.get("error_description") ||
+                    url.searchParams.get("error") ||
+                    (!value ? "Missing authorization code" : undefined)
+              Effect.runFork(error ? Deferred.fail(code, new Error(error)) : Deferred.succeed(code, value ?? ""))
+              response
+                .writeHead(error ? 400 : 200, { "Content-Type": "text/html" })
+                .end(
+                  error
+                    ? OauthCallbackPage.error(error, { provider: "Snowflake" })
+                    : OauthCallbackPage.success({ provider: "Snowflake" }),
+                )
+            })
+            yield* Effect.addFinalizer(() => Effect.sync(() => server.close()))
+            yield* Effect.tryPromise(() => EventEmitter.once(server.listen(0, "127.0.0.1"), "listening"))
+            const address = server.address()
+            if (!address || typeof address === "string")
+              return yield* Effect.fail(new Error("Missing OAuth callback port"))
+            const redirect = `http://127.0.0.1:${address.port}/`
+            return {
+              mode: "auto" as const,
+              url: `${issuer(account)}/oauth/authorize?${new URLSearchParams({
+                client_id: clientID,
+                response_type: "code",
+                redirect_uri: redirect,
+                state,
+                scope: !role
+                  ? "refresh_token"
+                  : /^[-_A-Za-z0-9]+$/.test(role)
+                    ? `refresh_token session:role:${role}`
+                    : `refresh_token session:role-encoded:${encodeURIComponent(role)}`,
+                code_challenge: challenge,
+                code_challenge_method: "S256",
+              }).toString()}`,
+              instructions: "Complete Snowflake sign-in in your browser.",
+              callback: Effect.gen(function* () {
+                return yield* token(account, {
+                  grant_type: "authorization_code",
+                  code: yield* Deferred.await(code),
+                  redirect_uri: redirect,
+                  code_verifier: verifier,
+                })
+              }),
+            }
+          }),
+      })
+    })
+
+    const load = Effect.gen(function* () {
+      const value = (yield* saved)?.value
+      account.value = normalizeAccount(
+        process.env.SNOWFLAKE_ACCOUNT ??
+          (value?.type === "key"
+            ? (value.configuration?.account ?? value.metadata?.account)
+            : value?.metadata?.account) ??
+          configured?.account,
+      )
+    })
+    yield* load
+    yield* ctx.catalog.transform((catalog) => {
+      const item = catalog.provider.get(providerID)
+      if (!item) return
+      const settings = { ...item.provider.settings, ...configured }
+      item.provider.settings = {
+        ...settings,
+        baseURL: endpoint(settings.baseURL, account.value),
+        ...(typeof settings.token === "string" ? { apiKey: settings.token } : {}),
+      }
+      for (const model of item.models.values()) {
+        model.compatibility = { maxTokensField: "max_completion_tokens", ...model.compatibility }
+        if (model.settings?.baseURL !== undefined)
+          model.settings.baseURL = endpoint(model.settings.baseURL, account.value)
+      }
+    })
+    yield* bus.subscribe(Credential.Event.Switched).pipe(
+      Stream.filter((event) => event.data.integrationID === integrationID),
+      Stream.runForEach(() => load.pipe(Effect.andThen(ctx.catalog.reload()))),
+      Effect.forkScoped({ startImmediately: true }),
+    )
+    yield* ctx.session.hook(
+      "http.request",
+      (event) =>
+        Effect.sync(() => {
+          // Model resolution already supplies and refreshes stored credentials on each attempt.
+          const token = envToken()
+          if (token) event.request.headers.set("authorization", `Bearer ${token}`)
+          event.request.headers.set("user-agent", App.useragent(ctx.app))
+        }),
+      { providerID },
+    )
+    yield* ctx.session.hook(
+      "http.response",
+      Effect.fn(function* (event) {
+        if (event.response.status !== 400) return
+        const error = Option.getOrUndefined(decodeError(yield* Effect.promise(() => event.response.clone().text())))
+        // oxlint-disable-next-line typescript-eslint/no-base-to-string -- Preserve V1's error-body coercion.
+        const message = String(error?.message || error?.error || "")
+        if (!message.toLowerCase().includes("conversation complete")) return
+        event.response = new Response(
+          'data: {"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n',
+          { headers: { "content-type": "text/event-stream" } },
+        )
       }),
+      { providerID },
+    )
+    yield* ctx.session.hook(
+      "retry",
+      Effect.fn(function* (event) {
+        if (event.error.status !== 401 || event.attempt !== 2 || envToken()) return
+        const current = yield* saved
+        if (current?.value.type !== "oauth" || current.value.methodID !== methodID) return
+        yield* credentials.update(current.id, { value: yield* refresh(current.value).pipe(Effect.orDie) })
+        event.decision = { retry: true, delay: 0 }
+      }),
+      { providerID },
     )
   }),
 })
+
+function normalizeAccount(value: unknown) {
+  if (typeof value !== "string") return ""
+  return value
+    .trim()
+    .replace(/^https?:\/\//i, "")
+    .replace(/\/+$/, "")
+    .replace(/\.snowflakecomputing\.com$/i, "")
+}
+
+function issuer(account: string) {
+  return `https://${account}.snowflakecomputing.com`
+}
+
+function endpoint(value: unknown, account: string) {
+  const baseURL = typeof value === "string" ? value : `${issuer("${SNOWFLAKE_ACCOUNT}")}/api/v2/cortex/v1`
+  return account ? baseURL.replaceAll("${SNOWFLAKE_ACCOUNT}", account) : baseURL
+}
+
+function envToken() {
+  return process.env.SNOWFLAKE_CORTEX_TOKEN ?? process.env.SNOWFLAKE_CORTEX_PAT
+}

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

@@ -53,7 +53,3 @@ Use the instructions below and the tools available to assist the user.
 
 # Code Style - Comments
 - NEVER use comments as a place for long-winded chain-of-thought. Long thinking texts must be generated as private reasoning. Comments in code must be appropriately concise.
-
-# User Help & Feedback
-- Users can give feedback or report issues at https://github.com/anomalyco/opencode and mention that they are using Meta {{MODEL_NAME}}.
-- When users ask directly about OpenCode (eg. "can OpenCode do...", "are you able to do...") or its features (eg. implement a hook, write a slash command, or install an MCP server), use the `webfetch` tool to gather information to answer the question from the V2 OpenCode docs at https://opencode.ai/v2/docs/.

packages/core/src/session.ts

@@ -57,8 +57,11 @@ import { SessionModelTransport } from "./session/model-transport.js"
 import { llmClient } from "./effect/app-node-platform.js"
 import { Snapshot } from "./snapshot.js"
 import { Session } from "./session/session.js"
+import { SessionDiff, TurnRangeError } from "./session/diff.js"
+import { LocationServiceMap } from "./location-service-map.js"
 import { FSUtil } from "@opencode/util/fs-util"
 import type { EventLog } from "@opencode/schema/event-log"
+import type { FileDiff } from "@opencode/schema/file-diff"
 import { Job } from "./job.js"
 import type { Command } from "./command.js"
 import { SessionEnvironment } from "./session/environment.js"
@@ -113,6 +116,7 @@ export {
 type InboxItemRef = { readonly sessionID: SessionSchema.ID; readonly inboxID: SessionMessage.ID }
 
 export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError }
+export { TurnRangeError }
 
 export interface Interface {
   readonly list: (input?: ListInput) => Effect.Effect<{
@@ -142,6 +146,13 @@ export interface Interface {
   readonly context: (
     sessionID: SessionSchema.ID,
   ) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>
+  /** Structured diffs of the files changed by a turn or range of turns; see `SessionDiff.turn`. */
+  readonly diff: (input: {
+    readonly sessionID: SessionSchema.ID
+    readonly messageID?: SessionMessage.ID
+    readonly to?: SessionMessage.ID
+    readonly context?: number
+  }) => Effect.Effect<readonly FileDiff.Info[], NotFoundError | MessageNotFoundError | TurnRangeError | Snapshot.Error>
   /**
    * Durable admitted session work not yet visible in projected history,
    * ordered by admission. Includes unpromoted user and synthetic inputs and
@@ -230,6 +241,7 @@ const layer = Layer.effect(
     const moves = yield* SessionMove.Service
     const jobs = yield* Job.Service
     const environments = yield* SessionEnvironment.Service
+    const locations = yield* LocationServiceMap.Service
     const sessions = yield* Session.make()
     const isDurableSessionEvent = Schema.is(SessionEvent.Durable)
 
@@ -362,6 +374,17 @@ const layer = Layer.effect(
         yield* result.get(sessionID)
         return yield* store.context(sessionID)
       }),
+      diff: Effect.fn("Session.diff")(function* (input) {
+        const session = yield* result.get(input.sessionID)
+        const active = yield* execution.isActive(input.sessionID)
+        return yield* SessionDiff.turn(db, locations, {
+          session,
+          active,
+          messageID: input.messageID,
+          to: input.to,
+          context: input.context,
+        })
+      }),
       inbox: (sessionID) => sessions.forSession(sessionID).inbox(),
       cancelInbox: (input) => sessions.forSession(input.sessionID).cancelInbox(input.inboxID),
       steerInbox: (input) => sessions.forSession(input.sessionID).steerInbox(input.inboxID),
@@ -450,6 +473,7 @@ export const node: LayerNode.Provider<Service, never, typeof Node.tags.values.gl
     SessionInbox.node,
     SessionMove.node,
     SessionProjector.node,
+    LocationServiceMap.node,
     FSUtil.node,
     App.node,
   ],

packages/core/src/session/diff.ts

@@ -0,0 +1,138 @@
+export * as SessionDiff from "./diff.js"
+
+import { and, asc, eq, gt, inArray, lt, or, sql } from "drizzle-orm"
+import { Context, Effect, Schema } from "effect"
+import { Location } from "@opencode/schema/location"
+import { Database } from "../database/database.js"
+import { LocationServiceMap } from "../location-service-map.js"
+import { Snapshot } from "../snapshot.js"
+import { PATCH_CONTEXT_LINES } from "../vcs/patch.js"
+import { MessageNotFoundError } from "./error.js"
+import { SessionMessage } from "./message.js"
+import { SessionSchema } from "./schema.js"
+import { SessionMessageTable } from "./sql.js"
+
+export class TurnRangeError extends Schema.TaggedError<TurnRangeError>()("Session.TurnRangeError", {
+  sessionID: SessionSchema.ID,
+  field: Schema.Literals(["messageID", "to"]),
+  message: Schema.String,
+}) {}
+
+const decodeLocation = Schema.decodeUnknownSync(Schema.fromJsonString(Location.Ref))
+
+/**
+ * Diff the files changed by the turn containing a user message. A turn runs from
+ * the first prompt after the Session was last idle until the next idle marker, so
+ * prompts steered in while it was busy belong to the same turn; `to` extends the
+ * range through the turn containing a later user message. Compares the range's
+ * first recorded start snapshot with its last recorded end snapshot; only a step
+ * still running in the active Session compares against the working copy. Like VCS
+ * diffs, an omitted `context` yields full-file patches.
+ *
+ * A Session without any idle marker predates them, so its prompts span until the
+ * next user message instead.
+ *
+ * Snapshot trees live in the repository of the Location that captured them, so a
+ * range spanning a location switch is rejected rather than diffed wrongly.
+ */
+export const turn = Effect.fn("SessionDiff.turn")(function* (
+  db: Database.Interface["db"],
+  locations: Context.Service.Shape<typeof LocationServiceMap.Service>,
+  input: {
+    readonly session: SessionSchema.Info
+    /** The process is currently executing this Session. */
+    readonly active: boolean
+    readonly messageID?: SessionMessage.ID
+    readonly to?: SessionMessage.ID
+    readonly context?: number
+  },
+) {
+  const sessionID = input.session.id
+  const rows = yield* db
+    .select({ id: SessionMessageTable.id, type: SessionMessageTable.type, seq: SessionMessageTable.seq })
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, sessionID),
+        or(
+          inArray(SessionMessageTable.type, ["user", "idle"]),
+          input.messageID ? eq(SessionMessageTable.id, input.messageID) : undefined,
+          input.to ? eq(SessionMessageTable.id, input.to) : undefined,
+        ),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  const users = rows.filter((row) => row.type === "user")
+  const markers = rows.filter((row) => row.type === "idle")
+  const resolve = Effect.fn(function* (field: "messageID" | "to", id: SessionMessage.ID) {
+    const row = rows.find((row) => row.id === id)
+    if (!row) return yield* new MessageNotFoundError({ sessionID, messageID: id })
+    if (row.type !== "user")
+      return yield* new TurnRangeError({ sessionID, field, message: `Message ${id} is not a user message` })
+    return row
+  })
+  const anchor = input.messageID ? yield* resolve("messageID", input.messageID) : users[users.length - 1]
+  if (!anchor) return []
+  const last = input.to ? yield* resolve("to", input.to) : anchor
+  if (last.seq < anchor.seq)
+    return yield* new TurnRangeError({ sessionID, field: "to", message: `Message ${last.id} precedes ${anchor.id}` })
+  // Without any marker, history predates idle markers and a prompt's turn ends at the next prompt.
+  const legacy = markers.length === 0
+  // The turn opens with the first prompt after the previous idle marker; the anchor itself is the latest candidate.
+  const opened = markers.findLast((row) => row.seq < anchor.seq)?.seq ?? -1
+  const start = legacy ? anchor.seq : (users.find((row) => row.seq > opened)?.seq ?? anchor.seq)
+  const end = legacy ? users.find((row) => row.seq > last.seq)?.seq : markers.find((row) => row.seq > last.seq)?.seq
+  const steps = yield* db
+    .select({
+      seq: SessionMessageTable.seq,
+      start: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.snapshot.start')`,
+      end: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.snapshot.end')`,
+      completed: sql<number | null>`json_extract(${SessionMessageTable.data}, '$.time.completed')`,
+    })
+    .from(SessionMessageTable)
+    .where(
+      and(
+        eq(SessionMessageTable.session_id, sessionID),
+        eq(SessionMessageTable.type, "assistant"),
+        gt(SessionMessageTable.seq, start),
+        end === undefined ? undefined : lt(SessionMessageTable.seq, end),
+      ),
+    )
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  const first = steps[0]
+  const final = steps[steps.length - 1]
+  const from = steps.find((step) => step.start)?.start
+  if (!first || !final || !from) return []
+  const switches = yield* db
+    .select({
+      seq: SessionMessageTable.seq,
+      location: sql<string>`json_extract(${SessionMessageTable.data}, '$.location')`,
+      previous: sql<string | null>`json_extract(${SessionMessageTable.data}, '$.previous.location')`,
+    })
+    .from(SessionMessageTable)
+    .where(and(eq(SessionMessageTable.session_id, sessionID), eq(SessionMessageTable.type, "location-switched")))
+    .orderBy(asc(SessionMessageTable.seq))
+    .all()
+    .pipe(Effect.orDie)
+  if (switches.some((row) => row.seq > first.seq && row.seq < final.seq))
+    return yield* new TurnRangeError({ sessionID, field: "to", message: "Turn range spans a location change" })
+  const before = switches.findLast((row) => row.seq < first.seq)?.location
+  const after = switches.find((row) => row.seq > first.seq)?.previous
+  const location = before ? decodeLocation(before) : after ? decodeLocation(after) : input.session.location
+  const recorded = steps.findLast((step) => step.end)?.end
+  return yield* Effect.gen(function* () {
+    const snapshot = yield* Snapshot.Service
+    const running = input.active && final.completed === null
+    const to = running ? ((yield* snapshot.capture()) ?? recorded) : recorded
+    if (!to) return []
+    return yield* snapshot.diff({
+      from: Snapshot.ID.make(from),
+      to: Snapshot.ID.make(to),
+      context: input.context ?? PATCH_CONTEXT_LINES,
+    })
+  }).pipe(Effect.provide(locations.get(location)))
+})

packages/core/src/session/message-updater.ts

@@ -60,6 +60,21 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
     )
   })
 
+  const idle = (outcome: SessionMessage.Idle["outcome"]) =>
+    clearCurrentRetry.pipe(
+      Effect.andThen(
+        adapter.appendMessage(
+          SessionMessage.Idle.make({
+            id: SessionMessage.ID.fromEvent(event.id),
+            type: "idle",
+            outcome,
+            metadata: event.metadata,
+            time: { created },
+          }),
+        ),
+      ),
+    )
+
   const project = pipe(
     Match.type<SessionEvent.DurableEvent>(),
     Match.discriminatorsExhaustive("type")({
@@ -123,9 +138,11 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
       "session.inbox.cancelled": () => Effect.void,
       "session.inbox.delivery.changed": () => Effect.void,
       "session.execution.started": () => Effect.void,
-      "session.execution.succeeded": () => clearCurrentRetry,
-      "session.execution.failed": () => clearCurrentRetry,
-      "session.execution.interrupted": () => clearCurrentRetry,
+      "session.execution.succeeded": () => idle("succeeded"),
+      "session.execution.failed": () => idle("failed"),
+      // Shutdown keeps the execution claim and the resumed drain continues the turn.
+      "session.execution.interrupted": (event) =>
+        event.data.reason === "shutdown" ? clearCurrentRetry : idle("interrupted"),
       "session.instructions.updated": (event) => {
         if (event.data.text === undefined) return Effect.void
         return adapter.appendMessage(

packages/core/src/session/runner/to-llm-message.ts

@@ -226,6 +226,7 @@ function toLLMMessage(message: SessionMessage.Info, model: Model.Ref, providerMe
   switch (message.type) {
     case "agent-switched":
     case "model-switched":
+    case "idle":
       return []
     case "location-switched":
       return [

packages/core/src/snapshot.ts

@@ -131,38 +131,55 @@ const layer = Layer.effect(
       )
     })
 
-    const compare = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
+    const comparison = Effect.fnUntraced(function* (operation: "files" | "diff", input: CompareInput) {
       const repo = yield* repository.pipe(Effect.mapError((cause) => failure(operation, cause)))
-      const comparison = {
+      return {
+        source: repo.source,
         repository: repo.snapshotRepository,
         from: Git.TreeID.make(input.from),
         to: Git.TreeID.make(input.to),
       }
-      const files = yield* git.tree.files(comparison).pipe(Effect.mapError((cause) => failure(operation, cause)))
-      const ignored = yield* git.index
-        .ignored({ repository: repo.source, paths: files })
+    })
+
+    // Snapshots track every scoped file; the source repository's ignore rules decide what callers see.
+    const ignored = Effect.fnUntraced(function* (
+      operation: "files" | "diff",
+      source: Git.Repository,
+      paths: readonly RelativePath[],
+    ) {
+      return yield* git.index
+        .ignored({ repository: source, paths })
         .pipe(Effect.mapError((cause) => failure(operation, cause)))
-      return {
-        input: comparison,
-        files,
-        ignored,
-      }
     })
 
     const files = Effect.fn("Snapshot.files")(function* (input: CompareInput) {
-      const comparison = yield* compare("files", input)
-      return comparison.files.filter((file) => !comparison.ignored.has(file))
+      const compared = yield* comparison("files", input)
+      const changed = yield* git.tree
+        .files({ repository: compared.repository, from: compared.from, to: compared.to })
+        .pipe(Effect.mapError((cause) => failure("files", cause)))
+      const skipped = yield* ignored("files", compared.source, changed)
+      return changed.filter((file) => !skipped.has(file))
     })
 
     const diff = Effect.fn("Snapshot.diff")(function* (input: DiffInput) {
-      const comparison = yield* compare("diff", input)
-      return yield* git.tree
+      if (input.paths?.length === 0) return []
+      const compared = yield* comparison("diff", input)
+      // Only an explicit selection becomes a pathspec; ignored paths are dropped from the result instead.
+      const diffs = yield* git.tree
         .diff({
-          ...comparison.input,
+          repository: compared.repository,
+          from: compared.from,
+          to: compared.to,
           context: input.context,
-          paths: (input.paths ?? comparison.files).filter((file) => !comparison.ignored.has(file)),
+          paths: input.paths,
         })
         .pipe(Effect.mapError((cause) => failure("diff", cause)))
+      const skipped = yield* ignored(
+        "diff",
+        compared.source,
+        diffs.map((file) => RelativePath.make(file.file)),
+      )
+      return diffs.filter((file) => !skipped.has(RelativePath.make(file.file)))
     })
 
     const plan = Effect.fnUntraced(function* (worktree: AbsolutePath, input: RestoreInput) {

packages/core/test/git.test.ts

@@ -6,6 +6,7 @@ import { Effect } from "effect"
 import { LayerNode } from "@opencode/util/effect/layer-node"
 import { Git } from "@opencode/core/git"
 import { AbsolutePath, RelativePath } from "@opencode/core/schema"
+import { VcsPatch } from "@opencode/core/vcs/patch"
 import { branch, commit, initRepo, read, withRemote } from "./fixture/git"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
@@ -196,6 +197,42 @@ describe("Git trees", () => {
     }),
   )
 
+  it.live("caps batched tree patches, keeps per-file stats past the cap, and matches non-ASCII names", () =>
+    Effect.gen(function* () {
+      const root = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
+      )
+      yield* Effect.promise(() => initRepo(root.path))
+      const git = yield* Git.Service
+      const repository = yield* git.repo.discover(AbsolutePath.make(root.path))
+      if (!repository) throw new Error("Repository not found")
+      const before = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] })
+      const lines = Math.ceil(VcsPatch.MAX_TOTAL_PATCH_BYTES / 80) + 1
+      yield* Effect.promise(async () => {
+        await Bun.write(path.join(root.path, "a-small.txt"), "small\n")
+        await Bun.write(path.join(root.path, "b-large.txt"), `${"x".repeat(79)}\n`.repeat(lines))
+        await Bun.write(path.join(root.path, "c-binary.bin"), new Uint8Array([0, 1, 2, 3]))
+        await Bun.write(path.join(root.path, "a-caf\u00e9.txt"), "caf\u00e9\n")
+      })
+      const after = yield* git.tree.capture({ repository, scopes: [RelativePath.make(".")] })
+
+      const diffs = yield* git.tree.diff({ repository, from: before, to: after, context: 0 })
+      expect(diffs.map((item) => [item.file, item.status, item.additions, item.deletions])).toEqual([
+        ["a-caf\u00e9.txt", "added", 1, 0],
+        ["a-small.txt", "added", 1, 0],
+        ["b-large.txt", "added", lines, 0],
+        ["c-binary.bin", "added", 0, 0],
+      ])
+      // Patch headers are not NUL-delimited; a quoted (octal-escaped) header would orphan this chunk.
+      expect(diffs[0]?.patch).toContain("+caf\u00e9\n")
+      expect(diffs[1]?.patch).toContain("+small\n")
+      expect(diffs[2]?.patch).toBe(VcsPatch.emptyPatch("b-large.txt"))
+      expect(diffs[3]?.patch).toBe("")
+      expect(yield* git.tree.diff({ repository, from: before, to: after, paths: [] })).toEqual([])
+    }),
+  )
+
   it.live("captures, compares, previews, and restores scoped trees", () =>
     Effect.gen(function* () {
       const root = yield* Effect.acquireRelease(

packages/core/test/plugin/command.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect, Layer } from "effect"
 import { Command } from "@opencode/core/command"
 import { Bus } from "@opencode/core/bus"
@@ -33,11 +33,6 @@ const it = testEffect(
 )
 
 describe("CommandPlugin.Plugin", () => {
-  test("refers to tools by their available capabilities", () => {
-    expect(PROMPT_REVIEW).toContain("Available documentation and code-search tools")
-    expect(PROMPT_REVIEW).not.toContain("Exa Code Context")
-  })
-
   it.effect("registers built-in init and review commands", () =>
     Effect.gen(function* () {
       const command = yield* Command.Service

packages/core/test/plugin/optimize.test.ts

@@ -15,6 +15,10 @@ import { Effect } from "effect"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 import PROMPT_META from "../../src/plugin/system-prompt/meta.txt"
+import PROMPT_GPT from "../../src/plugin/system-prompt/gpt.txt"
+import PROMPT_ASTRA from "../../src/plugin/system-prompt/gpt-astra.txt"
+import PROMPT_KIMI from "../../src/plugin/system-prompt/kimi.txt"
+import PROMPT_TRINITY from "../../src/plugin/system-prompt/trinity.txt"
 
 const it = testEffect(PluginTestLayer)
 const fallback = SessionSystemPrompt.make([])
@@ -42,20 +46,6 @@ const context = (id: string, system = fallback): SessionHooks["context"] => ({
 })
 
 describe("OptimizePlugin", () => {
-  test("uses current vocabulary in the Meta prompt", () => {
-    expect(PROMPT_META).toContain("`webfetch` tool")
-    expect(PROMPT_META).toContain("`subagent` tool")
-    expect(PROMPT_META).toContain("Reserve `shell`")
-    expect(PROMPT_META).toContain("`read` for reading files")
-    expect(PROMPT_META).toContain("`edit` for editing")
-    expect(PROMPT_META).toContain("`write` for creating files")
-    expect(PROMPT_META).toContain("Follow that reminder for the files you may edit")
-    expect(PROMPT_META).toContain("https://opencode.ai/v2/docs/")
-    expect(PROMPT_META).not.toMatch(
-      /TodoWrite|Task tool|WebFetch|\bBash\b|including planning files|https:\/\/opencode\.ai\/docs/,
-    )
-  })
-
   test("enables prompt plugins without model-specific tool optimization", () => {
     expect(OptimizePlugin.Plugins.map((plugin) => plugin.id)).toEqual([
       "opencode.prompt.openai",
@@ -81,16 +71,16 @@ describe("OptimizePlugin", () => {
         discard: true,
       })
       const cases = [
-        ["gpt-5", "# Delegation"],
-        ["gpt-4.1", "# Delegation"],
+        ["gpt-5", PROMPT_GPT],
+        ["gpt-4.1", PROMPT_GPT],
         ["o3", fallback],
-        ["gpt-5-codex", "# Delegation"],
-        ["gpt-6-astra", "Do not settle for a partial"],
+        ["gpt-5-codex", PROMPT_GPT],
+        ["gpt-6-astra", PROMPT_ASTRA],
         ["gemini-2.5-pro", fallback],
         ["claude-sonnet-4", fallback],
-        ["kimi-k2", "# Prompt and Tool Use"],
-        ["trinity", "what command should I run to list files"],
-        ["meta/muse-spark-1.1", "powered by Muse Spark"],
+        ["kimi-k2", PROMPT_KIMI],
+        ["trinity", PROMPT_TRINITY],
+        ["meta/muse-spark-1.1", PROMPT_META.replaceAll("{{MODEL_NAME}}", "Muse Spark")],
         ["llama-3.3", fallback],
       ] as const
 
@@ -102,7 +92,11 @@ describe("OptimizePlugin", () => {
             .trigger("session", "context", event)
             .pipe(
               Effect.tap(() =>
-                Effect.sync(() => expect(event.system.map((part) => part.text).join("\n\n")).toContain(expected)),
+                Effect.sync(() =>
+                  expect(event.system.map((part) => part.text)).toEqual([
+                    SessionSystemPrompt.render(expected, Object.keys(event.tools)),
+                  ]),
+                ),
               ),
             )
         },
@@ -127,14 +121,10 @@ describe("OptimizePlugin", () => {
       yield* hooks.trigger("session", "context", event)
 
       expect(event.system.map((part) => part.text)).toEqual([
-        expect.stringContaining("# Delegation"),
+        SessionSystemPrompt.render(PROMPT_GPT, Object.keys(event.tools)),
         "Project instructions",
       ])
-      expect(event.system[0]?.text).toStartWith("You are an AI agent powered by OpenCode")
-      expect(event.system[0]?.text).toContain("Prefer dedicated tools over shell commands")
       expect(event.system[0]?.text).not.toContain("${OPENCODE_TOOL_GUIDANCE}")
-      expect(event.system[0]?.text).toContain("Use the write tool")
-      expect(event.system[0]?.text).toContain("Use the edit tool")
       expect(Object.keys(event.tools).sort()).toEqual(["edit", "glob", "grep", "patch", "read", "shell", "write"])
     }),
   )
@@ -187,14 +177,14 @@ describe("OptimizePlugin", () => {
           yield* OptimizePlugin.OpenAIToolsPlugin.effect(pluginHost)
           const event = context("gpt-5")
           yield* hooks.trigger("session", "context", event)
-          expect(event.system[0]?.text).toContain("# Delegation")
+          expect(event.system[0]?.text).toBe(SessionSystemPrompt.render(PROMPT_GPT, Object.keys(event.tools)))
           expect(Object.keys(event.tools).sort()).toEqual(["edit", "patch", "read", "shell", "write"])
         }),
       )
 
       const event = context("gpt-5")
       yield* hooks.trigger("session", "context", event)
-      expect(event.system[0]?.text).toContain("# Delegation")
+      expect(event.system[0]?.text).toBe(SessionSystemPrompt.render(PROMPT_GPT, Object.keys(event.tools)))
       expect(Object.keys(event.tools).sort()).toEqual(["edit", "glob", "grep", "patch", "read", "shell", "write"])
       const claude = context("claude-sonnet-4-6")
       yield* hooks.trigger("session", "context", claude)
@@ -229,8 +219,9 @@ describe("OptimizePlugin", () => {
           return hooks.trigger("session", "context", event).pipe(
             Effect.tap(() =>
               Effect.sync(() => {
-                expect(event.system[0]?.text).toContain(`powered by ${name},`)
-                expect(event.system[0]?.text).toContain(`using Meta ${name}.`)
+                expect(event.system[0]?.text).toBe(
+                  SessionSystemPrompt.render(PROMPT_META.replaceAll("{{MODEL_NAME}}", name), Object.keys(event.tools)),
+                )
                 expect(event.system[0]?.text).not.toContain("{{MODEL_NAME}}")
               }),
             ),
@@ -292,7 +283,7 @@ describe("OptimizePlugin", () => {
       yield* hooks.trigger("session", "context", kimi)
 
       expect(gemini.system[0]?.text).toBe(fallback)
-      expect(kimi.system[0]?.text).toContain("# Prompt and Tool Use")
+      expect(kimi.system[0]?.text).toBe(SessionSystemPrompt.render(PROMPT_KIMI, Object.keys(kimi.tools)))
     }),
   )
 
@@ -302,8 +293,8 @@ describe("OptimizePlugin", () => {
       const hooks = yield* PluginHooks.Service
       const pluginHost = yield* makeHost
       const cases = [
-        ["gpt-5-alias", "custom-model", undefined, "# Delegation"],
-        ["gpt-6-alias", "custom-model", undefined, "Do not settle for a partial"],
+        ["gpt-5-alias", "custom-model", undefined, PROMPT_GPT],
+        ["gpt-6-alias", "custom-model", undefined, PROMPT_ASTRA],
         ["openai-alias", "GPT-5", undefined, fallback],
         ["codex-family-alias", "custom-deployment", "GPT-CODEX", fallback],
         ["astra-api-alias", "gpt-6-astra", undefined, fallback],
@@ -326,7 +317,7 @@ describe("OptimizePlugin", () => {
           Effect.gen(function* () {
             const event = context(id)
             yield* hooks.trigger("session", "context", event)
-            expect(event.system[0]?.text).toContain(prompt)
+            expect(event.system[0]?.text).toBe(SessionSystemPrompt.render(prompt, Object.keys(event.tools)))
             expect(Object.keys(event.tools).sort()).toEqual(["edit", "glob", "grep", "patch", "read", "shell", "write"])
           }),
         { discard: true },

packages/core/test/plugin/provider-snowflake-cortex.test.ts

@@ -1,262 +1,290 @@
-import { AISDK } from "@opencode/core/aisdk"
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
+import { Message } from "@opencode/ai"
+import { LLMClient, RequestExecutor } from "@opencode/ai/route"
+import { Agent } from "@opencode/core/agent"
+import { Catalog } from "@opencode/core/catalog"
+import { Credential } from "@opencode/core/credential"
+import { Integration } from "@opencode/core/integration"
+import { Location } from "@opencode/core/location"
 import { Model } from "@opencode/core/model"
+import { ModelResolver } from "@opencode/core/model-resolver"
 import { Plugin } from "@opencode/core/plugin"
 import { PluginHost } from "@opencode/core/plugin/host"
-import { SnowflakeCortexPlugin, cortexFetch } from "@opencode/core/plugin/provider/snowflake-cortex"
-import { ProviderPlugins } from "@opencode/core/plugin/provider"
+import { PluginHooks } from "@opencode/core/plugin/hooks"
+import { SnowflakeCortexPlugin } from "@opencode/core/plugin/provider/snowflake-cortex"
 import { Provider } from "@opencode/core/provider"
+import { Session } from "@opencode/core/session"
+import { SessionModelRequest } from "@opencode/core/session/model-request"
+import { SessionModelTransport } from "@opencode/core/session/model-transport"
+import { expect } from "bun:test"
+import { Effect, Layer, Schedule, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Socket } from "effect/unstable/socket"
+import { withEnv } from "../fixture/env"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 
-const it = testEffect(PluginTestLayer)
+const it = testEffect(
+  Layer.merge(PluginTestLayer, SessionModelTransport.layer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal))),
+)
+const providerID = Provider.ID.make("snowflake-cortex")
+const integrationID = Integration.ID.make(providerID)
+const methodID = Integration.MethodID.make("browser")
+const modelID = Model.ID.make("claude-sonnet-4-6")
+const env = { SNOWFLAKE_ACCOUNT: undefined, SNOWFLAKE_CORTEX_TOKEN: undefined, SNOWFLAKE_CORTEX_PAT: undefined }
+const endpoint = "https://myorg-myaccount.snowflakecomputing.com"
+const polling = { times: 100, schedule: Schedule.spaced("1 millis") }
+const expiredOAuth = (account: string, refresh = "refresh") =>
+  Credential.OAuth.make({ type: "oauth", methodID, access: "expired", refresh, expires: 1, metadata: { account } })
 
-const addPlugin = Effect.fn(function* () {
+const fixture = Effect.fn(function* () {
+  const requests: Request[] = []
+  const replies: Response[] = []
+  const http = HttpClient.make((request) =>
+    Effect.gen(function* () {
+      requests.push(yield* HttpClientRequest.toWeb(request).pipe(Effect.orDie))
+      const response = replies.shift()
+      if (!response) throw new Error(`Unexpected request: ${request.url}`)
+      return HttpClientResponse.fromWeb(request, response)
+    }),
+  )
+  const catalog = yield* Catalog.Service
+  const integrations = yield* Integration.Service
+  const sessions = yield* Session.Service
+  const location = yield* Location.Service
+  const hooks = yield* PluginHooks.Service
   const plugin = yield* Plugin.Service
   const host = yield* PluginHost.make(plugin)
-  yield* SnowflakeCortexPlugin.effect(host)
-})
-
-function withEnv<A, E, R>(vars: Record<string, string | undefined>, effect: () => Effect.Effect<A, E, R>) {
-  return Effect.acquireUseRelease(
-    Effect.sync(() => {
-      const previous = Object.fromEntries(Object.keys(vars).map((key) => [key, process.env[key]]))
-      Object.entries(vars).forEach(([key, value]) => {
-        if (value === undefined) delete process.env[key]
-        else process.env[key] = value
-      })
-      return previous
-    }),
-    effect,
-    (previous) =>
-      Effect.sync(() => {
-        Object.entries(previous).forEach(([key, value]) => {
-          if (value === undefined) delete process.env[key]
-          else process.env[key] = value
-        })
-      }),
-  )
-}
-
-describe("SnowflakeCortexPlugin", () => {
-  it.effect("is registered in ProviderPlugins before OpenAICompatiblePlugin", () =>
-    Effect.sync(() => {
-      expect(ProviderPlugins.map((item) => item.id)).toContain("opencode.provider.snowflake.cortex")
-      const ids = ProviderPlugins.map((p) => p.id)
-      expect(ids.indexOf("opencode.provider.snowflake.cortex")).toBeLessThan(
-        ids.indexOf("opencode.provider.openai.compatible"),
-      )
-    }),
-  )
-
-  it.effect("ignores non-snowflake-cortex providers", () =>
-    Effect.gen(function* () {
-      const aisdk = yield* AISDK.Service
-      yield* addPlugin()
-      const result = yield* aisdk.runSDK({
-        model: Model.Info.make({
-          ...Model.Info.default(Provider.ID.make("openai"), Model.ID.make("gpt-4")),
-          modelID: Model.ID.make("gpt-4"),
-          package: "aisdk:test-provider",
-        }),
-        package: "@ai-sdk/openai",
-        options: { name: "openai" },
-      })
-      expect(result.sdk).toBeUndefined()
-    }),
-  )
-
-  it.effect("creates SDK for snowflake-cortex using SNOWFLAKE_CORTEX_PAT env var", () =>
-    withEnv({ SNOWFLAKE_CORTEX_PAT: "test-pat" }, () =>
-      Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
-        yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: Model.Info.make({
-            ...Model.Info.default(Provider.ID.make("snowflake-cortex"), Model.ID.make("claude-sonnet-4-6")),
-            modelID: Model.ID.make("claude-sonnet-4-6"),
-            package: "aisdk:test-provider",
-          }),
-          package: "@ai-sdk/openai-compatible",
-          options: { name: "snowflake-cortex", baseURL: "https://test.snowflakecomputing.com/api/v2/cortex/v1" },
-        })
-        expect(result.sdk).toBeDefined()
-      }),
-    ),
-  )
-
-  it.effect("falls back to options.apiKey when SNOWFLAKE_CORTEX_PAT env var is absent", () =>
-    withEnv({ SNOWFLAKE_CORTEX_PAT: undefined }, () =>
-      Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
-        yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: Model.Info.make({
-            ...Model.Info.default(Provider.ID.make("snowflake-cortex"), Model.ID.make("claude-sonnet-4-6")),
-            modelID: Model.ID.make("claude-sonnet-4-6"),
-            package: "aisdk:test-provider",
-          }),
-          package: "@ai-sdk/openai-compatible",
-          options: {
-            name: "snowflake-cortex",
-            baseURL: "https://test.snowflakecomputing.com/api/v2/cortex/v1",
-            apiKey: "options-pat",
-          },
-        })
-        expect(result.sdk).toBeDefined()
-      }),
-    ),
-  )
-
-  it.effect("uses SNOWFLAKE_CORTEX_TOKEN env var", () =>
-    withEnv({ SNOWFLAKE_CORTEX_TOKEN: "oauth-token", SNOWFLAKE_CORTEX_PAT: undefined }, () =>
-      Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
-        yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: Model.Info.make({
-            ...Model.Info.default(Provider.ID.make("snowflake-cortex"), Model.ID.make("claude-sonnet-4-6")),
-            modelID: Model.ID.make("claude-sonnet-4-6"),
-            package: "aisdk:test-provider",
-          }),
-          package: "@ai-sdk/openai-compatible",
-          options: { name: "snowflake-cortex", baseURL: "https://test.snowflakecomputing.com/api/v2/cortex/v1" },
-        })
-        expect(result.sdk).toBeDefined()
-      }),
-    ),
-  )
-
-  it.effect("falls back to options.token when no Snowflake env token is set", () =>
-    withEnv({ SNOWFLAKE_CORTEX_TOKEN: undefined, SNOWFLAKE_CORTEX_PAT: undefined }, () =>
-      Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
-        yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: Model.Info.make({
-            ...Model.Info.default(Provider.ID.make("snowflake-cortex"), Model.ID.make("claude-sonnet-4-6")),
-            modelID: Model.ID.make("claude-sonnet-4-6"),
-            package: "aisdk:test-provider",
-          }),
-          package: "@ai-sdk/openai-compatible",
-          options: {
-            name: "snowflake-cortex",
-            baseURL: "https://test.snowflakecomputing.com/api/v2/cortex/v1",
-            token: "options-token",
-          },
-        })
-        expect(result.sdk).toBeDefined()
-      }),
-    ),
-  )
-
-  it.effect("sets includeUsage on the SDK options", () =>
-    withEnv({ SNOWFLAKE_CORTEX_PAT: "test-pat" }, () =>
-      Effect.gen(function* () {
-        const aisdk = yield* AISDK.Service
-        yield* addPlugin()
-        const result = yield* aisdk.runSDK({
-          model: Model.Info.make({
-            ...Model.Info.default(Provider.ID.make("snowflake-cortex"), Model.ID.make("claude-sonnet-4-6")),
-            modelID: Model.ID.make("claude-sonnet-4-6"),
-            package: "aisdk:test-provider",
-          }),
-          package: "@ai-sdk/openai-compatible",
-          options: { name: "snowflake-cortex", baseURL: "https://test.snowflakecomputing.com/api/v2/cortex/v1" },
-        })
-        expect(result.options.includeUsage).toBe(true)
-      }),
-    ),
-  )
-})
-
-type FetchLike = (url: string | URL | Request, init?: RequestInit) => Promise<Response>
-
-describe("cortexFetch", () => {
-  test("rewrites max_tokens to max_completion_tokens", async () => {
-    const captured: RequestInit[] = []
-    const upstream: FetchLike = async (_url, init) => {
-      captured.push(init ?? {})
-      return new Response("{}", { status: 200 })
-    }
-    await cortexFetch(upstream)("https://test", {
-      method: "POST",
-      body: JSON.stringify({ model: "claude-sonnet-4-6", max_tokens: 1024 }),
+  yield* catalog.transform((editor) => {
+    editor.provider.update(providerID, (provider) => {
+      provider.package = Provider.aisdk("@ai-sdk/openai-compatible")
+      provider.settings = { baseURL: "https://${SNOWFLAKE_ACCOUNT}.snowflakecomputing.com/api/v2/cortex/v1" }
     })
-    const body = JSON.parse(captured[0].body as string)
-    expect(body.max_completion_tokens).toBe(1024)
-    expect(body.max_tokens).toBeUndefined()
+    editor.model.update(providerID, modelID, () => {})
   })
-
-  test("preserves body when max_tokens is absent", async () => {
-    const captured: RequestInit[] = []
-    const upstream: FetchLike = async (_url, init) => {
-      captured.push(init ?? {})
-      return new Response("{}", { status: 200 })
-    }
-    const original = JSON.stringify({ model: "claude-sonnet-4-6", temperature: 0.7 })
-    await cortexFetch(upstream)("https://test", { method: "POST", body: original })
-    expect(captured[0].body).toBe(original)
-  })
-
-  test("treats 400 'conversation complete' as a stop response", async () => {
-    const upstream: FetchLike = async () =>
-      new Response(JSON.stringify({ message: "Conversation complete" }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      })
-    const response = await cortexFetch(upstream)("https://test", {})
-    expect(response.status).toBe(200)
-    const data = (await response.json()) as { choices: { finish_reason: string }[] }
-    expect(data.choices[0].finish_reason).toBe("stop")
-  })
-
-  test("passes through other 400 errors unchanged", async () => {
-    const upstream: FetchLike = async () =>
-      new Response(JSON.stringify({ message: "Invalid model" }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      })
-    const response = await cortexFetch(upstream)("https://test", {})
-    expect(response.status).toBe(400)
-  })
-
-  test("passes through non-400 errors unchanged", async () => {
-    const upstream: FetchLike = async () => new Response("Unauthorized", { status: 401 })
-    const response = await cortexFetch(upstream)("https://test", {})
-    expect(response.status).toBe(401)
-  })
-
-  test("handles invalid JSON body gracefully without throwing", async () => {
-    const captured: RequestInit[] = []
-    const upstream: FetchLike = async (_url, init) => {
-      captured.push(init ?? {})
-      return new Response("{}", { status: 200 })
-    }
-    const invalidBody = "{ not json }"
-    await cortexFetch(upstream)("https://test", { method: "POST", body: invalidBody })
-    expect(captured[0].body).toBe(invalidBody)
-  })
-
-  test("rewrites role:'' to role:'assistant' in streaming SSE chunks", async () => {
-    const chunk = `data: {"choices":[{"delta":{"role":"","content":"Hi"},"index":0}]}\n\n`
-    const upstream: FetchLike = async () =>
-      new Response(
-        new ReadableStream({
-          start: (ctrl) => {
-            ctrl.enqueue(new TextEncoder().encode(chunk))
-            ctrl.close()
-          },
-        }),
-        {
-          status: 200,
-          headers: { "content-type": "text/event-stream" },
-        },
-      )
-    const response = await cortexFetch(upstream)("https://test", {})
-    const text = await response.text()
-    expect(text).toContain('"role":"assistant"')
-    expect(text).not.toContain('"role":""')
+  yield* SnowflakeCortexPlugin.effect(host).pipe(Effect.provideService(HttpClient.HttpClient, http))
+  const session = yield* sessions.create({ location: Location.Ref.make({ directory: location.directory }) })
+  const scope = {
+    sessionID: session.id,
+    agent: Agent.ID.make("build"),
+    model: Model.Ref.make({ providerID, id: modelID }),
+  }
+  const send = Effect.gen(function* () {
+    const model = yield* Effect.gen(function* () {
+      const model = yield* catalog.model.get(providerID, modelID)
+      if (!model || String(model.settings?.baseURL).includes("${")) return yield* Effect.fail("Catalog pending")
+      return model
+    }).pipe(Effect.retry(polling))
+    const resolver = yield* ModelResolver.Service
+    const resolved = yield* resolver.resolveModel(model)
+    const service = yield* SessionModelRequest.Service
+    const prepared = yield* service.prepare({
+      kind: "primary",
+      scope: { session, agentID: scope.agent, model: resolved },
+      transcript: { system: [], messages: [Message.user("Hello")] },
+    })
+    return yield* LLMClient.stream(prepared.request, prepared.options).pipe(
+      Stream.runCollect,
+      Effect.provide(LLMClient.layer.pipe(Layer.provide(RequestExecutor.layer), Layer.fresh)),
+      Effect.provideService(HttpClient.HttpClient, http),
+    )
+  }).pipe(Effect.provide(SessionModelRequest.layer), Effect.provide(ModelResolver.layer))
+  const stop = Effect.gen(function* () {
+    replies.push(Response.json({ message: "Conversation complete", error: {} }, { status: 400 }))
+    expect((yield* send).find((event) => event.type === "finish")?.reason.normalized).toBe("stop")
   })
+  const status = (attemptID: Integration.AttemptID) =>
+    integrations.oauth
+      .status({ integrationID, attemptID })
+      .pipe(Effect.repeat({ ...polling, until: (status) => status.status !== "pending" }))
+  return { requests, replies, catalog, integrations, hooks, scope, send, stop, status }
 })
+
+it.live("browser OAuth supplies the native endpoint/token and refreshes a rejected token once", () =>
+  withEnv(env, () =>
+    Effect.gen(function* () {
+      const test = yield* fixture()
+      const attempt = yield* test.integrations.oauth.connect({
+        integrationID,
+        methodID,
+        answer: { account: `${endpoint}///`, role: "My Role" },
+      })
+      const url = new URL(attempt.url)
+      expect(url.origin + url.pathname).toBe(`${endpoint}/oauth/authorize`)
+      expect(url.searchParams.get("scope")).toBe("refresh_token session:role-encoded:My%20Role")
+      const callback = new URL(url.searchParams.get("redirect_uri") ?? "")
+      callback.searchParams.set("state", url.searchParams.get("state") ?? "")
+      callback.searchParams.set("code", "auth-code")
+      test.replies.push(Response.json({ access_token: "access", refresh_token: "refresh", expires_in: 3600 }))
+      yield* Effect.promise(() => fetch(callback))
+      expect((yield* test.status(attempt.attemptID)).status).toBe("complete")
+      const exchange = test.requests[0]
+      expect(exchange.url).toBe(`${endpoint}/oauth/token-request`)
+      expect(exchange.headers.get("authorization")).toBe(
+        `Basic ${Buffer.from("LOCAL_APPLICATION:LOCAL_APPLICATION").toString("base64")}`,
+      )
+      const form = new URLSearchParams(yield* Effect.promise(() => exchange.text()))
+      expect(Object.fromEntries(form)).toMatchObject({
+        grant_type: "authorization_code",
+        code: "auth-code",
+        redirect_uri: url.searchParams.get("redirect_uri"),
+      })
+      const challenge = Buffer.from(
+        yield* Effect.promise(() =>
+          crypto.subtle.digest("SHA-256", new TextEncoder().encode(form.get("code_verifier") ?? "")),
+        ),
+      ).toString("base64url")
+      expect(url.searchParams.get("code_challenge")).toBe(challenge)
+
+      test.replies.push(new Response("Unauthorized", { status: 401 }))
+      expect((yield* test.send.pipe(Effect.exit))._tag).toBe("Failure")
+      expect(test.requests[1].headers.get("authorization")).toBe("Bearer access")
+      test.replies.push(Response.json({ access_token: "renewed", refresh_token: "", expires_in: 3600 }))
+      const retry = {
+        ...test.scope,
+        error: { type: "provider.authentication", message: "Unauthorized", status: 401 },
+        attempt: 2,
+        decision: { retry: false as const },
+      }
+      expect((yield* test.hooks.trigger("session", "retry", retry)).decision).toEqual({ retry: true, delay: 0 })
+      const refresh = new URLSearchParams(yield* Effect.promise(() => test.requests[2].text()))
+      expect(Object.fromEntries(refresh)).toMatchObject({ grant_type: "refresh_token", refresh_token: "refresh" })
+      yield* test.stop
+      expect(test.requests[3].headers.get("authorization")).toBe("Bearer renewed")
+      expect(
+        (yield* test.hooks.trigger("session", "retry", { ...retry, attempt: 3, decision: { retry: false } })).decision
+          .retry,
+      ).toBe(false)
+      const credentials = yield* Credential.Service
+      expect((yield* credentials.list(integrationID))[0]?.value).toMatchObject({
+        access: "renewed",
+        refresh: "refresh",
+      })
+    }),
+  ),
+)
+
+it.live("manual PAT uses its account and native compatibility rather than an SDK request rewrite", () =>
+  withEnv(env, () =>
+    Effect.gen(function* () {
+      const test = yield* fixture()
+      yield* test.integrations.connection.key({ integrationID, key: "pat", answer: { account: `${endpoint}/` } })
+      yield* test.hooks.register(
+        "session",
+        "context",
+        (event) =>
+          Effect.sync(() => {
+            event.generation.maxTokens = 1024
+          }),
+        { providerID },
+      )
+      test.replies.push(
+        new Response(
+          'data: {"choices":[{"index":0,"delta":{"role":"","content":"Hello"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n',
+          { headers: { "content-type": "text/event-stream" } },
+        ),
+      )
+      expect(yield* test.send).toContainEqual(expect.objectContaining({ type: "text-delta", text: "Hello" }))
+      const request = test.requests[0]
+      expect(request.url).toBe(`${endpoint}/api/v2/cortex/v1/chat/completions`)
+      expect(request.headers.get("authorization")).toBe("Bearer pat")
+      const body = yield* Effect.promise(() => request.json())
+      expect(body).toMatchObject({ model: modelID, max_completion_tokens: 1024 })
+      expect(body).not.toHaveProperty("max_tokens")
+    }),
+  ),
+)
+
+it.live("rejects a mismatched callback state before token exchange", () =>
+  withEnv(env, () =>
+    Effect.gen(function* () {
+      const test = yield* fixture()
+      const attempt = yield* test.integrations.oauth.connect({
+        integrationID,
+        methodID,
+        answer: { account: "myorg-myaccount" },
+      })
+      const callback = new URL(new URL(attempt.url).searchParams.get("redirect_uri") ?? "")
+      callback.searchParams.set("state", "wrong")
+      callback.searchParams.set("code", "forged")
+      expect((yield* Effect.promise(() => fetch(callback))).status).toBe(400)
+      expect(yield* test.status(attempt.attemptID)).toMatchObject({ status: "failed", message: "Invalid OAuth state" })
+      expect(test.requests).toHaveLength(0)
+    }),
+  ),
+)
+
+it.live("uses environment tokens rather than the account identifier and bypasses expired stored OAuth", () =>
+  withEnv(
+    { ...env, SNOWFLAKE_ACCOUNT: `${endpoint}/`, SNOWFLAKE_CORTEX_TOKEN: "env-token", SNOWFLAKE_CORTEX_PAT: "env-pat" },
+    () =>
+      Effect.gen(function* () {
+        const test = yield* fixture()
+        expect(yield* test.integrations.connection.active(integrationID)).toEqual({
+          type: "env",
+          name: "SNOWFLAKE_CORTEX_TOKEN",
+        })
+        expect((yield* test.catalog.provider.get(providerID))?.package).toBe(
+          Provider.aisdk("@ai-sdk/openai-compatible"),
+        )
+        expect(yield* test.hooks.has("aisdk", "sdk", providerID)).toBe(false)
+
+        yield* test.stop
+        expect(test.requests[0].url).toBe(`${endpoint}/api/v2/cortex/v1/chat/completions`)
+        expect(test.requests[0].headers.get("authorization")).toBe("Bearer env-token")
+
+        const credentials = yield* Credential.Service
+        yield* credentials.create({
+          integrationID,
+          value: expiredOAuth("other-account", "revoked-refresh"),
+        })
+        yield* test.stop
+        expect(test.requests).toHaveLength(2)
+        expect(test.requests[1].url).toBe(`${endpoint}/api/v2/cortex/v1/chat/completions`)
+        expect(test.requests[1].headers.get("authorization")).toBe("Bearer env-token")
+      }),
+  ),
+)
+
+it.live("requires a token separately from the account and supports environment PATs", () =>
+  withEnv({ ...env, SNOWFLAKE_ACCOUNT: "myorg-myaccount" }, () =>
+    Effect.gen(function* () {
+      const test = yield* fixture()
+      expect(yield* test.integrations.connection.active(integrationID)).toBeUndefined()
+      yield* withEnv({ SNOWFLAKE_CORTEX_PAT: "env-pat" }, () =>
+        Effect.gen(function* () {
+          yield* test.stop
+          expect(test.requests[0].headers.get("authorization")).toBe("Bearer env-pat")
+          test.replies.push(Response.json({ message: "Invalid model" }, { status: 400 }))
+          expect((yield* test.send.pipe(Effect.exit))._tag).toBe("Failure")
+        }),
+      )
+    }),
+  ),
+)
+
+it.live("refreshes expired OAuth during native model resolution and persists rotated credentials", () =>
+  withEnv(env, () =>
+    Effect.gen(function* () {
+      const credentials = yield* Credential.Service
+      const saved = yield* credentials.create({
+        integrationID,
+        value: expiredOAuth("myorg-myaccount"),
+      })
+      const test = yield* fixture()
+      test.replies.push(Response.json({ access_token: "renewed", refresh_token: "rotated-refresh", expires_in: 3600 }))
+      yield* test.stop
+      expect(test.requests[0].url).toBe(`${endpoint}/oauth/token-request`)
+      expect(Object.fromEntries(new URLSearchParams(yield* Effect.promise(() => test.requests[0].text())))).toEqual({
+        grant_type: "refresh_token",
+        refresh_token: "refresh",
+        client_id: "LOCAL_APPLICATION",
+      })
+      expect(test.requests[1].headers.get("authorization")).toBe("Bearer renewed")
+      expect((yield* credentials.get(saved.id))?.value).toMatchObject({
+        access: "renewed",
+        refresh: "rotated-refresh",
+        metadata: { account: "myorg-myaccount" },
+      })
+    }),
+  ),
+)

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

@@ -0,0 +1,198 @@
+import { $ } from "bun"
+import { describe, expect } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { Effect } from "effect"
+import { Agent } from "@opencode/core/agent"
+import { Bus } from "@opencode/core/bus"
+import { Database } from "@opencode/core/database/database"
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder"
+import { LocationServiceMap } from "@opencode/core/location-service-map"
+import { Model } from "@opencode/core/model"
+import { Plugin } from "@opencode/core/plugin"
+import { Provider } from "@opencode/core/provider"
+import { AbsolutePath } from "@opencode/core/schema"
+import { Session } from "@opencode/core/session"
+import { SessionDiff } from "@opencode/core/session/diff"
+import { SessionEvent } from "@opencode/core/session/event"
+import { SessionExecution } from "@opencode/core/session/execution"
+import { SessionInbox } from "@opencode/core/session/inbox"
+import { SessionMessage } from "@opencode/core/session/message"
+import { SessionProjector } from "@opencode/core/session/projector"
+import { Snapshot } from "@opencode/core/snapshot"
+import { Money } from "@opencode/schema/money"
+import { LayerNode } from "@opencode/util/effect/layer-node"
+import { Global } from "@opencode/util/global"
+import { tempGlobalLayer } from "./fixture/global"
+import { offlineModels } from "./fixture/models"
+import { tmpdirScoped } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, Session.node, LocationServiceMap.node]),
+    [Global.node.replace(tempGlobalLayer), SessionExecution.node.replace(SessionExecution.noopLayer), offlineModels],
+  ),
+)
+
+const summarize = (file: { file: string; status: string; additions: number; deletions: number }) => [
+  file.file,
+  file.status,
+  file.additions,
+  file.deletions,
+]
+
+describe("Session.diff", () => {
+  it.live(
+    "diffs the busy period containing a user message and ranges across later turns",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* tmpdirScoped()
+        const directory = path.join(tmp.path, "project")
+        const write = (name: string, content: string) => () => Bun.write(path.join(directory, name), content)
+        yield* Effect.promise(async () => {
+          await fs.mkdir(directory)
+          await write("first.txt", "first\n")()
+          await write("second.txt", "second\n")()
+          await write("manual.txt", "manual\n")()
+          await $`git init -q`.cwd(directory).quiet()
+          await $`git -c core.fsmonitor=false add .`.cwd(directory).quiet()
+        })
+        const sessions = yield* Session.Service
+        const database = yield* Database.Service
+        const bus = yield* Bus.Service
+        const locations = yield* LocationServiceMap.Service
+        const created = yield* sessions.create({ location: { directory: AbsolutePath.make(directory) } })
+        const diff = (input?: { messageID?: SessionMessage.ID; to?: SessionMessage.ID }) =>
+          sessions
+            .diff({ sessionID: created.id, context: 0, ...input })
+            .pipe(Effect.map((files) => files.map(summarize)))
+        expect(yield* diff()).toEqual([])
+
+        yield* Effect.gen(function* () {
+          const plugins = yield* Plugin.Service
+          yield* plugins.awaitActivation
+          const snapshot = yield* Snapshot.Service
+          const usage = {
+            cost: Money.USD.zero,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          }
+          const prompt = Effect.fn(function* (text: string) {
+            const admitted = yield* sessions.prompt({ sessionID: created.id, text, resume: false })
+            yield* SessionInbox.promote(database.db, bus, created.id, "steer")
+            return admitted.id
+          })
+          const step = Effect.fn(function* (edit: () => Promise<unknown>, end: "recorded" | "unrecorded" | "running") {
+            const before = yield* snapshot.capture()
+            if (!before) throw new Error("Start snapshot missing")
+            const assistantMessageID = SessionMessage.ID.create()
+            yield* bus.publish(SessionEvent.Step.Started, {
+              sessionID: created.id,
+              assistantMessageID,
+              agent: Agent.defaultID,
+              model: { id: Model.ID.make("test-model"), providerID: Provider.ID.make("test-provider") },
+              snapshot: before,
+            })
+            yield* Effect.promise(edit)
+            if (end === "running") return assistantMessageID
+            const after = end === "recorded" ? yield* snapshot.capture() : undefined
+            yield* bus.publish(SessionEvent.Step.Ended, {
+              sessionID: created.id,
+              assistantMessageID,
+              finish: "stop",
+              ...usage,
+              snapshot: after,
+              files: after && before ? yield* snapshot.files({ from: before, to: after }) : undefined,
+            })
+            return assistantMessageID
+          })
+
+          const idle = (outcome: "succeeded" | "failed") =>
+            outcome === "succeeded"
+              ? bus.publish(SessionEvent.Execution.Succeeded, { sessionID: created.id })
+              : bus.publish(SessionEvent.Execution.Failed, {
+                  sessionID: created.id,
+                  error: { type: "unknown", message: "failed" },
+                })
+
+          // Before any idle marker exists, a prompt's turn ends at the next prompt.
+          const first = yield* prompt("Edit the first file")
+          const firstStep = yield* step(write("first.txt", "first edited\n"), "recorded")
+          // Edits made while idle are not a turn's work, but a range spanning them still sees them.
+          yield* Effect.promise(write("manual.txt", "manual edited\n"))
+          const second = yield* prompt("Edit the second file")
+          yield* step(write("second.txt", "second edited\n"), "recorded")
+          expect(yield* diff()).toEqual([["second.txt", "modified", 1, 1]])
+          expect(yield* diff({ messageID: first })).toEqual([["first.txt", "modified", 1, 1]])
+
+          // Once markers exist, a turn spans a whole busy period, steers included; earlier history merges into the first one.
+          yield* idle("succeeded")
+          const third = yield* prompt("Add a third file")
+          yield* step(write("third.txt", "third\n"), "recorded")
+          const steer = yield* prompt("Also add a fourth file")
+          yield* step(write("fourth.txt", "fourth\n"), "recorded")
+          yield* idle("failed")
+          const busy = [
+            ["fourth.txt", "added", 1, 0],
+            ["third.txt", "added", 1, 0],
+          ]
+          expect(yield* diff()).toEqual(busy)
+          expect(yield* diff({ messageID: steer })).toEqual(busy)
+          expect(yield* diff({ messageID: second })).toEqual([
+            ["first.txt", "modified", 1, 1],
+            ["manual.txt", "modified", 1, 1],
+            ["second.txt", "modified", 1, 1],
+          ])
+          expect(yield* diff({ messageID: first, to: third })).toEqual([
+            ["first.txt", "modified", 1, 1],
+            ["fourth.txt", "added", 1, 0],
+            ["manual.txt", "modified", 1, 1],
+            ["second.txt", "modified", 1, 1],
+            ["third.txt", "added", 1, 0],
+          ])
+          const full = yield* sessions.diff({ sessionID: created.id, messageID: first })
+          expect(full[0]?.patch).toContain("-first\n+first edited\n")
+          expect(yield* diff({ messageID: steer, to: second }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.TurnRangeError",
+            field: "to",
+          })
+          expect(yield* diff({ messageID: firstStep }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.TurnRangeError",
+            field: "messageID",
+          })
+          expect(yield* diff({ messageID: SessionMessage.ID.create() }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.MessageNotFoundError",
+          })
+
+          // A completed step without an end snapshot falls back to the last recorded end.
+          yield* prompt("Edit both files again")
+          yield* step(write("first.txt", "first edited twice\n"), "recorded")
+          yield* step(write("second.txt", "second edited twice\n"), "unrecorded")
+          yield* idle("succeeded")
+          expect(yield* diff()).toEqual([["first.txt", "modified", 1, 1]])
+
+          // Only a step still running in the active session compares against the working copy.
+          yield* prompt("Delete the manual file")
+          yield* step(() => fs.rm(path.join(directory, "manual.txt")), "running")
+          expect(yield* diff()).toEqual([])
+          const session = yield* sessions.get(created.id)
+          const live = yield* SessionDiff.turn(database.db, locations, { session, active: true, context: 0 })
+          expect(live.map(summarize)).toEqual([["manual.txt", "deleted", 0, 1]])
+
+          // Reverting removes later history, markers included; a fork keeps the copied turns.
+          yield* sessions.revert.stage({ sessionID: created.id, messageID: steer, files: false })
+          yield* sessions.revert.commit(created.id)
+          expect(yield* diff()).toEqual([["third.txt", "added", 1, 0]])
+          expect(yield* diff({ messageID: steer }).pipe(Effect.flip)).toMatchObject({
+            _tag: "Session.MessageNotFoundError",
+          })
+          const forked = yield* sessions.fork({ sessionID: created.id, boundary: { type: "through" } })
+          expect((yield* sessions.diff({ sessionID: forked.id, context: 0 })).map(summarize)).toEqual([
+            ["third.txt", "added", 1, 0],
+          ])
+        }).pipe(Effect.provide(LocationServiceMap.Service.get(created.location)))
+      }),
+    // Real Location/plugin startup and Git snapshots can exceed five seconds under CI load.
+    { timeout: 30_000 },
+  )
+})

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

@@ -561,7 +561,9 @@ describe("SessionRestart background recovery", () => {
         expect(yield* restarted.pendingBackground).toEqual([])
         expect(yield* SessionInbox.list(database.db, sessionID)).toHaveLength(delivered ? 0 : 1)
         yield* SessionInbox.promote(database.db, bus, sessionID, "steer")
-        expect(yield* sessions.messages({ sessionID })).toMatchObject([
+        // Recovery ends a busy period, so an idle marker follows the notification.
+        const messages = (yield* sessions.messages({ sessionID })).filter((message) => message.type !== "idle")
+        expect(messages).toMatchObject([
           {
             id: background.notificationID,
             type: "synthetic",
@@ -569,7 +571,6 @@ describe("SessionRestart background recovery", () => {
             metadata: { state: "completed" },
           },
         ])
-        expect(yield* sessions.messages({ sessionID })).toHaveLength(1)
       }),
     )
   }

packages/desktop/electron-builder.config.ts

@@ -174,7 +174,7 @@ function getConfig() {
         protocols: { name: "OpenCode Beta", schemes: ["opencode"] },
         publish: {
           provider: "generic",
-          url: "https://opencode.ai/update/api/beta/desktop/github/",
+          url: "https://opencode.ai/update/api/beta/desktop/opencode/",
           channel: "latest",
         },
         deb: { fpm: [metainfoFpm(appId)] },
@@ -189,7 +189,7 @@ function getConfig() {
         protocols: { name: "OpenCode", schemes: ["opencode"] },
         publish: {
           provider: "generic",
-          url: "https://opencode.ai/update/api/latest/desktop/github/",
+          url: "https://opencode.ai/update/api/latest/desktop/opencode/",
           channel: "latest",
         },
         deb: { fpm: [metainfoFpm(appId), legacyDesktopEntryFpm] },

packages/desktop/src/main/updater/index.test.ts

@@ -9,7 +9,8 @@ afterEach(async () => {
 })
 
 // Drives the updater the way the app does: start or check, then install like a button click. `calls` records the platform
-// operations in order; installs record the staged version they would apply.
+// operations in order; downloads record whether a differential download was allowed and installs record the staged
+// version they would apply.
 function setup(input?: {
   currentVersion?: string
   ready?: { version: string }
@@ -29,10 +30,11 @@ function setup(input?: {
         },
         catch: (error) => error,
       }),
-      stageUpdate: Effect.tryPromise(async () => {
-        calls.push("download")
-        await input?.stage?.()
-      }),
+      stageUpdate: (options) =>
+        Effect.tryPromise(async () => {
+          calls.push(options.differential ? "download" : "download:full")
+          await input?.stage?.()
+        }),
       installAndRestart: Effect.suspend(() => {
         calls.push(`install:${ready?.version}`)
         return Effect.tryPromise({
@@ -76,6 +78,7 @@ describe("updater", () => {
 
     await app.updater.start()
 
+    expect(app.calls).toEqual(["check", "download"])
     expect(await app.updater.getState()).toEqual({ status: "ready", version: "2.0.0" })
     expect(app.getReady()).toEqual({ version: "2.0.0" })
   })
@@ -90,15 +93,37 @@ describe("updater", () => {
     expect(app.getReady()).toBeUndefined()
   })
 
-  test("revalidates a persisted target through the updater cache on launch", async () => {
+  test("revalidates a persisted target through the updater cache on launch without a differential download", async () => {
     const app = setup({ ready: { version: "2.0.0" } })
 
     await app.updater.start()
 
-    expect(app.calls).toEqual(["check", "download"])
+    expect(app.calls).toEqual(["check", "download:full"])
     expect(await app.updater.getState()).toEqual({ status: "ready", version: "2.0.0" })
   })
 
+  test("keeps differential downloads after the persisted target was installed", async () => {
+    const app = setup({ currentVersion: "2.0.0", ready: { version: "2.0.0" }, latest: () => "3.0.0" })
+
+    await app.updater.start()
+
+    expect(app.calls).toEqual(["check", "download"])
+    expect(await app.updater.getState()).toEqual({ status: "ready", version: "3.0.0" })
+    expect(app.getReady()).toEqual({ version: "3.0.0" })
+  })
+
+  test("downloads newer releases in full once one is staged", async () => {
+    let latest = "2.0.0"
+    const app = setup({ latest: () => latest })
+    await app.updater.start()
+
+    latest = "3.0.0"
+    await app.updater.check()
+
+    expect(app.calls).toEqual(["check", "download", "check", "download:full"])
+    expect(await app.updater.getState()).toEqual({ status: "ready", version: "3.0.0" })
+  })
+
   test("concurrent checks share one platform check", async () => {
     const app = setup()
 
@@ -140,7 +165,7 @@ describe("updater", () => {
 
     expect(await app.updater.getState()).toEqual({ status: "installing", version: "2.0.0" })
     await new Promise((resolve) => setTimeout(resolve, 0))
-    expect(app.calls).toEqual(["check", "download", "check", "download", "prepare", "install:3.0.0"])
+    expect(app.calls).toEqual(["check", "download", "check", "download:full", "prepare", "install:3.0.0"])
     expect(await app.updater.getState()).toEqual({ status: "installing", version: "3.0.0" })
   })
 
@@ -220,7 +245,7 @@ describe("updater", () => {
     await refresh
     expect(await app.updater.getState()).toEqual({ status: "installing", version: "3.0.0" })
     await new Promise((resolve) => setTimeout(resolve, 0))
-    expect(app.calls).toEqual(["check", "download", "check", "download", "prepare", "install:3.0.0"])
+    expect(app.calls).toEqual(["check", "download", "check", "download:full", "prepare", "install:3.0.0"])
   })
 
   test("returns to ready after a failed installation and allows a retry", async () => {

packages/desktop/src/main/updater/index.ts

@@ -8,7 +8,7 @@ import { emitIpcEvent } from "../ipc-events"
 
 export type Platform = {
   readonly checkForUpdate: Effect.Effect<string | undefined, unknown>
-  readonly stageUpdate: Effect.Effect<unknown, unknown>
+  readonly stageUpdate: (options: { readonly differential: boolean }) => Effect.Effect<unknown, unknown>
   readonly installAndRestart: Effect.Effect<never, unknown>
   readonly dispose: () => void
 }
@@ -55,6 +55,22 @@ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependenc
     listeners.forEach((listener) => listener(state))
     return state
   }
+  // electron-updater builds NSIS deltas against the installer of the running version but reads the "old" blockmap from
+  // the last download. Once a release is staged without installing, the two no longer match and every later delta fails
+  // its checksum before falling back to a full download, so remember which release the cache holds and skip the attempt.
+  let downloaded: string | undefined
+  const stage = (platform: Platform, version: string) =>
+    Effect.gen(function* () {
+      if (downloaded)
+        yield* Effect.logInfo("skipping differential download, updater cache is stale", {
+          current: dependencies.currentVersion,
+          staged: downloaded,
+          version,
+        })
+      yield* platform.stageUpdate({ differential: !downloaded })
+      downloaded = version
+      yield* dependencies.persistence.set({ version })
+    })
   const findAndStage = (platform: Platform) =>
     Effect.gen(function* () {
       yield* Effect.sync(() => transition({ status: "checking" }))
@@ -64,8 +80,7 @@ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependenc
         return transition({ status: "up-to-date" })
       }
       transition({ status: "downloading", version })
-      yield* platform.stageUpdate
-      yield* dependencies.persistence.set({ version })
+      yield* stage(platform, version)
       return transition({ status: "ready", version })
     }).pipe(
       Effect.catch((error) =>
@@ -78,8 +93,7 @@ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependenc
     Effect.gen(function* () {
       const version = yield* platform.checkForUpdate
       if (!version || version === staged || version === dependencies.currentVersion) return state
-      yield* platform.stageUpdate
-      yield* dependencies.persistence.set({ version })
+      yield* stage(platform, version)
       return transition({ status: installing ? "installing" : "ready", version })
     }).pipe(
       Effect.catch((error) =>
@@ -137,6 +151,8 @@ export const make = Effect.fn("Updater.make")(function* (dependencies: Dependenc
   const start = Effect.gen(function* () {
     const ready = yield* dependencies.persistence.get
     if (ready?.version === dependencies.currentVersion) yield* dependencies.persistence.clear
+    // Any other persisted target was downloaded by an earlier launch and never installed, so its blockmap is cached.
+    if (ready && ready.version !== dependencies.currentVersion) downloaded = ready.version
     yield* check
   })
   const unsubscribe = (id: number) => {

packages/desktop/src/main/updater/platform.ts

@@ -37,16 +37,21 @@ export const make = Effect.gen(function* () {
       },
       catch: (error) => error,
     }),
-    stageUpdate: stageUpdate(),
+    stageUpdate,
     installAndRestart,
     dispose: () => autoUpdater.off("before-quit-for-update", beforeQuit),
   } satisfies Platform
 })
 
-function stageUpdate() {
+function stageUpdate(options: { readonly differential: boolean }) {
   if (process.platform !== "darwin")
     return Effect.tryPromise({
-      try: () => updateClient.downloadUpdate(),
+      try: () => {
+        // Only the NSIS cache goes stale: macOS refreshes its cached zip with every download and AppImage reads the
+        // blockmap embedded in the running file.
+        updateClient.disableDifferentialDownload = process.platform === "win32" && !options.differential
+        return updateClient.downloadUpdate()
+      },
       catch: (error) => error,
     }).pipe(Effect.asVoid)
 

packages/protocol/openapi.json

@@ -1621,14 +1621,7 @@
             "content": {
               "application/json": {
                 "schema": {
-                  "anyOf": [
-                    {
-                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
-                    },
-                    {
-                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
-                    }
-                  ]
+                  "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
                 }
               }
             }
@@ -3249,6 +3242,152 @@
         "summary": "Get session context"
       }
     },
+    "/api/session/{sessionID}/diff": {
+      "get": {
+        "tags": ["session"],
+        "operationId": "v2.session.diff",
+        "parameters": [
+          {
+            "name": "sessionID",
+            "in": "path",
+            "schema": {
+              "type": "string",
+              "pattern": "^ses"
+            },
+            "required": true
+          },
+          {
+            "name": "messageID",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "User message whose turn to diff. Defaults to the turn of the newest user message."
+            },
+            "required": false
+          },
+          {
+            "name": "to",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "pattern": "^msg_"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Later user message whose turn ends the range. Defaults to the turn of `messageID` alone."
+            },
+            "required": false
+          },
+          {
+            "name": "context",
+            "in": "query",
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "null"
+                }
+              ],
+              "description": "Unchanged lines around each hunk. Omit for full-file patches."
+            },
+            "required": false
+          }
+        ],
+        "security": [],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "data": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/components/schemas/FileDiff.Info"
+                      }
+                    }
+                  },
+                  "required": ["data"],
+                  "additionalProperties": false
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "InvalidRequestError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/InvalidRequestErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "UnauthorizedError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnauthorizedErrorEncoded"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "MessageNotFoundError | SessionNotFoundError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "anyOf": [
+                    {
+                      "$ref": "#/components/schemas/MessageNotFoundErrorEncoded"
+                    },
+                    {
+                      "$ref": "#/components/schemas/SessionNotFoundErrorEncoded"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "500": {
+            "description": "UnknownError",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/UnknownErrorEncoded"
+                }
+              }
+            }
+          }
+        },
+        "description": "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        "summary": "Diff session turns"
+      }
+    },
     "/api/session/{sessionID}/inbox": {
       "get": {
         "tags": ["session"],
@@ -18486,6 +18625,38 @@
         "required": ["type", "id", "time", "status", "reason", "summary", "recent"],
         "additionalProperties": false
       },
+      "Session.Message.Idle": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^msg_"
+          },
+          "metadata": {
+            "type": "object"
+          },
+          "time": {
+            "type": "object",
+            "properties": {
+              "created": {
+                "type": "number"
+              }
+            },
+            "required": ["created"],
+            "additionalProperties": false
+          },
+          "type": {
+            "type": "string",
+            "enum": ["idle"]
+          },
+          "outcome": {
+            "type": "string",
+            "enum": ["succeeded", "failed", "interrupted"]
+          }
+        },
+        "required": ["id", "time", "type", "outcome"],
+        "additionalProperties": false
+      },
       "Session.Message.Info": {
         "anyOf": [
           {
@@ -18517,6 +18688,9 @@
           },
           {
             "$ref": "#/components/schemas/Session.Message.Compaction"
+          },
+          {
+            "$ref": "#/components/schemas/Session.Message.Idle"
           }
         ]
       },

packages/protocol/src/groups/session.ts

@@ -30,6 +30,7 @@ import { Model } from "@opencode/schema/model"
 import { Location } from "@opencode/schema/location"
 import { SessionEvent } from "@opencode/schema/session-event"
 import { EventLog } from "@opencode/schema/event-log"
+import { FileDiff } from "@opencode/schema/file-diff"
 
 const ParentIDFilter = Schema.Union([
   Session.ID,
@@ -521,6 +522,31 @@ export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLo
         }),
       ),
     )
+    .add(
+      HttpApiEndpoint.get("session.diff", "/api/session/:sessionID/diff", {
+        params: { sessionID: Session.ID },
+        query: Schema.Struct({
+          messageID: Schema.optional(SessionMessage.ID).annotate({
+            description: "User message whose turn to diff. Defaults to the turn of the newest user message.",
+          }),
+          to: Schema.optional(SessionMessage.ID).annotate({
+            description: "Later user message whose turn ends the range. Defaults to the turn of `messageID` alone.",
+          }),
+          context: Schema.NumberFromString.pipe(Schema.decodeTo(NonNegativeInt), Schema.optional).annotate({
+            description: "Unchanged lines around each hunk. Omit for full-file patches.",
+          }),
+        }),
+        success: Schema.Struct({ data: Schema.Array(FileDiff.Info) }),
+        error: [InvalidRequestError, MessageNotFoundError, SessionNotFoundError, UnknownError],
+      }).annotateMerge(
+        OpenApi.annotations({
+          identifier: "v2.session.diff",
+          summary: "Diff session turns",
+          description:
+            "Structured per-file diffs of the files a turn changed. A turn runs from the first prompt after the session was last idle until its next idle marker, so prompts steered in while it was busy belong to the same turn; `to` extends the range through a later turn. Compares the range's first recorded snapshot with its last; a step still running in the active session compares against the working copy. Ranges that span a location change are rejected. In sessions without any idle marker, a prompt's turn spans until the next user message.",
+        }),
+      ),
+    )
     .add(
       HttpApiEndpoint.get("session.inbox.list", "/api/session/:sessionID/inbox", {
         params: { sessionID: Session.ID },

packages/schema/src/session-message.ts

@@ -272,6 +272,18 @@ export const Compaction = Schema.Union([CompactionRunning, CompactionCompleted,
 )
 export type Compaction = CompactionRunning | CompactionCompleted | CompactionFailed
 
+/**
+ * Marks the Session going idle: every step since the previous marker belongs to
+ * one turn, including prompts steered in while it was busy. A shutdown does not
+ * record one, since the resumed execution continues the same turn.
+ */
+export interface Idle extends Schema.Schema.Type<typeof Idle> {}
+export const Idle = Schema.Struct({
+  ...Base,
+  type: Schema.tag("idle"),
+  outcome: Schema.Literals(["succeeded", "failed", "interrupted"]),
+}).annotate({ identifier: "Session.Message.Idle" })
+
 export const Info = Schema.Union([
   AgentSelected,
   ModelSelected,
@@ -283,6 +295,7 @@ export const Info = Schema.Union([
   Shell,
   Assistant,
   Compaction,
+  Idle,
 ]).annotate({ identifier: "Session.Message.Info" })
 export type Info =
   | AgentSelected
@@ -295,4 +308,5 @@ export type Info =
   | Shell
   | Assistant
   | Compaction
+  | Idle
 export type Type = Info["type"]

packages/server/src/handlers/session-error.ts

@@ -1,5 +1,6 @@
 import { Session } from "@opencode/core/session"
-import { SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
+import type { Snapshot } from "@opencode/core/snapshot"
+import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors"
 import { Effect } from "effect"
 
 export function missingSession(error: Session.NotFoundError) {
@@ -9,6 +10,14 @@ export function missingSession(error: Session.NotFoundError) {
   })
 }
 
+export function missingMessage(error: Session.MessageNotFoundError) {
+  return new MessageNotFoundError({
+    sessionID: error.sessionID,
+    messageID: error.messageID,
+    message: `Message not found: ${error.messageID}`,
+  })
+}
+
 export function failedMessageDecode(error: Session.MessageDecodeError) {
   const ref = `err_${crypto.randomUUID().slice(0, 8)}`
   return Effect.logError("failed to decode session message").pipe(
@@ -18,3 +27,16 @@ export function failedMessageDecode(error: Session.MessageDecodeError) {
     ),
   )
 }
+
+/** Snapshot repositories are host state clients cannot repair, so surface only a log reference. */
+export function failedSnapshot(operation: string, sessionID: Session.ID) {
+  return (error: Snapshot.Error) => {
+    const ref = `err_${crypto.randomUUID().slice(0, 8)}`
+    return Effect.logError(`failed to ${operation}`, { cause: error }).pipe(
+      Effect.annotateLogs({ ref, sessionID }),
+      Effect.andThen(
+        Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref })),
+      ),
+    )
+  }
+}

packages/server/src/handlers/session.ts

@@ -17,10 +17,9 @@ import {
   ServiceUnavailableError,
   SessionBusyError,
   SkillNotFoundError,
-  UnknownError,
 } from "@opencode/protocol/errors"
 import { AbsolutePath } from "@opencode/core/schema"
-import { failedMessageDecode, missingSession } from "./session-error"
+import { failedMessageDecode, failedSnapshot, missingMessage, missingSession } from "./session-error"
 
 const DefaultSessionsLimit = 50
 
@@ -212,15 +211,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           return {
             data: yield* session.fork({ sessionID: ctx.params.sessionID, boundary: ctx.payload.boundary }).pipe(
               Effect.catchTag("Session.NotFoundError", missingSession),
-              Effect.catchTag(
-                "Session.MessageNotFoundError",
-                (error) =>
-                  new MessageNotFoundError({
-                    sessionID: error.sessionID,
-                    messageID: error.messageID,
-                    message: `Message not found: ${error.messageID}`,
-                  }),
-              ),
+              Effect.catchTag("Session.MessageNotFoundError", missingMessage),
               Effect.catchTag(
                 "Session.ForkEmptyError",
                 (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" }),
@@ -448,32 +439,14 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
             files: ctx.payload.files,
           })
           return {
-            data: yield* session.revert.stage({ ...ctx.params, ...ctx.payload }).pipe(
-              Effect.catchTag("Session.NotFoundError", missingSession),
-              Effect.catchTag(
-                "Session.MessageNotFoundError",
-                (error) =>
-                  new MessageNotFoundError({
-                    sessionID: error.sessionID,
-                    messageID: error.messageID,
-                    message: `Message not found: ${error.messageID}`,
-                  }),
+            data: yield* session.revert
+              .stage({ ...ctx.params, ...ctx.payload })
+              .pipe(
+                Effect.catchTag("Session.NotFoundError", missingSession),
+                Effect.catchTag("Session.MessageNotFoundError", missingMessage),
+                Effect.catchTag("Session.BusyError", busySession),
+                Effect.catchTag("Snapshot.Error", failedSnapshot("stage session revert", ctx.params.sessionID)),
               ),
-              Effect.catchTag("Session.BusyError", busySession),
-              Effect.catchTag("Snapshot.Error", (error) => {
-                const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-                return Effect.logError("failed to stage session revert", { cause: error }).pipe(
-                  Effect.andThen(
-                    Effect.fail(
-                      new UnknownError({
-                        message: "Unexpected server error. Check server logs for details.",
-                        ref,
-                      }),
-                    ),
-                  ),
-                )
-              }),
-            ),
           }
         }),
       )
@@ -481,23 +454,13 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
         "session.revert.clear",
         Effect.fn(function* (ctx) {
           yield* Effect.log("session.revert.clear", { sessionID: ctx.params.sessionID })
-          yield* session.revert.clear(ctx.params.sessionID).pipe(
-            Effect.catchTag("Session.NotFoundError", missingSession),
-            Effect.catchTag("Session.BusyError", busySession),
-            Effect.catchTag("Snapshot.Error", (error) => {
-              const ref = `err_${crypto.randomUUID().slice(0, 8)}`
-              return Effect.logError("failed to clear session revert", { cause: error }).pipe(
-                Effect.andThen(
-                  Effect.fail(
-                    new UnknownError({
-                      message: "Unexpected server error. Check server logs for details.",
-                      ref,
-                    }),
-                  ),
-                ),
-              )
-            }),
-          )
+          yield* session.revert
+            .clear(ctx.params.sessionID)
+            .pipe(
+              Effect.catchTag("Session.NotFoundError", missingSession),
+              Effect.catchTag("Session.BusyError", busySession),
+              Effect.catchTag("Snapshot.Error", failedSnapshot("clear session revert", ctx.params.sessionID)),
+            )
           return HttpApiSchema.NoContent.make()
         }),
       )
@@ -527,6 +490,22 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
           }
         }),
       )
+      .handle(
+        "session.diff",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* session.diff({ sessionID: ctx.params.sessionID, ...ctx.query }).pipe(
+              Effect.catchTag("Session.NotFoundError", missingSession),
+              Effect.catchTag("Session.MessageNotFoundError", missingMessage),
+              Effect.catchTag(
+                "Session.TurnRangeError",
+                (error) => new InvalidRequestError({ message: error.message, field: error.field }),
+              ),
+              Effect.catchTag("Snapshot.Error", failedSnapshot("diff session turn", ctx.params.sessionID)),
+            ),
+          }
+        }),
+      )
       .handle(
         "session.inbox.list",
         Effect.fn(function* (ctx) {
@@ -642,15 +621,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
         Effect.fn(function* (ctx) {
           const message = yield* session.updateMessage({ ...ctx.params, content: ctx.payload.content }).pipe(
             Effect.catchTag("Session.NotFoundError", missingSession),
-            Effect.catchTag(
-              "Session.MessageNotFoundError",
-              (error) =>
-                new MessageNotFoundError({
-                  sessionID: error.sessionID,
-                  messageID: error.messageID,
-                  message: `Message not found: ${error.messageID}`,
-                }),
-            ),
+            Effect.catchTag("Session.MessageNotFoundError", missingMessage),
             Effect.catchTag("Session.BusyError", busySession),
             Effect.catchTag(
               "Session.MessageNotAssistantError",

packages/server/test/session-diff.test.ts

@@ -0,0 +1,98 @@
+import { expect, setDefaultTimeout } from "bun:test"
+import { Agent } from "@opencode/core/agent"
+import { Bus } from "@opencode/core/bus"
+import { Model } from "@opencode/core/model"
+import { Provider } from "@opencode/core/provider"
+import { Session } from "@opencode/core/session"
+import { SessionEvent } from "@opencode/core/session/event"
+import { SessionExecution } from "@opencode/core/session/execution"
+import { SessionMessage } from "@opencode/core/session/message"
+import { Money } from "@opencode/schema/money"
+import { makeGlobalNode } from "@opencode/util/effect/app-node"
+import { Effect, Layer } from "effect"
+import { tmpdir } from "../../core/test/fixture/tmpdir"
+import { it } from "../../core/test/lib/effect"
+import { ServerFetch } from "../src/fetch"
+
+setDefaultTimeout(30_000)
+
+it.live("serves turn diffs by user message with range validation", () =>
+  Effect.gen(function* () {
+    const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-session-diff-")))
+    const ids = { user: SessionMessage.ID.create(), assistant: SessionMessage.ID.create() }
+    // Deliver the prompt and one step the way the runner would, without a model.
+    const execution = Layer.effect(
+      SessionExecution.Service,
+      Effect.gen(function* () {
+        const bus = yield* Bus.Service
+        return SessionExecution.Service.of({
+          active: Effect.succeed(new Set()),
+          isActive: () => Effect.succeed(false),
+          resume: () => Effect.void,
+          wake: (sessionID) =>
+            Effect.gen(function* () {
+              yield* bus.publish(SessionEvent.InboxDelivered, { sessionID, inboxID: ids.user })
+              yield* bus.publish(SessionEvent.Step.Started, {
+                sessionID,
+                assistantMessageID: ids.assistant,
+                agent: Agent.defaultID,
+                model: { id: Model.ID.make("model"), providerID: Provider.ID.make("provider") },
+              })
+              yield* bus.publish(SessionEvent.Step.Ended, {
+                sessionID,
+                assistantMessageID: ids.assistant,
+                finish: "stop",
+                cost: Money.USD.zero,
+                tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+              })
+            }),
+          interrupt: () => Effect.succeed(false),
+          awaitIdle: () => Effect.void,
+        })
+      }),
+    )
+    const handler = yield* ServerFetch.make(
+      {
+        app: { version: "test-version" },
+        database: { path: ":memory:" },
+        fs: { filewatcher: false },
+        models: { fetch: false },
+      },
+      {
+        overrides: [
+          SessionExecution.node.replace(
+            makeGlobalNode({ service: SessionExecution.Service, layer: execution, deps: [Bus.node] }),
+          ),
+        ],
+      },
+    )
+    const request = (path: string, body?: unknown) =>
+      Effect.promise(async () => {
+        const response = await handler(
+          new Request(`http://opencode.local${path}`, {
+            method: body === undefined ? "GET" : "POST",
+            headers: body === undefined ? undefined : { "content-type": "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+          }),
+        )
+        return { status: response.status, body: (await response.json()) as Record<string, unknown> }
+      })
+    const created = yield* request("/api/session", { location: { directory: tmp.path } })
+    const sessionID = Session.ID.make((created.body.data as { id: string }).id)
+    const diff = (query = "") => request(`/api/session/${sessionID}/diff${query}`)
+
+    expect(yield* diff()).toEqual({ status: 200, body: { data: [] } })
+    expect((yield* request(`/api/session/${sessionID}/prompt`, { id: ids.user, text: "prompt" })).status).toBe(200)
+    // Not a git repository, so steps record no snapshots and the turn has no diff.
+    expect(yield* diff(`?messageID=${ids.user}&context=3`)).toEqual({ status: 200, body: { data: [] } })
+    expect(yield* diff(`?messageID=${ids.assistant}`)).toMatchObject({
+      status: 400,
+      body: { _tag: "InvalidRequestError", field: "messageID" },
+    })
+    expect(yield* diff(`?messageID=${SessionMessage.ID.create()}`)).toMatchObject({
+      status: 404,
+      body: { _tag: "MessageNotFoundError" },
+    })
+    expect((yield* request(`/api/session/${Session.ID.create()}/diff`)).status).toBe(404)
+  }),
+)

packages/session-ui/src/timeline/projection.ts

@@ -16,7 +16,7 @@ export { TimelineRow, type PartGroup, type PartRef, type TimelineRowMap }
 
 export type ReasoningMode = "hidden" | "compact" | "full"
 
-type Notice = Exclude<SessionMessageInfo, { type: "user" | "assistant" | "shell" }>
+type Notice = Exclude<SessionMessageInfo, { type: "user" | "assistant" | "shell" | "idle" }>
 type Entry = { type: "assistant"; message: SessionMessageAssistant } | { type: "notice"; message: Notice }
 type Content = SessionMessageAssistant["content"][number]
 type GroupRow = Extract<TimelineRow.TimelineRow, { _tag: "AssistantPart" }>
@@ -765,7 +765,8 @@ function record(value: unknown): value is Record<string, unknown> {
 }
 
 function isNotice(message: SessionMessageInfo): message is Notice {
-  if (message.type === "user" || message.type === "assistant" || message.type === "shell") return false
+  if (message.type === "user" || message.type === "assistant" || message.type === "shell" || message.type === "idle")
+    return false
   if (message.type !== "synthetic") return true
   return !!message.description?.trim() || timelineNoticeRequired(message)
 }

packages/session-ui/src/tools/shell-output.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test, vi } from "bun:test"
+import type { ShellOutputInput, ShellOutputOutput } from "@opencode/client/promise"
+import { followShellOutput, SHELL_OUTPUT_TAIL_BYTES } from "./shell-output"
+
+const location = { directory: "/repo", project: { id: "project", directory: "/repo", canonical: "/repo" } }
+
+// Serves the current text from the requested cursor, at most one page per request.
+function server(text: () => string, page = Infinity) {
+  const cursors: number[] = []
+  return {
+    cursors,
+    load: (input: ShellOutputInput): Promise<ShellOutputOutput> => {
+      const cursor = input.cursor ?? 0
+      cursors.push(cursor)
+      const full = text()
+      const output = full.slice(cursor, cursor + page)
+      return Promise.resolve({
+        location,
+        data: { output, cursor: cursor + output.length, size: full.length, truncated: false },
+      })
+    },
+  }
+}
+
+// Reads settle within a few microtasks; timers are faked so this never waits on the clock.
+async function flush() {
+  for (let i = 0; i < 20; i++) await Promise.resolve()
+}
+
+describe("followShellOutput", () => {
+  test("stops polling a missing shell and never requests it again", async () => {
+    vi.useFakeTimers()
+    try {
+      const cursors: number[] = []
+      const load = (input: ShellOutputInput): Promise<ShellOutputOutput> => {
+        cursors.push(input.cursor ?? 0)
+        return Promise.reject({ _tag: "ShellNotFoundError", id: input.id, message: "Shell command not found" })
+      }
+      const follow = () =>
+        followShellOutput({ id: "shell_missing", directory: "/repo", running: true, load, onOutput() {} })
+
+      const stop = follow()
+      await flush()
+      expect(cursors).toEqual([0])
+
+      vi.advanceTimersByTime(10_000)
+      await flush()
+      expect(cursors).toEqual([0])
+
+      stop()
+      const remounted = follow()
+      await flush()
+      vi.advanceTimersByTime(10_000)
+      remounted()
+      expect(cursors).toEqual([0])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test("polls a running shell once per second and resumes from the cached cursor after a remount", async () => {
+    vi.useFakeTimers()
+    try {
+      let text = "hello\n"
+      const shell = server(() => text)
+      const outputs: string[] = []
+      const follow = (running: boolean) =>
+        followShellOutput({
+          id: "shell_live",
+          directory: "/repo",
+          running,
+          load: shell.load,
+          onOutput: (output) => outputs.push(output),
+        })
+
+      const first = follow(true)
+      await flush()
+      expect(outputs.at(-1)).toBe("hello\n")
+
+      text += "world\n"
+      vi.advanceTimersByTime(1_000)
+      await flush()
+      expect(shell.cursors).toEqual([0, 6])
+      expect(outputs.at(-1)).toBe("hello\nworld\n")
+
+      first()
+      text += "done\n"
+      const second = follow(true)
+      await flush()
+      expect(shell.cursors).toEqual([0, 6, 12])
+      expect(outputs.at(-1)).toBe("hello\nworld\ndone\n")
+
+      second()
+      const exited = follow(false)
+      await flush()
+      exited()
+      expect(shell.cursors).toEqual([0, 6, 12, 17])
+
+      outputs.length = 0
+      follow(false)()
+      await flush()
+      expect(shell.cursors).toEqual([0, 6, 12, 17])
+      expect(outputs).toEqual(["hello\nworld\ndone\n"])
+
+      // The running-shell inventory can arrive late; a complete shell believed to be live is re-read from its cursor.
+      follow(true)()
+      expect(shell.cursors).toEqual([0, 6, 12, 17, 17])
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  test("keeps only the most recent tail of a large output", async () => {
+    const shell = server(() => "a".repeat(SHELL_OUTPUT_TAIL_BYTES) + "tail", SHELL_OUTPUT_TAIL_BYTES)
+    const outputs: string[] = []
+    followShellOutput({
+      id: "shell_large",
+      directory: "/repo",
+      running: false,
+      load: shell.load,
+      onOutput: (output) => outputs.push(output),
+    })
+    await flush()
+    expect(shell.cursors).toEqual([0, SHELL_OUTPUT_TAIL_BYTES])
+    expect(outputs.at(-1)?.length).toBe(SHELL_OUTPUT_TAIL_BYTES)
+    expect(outputs.at(-1)?.endsWith("a".repeat(8) + "tail")).toBe(true)
+  })
+})

packages/session-ui/src/tools/shell-output.ts

@@ -0,0 +1,74 @@
+import { isShellNotFoundError, type ShellOutputInput, type ShellOutputOutput } from "@opencode/client/promise"
+
+// Same page size as the TUI shell output viewer; only this much recent output is retained and rendered.
+export const SHELL_OUTPUT_TAIL_BYTES = 64 * 1024
+const PROGRESS_LIMIT = 32
+
+type Progress = { cursor: number; output: string; state: "partial" | "complete" | "missing" }
+
+// Virtualized timelines remount shell tools frequently. Progress is remembered per shell so a
+// remount resumes from its cursor instead of re-reading from zero, and so a shell the server no
+// longer knows is never requested again.
+const progress = new Map<string, Progress>()
+
+function remember(id: string, entry: Progress) {
+  progress.delete(id)
+  progress.set(id, entry)
+  if (progress.size <= PROGRESS_LIMIT) return
+  const oldest = progress.keys().next().value
+  if (oldest !== undefined) progress.delete(oldest)
+}
+
+export function followShellOutput(input: {
+  id: string
+  directory: string
+  running: boolean
+  load: (input: ShellOutputInput) => Promise<ShellOutputOutput>
+  onOutput: (output: string) => void
+}) {
+  const cached = progress.get(input.id)
+  if (cached) {
+    remember(input.id, cached)
+    input.onOutput(cached.output)
+  }
+  // A missing shell never comes back. A complete one is only re-read while the shell is believed to be
+  // running, because the running-shell inventory can arrive after history has already rendered.
+  if (cached?.state === "missing" || (cached?.state === "complete" && !input.running)) return () => {}
+  let cursor = cached?.cursor ?? 0
+  let text = cached?.output ?? ""
+  let loading = false
+  let disposed = false
+  const read = async () => {
+    if (loading) return
+    loading = true
+    while (true) {
+      const page = await input.load({ id: input.id, location: { directory: input.directory }, cursor }).then(
+        (response) => response.data,
+        (cause: unknown) => (isShellNotFoundError(cause) ? "missing" : undefined),
+      )
+      if (disposed) break
+      if (page === "missing") {
+        // The server drops exited shells past its retention limit; stop asking for this one.
+        remember(input.id, { cursor, output: text, state: "missing" })
+        clearInterval(interval)
+        break
+      }
+      if (!page) break
+      const advanced = page.cursor > cursor
+      cursor = Math.max(cursor, page.cursor)
+      text = (text + page.output).slice(-SHELL_OUTPUT_TAIL_BYTES)
+      const complete = !input.running && cursor >= page.size
+      remember(input.id, { cursor, output: text, state: complete ? "complete" : "partial" })
+      input.onOutput(text)
+      if (input.running || complete || !advanced) break
+    }
+    loading = false
+  }
+  void read()
+  // Refresh the final snapshot on exit, but poll only while the shell is live.
+  const interval = input.running ? setInterval(() => void read(), 1_000) : undefined
+  return () => {
+    disposed = true
+    clearInterval(interval)
+  }
+}

packages/session-ui/src/tools/tool-renderer.tsx

@@ -51,6 +51,7 @@ import {
   executeToolFailed,
 } from "../message/current-tool-state"
 import { AssistantReasoningContent, writeClipboard } from "../message/message-content"
+import { followShellOutput } from "./shell-output"
 
 function ShellSubmessage(props: { text: string; animate?: boolean }) {
   let widthRef: HTMLSpanElement | undefined
@@ -1629,33 +1630,9 @@ ToolRegistry.register({
     createEffect(() => {
       if (saved() !== undefined) return
       const id = props.metadata.shellID
-      const shellOutput = data.shellOutput
-      if (typeof id !== "string" || !shellOutput) return
-      const directory = data.directory
-      const running = pending()
-      let cursor = 0
-      let loading = false
-      let disposed = false
-      const load = async () => {
-        if (loading) return
-        loading = true
-        do {
-          const response = await shellOutput({ id, location: { directory }, cursor }).catch(() => undefined)
-          if (disposed || !response) break
-          setStreamed((output) => (cursor === 0 ? response.data.output : output + response.data.output))
-          if (response.data.cursor <= cursor) break
-          cursor = response.data.cursor
-          if (running || cursor >= response.data.size) break
-        } while (!disposed)
-        loading = false
-      }
-      void load()
-      // Refresh the final snapshot on exit, but poll only while the shell is live.
-      const interval = running ? setInterval(() => void load(), 1_000) : undefined
-      onCleanup(() => {
-        disposed = true
-        clearInterval(interval)
-      })
+      const load = data.shellOutput
+      if (typeof id !== "string" || !load) return
+      onCleanup(followShellOutput({ id, directory: data.directory, running: pending(), load, onOutput: setStreamed }))
     })
     const command = () => {
       if (typeof props.input.command === "string") return props.input.command

packages/tui/src/app.tsx

@@ -579,7 +579,7 @@ function App(props: { pair?: DialogPairCredentials }) {
   const terminalTitleEnabled = () => config.data.terminal?.title ?? true
   const pasteSummaryEnabled = () => config.data.prompt?.paste !== "full"
   const tabsVertical = () =>
-    config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width, tabsResize.preferredSize())
+    config.data.tabs.layout === "vertical" && sessionTabsFitVertically(dimensions().width, tabsResize.size())
   const tabsAvailable = () => sessionTabs.enabled() && sessionTabs.tabs().length > 0 && route.data.type !== "plugin"
   const fullscreenPanel = () =>
     route.data.type === "session" &&

packages/tui/src/component/session-tabs-rail.tsx

@@ -0,0 +1,94 @@
+import { createMemo, createSignal } from "solid-js"
+import type { RGBA } from "@opentui/core"
+import { Keymap } from "../context/keymap"
+import { useTheme } from "../context/theme"
+import { tint } from "../theme/color"
+import type { SessionTabsController } from "./session-tabs"
+
+export function SessionTabsRailControls(props: {
+  width: number
+  tabs: SessionTabsController
+  belowHighlighted: boolean
+}) {
+  const theme = useTheme("elevated")
+  const keymap = Keymap.use()
+  const [hovered, setHovered] = createSignal(false)
+  const hoverColor = createMemo(() =>
+    tint(theme.background.default, theme.background.action.primary.hovered, theme.background.action.primary.hovered.a),
+  )
+  let pressed = false
+  const search = () => (props.tabs.search ? props.tabs.search() : keymap.dispatch("session.list"))
+  return (
+    <box height={1} position="relative" flexShrink={0} backgroundColor={theme.background.default}>
+      <SessionTabHalfRow
+        top={-1}
+        edge="top"
+        width={props.width}
+        color={hovered() ? hoverColor() : theme.background.default}
+        background={theme.background.default}
+      />
+      <box
+        height={1}
+        position="relative"
+        flexDirection="row"
+        justifyContent="center"
+        backgroundColor={hovered() ? theme.background.action.primary.hovered : undefined}
+        onMouseOver={() => setHovered(true)}
+        onMouseOut={() => setHovered(false)}
+        onMouseDown={(event) => {
+          pressed = event.button === 0
+          event.stopPropagation()
+        }}
+        onMouseUp={(event) => {
+          event.stopPropagation()
+          if (event.button !== 0 || !pressed) return
+          pressed = false
+          search()
+        }}
+        onMouseDragEnd={() => (pressed = false)}
+      >
+        <text width={1} height={1} fg={theme.text.action.secondary.default} selectable={false} wrapMode="none">
+          ⌕
+        </text>
+      </box>
+      <text
+        position="absolute"
+        top={1}
+        left={0}
+        width={props.width}
+        height={1}
+        zIndex={2}
+        fg={hoverColor()}
+        bg={hovered() && props.belowHighlighted ? hoverColor() : theme.background.default}
+        selectable={false}
+      >
+        {(hovered() ? "▀" : props.belowHighlighted ? "▄" : " ").repeat(props.width)}
+      </text>
+    </box>
+  )
+}
+
+export function SessionTabHalfRow(props: {
+  top: number
+  edge: "top" | "bottom"
+  width: number
+  color: RGBA
+  background: RGBA
+}) {
+  return (
+    <text
+      position="absolute"
+      top={props.top}
+      left={0}
+      width={props.width}
+      height={1}
+      zIndex={1}
+      fg={props.color}
+      bg={props.background}
+      selectable={false}
+      wrapMode="none"
+    >
+      {(props.edge === "top" ? "▄" : "▀").repeat(props.width)}
+    </text>
+  )
+}

packages/tui/src/component/session-tabs.tsx

@@ -1,4 +1,11 @@
-import { BoxRenderable, RGBA, ScrollBoxRenderable, TextAttributes, type MouseEvent } from "@opentui/core"
+import {
+  BoxRenderable,
+  CliRenderEvents,
+  RGBA,
+  ScrollBoxRenderable,
+  TextAttributes,
+  type MouseEvent,
+} from "@opentui/core"
 import {
   For,
   Index,
@@ -12,7 +19,7 @@ import {
   onCleanup,
   untrack,
 } from "solid-js"
-import { Portal, useTerminalDimensions } from "@opentui/solid"
+import { Portal, useRenderer, useTerminalDimensions } from "@opentui/solid"
 import { useConfig } from "../config"
 import { useSessionTabs } from "../context/session-tabs"
 import { useData } from "../context/data"
@@ -33,7 +40,7 @@ import { createAnimatable, spring, tween } from "../ui/animation"
 import { Locale } from "../util/locale"
 import { TabPulse, unreadGlowIntensity } from "./tab-pulse"
 import { tint } from "../theme/color"
-import { SESSION_SIDEBAR_WIDTH } from "../ui/layout"
+import { SESSION_SIDEBAR_WIDTH, SESSION_TABS_COMPACT_BREAKPOINT } from "../ui/layout"
 import { projectName } from "../util/project"
 import { marqueeCycleWidth, marqueeOverflows, marqueeTextParts } from "../util/marquee"
 import { useDialog } from "../ui/dialog"
@@ -41,6 +48,7 @@ import { DialogSessionRename } from "./dialog-session-rename"
 import { Keymap } from "../context/keymap"
 import { registerOpencodeSpinner } from "./register-spinner"
 import { SPINNER_FRAMES } from "./spinner-frames"
+import { SessionTabsRailControls, SessionTabHalfRow } from "./session-tabs-rail"
 import "./title-shimmer"
 
 registerOpencodeSpinner()
@@ -105,6 +113,8 @@ export type SessionTabsController = Pick<ContextController, "tabs" | "current" |
   detail?: (sessionID: string) => string | undefined
   isPreview?: (sessionID: string) => boolean
   promote?: (sessionID: string) => void
+  rename?: (sessionID: string) => void
+  search?: () => void
   status(sessionID: string): SessionTabsStatus
 }
 const NEW_SESSION_TAB: SessionTab = { sessionID: "new", title: NEW_SESSION_TAB_TITLE }
@@ -120,13 +130,16 @@ function tabFeedbackColor(status: SessionTabsStatus, theme: ReturnType<typeof us
 function TabIndicator(props: {
   status: SessionTabsStatus
   label: string
+  idleLabel?: string
   width: number
+  centered?: boolean
   color: RGBA
   unreadColor: RGBA
   backgroundColor: RGBA
   flashColor: RGBA
   animations: boolean
   numbers: boolean
+  selected?: boolean
   spinner?: TabSpinner
   unreadMarker?: TabUnreadMarker
   attributes?: number
@@ -146,7 +159,7 @@ function TabIndicator(props: {
   })
   const fading = () => !props.status.unread && fade.value().opacity > 0
   const color = () => {
-    if (props.numbers) return props.color
+    if (props.numbers || props.selected) return props.color
     if (unread()) return props.unreadColor
     if (!fading()) return props.color
     const opacity = fade.value().opacity
@@ -162,10 +175,17 @@ function TabIndicator(props: {
     if (runs()) return spinner().frames[0]
     if (props.label === "+") return "+"
     if (props.status.unread || fading()) return TAB_UNREAD_MARKERS[props.unreadMarker ?? "small-dot"]
-    return ""
+    return props.idleLabel ?? ""
   }
   return (
-    <box width={props.width + 1} flexShrink={0} flexDirection="row" justifyContent="flex-end" paddingRight={1}>
+    <box
+      width={props.width + (props.centered ? 0 : 1)}
+      height={props.centered ? 1 : undefined}
+      flexShrink={0}
+      flexDirection="row"
+      justifyContent={props.centered ? "center" : "flex-end"}
+      paddingRight={props.centered ? 0 : 1}
+    >
       <Show
         when={runs() && props.animations && !props.numbers}
         fallback={
@@ -384,7 +404,8 @@ function TabContextMenu(props: { state: TabContextMenuState; tabs: SessionTabsCo
               : []),
             {
               title: "Rename",
-              run: () => DialogSessionRename.show(dialog, sessionID, title),
+              run: () =>
+                props.tabs.rename ? props.tabs.rename(sessionID) : DialogSessionRename.show(dialog, sessionID, title),
             },
             { title: "Close", run: () => props.tabs.close(sessionID) },
           ]
@@ -472,6 +493,7 @@ export function SessionTabs(
     animations?: boolean
     spinner?: TabSpinner
     unreadMarker?: TabUnreadMarker
+    indicators?: "status" | "numbers"
     orientation?: "horizontal" | "vertical"
     width?: number
   } = {},
@@ -486,7 +508,7 @@ export function SessionTabs(
           animations={props.animations}
           spinner={props.spinner}
           unreadMarker={props.unreadMarker}
-          numbers={config.tabs.indicators === "numbers"}
+          numbers={(props.indicators ?? config.tabs.indicators) === "numbers"}
           width={props.width}
         />
       </Match>
@@ -496,7 +518,7 @@ export function SessionTabs(
           animations={props.animations}
           spinner={props.spinner}
           unreadMarker={props.unreadMarker}
-          numbers={config.tabs.indicators === "numbers"}
+          numbers={(props.indicators ?? config.tabs.indicators) === "numbers"}
         />
       </Match>
     </Switch>
@@ -511,13 +533,18 @@ function VerticalSessionTabs(props: {
   unreadMarker?: TabUnreadMarker
   width?: number
 }) {
-  const contextTabs = useSessionTabs()
-  const tabs: SessionTabsController = props.controller ?? contextTabs
-  const data = useData()
+  const tabs: SessionTabsController = props.controller ?? useSessionTabs()
+  const data = props.controller ? undefined : useData()
+  const dimensions = useTerminalDimensions()
+  const renderer = useRenderer()
   const theme = useTheme("elevated")
+  const base = useTheme()
   const config = useConfig().data
   const animations = () => props.animations ?? config.animations ?? true
   const width = () => props.width ?? SESSION_SIDEBAR_WIDTH
+  const compact = createMemo(() => width() < SESSION_TABS_COMPACT_BREAKPOINT)
+  const tooltipWidth = () => Math.min(54, dimensions().width - width())
+  const stride = () => (compact() ? 2 : 3)
   const unreadColor = () => theme.text.status.unread
   const activeNumber = () => theme.text.status.running
   const idleNumber = () => tint(theme.text.formfield.default, theme.background.default, 0.55)
@@ -526,6 +553,26 @@ function VerticalSessionTabs(props: {
   const [addHovered, setAddHovered] = createSignal(false)
   const marquee = createTabMarquee(animations)
   const hovered = marquee.hovered
+  createEffect(() => {
+    compact()
+    untrack(marquee.reset)
+  })
+  const [hoverY, setHoverY] = createSignal(0)
+  const [scrollTop, setScrollTop] = createSignal(0)
+  const detail = (sessionID: string) => {
+    const fixture = tabs.detail?.(sessionID)
+    if (fixture !== undefined) return fixture
+    const session = data?.session.get(sessionID)
+    const project = session ? data?.project.get(session.projectID) : undefined
+    const vcs = session ? data?.location.vcs.info(session.location) : undefined
+    const location = session ? data?.location.info(session.location) : undefined
+    return sessionTabDetail(
+      projectName(project, session?.location.directory) ?? "",
+      vcs?.branch.current,
+      vcs?.branch.default,
+      !!location && location.project.directory !== location.project.canonical,
+    )
+  }
   const handleClick = createPreviewDoubleClick(tabs)
   // OpenTUI captures the first drag target, which may differ from the tab pressed on a fast move.
   const [dragging, setDragging] = createSignal<string>()
@@ -539,6 +586,16 @@ function VerticalSessionTabs(props: {
     return moveSessionTab(tabs.tabs(), pending.sessionID, pending.index)
   })
   const items = ordered
+  const highlightColor = createMemo(() =>
+    tint(theme.background.default, theme.background.action.primary.hovered, theme.background.action.primary.hovered.a),
+  )
+  const highlighted = (sessionID: string | undefined) =>
+    sessionID !== undefined && (activeID() === sessionID || hovered() === sessionID || dragging() === sessionID)
+  const addHighlighted = () => newTab() || addHovered()
+  const belowHighlighted = createMemo(() => {
+    const tab = items()[Math.floor(scrollTop() / stride())]
+    return tab ? highlighted(tab.sessionID) : addHighlighted()
+  })
   createEffect(() => {
     const active = marquee.active()
     if (active && !items().some((tab) => tab.sessionID === active)) marquee.reset()
@@ -565,6 +622,8 @@ function VerticalSessionTabs(props: {
   const itemStatus = (tab: SessionTab) => statuses().get(tab.sessionID)!
   let rail: { screenX: number; screenY: number } | undefined
   let scroll: ScrollBoxRenderable | undefined
+  const updateScroll = () => setScrollTop(scroll?.scrollTop ?? 0)
+  onCleanup(() => scroll?.verticalScrollBar.off("change", updateScroll))
   let didDrag = false
   let addPressed = false
   // A captured drag ends with a synthetic up on its drop target; do not turn that into a click.
@@ -579,15 +638,22 @@ function VerticalSessionTabs(props: {
 
   createEffect(() => {
     if (!scroll) return
-    // The promoted new-session slot sits below the list, so bring the rail's bottom into view.
-    if (newTab()) return scroll.scrollTo(Math.max(0, items().length * 3 + 1 - scroll.viewport.height))
-    const index = items().findIndex((tab) => tab.sessionID === activeID())
+    dimensions()
+    const index = newTab() ? items().length : items().findIndex((tab) => tab.sessionID === activeID())
     if (index === -1) return
-    const top = index * 3
-    if (top < scroll.scrollTop) return scroll.scrollTo(top)
-    if (top + 2 > scroll.scrollTop + scroll.viewport.height) {
-      scroll.scrollTo(top + 2 - scroll.viewport.height)
+    const top = index * stride()
+    const height = compact() ? 3 : newTab() ? 1 : 2
+    // Scroll after layout: newly opened tabs do not contribute to the scroll range yet.
+    const reveal = () => {
+      if (!scroll) return
+      if (top < scroll.scrollTop) return scroll.scrollTo(top)
+      if (top + height > scroll.scrollTop + scroll.viewport.height) {
+        scroll.scrollTo(top + height - scroll.viewport.height)
+      }
     }
+    renderer.once(CliRenderEvents.FRAME, reveal)
+    renderer.requestRender()
+    onCleanup(() => renderer.off(CliRenderEvents.FRAME, reveal))
   })
 
   const release = () => {
@@ -607,7 +673,13 @@ function VerticalSessionTabs(props: {
     didDrag = true
     const target = Math.max(
       0,
-      Math.min(tabs.tabs().length - 1, Math.floor((event.y - rail.screenY - 1 + (scroll?.scrollTop ?? 0)) / 3)),
+      Math.min(
+        tabs.tabs().length - 1,
+        Math.floor(
+          (event.y - (scroll?.viewport.screenY ?? rail.screenY + 1) - (compact() ? 1 : 0) + (scroll?.scrollTop ?? 0)) /
+            stride(),
+        ),
+      ),
     )
     const sourceIndex = items().findIndex((item) => item.sessionID === source)
     if (target !== sourceIndex && preview()?.index !== target) setPreview({ sessionID: source, index: target })
@@ -634,21 +706,31 @@ function VerticalSessionTabs(props: {
       onMouseDrag={drag}
       onMouseDragEnd={release}
     >
-      <scrollbox ref={(element) => (scroll = element)} flexGrow={1} scrollbarOptions={{ visible: false }}>
-        <box flexShrink={0} flexDirection="column" gap={1}>
+      <Show when={compact()}>
+        <SessionTabsRailControls width={width()} tabs={tabs} belowHighlighted={belowHighlighted()} />
+      </Show>
+      <scrollbox
+        ref={(element) => {
+          scroll = element
+          scroll.verticalScrollBar.on("change", updateScroll)
+          updateScroll()
+        }}
+        flexGrow={1}
+        minHeight={0}
+        backgroundColor={theme.background.default}
+        scrollbarOptions={{ visible: false }}
+      >
+        <box flexShrink={0} flexDirection="column" gap={1} paddingY={compact() ? 1 : 0}>
           <For each={items()}>
             {(tab, index) => {
               const selected = () => activeID() === tab.sessionID
               const status = createMemo(() => itemStatus(tab))
               const [sweepLevel, setSweepLevel] = createSignal(0)
               const [closeHovered, setCloseHovered] = createSignal(false)
-              const session = createMemo(() => data.session.get(tab.sessionID))
-              const project = createMemo(() => {
-                const value = session()
-                return value ? data.project.get(value.projectID) : undefined
-              })
+              const session = createMemo(() => data?.session.get(tab.sessionID))
               const numberWidth = () => Math.max(2, String(items().length).length)
-              const restingTitleWidth = () => Math.max(1, width() - numberWidth() - 2)
+              const prefixWidth = () => numberWidth() + 1
+              const restingTitleWidth = () => Math.max(1, width() - prefixWidth() - 1)
               const hoveredTitleWidth = () => Math.max(1, restingTitleWidth() - 1)
               const titleWidth = () => (hovered() === tab.sessionID ? hoveredTitleWidth() : restingTitleWidth())
               const title = () => (props.controller ? undefined : session()?.title) ?? tab.title ?? "Untitled session"
@@ -667,25 +749,15 @@ function VerticalSessionTabs(props: {
                   .join(""),
               )
               const titleFades = createMemo(() => marqueeOverflows(title(), titleWidth()) && titleWidth() > FADE_WIDTH)
-              const detail = createMemo(() => {
-                const fixture = tabs.detail?.(tab.sessionID)
-                if (fixture !== undefined) return fixture
-                const value = session()
-                const currentProject = project()
-                const projectLabel = projectName(currentProject, value?.location.directory) ?? ""
-                const vcs = value ? data.location.vcs.info(value.location) : undefined
-                const location = value ? data.location.info(value.location) : undefined
-                const worktree = !!location && location.project.directory !== location.project.canonical
-                return sessionTabDetail(projectLabel, vcs?.branch.current, vcs?.branch.default, worktree)
-              })
-              const visibleDetail = createMemo(() => Locale.takeWidth(detail(), titleWidth()))
+              const tabDetail = createMemo(() => detail(tab.sessionID))
+              const visibleDetail = createMemo(() => Locale.takeWidth(tabDetail(), titleWidth()))
               const visibleDetailParts = createMemo(() => Locale.graphemes(visibleDetail()))
               const detailFades = createMemo(
-                () => marqueeOverflows(detail(), titleWidth()) && titleWidth() > FADE_WIDTH,
+                () => marqueeOverflows(tabDetail(), titleWidth()) && titleWidth() > FADE_WIDTH,
               )
               const background = createMemo(() => {
-                if (selected()) return theme.background.action.primary.selected
-                if (hovered() === tab.sessionID || dragging() === tab.sessionID)
+                if (selected() && !compact()) return theme.background.action.primary.selected
+                if ((compact() && selected()) || hovered() === tab.sessionID || dragging() === tab.sessionID)
                   return theme.background.action.primary.hovered
                 return theme.background.default
               })
@@ -790,12 +862,15 @@ function VerticalSessionTabs(props: {
               }
               return (
                 <box
-                  height={2}
+                  height={compact() ? 1 : 2}
                   width="100%"
                   position="relative"
                   flexDirection="column"
                   backgroundColor={background()}
-                  onMouseOver={() => marquee.enter(tab.sessionID, title(), hoveredTitleWidth())}
+                  onMouseOver={(event) => {
+                    setHoverY(event.y)
+                    marquee.enter(tab.sessionID, title(), compact() ? Infinity : hoveredTitleWidth())
+                  }}
                   onMouseOut={() => marquee.leave(tab.sessionID)}
                   onMouseDown={(event) => {
                     if (event.button === MIDDLE_MOUSE_BUTTON) {
@@ -822,85 +897,52 @@ function VerticalSessionTabs(props: {
                     }
                     didDrag = false
                     handleClick(tab.sessionID)
-                    marquee.enter(tab.sessionID, title(), hoveredTitleWidth())
+                    marquee.enter(tab.sessionID, title(), compact() ? Infinity : hoveredTitleWidth())
                     setDragging(tab.sessionID)
                   }}
                 >
-                  <TabPulse
-                    top={-1}
-                    edge="above"
-                    enabled={animations()}
-                    active={runs()}
-                    outerActive={previousRuns()}
-                    promptPulse={status().promptPulse}
-                    outerPromptPulse={previousStatus().promptPulse}
-                    complete={complete() && !status().attention}
-                    outerComplete={previousStatus().complete && !previousStatus().attention}
-                    glow={glows()}
-                    outerGlow={previousGlows()}
-                    color={separatorLowerPulseColor()}
-                    width={indicatorWidth}
-                    outerColor={separatorUpperPulseColor()}
-                    flashColor={tint(theme.background.default, theme.text.default, 0.22)}
-                    outerFlashColor={tint(theme.background.default, theme.text.default, 0.18)}
-                    flashTail={8}
-                    glowColor={separatorLowerColor()}
-                    outerGlowColor={separatorUpperColor()}
-                    glowTail={8}
-                    outerGlowTail={5}
-                    completionColor={separatorLowerColor()}
-                    outerCompletionColor={separatorUpperColor()}
-                    backgroundColor={theme.background.default}
-                  />
-                  <Show when={index() === items().length - 1}>
-                    <TabPulse
-                      top={2}
-                      edge="below"
-                      enabled={animations()}
-                      active={runs()}
-                      outerActive={false}
-                      promptPulse={status().promptPulse}
-                      outerPromptPulse={0}
-                      complete={complete() && !status().attention}
-                      outerComplete={false}
-                      glow={glows()}
-                      outerGlow={false}
-                      color={tint(theme.background.default, theme.text.default, 0.04)}
-                      width={indicatorWidth}
-                      outerColor={tint(theme.background.default, theme.text.default, 0.006)}
-                      flashColor={tint(theme.background.default, theme.text.default, 0.18)}
-                      flashTail={8}
-                      glowColor={tint(theme.background.default, glowHue(), 0.1 * glowLevel())}
-                      outerGlowColor={theme.background.default}
-                      glowTail={8}
-                      outerGlowTail={5}
-                      completionColor={tint(theme.background.default, glowHue(), 0.1 * glowLevel())}
-                      outerCompletionColor={theme.background.default}
-                      backgroundColor={theme.background.default}
-                    />
-                  </Show>
-                  <box height={1} width="100%" flexDirection="row" position="relative">
-                    <TabPulse
-                      enabled={animations()}
-                      active={runs()}
-                      promptPulse={status().promptPulse}
-                      complete={complete() && !status().attention}
-                      glow={glows()}
-                      color={pulseColor()}
-                      width={indicatorWidth}
-                      glowColor={glowColor()}
-                      flashColor={flashColor()}
-                      flashTail={8}
-                      completionColor={glowColor()}
-                      backgroundColor={pulseBackground()}
-                      onLevel={setSweepLevel}
-                    />
-                    <box zIndex={1} width="100%" flexDirection="row" paddingRight={1}>
+                  <Show when={compact()}>
+                    <Show when={highlighted(tab.sessionID)}>
+                      <SessionTabHalfRow
+                        top={-1}
+                        edge="top"
+                        width={width()}
+                        color={pulseBackground()}
+                        background={
+                          highlighted(items()[index() - 1]?.sessionID) ? highlightColor() : theme.background.default
+                        }
+                      />
+                      <SessionTabHalfRow
+                        top={1}
+                        edge="bottom"
+                        width={width()}
+                        color={pulseBackground()}
+                        background={
+                          (
+                            index() === items().length - 1
+                              ? addHighlighted()
+                              : highlighted(items()[index() + 1]?.sessionID)
+                          )
+                            ? highlightColor()
+                            : theme.background.default
+                        }
+                      />
+                    </Show>
+                    <box height={1} flexDirection="row" justifyContent="center">
                       <TabIndicator
+                        centered
+                        selected={selected()}
+                        width={width()}
                         status={status()}
                         label={sessionTabNumberLabel(index())}
-                        width={numberWidth()}
-                        color={numberColor()}
+                        idleLabel={Locale.graphemes(title().trimStart())[0] ?? "U"}
+                        color={
+                          selected()
+                            ? theme.text.default
+                            : props.numbers
+                              ? numberColor()
+                              : (tabFeedbackColor(status(), theme) ?? (runs() ? activeNumber() : foreground()))
+                        }
                         unreadColor={tabFeedbackColor(status(), theme) ?? unreadColor()}
                         backgroundColor={pulseBackground()}
                         flashColor={theme.text.default}
@@ -908,88 +950,179 @@ function VerticalSessionTabs(props: {
                         numbers={props.numbers}
                         spinner={props.spinner}
                         unreadMarker={props.unreadMarker}
-                        attributes={selected() ? TextAttributes.BOLD : undefined}
-                      />
-                      <title_shimmer
-                        width={titleWidth()}
-                        height={1}
-                        fg={foreground()}
-                        rename={{ pending: status().renaming, title: title() }}
-                        enabled={animations()}
-                        backdrop={pulseBackground()}
-                        wrapMode="none"
-                        selectable={false}
                         attributes={
-                          (status().renaming && !animations()
-                            ? TextAttributes.DIM
-                            : selected()
-                              ? TextAttributes.BOLD
-                              : 0) | (tabs.isPreview?.(tab.sessionID) ? TextAttributes.ITALIC : 0) || undefined
+                          (selected() ? TextAttributes.BOLD : 0) |
+                          (tabs.isPreview?.(tab.sessionID) ? TextAttributes.ITALIC : 0)
                         }
-                      >
-                        <Show
-                          when={scrolling() || titleGlow.value().level > 0 || titleFades()}
-                          fallback={visibleTitle()}
-                        >
-                          <Index each={visibleTitleParts()}>
-                            {(part, index) => (
-                              <span style={{ fg: titleColor(index, part().separator) }}>{part().value}</span>
-                            )}
-                          </Index>
-                        </Show>
-                      </title_shimmer>
-                      <text
-                        position="absolute"
-                        right={1}
-                        zIndex={2}
-                        width={1}
-                        fg={closeHovered() ? theme.text.default : theme.text.subdued}
-                        selectable={false}
-                        onMouseOver={() => setCloseHovered(true)}
-                        onMouseOut={() => setCloseHovered(false)}
-                        onMouseDown={(event) => {
-                          if (event.button === RIGHT_MOUSE_BUTTON || hovered() !== tab.sessionID) return
-                          didDrag = false
-                          event.stopPropagation()
-                        }}
-                        onMouseUp={(event) => {
-                          if (event.button === RIGHT_MOUSE_BUTTON) return
-                          if (suppressClick) return
-                          if (hovered() !== tab.sessionID) return
-                          event.stopPropagation()
-                          tabs.close(tab.sessionID)
-                        }}
-                      >
-                        {hovered() === tab.sessionID ? "✕" : ""}
-                      </text>
+                      />
                     </box>
-                  </box>
-                  <box height={1} width="100%" position="relative" flexDirection="row">
+                  </Show>
+                  <Show when={!compact()}>
                     <TabPulse
+                      top={-1}
+                      edge="above"
                       enabled={animations()}
                       active={runs()}
+                      outerActive={previousRuns()}
                       promptPulse={status().promptPulse}
+                      outerPromptPulse={previousStatus().promptPulse}
                       complete={complete() && !status().attention}
+                      outerComplete={previousStatus().complete && !previousStatus().attention}
                       glow={glows()}
-                      color={detailPulseColor()}
+                      outerGlow={previousGlows()}
+                      color={separatorLowerPulseColor()}
                       width={indicatorWidth}
-                      glowColor={detailGlowColor()}
-                      glowTail={10}
-                      flashColor={detailFlashColor()}
+                      outerColor={separatorUpperPulseColor()}
+                      flashColor={tint(theme.background.default, theme.text.default, 0.22)}
+                      outerFlashColor={tint(theme.background.default, theme.text.default, 0.18)}
                       flashTail={8}
-                      completionColor={detailGlowColor()}
-                      backgroundColor={pulseBackground()}
+                      glowColor={separatorLowerColor()}
+                      outerGlowColor={separatorUpperColor()}
+                      glowTail={8}
+                      outerGlowTail={5}
+                      completionColor={separatorLowerColor()}
+                      outerCompletionColor={separatorUpperColor()}
+                      backgroundColor={theme.background.default}
                     />
-                    <box zIndex={1} width="100%" flexDirection="row" paddingLeft={numberWidth() + 1} paddingRight={2}>
-                      <text fg={detailColor()} wrapMode="none" selectable={false}>
-                        <Show when={detailFades()} fallback={visibleDetail()}>
-                          <For each={visibleDetailParts()}>
-                            {(character, index) => <span style={{ fg: detailTextColor(index()) }}>{character}</span>}
-                          </For>
-                        </Show>
-                      </text>
+                    <Show when={index() === items().length - 1}>
+                      <TabPulse
+                        top={2}
+                        edge="below"
+                        enabled={animations()}
+                        active={runs()}
+                        outerActive={false}
+                        promptPulse={status().promptPulse}
+                        outerPromptPulse={0}
+                        complete={complete() && !status().attention}
+                        outerComplete={false}
+                        glow={glows()}
+                        outerGlow={false}
+                        color={tint(theme.background.default, theme.text.default, 0.04)}
+                        width={indicatorWidth}
+                        outerColor={tint(theme.background.default, theme.text.default, 0.006)}
+                        flashColor={tint(theme.background.default, theme.text.default, 0.18)}
+                        flashTail={8}
+                        glowColor={tint(theme.background.default, glowHue(), 0.1 * glowLevel())}
+                        outerGlowColor={theme.background.default}
+                        glowTail={8}
+                        outerGlowTail={5}
+                        completionColor={tint(theme.background.default, glowHue(), 0.1 * glowLevel())}
+                        outerCompletionColor={theme.background.default}
+                        backgroundColor={theme.background.default}
+                      />
+                    </Show>
+                    <box height={1} width="100%" flexDirection="row" position="relative">
+                      <TabPulse
+                        enabled={animations()}
+                        active={runs()}
+                        promptPulse={status().promptPulse}
+                        complete={complete() && !status().attention}
+                        glow={glows()}
+                        color={pulseColor()}
+                        width={indicatorWidth}
+                        glowColor={glowColor()}
+                        flashColor={flashColor()}
+                        flashTail={8}
+                        completionColor={glowColor()}
+                        backgroundColor={pulseBackground()}
+                        onLevel={setSweepLevel}
+                      />
+                      <box zIndex={1} width="100%" flexDirection="row" paddingRight={1}>
+                        <TabIndicator
+                          status={status()}
+                          label={sessionTabNumberLabel(index())}
+                          width={numberWidth()}
+                          color={numberColor()}
+                          unreadColor={tabFeedbackColor(status(), theme) ?? unreadColor()}
+                          backgroundColor={pulseBackground()}
+                          flashColor={theme.text.default}
+                          animations={animations()}
+                          numbers={props.numbers}
+                          spinner={props.spinner}
+                          unreadMarker={props.unreadMarker}
+                          attributes={selected() ? TextAttributes.BOLD : undefined}
+                        />
+                        <title_shimmer
+                          width={titleWidth()}
+                          height={1}
+                          fg={foreground()}
+                          rename={{ pending: status().renaming, title: title() }}
+                          enabled={animations()}
+                          backdrop={pulseBackground()}
+                          wrapMode="none"
+                          selectable={false}
+                          attributes={
+                            (status().renaming && !animations()
+                              ? TextAttributes.DIM
+                              : selected()
+                                ? TextAttributes.BOLD
+                                : 0) | (tabs.isPreview?.(tab.sessionID) ? TextAttributes.ITALIC : 0) || undefined
+                          }
+                        >
+                          <Show
+                            when={scrolling() || titleGlow.value().level > 0 || titleFades()}
+                            fallback={visibleTitle()}
+                          >
+                            <Index each={visibleTitleParts()}>
+                              {(part, index) => (
+                                <span style={{ fg: titleColor(index, part().separator) }}>{part().value}</span>
+                              )}
+                            </Index>
+                          </Show>
+                        </title_shimmer>
+                        <text
+                          position="absolute"
+                          right={1}
+                          zIndex={2}
+                          width={1}
+                          fg={closeHovered() ? theme.text.default : theme.text.subdued}
+                          selectable={false}
+                          onMouseOver={() => setCloseHovered(true)}
+                          onMouseOut={() => setCloseHovered(false)}
+                          onMouseDown={(event) => {
+                            if (event.button === RIGHT_MOUSE_BUTTON || hovered() !== tab.sessionID) return
+                            didDrag = false
+                            event.stopPropagation()
+                          }}
+                          onMouseUp={(event) => {
+                            if (event.button === RIGHT_MOUSE_BUTTON) return
+                            if (suppressClick) return
+                            if (hovered() !== tab.sessionID) return
+                            event.stopPropagation()
+                            tabs.close(tab.sessionID)
+                          }}
+                        >
+                          {hovered() === tab.sessionID ? "✕" : ""}
+                        </text>
+                      </box>
                     </box>
-                  </box>
+                    <box height={1} width="100%" position="relative" flexDirection="row">
+                      <TabPulse
+                        enabled={animations()}
+                        active={runs()}
+                        promptPulse={status().promptPulse}
+                        complete={complete() && !status().attention}
+                        glow={glows()}
+                        color={detailPulseColor()}
+                        width={indicatorWidth}
+                        glowColor={detailGlowColor()}
+                        glowTail={10}
+                        flashColor={detailFlashColor()}
+                        flashTail={8}
+                        completionColor={detailGlowColor()}
+                        backgroundColor={pulseBackground()}
+                      />
+                      <box zIndex={1} width="100%" flexDirection="row" paddingLeft={prefixWidth()} paddingRight={2}>
+                        <text fg={detailColor()} wrapMode="none" selectable={false}>
+                          <Show when={detailFades()} fallback={visibleDetail()}>
+                            <For each={visibleDetailParts()}>
+                              {(character, index) => <span style={{ fg: detailTextColor(index()) }}>{character}</span>}
+                            </For>
+                          </Show>
+                        </text>
+                      </box>
+                    </box>
+                  </Show>
                 </box>
               )
             }}
@@ -1002,11 +1135,13 @@ function VerticalSessionTabs(props: {
               width="100%"
               position="relative"
               flexDirection="row"
-              paddingLeft={1}
+              paddingLeft={compact() ? 0 : 1}
+              justifyContent={compact() ? "center" : "flex-start"}
+              alignItems="center"
               backgroundColor={
-                newTab()
+                newTab() && !compact()
                   ? theme.background.action.primary.selected
-                  : addHovered()
+                  : addHovered() || (compact() && newTab())
                     ? theme.background.action.primary.hovered
                     : theme.background.default
               }
@@ -1031,23 +1166,41 @@ function VerticalSessionTabs(props: {
               }}
               onMouseDragEnd={() => (addPressed = false)}
             >
+              <Show when={compact() && addHighlighted()}>
+                <SessionTabHalfRow
+                  top={-1}
+                  edge="top"
+                  width={width()}
+                  color={highlightColor()}
+                  background={highlighted(items().at(-1)?.sessionID) ? highlightColor() : theme.background.default}
+                />
+                <SessionTabHalfRow
+                  top={1}
+                  edge="bottom"
+                  width={width()}
+                  color={highlightColor()}
+                  background={theme.background.default}
+                />
+              </Show>
               <text
-                width={2}
+                width={compact() ? 1 : 2}
                 fg={newTab() || addHovered() ? theme.text.default : idleNumber()}
                 selectable={false}
                 attributes={newTab() ? TextAttributes.BOLD : undefined}
               >
                 +
               </text>
-              <text
-                fg={newTab() || addHovered() ? theme.text.default : theme.text.subdued}
-                wrapMode="none"
-                selectable={false}
-                attributes={newTab() ? TextAttributes.BOLD : undefined}
-              >
-                {NEW_SESSION_TAB_TITLE}
-              </text>
-              <Show when={newTab()}>
+              <Show when={!compact()}>
+                <text
+                  fg={newTab() || addHovered() ? theme.text.default : theme.text.subdued}
+                  wrapMode="none"
+                  selectable={false}
+                  attributes={newTab() ? TextAttributes.BOLD : undefined}
+                >
+                  {NEW_SESSION_TAB_TITLE}
+                </text>
+              </Show>
+              <Show when={newTab() && !compact()}>
                 <text
                   position="absolute"
                   right={1}
@@ -1070,6 +1223,47 @@ function VerticalSessionTabs(props: {
           </Show>
         </box>
       </scrollbox>
+      <Show when={compact() && !dragging() && !contextMenu() && hovered()}>
+        {(sessionID) => (
+          <box
+            position="absolute"
+            left={width()}
+            top={Math.max(0, Math.min(hoverY() - 1, dimensions().height - 4) - (rail?.screenY ?? 0))}
+            width={tooltipWidth()}
+            height={4}
+            paddingY={1}
+            zIndex={2000}
+          >
+            <SessionTabHalfRow
+              top={0}
+              edge="top"
+              width={tooltipWidth()}
+              color={theme.background.default}
+              background={base.background.default}
+            />
+            <box height={2} paddingX={1} backgroundColor={theme.background.default}>
+              <text fg={theme.text.default} wrapMode="none" selectable={false}>
+                {Locale.truncateWidth(
+                  data?.session.get(sessionID())?.title ??
+                    items().find((tab) => tab.sessionID === sessionID())?.title ??
+                    "Untitled session",
+                  tooltipWidth() - 2,
+                )}
+              </text>
+              <text fg={theme.text.subdued} wrapMode="none" selectable={false}>
+                {Locale.takeWidth(detail(sessionID()), tooltipWidth() - 2)}
+              </text>
+            </box>
+            <SessionTabHalfRow
+              top={3}
+              edge="bottom"
+              width={tooltipWidth()}
+              color={theme.background.default}
+              background={base.background.default}
+            />
+          </box>
+        )}
+      </Show>
       <Show when={contextMenu()}>
         {(state) => <TabContextMenu state={state()} tabs={tabs} onClose={() => setContextMenu(undefined)} />}
       </Show>

packages/tui/src/config/index.tsx

@@ -191,6 +191,9 @@ export const Info = Schema.Struct({
       thinking: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
         description: "Show or hide model reasoning",
       }),
+      tools: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
+        description: "Show or hide tool calls and the assistant text that precedes them",
+      }),
       shell_output: Schema.optional(Schema.Literals(["show", "hide"])).annotate({
         description: "Show or hide raw shell tool output",
       }),

packages/tui/src/config/keybind.ts

@@ -46,6 +46,7 @@ export const Definitions = {
   leader: keybind(LeaderDefault, "Leader key for keybind combinations"),
 
   "app.exit": keybind("ctrl+c,ctrl+d,<leader>q", "Exit the application"),
+  "app.clear": keybind("ctrl+l", "Clear the screen in mini"),
   "app.debug": keybind("none", "Toggle debug panel"),
   "app.console": keybind("none", "Toggle console"),
   "app.scrap": keybind("none", "Open scrap screen"),

packages/tui/src/feature-plugins/system/storybook/session-tabs.tsx

@@ -1,6 +1,6 @@
 import { Plugin } from "@opencode/plugin/tui"
 import { useTerminalDimensions } from "@opentui/solid"
-import { batch, createSignal, For } from "solid-js"
+import { batch, createSignal, For, Show } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
 import {
   EMPTY_SESSION_TAB_STATUS,
@@ -13,6 +13,18 @@ import {
 } from "../../../component/session-tabs"
 import { closeSessionTab, cycleSessionTab, moveSessionTab } from "../../../context/session-tabs-model"
 import { StoryFooter } from "./footer"
+import { DialogPrompt } from "../../../ui/dialog-prompt"
+import { useDialog } from "../../../ui/dialog"
+import { DialogSelect } from "../../../ui/dialog-select"
+import {
+  clampSessionTabsWidth,
+  sessionTabsFitVertically,
+  SESSION_SIDEBAR_WIDTH,
+  SESSION_TABS_COMPACT_BREAKPOINT,
+  SESSION_TABS_COMPACT_WIDTH,
+} from "../../../ui/layout"
+import { createPaneResize } from "../../../ui/pane-resize"
+import { PaneResizeHandle } from "../../../ui/pane-resize-handle"
 import type { Story } from "./index"
 
 type FixtureStatus = ReturnType<SessionTabsController["status"]>
@@ -54,6 +66,7 @@ const TRANSCRIPT_FILES = [
 function SessionTabsStory(props: { context: Plugin.Context }) {
   const dimensions = useTerminalDimensions()
   const theme = props.context.theme
+  const dialog = useDialog()
   // A keyed store mirrors production: retitles mutate rows in place instead of remounting them.
   const [tabStore, setTabStore] = createStore<{ items: { sessionID: string; title?: string }[] }>({
     items: FIXTURE_TABS.slice(0, 6).map((tab) => ({ ...tab })),
@@ -65,6 +78,18 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
   const [lastEvent, setLastEvent] = createSignal("idle / working / question / permission / complete / error")
   const [statuses, setStatuses] = createSignal<Record<string, FixtureStatus>>(FIXTURE_STATUSES)
   const [orientation, setOrientation] = createSignal<"horizontal" | "vertical">("vertical")
+  const [width, setWidth] = createSignal(SESSION_SIDEBAR_WIDTH)
+  const resize = createPaneResize({
+    value: width,
+    defaultValue: () => SESSION_SIDEBAR_WIDTH,
+    clamp: (width) => clampSessionTabsWidth(width, dimensions().width),
+    fromMouse: (event) => event.x + 1,
+    contains: (event, width) => event.x >= width - 1 && event.x <= width,
+    onCommit: setWidth,
+  })
+  const vertical = () => orientation() === "vertical" && sessionTabsFitVertically(dimensions().width, resize.size())
+  const [indicators, setIndicators] = createSignal<"status" | "numbers">("status")
+  const railCompact = () => resize.size() < SESSION_TABS_COMPACT_BREAKPOINT
   const spinners = Object.keys(TAB_SPINNERS) as TabSpinner[]
   const [spinner, setSpinner] = createSignal<TabSpinner>("dots")
   const markers = Object.keys(TAB_UNREAD_MARKERS) as TabUnreadMarker[]
@@ -116,6 +141,22 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
     tabs,
     current: active,
     add: addTab,
+    search() {
+      dialog.replace(() => (
+        <DialogSelect
+          title="Sessions (fixture)"
+          current={active()}
+          options={FIXTURE_TABS.map((tab) => ({ title: tab.title, value: tab.sessionID, description: tab.project }))}
+          onSelect={(option) => {
+            if (!tabs().some((tab) => tab.sessionID === option.value)) {
+              setItems([...tabs(), { ...FIXTURE_TABS.find((tab) => tab.sessionID === option.value)! }])
+            }
+            select(option.value)
+            dialog.clear()
+          }}
+        />
+      ))
+    },
     detail(sessionID) {
       return FIXTURE_TABS.find((tab) => tab.sessionID === sessionID)?.project
     },
@@ -123,6 +164,19 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
       return statuses()[sessionID] ?? EMPTY_SESSION_TAB_STATUS
     },
     select,
+    rename(sessionID: string) {
+      dialog.replace(() => (
+        <DialogPrompt
+          title="Rename fixture tab"
+          value={tabs().find((tab) => tab.sessionID === sessionID)?.title}
+          onConfirm={(title) => {
+            if (!title.trim()) return
+            setTabStore("items", (tab) => tab.sessionID === sessionID, "title", title.trim())
+            dialog.clear()
+          }}
+        />
+      ))
+    },
     move(sessionID: string, index: number) {
       const next = moveSessionTab(tabs(), sessionID, index)
       if (next === tabs()) return
@@ -267,6 +321,8 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
       setMarker("small-dot")
       setAnimations(true)
       setOrientation("vertical")
+      setWidth(SESSION_SIDEBAR_WIDTH)
+      setIndicators("status")
     })
     setLastEvent(showcase ? "all six states are visible" : "reset; all tabs idle")
   }
@@ -395,8 +451,30 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
         run: () => setMarker((value) => markers[(markers.indexOf(value) + 1) % markers.length]),
       },
       { bind: "m", title: "Toggle animations", group: "Storybook", run: () => setAnimations((value) => !value) },
+      {
+        bind: "g",
+        title: "Toggle status icons or numbers",
+        group: "Storybook",
+        run: () => setIndicators((value) => (value === "status" ? "numbers" : "status")),
+      },
       { bind: "t", title: "Add tab", group: "Storybook", run: addTab },
       { bind: "d", title: "Close tab", group: "Storybook", run: () => controller.close() },
+      {
+        bind: "b",
+        title: "Switch minimum or default width",
+        group: "Storybook",
+        run: () => setWidth(railCompact() ? SESSION_SIDEBAR_WIDTH : SESSION_TABS_COMPACT_WIDTH),
+      },
+      {
+        bind: "n",
+        title: "Cycle tab count",
+        group: "Storybook",
+        run() {
+          const count = tabs().length < 6 ? 6 : tabs().length < 12 ? 12 : 3
+          setItems(FIXTURE_TABS.slice(0, count).map((tab) => ({ ...tab })))
+          if (!tabs().some((tab) => tab.sessionID === active())) setActive("fixture-1")
+        },
+      },
       {
         bind: "o",
         title: "Toggle tab orientation",
@@ -417,15 +495,24 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
       flexDirection="column"
       backgroundColor={theme.background.default}
     >
-      <box flexGrow={1} flexDirection={orientation() === "vertical" ? "row" : "column"}>
+      <box
+        flexGrow={1}
+        minHeight={0}
+        flexDirection={vertical() ? "row" : "column"}
+        onMouseDrag={resize.onMouseDrag}
+        onMouseDragEnd={resize.onMouseDragEnd}
+        onMouseUp={resize.onMouseUp}
+      >
         <SessionTabs
           controller={controller}
-          orientation={orientation()}
+          orientation={vertical() ? "vertical" : "horizontal"}
+          width={resize.size()}
           spinner={spinner()}
           unreadMarker={marker()}
           animations={animations()}
+          indicators={indicators()}
         />
-        <box flexGrow={1} paddingLeft={2} paddingRight={2} paddingTop={1} flexDirection="column">
+        <box flexGrow={1} minWidth={0} paddingLeft={2} paddingRight={2} paddingTop={1} flexDirection="column">
           <For each={transcript()}>
             {(line) => (
               <text fg={line.color} wrapMode="none" selectable={false}>
@@ -434,19 +521,25 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
             )}
           </For>
         </box>
+        <Show when={vertical()}>
+          <PaneResizeHandle resize={resize} left={resize.size() - 1} />
+        </Show>
       </box>
       <StoryFooter
         context={props.context}
         title="storybook / tabs"
         details={[
-          orientation() === "vertical" ? "left rail" : "top strip",
+          vertical() ? `${railCompact() ? "compact rail" : "expanded rail"} · ${resize.size()} cols` : "top strip",
           spinner(),
+          indicators(),
           `${TAB_UNREAD_MARKERS[marker()]} ${marker()}`,
           animations() ? "animated" : "still",
         ]}
         status={stateSummary()}
         message={lastEvent()}
         controls={[
+          { shortcut: "b", label: "min/default width" },
+          { shortcut: "n", label: "3/6/12 tabs" },
           { shortcut: "s", label: "work" },
           { shortcut: "space/e", label: "random work" },
           { shortcut: "p", label: "prompt" },
@@ -456,10 +549,12 @@ function SessionTabsStory(props: { context: Plugin.Context }) {
           { shortcut: "f/x", label: "complete/fail" },
           { shortcut: "t/d", label: "add/close" },
           { shortcut: "c", label: "spinner" },
+          { shortcut: "g", label: "status/numbers" },
           { shortcut: "u", label: "unread marker" },
           { shortcut: "m", label: "motion" },
           { shortcut: "↑/↓", label: "select" },
           { shortcut: "o", label: "layout" },
+          { shortcut: "drag edge", label: "resize / double-click reset" },
           { shortcut: "r", label: "reset idle" },
           { shortcut: "v", label: "all states" },
           { shortcut: "esc", label: "back" },

packages/tui/src/mini/footer.command.tsx

@@ -27,6 +27,7 @@ import type {
   RunInput,
   RunProvider,
 } from "./types"
+import { matchMiniVerbosity, verbosityChange, verbosityLabel } from "./verbosity"
 
 type PanelEntry = RunFooterMenuItem & {
   category: string
@@ -45,6 +46,7 @@ type CommandEntry =
   | (PanelEntry & { action: "variant.list" })
   | (PanelEntry & { action: "settings" })
   | (PanelEntry & { action: "slash"; name: string })
+  | (PanelEntry & { action: "clear" })
   | (PanelEntry & { action: "exit" })
 
 type ModelEntry = PanelEntry & {
@@ -78,7 +80,7 @@ type SubagentEntry = PanelEntry & {
 }
 
 type SettingEntry = PanelEntry & {
-  key: keyof MiniSettings
+  key: keyof MiniSettings | "verbosity"
 }
 
 const PANEL_PAD = 2
@@ -411,7 +413,9 @@ export function RunCommandMenuBody(props: {
   onSettings: () => void
   onCommand: (name: string) => void
   onNew: () => void
+  onClear?: () => void
   onExit: () => void
+  clearShortcut?: string
   mono?: boolean
 }) {
   const skills = createMemo(() => (props.commands() ?? []).filter((item) => item.source === "skill"))
@@ -524,6 +528,13 @@ export function RunCommandMenuBody(props: {
       ...session,
       ...prompt,
       ...agent,
+      {
+        action: "clear",
+        category: "System",
+        display: "Clear screen",
+        footer: props.clearShortcut,
+        keywords: "clear screen cls redraw",
+      },
       {
         action: "settings",
         category: "System",
@@ -585,6 +596,11 @@ export function RunCommandMenuBody(props: {
       return
     }
 
+    if (item.action === "clear") {
+      props.onClear?.()
+      return
+    }
+
     if (item.action === "exit") {
       props.onExit()
       return
@@ -711,8 +727,16 @@ export function RunSettingsBody(props: {
   mono?: boolean
   animations?: boolean
 }) {
-  const [saving, setSaving] = createSignal<keyof MiniSettings>()
+  const [saving, setSaving] = createSignal<SettingEntry["key"]>()
   const entries = createMemo<SettingEntry[]>(() => [
+    {
+      category: "Transcript",
+      display: "Verbosity",
+      footer: saving() === "verbosity" ? "saving" : verbosityLabel(matchMiniVerbosity(props.settings())),
+      footerTone: saving() === "verbosity" ? "running" : "selection",
+      keywords: `verbosity quiet default everything custom noise ${verbosityLabel(matchMiniVerbosity(props.settings()))}`,
+      key: "verbosity",
+    },
     {
       category: "Transcript",
       display: "Thinking",
@@ -721,6 +745,14 @@ export function RunSettingsBody(props: {
       keywords: `thinking reasoning ${props.settings().thinking}`,
       key: "thinking",
     },
+    {
+      category: "Transcript",
+      display: "Tools",
+      footer: saving() === "tools" ? "saving" : props.settings().tools,
+      footerTone: saving() === "tools" ? "running" : "selection",
+      keywords: `tools files skills activity work steps intermediate ${props.settings().tools}`,
+      key: "tools",
+    },
     {
       category: "Transcript",
       display: "Shell",
@@ -785,18 +817,21 @@ export function RunSettingsBody(props: {
   const change = (item: SettingEntry, direction = 1) => {
     if (saving()) return
     const spinners = Config.MiniWorkSpinner.literals
-    const next: MiniSettingChange =
-      item.key === "work_spinner"
-        ? {
-            key: "work_spinner",
-            value:
-              spinners[
-                (spinners.indexOf(props.settings().work_spinner) + direction + spinners.length) % spinners.length
-              ]!,
-          }
-        : item.key === "mono"
-          ? { key: "mono", value: !props.settings().mono }
-          : { key: item.key, value: props.settings()[item.key] === "show" ? "hide" : "show" }
+    const next: MiniSettingChange | undefined =
+      item.key === "verbosity"
+        ? verbosityChange(props.settings(), direction < 0 ? -1 : 1)
+        : item.key === "work_spinner"
+          ? {
+              key: "work_spinner",
+              value:
+                spinners[
+                  (spinners.indexOf(props.settings().work_spinner) + direction + spinners.length) % spinners.length
+                ]!,
+            }
+          : item.key === "mono"
+            ? { key: "mono", value: !props.settings().mono }
+            : { key: item.key, value: props.settings()[item.key] === "show" ? "hide" : "show" }
+    if (!next) return
     setSaving(item.key)
     void Promise.resolve(props.onChange(next))
       .catch(() => {})