fix(app): paste plain text into session titles

feat(app): add /btw side question panel (#49750 )
Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>
2026-09-23 00:57:38 +00:00 · 2026-09-22 08:12:08 +00:00 · 2026-09-22 15:20:09 +08:00 · 2026-09-22 05:45:49 +00:00 · 2026-09-22 00:25:06 -05:00 · 2026-09-22 00:53:42 -04:00
401 changed files with 10018 additions and 4725 deletions
@@ -112,11 +112,12 @@ jobs:
      - name: Run unit tests
        timeout-minutes: 20
        run: |
+          # The runners have four vCPUs, and each Bun test process performs its own concurrent work.
          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            GITHUB_ACTIONS=false bun turbo test
+            GITHUB_ACTIONS=false bun turbo test --concurrency=3
            exit 0
          fi
-          GITHUB_ACTIONS=false bun turbo test --affected
+          GITHUB_ACTIONS=false bun turbo test --affected --concurrency=3
        env:
          OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
          TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
@@ -32,7 +32,7 @@
    },
    "packages/ai": {
      "name": "@opencode/ai",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/credential-providers": "3.1057.0",
        "@opencode/schema": "workspace:*",
@@ -54,7 +54,7 @@
    },
    "packages/app": {
      "name": "@opencode/app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@corvu/drawer": "catalog:",
        "@dnd-kit/abstract": "0.5.0",
@@ -111,7 +111,7 @@
    },
    "packages/cli": {
      "name": "@opencode/cli",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "bin": {
        "opencode2": "./bin/opencode2.cjs",
      },
@@ -175,7 +175,7 @@
    },
    "packages/client": {
      "name": "@opencode/client",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/protocol": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -201,7 +201,7 @@
    },
    "packages/codemode": {
      "name": "@opencode/codemode",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "acorn": "8.15.0",
        "effect": "catalog:",
@@ -214,7 +214,7 @@
    },
    "packages/console/app": {
      "name": "@opencode/console-app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@ibm/plex": "6.4.1",
@@ -250,7 +250,7 @@
    },
    "packages/console/core": {
      "name": "@opencode/console-core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-sts": "3.782.0",
        "@jsx-email/render": "1.1.1",
@@ -277,7 +277,7 @@
    },
    "packages/console/function": {
      "name": "@opencode/console-function",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@openauthjs/openauth": "0.0.0-20250322224806",
        "@opencode/console-core": "workspace:*",
@@ -294,7 +294,7 @@
    },
    "packages/console/mail": {
      "name": "@opencode/console-mail",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@jsx-email/all": "2.2.3",
        "@jsx-email/cli": "1.4.3",
@@ -318,7 +318,7 @@
    },
    "packages/console/support": {
      "name": "@opencode/console-support",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@cloudflare/vite-plugin": "1.15.2",
        "@opencode/console-core": "workspace:*",
@@ -338,7 +338,7 @@
    },
    "packages/core": {
      "name": "@opencode/core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ai-sdk/cohere": "3.0.27",
        "@ai-sdk/gateway": "3.0.104",
@@ -406,10 +406,10 @@
    },
    "packages/desktop": {
      "name": "@opencode/desktop",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@zip.js/zip.js": "2.7.62",
-        "electron-context-menu": "4.1.2",
+        "electron-context-menu": "5.0.0",
        "electron-log": "^5",
        "electron-updater": "6.8.9",
        "lighthouse": "13.4.1",
@@ -436,7 +436,7 @@
        "drizzle-kit": "catalog:",
        "drizzle-orm": "catalog:",
        "effect": "catalog:",
-        "electron": "42.10.1",
+        "electron": "44.4.3",
        "electron-builder": "26.15.7",
        "electron-vite": "6.0.0-beta.1",
        "puppeteer-core": "25.9.0",
@@ -455,7 +455,7 @@
    },
    "packages/enterprise": {
      "name": "@opencode/enterprise",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@hono/standard-validator": "catalog:",
        "@opencode-ai/sdk": "1.18.21",
@@ -492,7 +492,7 @@
    },
    "packages/function": {
      "name": "@opencode/function",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@octokit/auth-app": "8.0.1",
        "@octokit/rest": "catalog:",
@@ -508,7 +508,7 @@
    },
    "packages/http-recorder": {
      "name": "@opencode/http-recorder",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/platform-node-shared": "4.0.0-rc.112",
      },
@@ -527,7 +527,7 @@
    },
    "packages/httpapi-codegen": {
      "name": "@opencode/httpapi-codegen",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "effect": "catalog:",
        "prettier": "3.6.2",
@@ -540,7 +540,7 @@
    },
    "packages/latex": {
      "name": "@opencode/latex",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -554,7 +554,7 @@
    },
    "packages/merman": {
      "name": "@opencode/merman",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opentui/core": "catalog:",
@@ -569,7 +569,7 @@
    },
    "packages/plugin": {
      "name": "@opencode/plugin",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ai-sdk/provider": "3.0.8",
        "@opencode/ai": "workspace:*",
@@ -608,7 +608,7 @@
    },
    "packages/plugin-browser": {
      "name": "@opencode/plugin-browser",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/plugin": "workspace:*",
        "@opencode/schema": "workspace:*",
@@ -638,7 +638,7 @@
    },
    "packages/protocol": {
      "name": "@opencode/protocol",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/schema": "workspace:*",
        "effect": "catalog:",
@@ -653,7 +653,7 @@
    },
    "packages/schema": {
      "name": "@opencode/schema",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@standard-schema/spec": "catalog:",
        "effect": "catalog:",
@@ -677,7 +677,7 @@
    },
    "packages/sdk": {
      "name": "@opencode/sdk",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -698,7 +698,7 @@
    },
    "packages/server": {
      "name": "@opencode/server",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/platform-node": "catalog:",
        "@effect/platform-node-shared": "catalog:",
@@ -720,7 +720,7 @@
    },
    "packages/session-ui": {
      "name": "@opencode/session-ui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@opencode/client": "workspace:*",
@@ -755,7 +755,7 @@
    },
    "packages/simulation": {
      "name": "@opencode/simulation",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/ai": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -775,7 +775,7 @@
    },
    "packages/stats/app": {
      "name": "@opencode/stats-app",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@ibm/plex": "6.4.1",
        "@kobalte/core": "catalog:",
@@ -809,7 +809,7 @@
    },
    "packages/stats/core": {
      "name": "@opencode/stats-core",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-athena": "3.933.0",
        "@planetscale/database": "1.19.0",
@@ -828,7 +828,7 @@
    },
    "packages/stats/server": {
      "name": "@opencode/stats-server",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@aws-sdk/client-firehose": "3.933.0",
        "@effect/platform-node": "catalog:",
@@ -874,7 +874,7 @@
    },
    "packages/theme": {
      "name": "@opencode/theme",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opentui/core": "catalog:",
        "effect": "catalog:",
@@ -888,7 +888,7 @@
    },
    "packages/tui": {
      "name": "@opencode/tui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@opencode/client": "workspace:*",
        "@opencode/core": "workspace:*",
@@ -923,7 +923,7 @@
    },
    "packages/ui": {
      "name": "@opencode/ui",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@kobalte/core": "catalog:",
        "@pierre/diffs": "catalog:",
@@ -958,7 +958,7 @@
    },
    "packages/util": {
      "name": "@opencode/util",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@effect/opentelemetry": "catalog:",
        "@effect/platform-node": "catalog:",
@@ -991,7 +991,7 @@
    },
    "packages/web": {
      "name": "@opencode/web",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "@astrojs/cloudflare": "12.6.3",
        "@astrojs/markdown-remark": "6.3.1",
@@ -1032,7 +1032,7 @@
    },
    "services/update": {
      "name": "@opencode/update",
-      "version": "2.0.10",
+      "version": "2.0.12",
      "dependencies": {
        "jose": "6.0.11",
        "semver": "catalog:",
@@ -3880,13 +3880,13 @@

    "ejs": ["ejs@3.1.10", "", { "dependencies": { "jake": "^10.8.5" }, "bin": { "ejs": "bin/cli.js" } }, "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA=="],

-    "electron": ["electron@42.10.1", "", { "dependencies": { "@electron-internal/extract-zip": "^1.0.1", "@electron/get": "^5.0.0", "@types/node": "^24.9.0" }, "bin": { "electron": "cli.js", "install-electron": "install.js" } }, "sha512-ITc1HPeoDzsxCCaH6MFsN67Nq2nUiJf5N9pBWxzhUpFfKJF0IwiAkKT3emg1lPbvC4OfFE+Cdwe4vhgdOZ1YKg=="],
+    "electron": ["electron@44.4.3", "", { "dependencies": { "@electron-internal/extract-zip": "^1.0.1", "@electron/get": "^5.0.0", "@types/node": "^24.9.0" }, "bin": { "electron": "cli.js", "install-electron": "install.js" } }, "sha512-LTpSFTB40qVCXIX5xMo+cgHI/Jjkbjw7VpB26PccEbroqOn72LBukeaDwPVo1fBYzSzs0c9iPuAucFCO7Tw81Q=="],

    "electron-builder": ["electron-builder@26.15.7", "", { "dependencies": { "app-builder-lib": "26.15.7", "builder-util": "26.15.3", "builder-util-runtime": "9.7.0", "chalk": "^4.1.2", "ci-info": "^4.2.0", "dmg-builder": "26.15.7", "fs-extra": "^10.1.0", "lazy-val": "^1.0.5", "simple-update-notifier": "2.0.0", "yargs": "^17.6.2" }, "bin": { "electron-builder": "./cli.js", "install-app-deps": "./install-app-deps.js" } }, "sha512-DBpaNzxsPs1BvEblzFoNriSbzsBqDCy/gseIngeEhYzQG1IxfB7Hvc2tBBVmpWE2BTQGP9J1RrAvDT+Vc/uAxg=="],

    "electron-builder-squirrel-windows": ["electron-builder-squirrel-windows@26.15.7", "", { "dependencies": { "app-builder-lib": "26.15.7", "builder-util": "26.15.3", "electron-winstaller": "5.4.0" } }, "sha512-B4uvn2NzFSuf084udWqugludFull6CRJiWe2dLzMnZLl6G5hdAGk0fsBMGlBSpKjvQCJn8IPc+S7OnJ+GXqwLA=="],

-    "electron-context-menu": ["electron-context-menu@4.1.2", "", { "dependencies": { "cli-truncate": "^4.0.0", "electron-dl": "^4.0.0", "electron-is-dev": "^3.0.1" } }, "sha512-9xYTUV0oRqKL50N9W71IrXNdVRB0LuBp3R1zkUdUc2wfIa2/QZwYYj5RLuO7Tn7ZSLVIaO3X6u+EIBK+cBvzrQ=="],
+    "electron-context-menu": ["electron-context-menu@5.0.0", "", { "dependencies": { "cli-truncate": "^4.0.0", "electron-dl": "^4.0.0", "electron-is-dev": "^3.0.1" } }, "sha512-rgFpRtwY0/rhsRCoz9rE6VM4WueEsLbIpca7ucOhERVrbGB2dQrxa9xwBNLplU54jRgPuv6nTEbxoplE5bzy2A=="],

    "electron-dl": ["electron-dl@4.0.0", "", { "dependencies": { "ext-name": "^5.0.0", "pupa": "^3.1.0", "unused-filename": "^4.0.1" } }, "sha512-USiB9816d2JzKv0LiSbreRfTg5lDk3lWh0vlx/gugCO92ZIJkHVH0UM18EHvKeadErP6Xn4yiTphWzYfbA2Ong=="],

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-8mOzCscBAuogG4tm8CroqjTX5E5yzCvTobbhKvxQP0U=",
-    "aarch64-linux": "sha256-drrRSpzxC8bfaTXBpOyaN0QAyBVV7WJzm0NstJ+8sAE=",
-    "aarch64-darwin": "sha256-YY5A/zxLPONvgnI+DZlzcD2K5Q9PIw4F2YbDxKbT4UU=",
-    "x86_64-darwin": "sha256-/c/Ew4onA+9+l6GRKXz3zWq3QFESM7j5RyGLCWRPQFw="
+    "x86_64-linux": "sha256-8hc0Typ9cA1NDpToM0Pq7q3AutSp+I80Sakthq10F4c=",
+    "aarch64-linux": "sha256-7bzI4zWOdxuoMdMHMuqIAOgnuzWiHmpdCMYCYPbs+3c=",
+    "aarch64-darwin": "sha256-EWDHUSVH2AjsNvoKvzC392H6GjCWVh07cOg2x0mAsng=",
+    "x86_64-darwin": "sha256-7b2BRdRRVG+PMCSd/cm4E+slziwWIKLVttYkotdSrK4="
  }
 }
@@ -2,7 +2,7 @@
  "$schema": "https://json.schemastore.org/package.json",
  "name": "opencode",
  "description": "AI-powered development tool",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "private": true,
  "type": "module",
  "packageManager": "bun@1.4.2",
@@ -29,6 +29,47 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))

 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.

+## Experimental evaluation
+
+Evaluation models compare shared state with typed choice, score, and boolean questions. The API is
+isolated under an experimental entrypoint and provider namespace while the contract evolves:
+
+```ts
+import { Effect } from "effect"
+import { Evaluation, EvaluationClient } from "@opencode/ai/experimental"
+import { TypeSafeAI } from "@opencode/ai/providers"
+
+const model = TypeSafeAI.configure().experimental.evaluation("jev-latest")
+
+const program = Evaluation.evaluate({
+  model,
+  state: "I was charged twice. Please refund the duplicate payment.",
+  questions: {
+    department: {
+      type: "choice",
+      instructions: "Which team should handle this?",
+      criteria: { billing: "Payments and refunds", technical: "Bugs and outages" },
+    },
+    urgency: {
+      type: "score",
+      instructions: "How urgent is this?",
+      criteria: ["Can wait", "Needs prompt attention", "Blocking revenue"],
+    },
+    refund: { type: "boolean", instructions: "Is the customer asking for a refund?" },
+  },
+})
+
+const response = await Effect.runPromise(program.pipe(Effect.provide(EvaluationClient.fetchLayer)))
+
+console.log(response.answers.department.choice)
+console.log(response.answers.refund.probability)
+```
+
+`TypeSafeAI` reads `TYPESAFE_API_KEY`. `OpenCodeZen` exposes the same selector and reads
+`OPENCODE_API_KEY`. The common API uses `boolean`; System One routes lower it to native `noul`.
+Choice and score confidence plus score legends remain available in provider metadata, and the
+provider's rounded probabilities are returned unchanged.
+
 ## Alibaba Cloud Model Studio

 `Alibaba` provides standard Model Studio inference. Configure a region explicitly, then select
@@ -1,6 +1,6 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "name": "@opencode/ai",
  "type": "module",
  "license": "MIT",
@@ -0,0 +1,29 @@
+export { EvaluationClient } from "./experimental/evaluation-client.js"
+export {
+  BooleanAnswer,
+  BooleanQuestion,
+  ChoiceAnswer,
+  ChoiceQuestion,
+  Evaluation,
+  EvaluationAnswer,
+  EvaluationInput,
+  EvaluationModel,
+  EvaluationModelSchema,
+  EvaluationQuestion,
+  EvaluationRequest,
+  EvaluationResponse,
+  EvaluationRounding,
+  ScoreAnswer,
+  ScoreQuestion,
+} from "./experimental/evaluation.js"
+export type {
+  AnswerFor,
+  AnswersFor,
+  EvaluationModelOptions,
+  EvaluationOptions,
+  EvaluationQuestions,
+  EvaluationRequestFor,
+  EvaluationRequestInput,
+  EvaluationResponseFor,
+  EvaluationRoute,
+} from "./experimental/evaluation.js"
@@ -0,0 +1,54 @@
+import { Context, Effect, Layer } from "effect"
+import { RequestExecutor } from "../route/executor.js"
+import { mergeHttpOptions, type AIError } from "../schema/index.js"
+import { sanitizeSurrogates } from "../utils/sanitize.js"
+import {
+  type EvaluationOptions,
+  type EvaluationQuestions,
+  type EvaluationRequestFor,
+  type EvaluationResponseFor,
+} from "./evaluation.js"
+
+export type Execute = RequestExecutor.Interface["execute"]
+
+export interface Interface {
+  readonly evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(
+    request: EvaluationRequestFor<Options, Questions>,
+  ) => Effect.Effect<EvaluationResponseFor<Questions>, AIError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/AI/Experimental/EvaluationClient") {}
+
+export const evaluate = <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(
+  request: EvaluationRequestFor<Options, Questions>,
+): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service> =>
+  Effect.flatMap(Service, (client) => client.evaluate(request))
+
+export const layer: Layer.Layer<Service, never, RequestExecutor.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service
+    return Service.of({
+      evaluate: (request) =>
+        request.model.route.evaluate(
+          {
+            ...sanitizeSurrogates({
+              ...request,
+              model: undefined,
+              http: mergeHttpOptions(request.model.http, request.http),
+            }),
+            model: request.model,
+          },
+          executor.execute,
+        ),
+    })
+  }),
+)
+export const fetchLayer = layer.pipe(Layer.provide(RequestExecutor.fetchLayer))
+
+export const EvaluationClient = {
+  Service,
+  layer,
+  fetchLayer,
+  evaluate,
+} as const
@@ -0,0 +1,245 @@
+import { Effect, Schema } from "effect"
+import {
+  AIError,
+  HttpOptions,
+  InvalidRequestError,
+  ModelID,
+  ProviderID,
+  ProviderMetadata,
+  Usage,
+} from "../schema/index.js"
+import { EvaluationClient, Service, type Execute } from "./evaluation-client.js"
+
+export const EvaluationInput = Schema.Union([Schema.String, Schema.JsonObject, Schema.Array(Schema.Json)])
+export type EvaluationInput = Schema.Schema.Type<typeof EvaluationInput>
+
+const EvaluationCriterion = Schema.NullOr(EvaluationInput)
+const ChoiceCriteria = Schema.Record(Schema.String, EvaluationCriterion).pipe(
+  Schema.refine((x): x is typeof x => Object.keys(x).length > 0, {
+    message: "Choice criteria must be a nonempty option map",
+  }),
+)
+
+export const ChoiceQuestion = Schema.Struct({
+  type: Schema.Literal("choice"),
+  instructions: EvaluationInput,
+  criteria: ChoiceCriteria,
+})
+export type ChoiceQuestion = Schema.Schema.Type<typeof ChoiceQuestion>
+
+export const ScoreQuestion = Schema.Struct({
+  type: Schema.Literal("score"),
+  instructions: EvaluationInput,
+  criteria: Schema.Array(EvaluationCriterion).check(Schema.isMinLength(2)),
+})
+export type ScoreQuestion = Schema.Schema.Type<typeof ScoreQuestion>
+
+export const BooleanQuestion = Schema.Struct({
+  type: Schema.Literal("boolean"),
+  instructions: EvaluationInput,
+  criteria: Schema.optional(
+    Schema.Struct({
+      true: Schema.optional(EvaluationCriterion),
+      false: Schema.optional(EvaluationCriterion),
+    }),
+  ),
+})
+export type BooleanQuestion = Schema.Schema.Type<typeof BooleanQuestion>
+
+export const EvaluationQuestion = Schema.Union([ChoiceQuestion, ScoreQuestion, BooleanQuestion]).pipe(
+  Schema.toTaggedUnion("type"),
+)
+export type EvaluationQuestion = Schema.Schema.Type<typeof EvaluationQuestion>
+export type EvaluationQuestions = Readonly<Record<string, EvaluationQuestion>>
+const EvaluationQuestions = Schema.Record(Schema.String, EvaluationQuestion).pipe(
+  Schema.refine((x): x is typeof x => Object.keys(x).length > 0, {
+    message: "Evaluation questions must be a nonempty map",
+  }),
+)
+
+const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }))
+
+export const ChoiceAnswer = Schema.Struct({
+  type: Schema.Literal("choice"),
+  choice: Schema.String,
+  probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+})
+export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswer>
+
+export const ScoreAnswer = Schema.Struct({
+  type: Schema.Literal("score"),
+  score: Schema.Number,
+  probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+})
+export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswer>
+
+export const BooleanAnswer = Schema.Struct({
+  type: Schema.Literal("boolean"),
+  probability: Probability,
+})
+export type BooleanAnswer = Schema.Schema.Type<typeof BooleanAnswer>
+
+export const EvaluationAnswer = Schema.Union([ChoiceAnswer, ScoreAnswer, BooleanAnswer]).pipe(
+  Schema.toTaggedUnion("type"),
+)
+export type EvaluationAnswer = Schema.Schema.Type<typeof EvaluationAnswer>
+
+export type AnswerFor<Question extends EvaluationQuestion> = Question extends {
+  readonly type: "choice"
+  readonly criteria: infer Criteria
+}
+  ? {
+      readonly type: "choice"
+      readonly choice: Extract<keyof Criteria, string>
+      readonly probabilities?: Readonly<Record<Extract<keyof Criteria, string>, number>>
+    }
+  : Question extends { readonly type: "score" }
+    ? ScoreAnswer
+    : BooleanAnswer
+
+export type AnswersFor<Questions extends EvaluationQuestions> = {
+  readonly [ID in keyof Questions]: AnswerFor<Questions[ID]>
+}
+
+export type EvaluationOptions = Record<string, unknown>
+
+export interface EvaluationRoute<Options extends EvaluationOptions = EvaluationOptions> {
+  readonly id: string
+  readonly evaluate: <const Questions extends EvaluationQuestions>(
+    request: EvaluationRequestFor<Options, Questions>,
+    execute: Execute,
+  ) => Effect.Effect<EvaluationResponseFor<Questions>, AIError>
+}
+
+export class EvaluationModel<Options extends EvaluationOptions = EvaluationOptions> {
+  declare protected readonly _Options: (options: Options) => Options
+  readonly id: ModelID
+  readonly provider: ProviderID
+  readonly route: EvaluationRoute<Options>
+  readonly http?: HttpOptions
+
+  constructor(input: EvaluationModel.Input<Options>) {
+    this.id = input.id
+    this.provider = input.provider
+    this.route = input.route
+    this.http = input.http
+  }
+
+  static make<Options extends EvaluationOptions = EvaluationOptions>(input: EvaluationModel.MakeInput<Options>) {
+    return new EvaluationModel<Options>({
+      id: ModelID.make(input.id),
+      provider: ProviderID.make(input.provider),
+      route: input.route,
+      http: input.http,
+    })
+  }
+}
+
+export namespace EvaluationModel {
+  export interface Input<Options extends EvaluationOptions = EvaluationOptions> {
+    readonly id: ModelID
+    readonly provider: ProviderID
+    readonly route: EvaluationRoute<Options>
+    readonly http?: HttpOptions
+  }
+
+  export interface MakeInput<Options extends EvaluationOptions = EvaluationOptions>
+    extends Omit<Input<Options>, "id" | "provider"> {
+    readonly id: string | ModelID
+    readonly provider: string | ProviderID
+  }
+}
+
+export const EvaluationModelSchema = Schema.declare(
+  (value): value is EvaluationModel => value instanceof EvaluationModel,
+  {
+    expected: "Evaluation.Model",
+  },
+)
+
+export class EvaluationRequest extends Schema.Class<EvaluationRequest>("Evaluation.Request")({
+  model: EvaluationModelSchema,
+  state: EvaluationInput,
+  questions: EvaluationQuestions,
+  options: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  http: Schema.optional(HttpOptions),
+}) {
+  declare protected readonly _EvaluationRequest: void
+}
+
+export type EvaluationModelOptions<Model> = Model extends EvaluationModel<infer Options> ? Options : never
+
+export type EvaluationRequestFor<
+  Options extends EvaluationOptions = EvaluationOptions,
+  Questions extends EvaluationQuestions = EvaluationQuestions,
+> = Omit<EvaluationRequest, "model" | "questions" | "options"> & {
+  readonly model: EvaluationModel<Options>
+  readonly questions: Questions
+  readonly options?: Options
+}
+
+export type EvaluationRequestInput<
+  Model extends object = EvaluationModel,
+  Questions extends EvaluationQuestions = EvaluationQuestions,
+> = Omit<ConstructorParameters<typeof EvaluationRequest>[0], "model" | "questions" | "options" | "http"> & {
+  readonly model: Model
+  readonly questions: Questions
+  readonly options?: NoInfer<EvaluationModelOptions<Model>>
+  readonly http?: HttpOptions.Input
+} & (Model extends EvaluationModel<EvaluationModelOptions<Model>> ? unknown : never)
+
+export class EvaluationRounding extends Schema.Class<EvaluationRounding>("Evaluation.Rounding")({
+  probabilityDecimals: Schema.optional(Schema.Int),
+  scoreDecimals: Schema.optional(Schema.Int),
+}) {}
+
+export class EvaluationResponse extends Schema.Class<EvaluationResponse>("Evaluation.Response")({
+  model: ModelID,
+  answers: Schema.Record(Schema.String, EvaluationAnswer),
+  usage: Schema.optional(Usage),
+  rounding: Schema.optional(EvaluationRounding),
+  providerMetadata: Schema.optional(ProviderMetadata),
+}) {}
+
+export type EvaluationResponseFor<Questions extends EvaluationQuestions> = Omit<EvaluationResponse, "answers"> & {
+  readonly answers: AnswersFor<Questions>
+}
+
+export function request<const Model extends object, const Questions extends EvaluationQuestions>(
+  input: EvaluationRequestInput<Model, Questions>,
+): EvaluationRequestFor<EvaluationModelOptions<Model>, Questions>
+export function request(input: EvaluationRequest): EvaluationRequest
+export function request(input: EvaluationRequest | EvaluationRequestInput) {
+  if (input instanceof EvaluationRequest) return input
+  return new EvaluationRequest({
+    ...input,
+    model: input.model as unknown as EvaluationModel,
+    http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+  })
+}
+
+export function evaluate<const Model extends object, const Questions extends EvaluationQuestions>(
+  input: EvaluationRequestInput<Model, Questions>,
+): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>
+export function evaluate(input: EvaluationRequest): Effect.Effect<EvaluationResponse, AIError, Service>
+export function evaluate(input: EvaluationRequest | EvaluationRequestInput) {
+  return Effect.try({
+    try: () => (input instanceof EvaluationRequest ? input : request(input)),
+    catch: (cause) =>
+      new AIError({
+        reason: new InvalidRequestError({
+          message: cause instanceof Error ? cause.message : String(cause),
+          cause,
+        }),
+      }),
+  }).pipe(
+    Effect.flatMap((request) =>
+      EvaluationClient.evaluate(request as EvaluationRequestFor<EvaluationOptions, EvaluationQuestions>),
+    ),
+  )
+}
+
+export const Evaluation = {
+  request,
+  evaluate,
+} as const
@@ -0,0 +1,222 @@
+import { Effect, Schema } from "effect"
+import { Headers, HttpClientRequest } from "effect/unstable/http"
+import {
+  BooleanAnswer,
+  ChoiceAnswer,
+  ChoiceQuestion,
+  EvaluationInput,
+  EvaluationModel,
+  EvaluationResponse,
+  EvaluationRounding,
+  ScoreAnswer,
+  ScoreQuestion,
+  type EvaluationResponseFor,
+  type EvaluationRoute,
+} from "./evaluation.js"
+import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
+import {
+  AIError,
+  HttpContext,
+  HttpOptions,
+  InvalidProviderOutputError,
+  InvalidRequestError,
+  ModelID,
+  Usage,
+  mergeJsonRecords,
+} from "../schema/index.js"
+
+const Noul = Schema.Struct({
+  type: Schema.Literal("noul"),
+  instructions: EvaluationInput,
+  criteria: Schema.optional(
+    Schema.Struct({
+      true: Schema.optional(Schema.NullOr(EvaluationInput)),
+      false: Schema.optional(Schema.NullOr(EvaluationInput)),
+    }),
+  ),
+})
+const Question = Schema.Union([
+  ChoiceQuestion.pipe(
+    Schema.refine((x): x is typeof x => Object.keys(x.criteria).length <= 255, {
+      message: "System One Choice questions support at most 255 options",
+    }),
+  ),
+  ScoreQuestion.pipe(
+    Schema.refine((x): x is typeof x => x.criteria.length <= 10, {
+      message: "System One Score questions support at most 10 levels",
+    }),
+  ),
+  Noul,
+])
+const Request = Schema.StructWithRest(
+  Schema.Struct({
+    model: Schema.String,
+    state: EvaluationInput,
+    questions: Schema.Record(Schema.String, Question),
+  }),
+  [Schema.Record(Schema.String, Schema.Any)],
+)
+
+const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }))
+const NoulAnswer = Schema.Struct({ type: Schema.Literal("noul"), noul: Probability })
+const Choice = Schema.Struct({
+  type: Schema.Literal("choice"),
+  choice: Schema.String,
+  probabilities: Schema.Record(Schema.String, Probability),
+  confidence: Schema.optional(Probability),
+})
+const Score = Schema.Struct({
+  type: Schema.Literal("score"),
+  score: Schema.Number,
+  probabilities: Schema.Record(Schema.String, Probability),
+  legend: Schema.optional(Schema.Record(Schema.String, Schema.Json)),
+  confidence: Schema.optional(Probability),
+})
+const NativeUsage = Schema.Struct({
+  input_tokens: Schema.optional(Schema.Number),
+  output_tokens: Schema.optional(Schema.Number),
+})
+
+const encode = Schema.encodeUnknownEffect(Schema.fromJsonString(Request))
+const exact = (x: Readonly<Record<string, unknown>>, keys: ReadonlyArray<string>) =>
+  Object.keys(x).length === keys.length && keys.every((key) => Object.hasOwn(x, key))
+
+export interface ModelInput {
+  readonly id: string | ModelID
+  readonly provider: string
+  readonly providerMetadataKey: string
+  readonly auth: AuthDefinition
+  readonly baseURL: string
+  readonly headers?: Record<string, string>
+  readonly http?: HttpOptions
+}
+
+export const model = (cfg: ModelInput) => {
+  const route: EvaluationRoute = {
+    id: "system-one",
+    evaluate: (req, send) =>
+      Effect.gen(function* () {
+        const url = new URL(`${cfg.baseURL.replace(/\/$/, "")}/systemone`)
+        Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value))
+        const body = yield* encode({
+          ...mergeJsonRecords(req.options, req.http?.body),
+          model: req.model.id,
+          state: req.state,
+          questions: Object.fromEntries(
+            Object.entries(req.questions).map(([id, x]) => [id, x.type === "boolean" ? { ...x, type: "noul" } : x]),
+          ),
+        }).pipe(
+          Effect.mapError(
+            (cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) }),
+          ),
+        )
+        const headers = yield* Auth.toEffect(cfg.auth)({
+          request: req,
+          method: "POST",
+          url: url.toString(),
+          body,
+          headers: Headers.fromInput({ ...cfg.headers, ...req.http?.headers }),
+        })
+        const res = yield* send(
+          HttpClientRequest.post(url).pipe(
+            HttpClientRequest.setHeaders(headers),
+            HttpClientRequest.bodyText(body, "application/json"),
+          ),
+        )
+        const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers })
+        const fail = (message: string, cause: unknown, body?: string) =>
+          new AIError({ reason: new InvalidProviderOutputError({ route: route.id, message, body, http, cause }) })
+        const text = yield* res.text.pipe(
+          Effect.mapError((cause) => fail("Failed to read the System One response", cause)),
+        )
+        const entries = Object.entries(req.questions)
+        const output = Schema.Struct({
+          model: Schema.String,
+          answers: Schema.Struct(
+            Object.fromEntries(
+              entries.map(([id, question]) => {
+                if (question.type === "boolean") return [id, NoulAnswer]
+                if (question.type === "choice") {
+                  const keys = Object.keys(question.criteria)
+                  return [
+                    id,
+                    Choice.pipe(
+                      Schema.refine(
+                        (x): x is typeof x =>
+                          Object.hasOwn(question.criteria, x.choice) && exact(x.probabilities, keys),
+                        { message: `Question "${id}" returned an invalid choice answer` },
+                      ),
+                    ),
+                  ]
+                }
+                const keys = question.criteria.map((_, index) => String(index))
+                return [
+                  id,
+                  Score.pipe(
+                    Schema.refine(
+                      (x): x is typeof x =>
+                        x.score >= 0 && x.score <= question.criteria.length - 1 && exact(x.probabilities, keys),
+                      { message: `Question "${id}" returned an invalid score answer` },
+                    ),
+                  ),
+                ]
+              }),
+            ) as Record<string, Schema.Codec<unknown>>,
+          ),
+          usage: Schema.optional(NativeUsage),
+        })
+        const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(output))(text).pipe(
+          Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)),
+        )
+
+        const confidence: Record<string, number> = {}
+        const legend: Record<string, Record<string, Schema.Json>> = {}
+        const answers = Object.fromEntries(
+          entries.map(([id, question]) => {
+            const answer = data.answers[id]
+            if (question.type === "boolean")
+              return [
+                id,
+                { type: "boolean", probability: (answer as typeof NoulAnswer.Type).noul } satisfies BooleanAnswer,
+              ]
+            if (question.type === "choice") {
+              const value = answer as typeof Choice.Type
+              if (value.confidence !== undefined) confidence[id] = value.confidence
+              return [
+                id,
+                { type: "choice", choice: value.choice, probabilities: value.probabilities } satisfies ChoiceAnswer,
+              ]
+            }
+            const value = answer as typeof Score.Type
+            if (value.confidence !== undefined) confidence[id] = value.confidence
+            if (value.legend !== undefined) legend[id] = value.legend
+            return [id, { type: "score", score: value.score, probabilities: value.probabilities } satisfies ScoreAnswer]
+          }),
+        )
+        const meta = {
+          ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
+          ...(Object.keys(legend).length === 0 ? {} : { legend }),
+        }
+        return new EvaluationResponse({
+          model: ModelID.make(data.model),
+          answers,
+          usage: data.usage
+            ? new Usage({
+                inputTokens: data.usage.input_tokens,
+                outputTokens: data.usage.output_tokens,
+                totalTokens:
+                  data.usage.input_tokens === undefined && data.usage.output_tokens === undefined
+                    ? undefined
+                    : (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0),
+                providerMetadata: { [cfg.providerMetadataKey]: data.usage },
+              })
+            : undefined,
+          rounding: new EvaluationRounding({ probabilityDecimals: 2, scoreDecimals: 2 }),
+          providerMetadata: Object.keys(meta).length === 0 ? undefined : { [cfg.providerMetadataKey]: meta },
+        }) as EvaluationResponseFor<typeof req.questions>
+      }),
+  }
+  return EvaluationModel.make({ id: cfg.id, provider: cfg.provider, route, http: cfg.http })
+}
+
+export const SystemOne = { model } as const
@@ -38,23 +38,13 @@ export type Settings = ProviderPackage.Settings &

 const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request: LLMRequest) {
  const { serviceTier: _, ...body } = yield* Gemini.protocol.body.from(request)
-  // Vertex's native REST schema rejects `id` on FunctionCall/FunctionResponse parts with HTTP 400,
-  // unlike AI Studio, so history minted there cannot be lowered verbatim.
-  const contents = body.contents.map((content) => ({
-    ...content,
-    parts: (content.parts ?? []).map((part) => {
-      if ("functionCall" in part) return { ...part, functionCall: { ...part.functionCall, id: undefined } }
-      if ("functionResponse" in part) return { ...part, functionResponse: { ...part.functionResponse, id: undefined } }
-      return part
-    }),
-  }))
  const value = request.providerOptions?.labels
  const labels = ProviderShared.isRecord(value)
    ? Object.fromEntries(
        Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
      )
    : undefined
-  return { ...body, contents, labels }
+  return { ...body, labels }
 })

 const protocol = {
@@ -24,8 +24,10 @@ export * as Moonshot from "./moonshot.js"
 export * as OpenAI from "./openai.js"
 export * as OpenAICompatible from "./openai-compatible.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"
+export * as OpenCodeZen from "./opencode-zen.js"
 export * as OpenRouter from "./openrouter.js"
 export * as TogetherAI from "./togetherai.js"
+export * as TypeSafeAI from "./typesafe-ai.js"
 export * as XAI from "./xai.js"
 export * as ZAI from "./zai.js"
 export * as ZAICodingPlan from "./zai-coding-plan.js"
@@ -0,0 +1,31 @@
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { SystemOne } from "../experimental/system-one.js"
+
+export const id = ProviderID.make("opencode")
+const baseURL = "https://opencode.ai/zen/v1"
+
+export type Options = ProviderAuthOption<"optional"> & {
+  readonly baseURL?: string
+  readonly headers?: Record<string, string>
+  readonly http?: HttpOptions.Input
+}
+
+export const configure = (input: Options = {}) => {
+  const evaluation = (modelID: string | ModelID) =>
+    SystemOne.model({
+      id: modelID,
+      provider: id,
+      providerMetadataKey: "opencode",
+      auth: AuthOptions.bearer(input, "OPENCODE_API_KEY"),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
+  return { id, experimental: { evaluation }, configure }
+}
+
+export const provider = configure()
+export const experimental = provider.experimental
+
+export * as OpenCodeZen from "./opencode-zen.js"
@@ -0,0 +1,31 @@
+import { HttpOptions, ProviderID, type ModelID } from "../schema/index.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { SystemOne } from "../experimental/system-one.js"
+
+export const id = ProviderID.make("typesafe-ai")
+const baseURL = "https://api.typesafe.ai/v1"
+
+export type Options = ProviderAuthOption<"optional"> & {
+  readonly baseURL?: string
+  readonly headers?: Record<string, string>
+  readonly http?: HttpOptions.Input
+}
+
+export const configure = (input: Options = {}) => {
+  const evaluation = (modelID: string | ModelID) =>
+    SystemOne.model({
+      id: modelID,
+      provider: id,
+      providerMetadataKey: "typesafe",
+      auth: AuthOptions.bearer(input, "TYPESAFE_API_KEY"),
+      baseURL: input.baseURL ?? baseURL,
+      headers: input.headers,
+      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    })
+  return { id, experimental: { evaluation }, configure }
+}
+
+export const provider = configure()
+export const experimental = provider.experimental
+
+export * as TypeSafeAI from "./typesafe-ai.js"
@@ -0,0 +1,173 @@
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { HttpClientRequest } from "effect/unstable/http"
+import { Evaluation, EvaluationClient } from "../src/experimental.js"
+import { OpenCodeZen, TypeSafeAI } from "../src/providers.js"
+import { it } from "./lib/effect.js"
+import { dynamicResponse } from "./lib/http.js"
+
+describe("experimental Evaluation", () => {
+  it.effect("evaluates typed questions through System One", () =>
+    Effect.gen(function* () {
+      const response = yield* Evaluation.evaluate({
+        model: TypeSafeAI.configure({
+          apiKey: "test",
+          baseURL: "https://typesafe.test/v1/",
+          headers: { "x-default": "yes" },
+          http: { body: { deployment: "test" }, query: { api: "v1" } },
+        }).experimental.evaluation("jev-latest"),
+        state: { ticket: "Please refund the duplicate charge." },
+        questions: {
+          department: {
+            type: "choice",
+            instructions: "Which team should handle this?",
+            criteria: { billing: "Payments and refunds", technical: "Bugs and outages" },
+          },
+          urgency: {
+            type: "score",
+            instructions: "How urgent is this?",
+            criteria: ["Can wait", "Needs attention", "Blocking"],
+          },
+          refund: { type: "boolean", instructions: "Is the customer asking for a refund?" },
+        },
+        options: { trace: { enabled: true } },
+        http: { body: { request_metadata: "value" }, headers: { "x-request": "yes" }, query: { trace: "1" } },
+      })
+
+      expect(response.model).toBe("jev-1.13.0")
+      expect(response.answers.department).toEqual({
+        type: "choice",
+        choice: "billing",
+        probabilities: { billing: 0.9, technical: 0.1 },
+      })
+      expect(response.answers.urgency).toEqual({
+        type: "score",
+        score: 1.2,
+        probabilities: { "0": 0, "1": 0.8, "2": 0.2 },
+      })
+      expect(response.answers.refund).toEqual({ type: "boolean", probability: 0.97 })
+      expect(response.usage?.totalTokens).toBe(36)
+      expect(response.providerMetadata).toEqual({
+        typesafe: {
+          confidence: { department: 0.8, urgency: 0.6 },
+          legend: { urgency: { "0": "Can wait", "1": "Needs attention", "2": "Blocking" } },
+        },
+      })
+    }).pipe(
+      Effect.provide(
+        EvaluationClient.layer.pipe(
+          Layer.provide(
+            dynamicResponse((input) =>
+              Effect.gen(function* () {
+                const request = yield* HttpClientRequest.toWeb(input.request).pipe(Effect.orDie)
+                expect(request.url).toBe("https://typesafe.test/v1/systemone?api=v1&trace=1")
+                expect(request.headers.get("authorization")).toBe("Bearer test")
+                expect(request.headers.get("x-default")).toBe("yes")
+                expect(request.headers.get("x-request")).toBe("yes")
+                expect(JSON.parse(input.text)).toEqual({
+                  deployment: "test",
+                  request_metadata: "value",
+                  trace: { enabled: true },
+                  model: "jev-latest",
+                  state: { ticket: "Please refund the duplicate charge." },
+                  questions: {
+                    department: {
+                      type: "choice",
+                      instructions: "Which team should handle this?",
+                      criteria: { billing: "Payments and refunds", technical: "Bugs and outages" },
+                    },
+                    urgency: {
+                      type: "score",
+                      instructions: "How urgent is this?",
+                      criteria: ["Can wait", "Needs attention", "Blocking"],
+                    },
+                    refund: { type: "noul", instructions: "Is the customer asking for a refund?" },
+                  },
+                })
+                return input.respond(
+                  JSON.stringify({
+                    model: "jev-1.13.0",
+                    answers: {
+                      department: {
+                        type: "choice",
+                        choice: "billing",
+                        probabilities: { billing: 0.9, technical: 0.1 },
+                        confidence: 0.8,
+                      },
+                      urgency: {
+                        type: "score",
+                        score: 1.2,
+                        probabilities: { "0": 0, "1": 0.8, "2": 0.2 },
+                        legend: { "0": "Can wait", "1": "Needs attention", "2": "Blocking" },
+                        confidence: 0.6,
+                      },
+                      refund: { type: "noul", noul: 0.97 },
+                    },
+                    usage: { input_tokens: 30, output_tokens: 6 },
+                  }),
+                  { headers: { "content-type": "application/json" } },
+                )
+              }),
+            ),
+          ),
+        ),
+      ),
+    ),
+  )
+
+  it.effect("configures the OpenCode Zen System One endpoint", () =>
+    Evaluation.evaluate({
+      model: OpenCodeZen.configure({ apiKey: "zen-key", baseURL: "https://zen.test/v1" }).experimental.evaluation(
+        "jev-1.13",
+      ),
+      state: "hello",
+      questions: { greeting: { type: "boolean", instructions: "Is this a greeting?" } },
+    }).pipe(
+      Effect.tap((response) =>
+        Effect.sync(() => {
+          expect(response.answers.greeting.probability).toBe(0.99)
+          expect(response.usage?.providerMetadata).toEqual({
+            opencode: { input_tokens: 10, output_tokens: 2 },
+          })
+        }),
+      ),
+      Effect.provide(
+        EvaluationClient.layer.pipe(
+          Layer.provide(
+            dynamicResponse((input) => {
+              expect(input.request.url).toBe("https://zen.test/v1/systemone")
+              expect(input.request.headers.authorization).toBe("Bearer zen-key")
+              return Effect.succeed(
+                input.respond(
+                  JSON.stringify({
+                    model: "jev-1.13.0",
+                    answers: { greeting: { type: "noul", noul: 0.99 } },
+                    usage: { input_tokens: 10, output_tokens: 2 },
+                  }),
+                  { headers: { "content-type": "application/json" } },
+                ),
+              )
+            }),
+          ),
+        ),
+      ),
+    ),
+  )
+
+  it.effect("rejects malformed questions before network I/O", () =>
+    Effect.gen(function* () {
+      const error = yield* Evaluation.evaluate({
+        model: TypeSafeAI.experimental.evaluation("jev-latest"),
+        state: "hello",
+        questions: { score: { type: "score", instructions: "How much?", criteria: ["only"] } },
+      }).pipe(Effect.flip)
+      expect(error.reason._tag).toBe("InvalidRequest")
+    }).pipe(
+      Effect.provide(
+        EvaluationClient.layer.pipe(
+          Layer.provide(dynamicResponse(() => Effect.die("invalid evaluation reached the network"))),
+        ),
+      ),
+    ),
+  )
+})
@@ -0,0 +1,60 @@
+import { Effect } from "effect"
+import { Evaluation, EvaluationClient, EvaluationModel, type EvaluationRoute } from "../src/experimental.js"
+import type { Service } from "../src/experimental/evaluation-client.js"
+import { OpenCodeZen, TypeSafeAI } from "../src/providers.js"
+
+type Requirements<T> = T extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
+type Success<T> = T extends Effect.Effect<infer A, infer _E, infer _R> ? A : never
+type Equal<A, B> = [A, B] extends [B, A] ? true : false
+type Assert<T extends true> = T
+
+const model = TypeSafeAI.configure({ apiKey: "test" }).experimental.evaluation("jev-latest")
+const request = Evaluation.request({
+  model,
+  state: { ticket: "refund" },
+  questions: {
+    topic: {
+      type: "choice",
+      instructions: "Which team?",
+      criteria: { billing: null, support: { includes: ["help"] } },
+    },
+    severity: { type: "score", instructions: "How severe?", criteria: ["Low", "High"] },
+    refund: { type: "boolean", instructions: "Refund?" },
+  },
+})
+
+const result = EvaluationClient.evaluate(request)
+type Result = Success<typeof result>
+type Choice = Assert<Equal<Result["answers"]["topic"]["choice"], "billing" | "support">>
+type ClientRequirements = Assert<Equal<Requirements<typeof result>, Service>>
+void (true satisfies Choice)
+void (true satisfies ClientRequirements)
+
+Effect.gen(function* () {
+  const response = yield* Evaluation.evaluate({
+    model: OpenCodeZen.experimental.evaluation("jev-1.13"),
+    state: ["hello"],
+    questions: { greeting: { type: "boolean", instructions: "Greeting?" } },
+  })
+  response.answers.greeting.probability satisfies number
+  // @ts-expect-error Boolean answers do not contain a selected choice.
+  response.answers.greeting.choice
+  // @ts-expect-error Unknown question IDs are not exposed.
+  response.answers.missing
+})
+
+declare const route: EvaluationRoute<{ readonly temperature?: number }>
+const custom = EvaluationModel.make({ id: "custom", provider: "custom", route })
+Evaluation.evaluate({
+  model: custom,
+  state: "hello",
+  questions: { ok: { type: "boolean", instructions: "OK?" } },
+  options: { temperature: 0.5 },
+})
+// @ts-expect-error Selected evaluation models retain their request option types.
+Evaluation.evaluate({
+  model: custom,
+  state: "hello",
+  questions: { ok: { type: "boolean", instructions: "OK?" } },
+  options: { temperature: "high" },
+})
@@ -8,9 +8,11 @@ import {
  CloudflareWorkersAI,
  DeepSeek,
  Fireworks,
+  OpenCodeZen,
  OpenAI,
  OpenAICompatible,
  OpenRouter,
+  TypeSafeAI,
  XAI,
 } from "@opencode/ai/providers"
 import {
@@ -23,6 +25,7 @@ import {
 } from "@opencode/ai/protocols"
 import * as AnthropicMessages from "@opencode/ai/protocols/anthropic-messages"
 import { TestLLM } from "@opencode/ai/testing"
+import { Evaluation, EvaluationClient } from "@opencode/ai/experimental"

 describe("public exports", () => {
  test("root exposes app-facing runtime APIs", () => {
@@ -37,6 +40,9 @@ describe("public exports", () => {
    expect(TestLLM.layer).toBeFunction()
    expect(TestLLM.testLayer).toBeFunction()
    expect(TestLLM.Test.of).toBeFunction()
+    expect(Evaluation.evaluate).toBeFunction()
+    expect(EvaluationClient.layer).toBeDefined()
+    expect(EvaluationClient.fetchLayer).toBeDefined()
  })

  test("route barrel exposes route-authoring APIs", () => {
@@ -66,6 +72,8 @@ describe("public exports", () => {
    expect(CloudflareWorkersAI.configure).toBeFunction()
    expect(CloudflareWorkersAI.configure({ accountId: "fixture", apiKey: "fixture" }).model).toBeFunction()
    expect(OpenRouter.model).toBeFunction()
+    expect(TypeSafeAI.experimental.evaluation).toBeFunction()
+    expect(OpenCodeZen.experimental.evaluation).toBeFunction()
    expect(XAI.model).toBeFunction()
    expect(XAI.provider.responses).toBe(XAI.responses)
    expect(XAI.provider.chat).toBe(XAI.chat)
@@ -1,9 +1,13 @@
 {
  "version": 1,
  "metadata": {
-    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
+    "tags": [
+      "prefix:google-vertex",
+      "provider:google-vertex",
+      "protocol:gemini"
+    ],
    "name": "google-vertex/calls-a-tool",
-    "recordedAt": "2026-08-23T17:21:51.036Z"
+    "recordedAt": "2026-09-22T03:46:29.725Z"
  },
  "interactions": [
    {
@@ -21,7 +25,7 @@
        "headers": {
          "content-type": "text/event-stream"
        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"functionCall\": {\"name\": \"lookup_weather\",\"args\": {\"city\": \"Paris\"},\"id\": \"call_425130\"},\"thoughtSignature\": \"AY89a1+1fXnLgYhHMuN3Ak6LBhT6PcrYOW7iPav4LfsacvG/Z6l1yJ+AsU7vWhFj/JyPIbsJJQ+GjohM9sCIZ6nqUOIg3reo/7osmrCvFrVHedTHQcwiPzoz2Kp3gb+uWjFAXxk1EX4IRAKcu0ox1W/Z9PpuZvHkTerGO2a82e02N6MAF1YhhtbXFvSdqLRih2Os68rdOk5/Bcld7ol8qUgeyIZ3CtI3OJ5jwRcD8LjvK33A7ZFzH5Bxp/peUmXvqnu5iNhnGBxZaJy/vupCtxRZxjaS+ojG0/UhyrnRiKIpbzQ0FBkxePPn8GCX/LOe2y3GUc98co8lN8OOuCd9ZmEdx5AjHmQkPO9fAV9SxG6Bda6SDWVL8o/Uz3WSQYoUEfAdoajEWIBvcisoeCJjb7zgmRRZ9VQSPl3RXj5LFRvX8jn0YKV1CahYbc24jA==\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:50.308576Z\",\"responseId\": \"LiyLauDqErCErb8Pj8aWkAs\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 39,\"candidatesTokenCount\": 16,\"totalTokenCount\": 102,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 39}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 16}],\"thoughtsTokenCount\": 47},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:50.308576Z\",\"responseId\": \"LiyLauDqErCErb8Pj8aWkAs\"}\r\n\r\n"
+        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"functionCall\": {\"name\": \"lookup_weather\",\"args\": {\"city\": \"Paris\"},\"id\": \"call_28936\"},\"thoughtSignature\": \"AY89a1/MVeBxtwu9l/96clFobOrrd7Q5MTf5o8/A22fc++1EsFYVeCFx9WCGmJ+D3yW3FWlRXKtJECYfprSoxixCSOYBNiV9g8/IkejbAxF26k1vxTsHkoqts0O2s8GqqBSRAavJfKQ/taTRbPuIq+b+RKZ8SDJFoWDnFjXpdS5S164uJTjmgs4ALd8oB1oQRycMsTbAY51TmkcNUnhARpjKQfqiizz4KfSRFjx7xDnza0v4jj73m2GV86eLDhVT7trIT+Dl5DsJt6RBLOE2Amse54mcpIbsYaANlY1YDU6FKuUBqnuwpl0OfhMXwWuYMogv1tH/0rTXsqNwmHyt/b9ZZXqYCdFXpMGt8udmoZ0d\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:28.953809Z\",\"responseId\": \"FPqxatGbOsSorb8PtY2z8Q4\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 39,\"candidatesTokenCount\": 16,\"totalTokenCount\": 93,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 39}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 16}],\"thoughtsTokenCount\": 38},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:28.953809Z\",\"responseId\": \"FPqxatGbOsSorb8PtY2z8Q4\"}\r\n\r\n"
      }
    }
  ]
@@ -1,9 +1,13 @@
 {
  "version": 1,
  "metadata": {
-    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
+    "tags": [
+      "prefix:google-vertex",
+      "provider:google-vertex",
+      "protocol:gemini"
+    ],
    "name": "google-vertex/continues-after-a-tool-result",
-    "recordedAt": "2026-08-23T17:21:51.853Z"
+    "recordedAt": "2026-09-22T03:46:30.691Z"
  },
  "interactions": [
    {
@@ -14,14 +18,14 @@
        "headers": {
          "content-type": "application/json"
        },
-        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"model\",\"parts\":[{\"functionCall\":{\"name\":\"lookup_weather\",\"args\":{\"city\":\"Paris\"}},\"thoughtSignature\":\"skip_thought_signature_validator\"}]},{\"role\":\"user\",\"parts\":[{\"functionResponse\":{\"name\":\"lookup_weather\",\"response\":{\"name\":\"lookup_weather\",\"content\":\"18C, light rain\"}}}]}],\"tools\":[{\"functionDeclarations\":[{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"required\":[\"city\"],\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}}}]}]}"
+        "body": "{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"model\",\"parts\":[{\"functionCall\":{\"id\":\"call_paris_1\",\"name\":\"lookup_weather\",\"args\":{\"city\":\"Paris\"}},\"thoughtSignature\":\"skip_thought_signature_validator\"}]},{\"role\":\"user\",\"parts\":[{\"functionResponse\":{\"id\":\"call_paris_1\",\"name\":\"lookup_weather\",\"response\":{\"name\":\"lookup_weather\",\"content\":\"18C, light rain\"}}}]}],\"tools\":[{\"functionDeclarations\":[{\"name\":\"lookup_weather\",\"description\":\"Look up the current weather for a city\",\"parameters\":{\"required\":[\"city\"],\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}}}}]}]}"
      },
      "response": {
        "status": 200,
        "headers": {
          "content-type": "text/event-stream"
        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"The weather in Paris is currently 18°C with light rain.\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:51.220919Z\",\"responseId\": \"LyyLave9DbWnrb8P1IjLmQQ\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a197c+fpHJftPtcufnqMAyoRQKVEQK+KeG+RVHVx2wKil3L4jP4YWvfVbcuOFr2jio4Kre/hCrDANAoMFSvaZrdaPeo1b5bXQSmJKMH03yM5M6q6ME6JiBvXym143U4exIde4UbOh2tMeyXMvB3aWxcavIHd78g5G5QPLreo6A3LO5871cYYVeRwteY+/zbEdqfaAq1hlk6WYpWkNljYpjMyKwr15YC8rFLh3HYayS9tTN++GGrk/reZn6C3OEPlzPou/pXRATzcEAGVl/TW\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 59,\"candidatesTokenCount\": 15,\"totalTokenCount\": 98,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 59}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 15}],\"thoughtsTokenCount\": 24},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:51.220919Z\",\"responseId\": \"LyyLave9DbWnrb8P1IjLmQQ\"}\r\n\r\n"
+        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"The weather\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:29.830958Z\",\"responseId\": \"Ffqxau7bMoCOrb8P_Iu5sA0\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \" in Paris is currently 18°C with light rain.\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:29.830958Z\",\"responseId\": \"Ffqxau7bMoCOrb8P_Iu5sA0\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a18aVI8Uxr2VaOI822u0DyuQdy4B00uhLnjqYb5Qb6Mkscccm018knLtYThB5UX8dRv1VFsORSQ0Qo6Gx9RCng2AK9EPce7p\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 59,\"candidatesTokenCount\": 15,\"totalTokenCount\": 74,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 59}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 15}]},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:29.830958Z\",\"responseId\": \"Ffqxau7bMoCOrb8P_Iu5sA0\"}\r\n\r\n"
      }
    }
  ]
@@ -1,9 +1,13 @@
 {
  "version": 1,
  "metadata": {
-    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
+    "tags": [
+      "prefix:google-vertex",
+      "provider:google-vertex",
+      "protocol:gemini"
+    ],
    "name": "google-vertex/streams-text",
-    "recordedAt": "2026-08-23T17:21:50.112Z"
+    "recordedAt": "2026-09-22T03:46:28.840Z"
  },
  "interactions": [
    {
@@ -21,7 +25,7 @@
        "headers": {
          "content-type": "text/event-stream"
        },
-        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"Hello\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:48.528714Z\",\"responseId\": \"LCyLasqiIO6crb8P1sDboQc\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a1+BGsRqlGpfT0psLB4jeTkT5rDV2HFOlrRuF7aVxDOjqNVUku6t4azeSnxpd+msHWuwXj4RS+7gmVlzVs+JNi8uj+iZWTBCi71vSh9kdK9ed/sHv9J7uL9ZWSOcgbhX/hxdXaUp5yVbQzHFXPjR9A/IkEkHV8VKarDZVFE1T1uASia74lkmyBeZZz+DQmRsLwbUHzFUKlF3qnk/SliLo21ZgASd7itlALQ0PBLJZwgeI3g7tDscDSE18hnB11Fky8q7MLd3HY16zbDvHBEMb18pmmPelPI01KdrCIwMSou/01/u5jiSUCc3pFksZawUj3tAHocHSC3ZKAQQQuUXGe5tm61C2E40/NANBeePc1S4HYE6Yo/vtX6tE02LDky5IQWX09H6+DZ7fpopP5nCUfcKPHa3hVjYquWYYMtZgXO4ZpxfVd3lt1VUDuJNN3BMMCZapjBoJZFPXPJ5t/yg9Rnd791+msGH77b4wztz1vtsPrT9oV9g6SDo9ZUH6BaOcbK7fw8FaXcGw+55malEwQy6zpRLGecooBu70p6RwhaAUyKIMX49y+F2hkNxQxDeBUNckJnu6n4w+KLyjP+bR0gqPJbGjVfteHm+QujqjJdBBT/m1u9kPo1nIbzdEs/PIADBdbuV7TkD/HoRFKpLnNmM2no8ioTtFEjKBDz4ippGi15r8pGgA6wIb/1HAvOGh+PVERdGcbelVTgfONwBqjQ7B1wmEizCfyYuMIskfwjxDGayfKlpDxrnNeogtEct9u5/DjEKlURlg9MtmW1B9P8BXYJ+7SCiRJWwW6bzB+5C+MLCnETl/mljDizoJMHK8DKIhI4oxBsrWXEuoHFwEwGIeOZq0BofH2Jz/l6+KIboV/zd581Kk0zPg/rlI6acfjUEtXtbF+t0+jzoJN7006x4i2tqXeJZ+4e5yisSArEsfJ0YzNWoJtBHG9V9/euDcEP3+jsr98efaQaQbLMPvT/Hb7CYQ7ChhGfcGxQ=\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 7,\"candidatesTokenCount\": 1,\"totalTokenCount\": 150,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 7}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 1}],\"thoughtsTokenCount\": 142},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-08-23T17:21:48.528714Z\",\"responseId\": \"LCyLasqiIO6crb8P1sDboQc\"}\r\n\r\n"
+        "body": "data: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"Hello\"}]}}],\"usageMetadata\": {\"trafficType\": \"ON_DEMAND\"},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:26.748531Z\",\"responseId\": \"EvqxavPXLbqerb8P1eSViQs\"}\r\n\r\ndata: {\"candidates\": [{\"content\": {\"role\": \"model\",\"parts\": [{\"text\": \"\",\"thoughtSignature\": \"AY89a18msz0aRAZc4U/Zl7rEXjdTJsE0EWee1+hD2dT7h711q6uIRem7KWCLlji7JVSu2hDV1L8uFh8SGAO5jU4MBSZ+mq661EVXf9DZBF1CV+fetSpCUggurbYHWGGGvLRxjI96W0wR93EMoV/1pLHa4fgGVcFupoFsz/3n9J3wCkT4pRvHjn+hC7V11aSMI07t/OUeo1ssAziob9apuB+HUm2/EO17ph9TZvg3rydE5J0nmJ+DnYGLl5FfQJHgnnsjR5qaKs5wVNIKNA811lv/K5Iee/O6gMNXI3GAcGUvPKHMD5oQSs5B343blFUiqw47H1WZ9KWBoLXhVcnss6hLPmpDchInVhr3ObAHQhZIaBDBnhQR6nuc5BtgoFnwWw3w5G1yNNFt3qT3c75Rd/8NamdtveyskDbrHxQ5GkUo7ICuE/3SQG0yqWhVDjakYgVqjLG3BTKRg6I/dT5+VCeQbdxTZ+ScWkJfXYDEnlZlTjMLz2FS+B+9Zwez/1Dy/pm9H51jvuXI942kv31DfDVcTTwvKmb3SqIB9D4aomb16gDAywC7I4L/+ZwsqmcQoUvVtHGEe5NL3r6fgWtWzKht+60ZgBalmzdBfhZHd/bDXvTAX7SVpHraXjfpcdGrtv1LhU6Kr3gol94TR5Xh9dWKNhwR0s6at7MNCpj3eG9ogrWkmYSiqNeVT1ovscWvH70tDCtCNwY5sIUJVUSWdHc2OdzFxNIPkzh9OuHIn0o9Dbmup6obFoQOgi587HA/Sqvre9pDVqVMzn7w57naDmg+lsR9wS67BxbV4tVrvvfeVQAQQRft5SmSu7WCBnaWuM2/o890nE5ynFG+M2FqApJLgdfXozOguo/hROrD3WxLUyT8+FDsoCY8ky6YYTaF3OlOHpuD5Zmw4UGSdDbcEzhc6cRqBAYfMpxzN58VwNRrjG/MGTY3jrvOLJDk3sF7URa7Tn5YuRLp/2jL5YKWF2QftWiW9jl1YeORYQwNdLBuRK9L4/WOxNRWhYZToAJfwT4byh5dKzY8OnjeFcJy8RVvuRpoYeQY1P63ie/K1D3TgJEwKQXylLdPwtZRGM/P5sm2dcf5F+lRfZGufmv+Q++unrqWr6uv3IlgVGKPa8zTh+ipSaik7taKd+jertOSYkgjrrUfjC0/oyg5giuNqXh+ebIxQC7TMX8bManc5N3aomFuYXmIJ4iT/euQctq8N3gPPWmUNmrnXztdEZgpQdV2ahj+yRr1yxCriOfRo3Az3oPMPEaXxrqDc8RoWt/lOgzzp7KfBGoOVzYdvaDGr8MhsZ8Pd7HD0vZW8TNSl8R7cEK3G5EotNA+s6lF/n/RH5ewmg3cQK8bnnZ4oNjqYo3pGtw+H2rbefMMzAk4mybGe9uDqSdhWJgBzRGsMXRW+0atn9tuJTu6vPNn9asNvwXS0lcvpQskbe5sK3yhzyFzqwrJxs7Ji6yiu6kOtsQ5Girzk1835A2Zun6ZegGtQH8DbgIPdSBMkh6kypndBu4ns2gg97g9yB8XFGbv3c60sxaXPRuycl9IjBL81Yy6n6PCOBx7Pqm9xrzPn7QzgtetKxCmNUMYJvF+myiQFrMdL1w+1DD7FoZX9VNBDbNWgcfhgnL8tlHSmTb36KnScJOe8D+3n3+aDfkWpiHjrLrGJsHlaek/Ji2Cgwa0dIC6EhQitNttskIKVMa+yD6D1T6Dvz/eolnutjYwbGb3y9mtpQzmVwf2Zp2dzxYRWZk=\"}]},\"finishReason\": \"STOP\"}],\"usageMetadata\": {\"promptTokenCount\": 7,\"candidatesTokenCount\": 1,\"totalTokenCount\": 285,\"trafficType\": \"ON_DEMAND\",\"promptTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 7}],\"candidatesTokensDetails\": [{\"modality\": \"TEXT\",\"tokenCount\": 1}],\"thoughtsTokenCount\": 277},\"modelVersion\": \"gemini-3.5-flash\",\"createTime\": \"2026-09-22T03:46:26.748531Z\",\"responseId\": \"EvqxavPXLbqerb8P1eSViQs\"}\r\n\r\n"
      }
    }
  ]
@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "jev-1.13-free",
+    "tags": [
+      "prefix:opencode-zen-evaluation",
+      "provider:opencode",
+      "protocol:system-one"
+    ],
+    "name": "opencode-zen-evaluation/evaluates-choice-score-and-boolean-questions",
+    "recordedAt": "2026-09-22T03:44:57.511Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://opencode.ai/zen/v1/systemone",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"jev-1.13-free\",\"state\":\"I was charged twice for the same invoice. Please refund the duplicate payment today.\",\"questions\":{\"department\":{\"type\":\"choice\",\"instructions\":\"Which team should handle this support request?\",\"criteria\":{\"billing\":\"Payments, invoices, refunds, or failed charges\",\"technical\":\"Bugs, outages, or integrations\",\"sales\":\"Pricing, upgrades, or new accounts\"}},\"urgency\":{\"type\":\"score\",\"instructions\":\"How urgent is this support request?\",\"criteria\":[\"Can wait for normal support\",\"Needs prompt attention\",\"Actively blocking revenue\"]},\"refund\":{\"type\":\"noul\",\"instructions\":\"Is the customer asking for a refund?\"}}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"jev-1.13-free\",\"answers\":{\"department\":{\"type\":\"choice\",\"choice\":\"billing\",\"confidence\":1,\"probabilities\":{\"technical\":0,\"sales\":0,\"billing\":1}},\"urgency\":{\"type\":\"score\",\"score\":1.02,\"confidence\":0.95,\"legend\":{\"0\":\"Can wait for normal support\",\"1\":\"Needs prompt attention\",\"2\":\"Actively blocking revenue\"},\"probabilities\":{\"0\":0,\"1\":0.97,\"2\":0.03}},\"refund\":{\"type\":\"noul\",\"noul\":0.99}},\"usage\":{\"input_tokens\":422,\"output_tokens\":69}}"
+      }
+    }
+  ]
+}
@@ -0,0 +1,33 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "jev-latest",
+    "tags": [
+      "prefix:typesafe-evaluation",
+      "provider:typesafe-ai",
+      "protocol:system-one"
+    ],
+    "name": "typesafe-evaluation/evaluates-choice-score-and-boolean-questions",
+    "recordedAt": "2026-09-22T03:44:28.626Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.typesafe.ai/v1/systemone",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"jev-latest\",\"state\":\"I was charged twice for the same invoice. Please refund the duplicate payment today.\",\"questions\":{\"department\":{\"type\":\"choice\",\"instructions\":\"Which team should handle this support request?\",\"criteria\":{\"billing\":\"Payments, invoices, refunds, or failed charges\",\"technical\":\"Bugs, outages, or integrations\",\"sales\":\"Pricing, upgrades, or new accounts\"}},\"urgency\":{\"type\":\"score\",\"instructions\":\"How urgent is this support request?\",\"criteria\":[\"Can wait for normal support\",\"Needs prompt attention\",\"Actively blocking revenue\"]},\"refund\":{\"type\":\"noul\",\"instructions\":\"Is the customer asking for a refund?\"}}}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"jev-1.13.0\",\"answers\":{\"department\":{\"type\":\"choice\",\"choice\":\"billing\",\"confidence\":1.0,\"probabilities\":{\"billing\":1.0,\"sales\":0.0,\"technical\":0.0}},\"urgency\":{\"type\":\"score\",\"score\":1.01,\"confidence\":0.97,\"legend\":{\"0\":\"Can wait for normal support\",\"1\":\"Needs prompt attention\",\"2\":\"Actively blocking revenue\"},\"probabilities\":{\"0\":0.0,\"1\":0.98,\"2\":0.02}},\"refund\":{\"type\":\"noul\",\"noul\":0.99}},\"usage\":{\"input_tokens\":422,\"output_tokens\":69}}"
+      }
+    }
+  ]
+}
@@ -0,0 +1,79 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Evaluation } from "../../src/experimental.js"
+import { OpenCodeZen, TypeSafeAI } from "../../src/providers.js"
+import { recordedTests } from "../recorded-test.js"
+
+const questions = {
+  department: {
+    type: "choice",
+    instructions: "Which team should handle this support request?",
+    criteria: {
+      billing: "Payments, invoices, refunds, or failed charges",
+      technical: "Bugs, outages, or integrations",
+      sales: "Pricing, upgrades, or new accounts",
+    },
+  },
+  urgency: {
+    type: "score",
+    instructions: "How urgent is this support request?",
+    criteria: ["Can wait for normal support", "Needs prompt attention", "Actively blocking revenue"],
+  },
+  refund: { type: "boolean", instructions: "Is the customer asking for a refund?" },
+} as const
+
+const state = "I was charged twice for the same invoice. Please refund the duplicate payment today."
+
+const typesafe = recordedTests({
+  prefix: "typesafe-evaluation",
+  provider: "typesafe-ai",
+  protocol: "system-one",
+  requires: ["TYPESAFE_API_KEY"],
+  metadata: { model: "jev-latest" },
+})
+
+const zen = recordedTests({
+  prefix: "opencode-zen-evaluation",
+  provider: "opencode",
+  protocol: "system-one",
+  requires: ["OPENCODE_API_KEY"],
+  metadata: { model: "jev-1.13-free" },
+})
+
+describe("experimental Evaluation recorded", () => {
+  typesafe.effect("evaluates choice score and boolean questions", () =>
+    assertEvaluation(
+      TypeSafeAI.configure({ apiKey: process.env.TYPESAFE_API_KEY ?? "fixture" }).experimental.evaluation("jev-latest"),
+      "typesafe",
+    ),
+  )
+
+  zen.effect("evaluates choice score and boolean questions", () =>
+    assertEvaluation(
+      OpenCodeZen.configure({ apiKey: process.env.OPENCODE_API_KEY ?? "fixture" }).experimental.evaluation(
+        "jev-1.13-free",
+      ),
+      "opencode",
+    ),
+  )
+})
+
+const assertEvaluation = (
+  model: ReturnType<typeof TypeSafeAI.experimental.evaluation>,
+  metadataKey: "typesafe" | "opencode",
+) =>
+  Effect.gen(function* () {
+    const response = yield* Evaluation.evaluate({ model, state, questions })
+    expect(response.model).toStartWith("jev-")
+    expect(response.answers.department.type).toBe("choice")
+    expect(response.answers.department.choice).toBe("billing")
+    expect(response.answers.department.probabilities?.billing).toBeGreaterThan(0.5)
+    expect(response.answers.urgency.type).toBe("score")
+    expect(response.answers.urgency.score).toBeGreaterThanOrEqual(0)
+    expect(response.answers.urgency.score).toBeLessThanOrEqual(2)
+    expect(response.answers.refund.type).toBe("boolean")
+    expect(response.answers.refund.probability).toBeGreaterThan(0.5)
+    expect(response.usage?.inputTokens).toBeGreaterThan(0)
+    expect(response.usage?.outputTokens).toBeGreaterThan(0)
+    expect(response.providerMetadata?.[metadataKey]?.confidence).toBeDefined()
+  })
@@ -114,7 +114,7 @@ describe("Google Vertex providers", () => {
    }),
  )

-  it.effect("strips function call ids Vertex does not accept from lowered bodies", () =>
+  it.effect("preserves function call ids in lowered Vertex bodies", () =>
    Effect.gen(function* () {
      const prepared = yield* compileRequest(
        LLM.request({
@@ -142,15 +142,14 @@ describe("Google Vertex providers", () => {
        }),
      )

-      expect(JSON.stringify(prepared.body.contents)).not.toContain('"id"')
      expect(prepared.body.contents).toMatchObject([
-        { role: "model", parts: [{ functionCall: { id: undefined, name: "lookup", args: { query: "weather" } } }] },
+        { role: "model", parts: [{ functionCall: { id: "call_1", name: "lookup", args: { query: "weather" } } }] },
        {
          role: "user",
          parts: [
            {
              functionResponse: {
-                id: undefined,
+                id: "call_1",
                name: "lookup",
                response: { name: "lookup", content: "sunny" },
              },
@@ -235,12 +234,23 @@ describe("Google Vertex providers", () => {
          parts: [
            { text: "Thinking.", thought: true, thoughtSignature: "reasoning_sig" },
            { text: "Checking.", thoughtSignature: "text_sig" },
-            { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
+            {
+              functionCall: { id: "provider_call_1", name: "lookup", args: { query: "weather" } },
+              thoughtSignature: "tool_sig",
+            },
          ],
        },
        {
          role: "user",
-          parts: [{ functionResponse: { name: "lookup", response: { name: "lookup", content: "sunny" } } }],
+          parts: [
+            {
+              functionResponse: {
+                id: "provider_call_1",
+                name: "lookup",
+                response: { name: "lookup", content: "sunny" },
+              },
+            },
+          ],
        },
      ])
    }),
@@ -6,6 +6,8 @@ import * as path from "node:path"
 import { fileURLToPath } from "node:url"
 import { LLMClient, RequestExecutor } from "../src/route.js"
 import { ImageClient } from "../src/image-client.js"
+import { EvaluationClient } from "../src/experimental/evaluation-client.js"
+import type { Service as EvaluationClientService } from "../src/experimental/evaluation-client.js"
 import type { Service as ImageClientService } from "../src/image-client.js"
 import type { Service as LLMClientService } from "../src/route/client.js"
 import type { Service as RequestExecutorService } from "../src/route/executor.js"
@@ -18,7 +20,12 @@ import {
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings")

-type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService | Socket.WebSocketConstructor
+type RecordedEnv =
+  | RequestExecutorService
+  | LLMClientService
+  | ImageClientService
+  | EvaluationClientService
+  | Socket.WebSocketConstructor

 type RecordedTestsOptions = RecordedGroupOptions & {
  readonly options?: HttpRecorder.RecorderOptions
@@ -92,6 +99,7 @@ export const recordedTests = (options: RecordedTestsOptions) =>
        requestExecutor,
        LLMClient.layer.pipe(Layer.provide(requestExecutor)),
        ImageClient.layer.pipe(Layer.provide(requestExecutor)),
+        EvaluationClient.layer.pipe(Layer.provide(requestExecutor)),
        webSocket,
      )
    },
@@ -19,6 +19,13 @@ export function mountBrowserPane() {
      session: "Alpha",
      mounted: true,
      visible: true,
+      url: undefined as string | undefined,
+      loading: false,
+      generation: 0,
+      delayNavigation: false,
+      pendingURL: undefined as string | undefined,
+      loadErrors: {} as Record<string, string | undefined>,
+      error: undefined as string | undefined,
      layouts: {} as Record<string, BrowserPaneLayout | undefined>,
    })
    const tabs = ["Alpha", "Beta"].map((name) => ({
@@ -47,13 +54,33 @@ export function mountBrowserPane() {
      opened: () => !!registrations.get(store.session),
      state: () => ({ tabs: tabs.filter((tab) => tab.title === store.session), focusedTabID: null }),
      tabs: () => tabs.filter((tab) => tab.title === store.session),
-      active: () => tabs.find((tab) => tab.title === store.session) ?? tabs[0],
+      active: () => {
+        const tab = tabs.find((tab) => tab.title === store.session) ?? tabs[0]
+        return {
+          ...tab,
+          url: store.url ?? tab.url,
+          loading: store.loading,
+          generation: store.generation,
+          loadError: store.loadErrors[store.session],
+        }
+      },
      registration: () => registrations.get(store.session),
-      error: () => undefined,
+      error: () => store.error ?? (store.loadErrors[store.session] ? "Request failed" : undefined),
      suspended: () => false,
      close: () => undefined,
      open: () => undefined,
-      command: () => undefined,
+      command: (command) => {
+        setStore("error", undefined)
+        if (command.type === "navigate" || command.type === "reload") setStore("loadErrors", store.session, undefined)
+        if (command.type === "navigate") {
+          if (store.delayNavigation) {
+            setStore("pendingURL", command.url)
+            return
+          }
+          setStore({ url: command.url, loading: false, generation: store.generation + 1 })
+        }
+        if (command.type === "stop") setStore("loading", false)
+      },
    }
    return (
      <>
@@ -64,6 +91,32 @@ export function mountBrowserPane() {
            {(name) => <button onClick={() => setStore({ session: name, mounted: name !== "Empty" })}>{name}</button>}
          </For>
          <button onClick={() => setStore("mounted", false)}>Unmount pane</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: false })}>Blank page</button>
+          <button onClick={() => setStore({ url: "about:blank", loading: true })}>Loading page</button>
+          <button
+            onClick={() =>
+              setStore({ loading: true, generation: store.generation + 1, loadErrors: { [store.session]: undefined } })
+            }
+          >
+            Load current page
+          </button>
+          <button onClick={() => setStore("loadErrors", store.session, "ERR_CONNECTION_REFUSED")}>Failed page</button>
+          <button onClick={() => setStore("delayNavigation", true)}>Delay navigation</button>
+          <button onClick={() => setStore({ error: "ERR_BLOCKED_BY_CLIENT", pendingURL: undefined })}>
+            Block navigation
+          </button>
+          <button
+            onClick={() =>
+              setStore({
+                url: store.pendingURL,
+                pendingURL: undefined,
+                loading: false,
+                generation: store.generation + 1,
+              })
+            }
+          >
+            Complete navigation
+          </button>
          <button onClick={() => setStore("visible", (visible) => !visible)}>Toggle Review tab</button>
        </nav>
        <div style={{ width: "640px", height: "360px", border: "1px solid #555" }}>
@@ -57,3 +57,153 @@ story("hides the native view immediately while the pane stays mounted", async ({
  await toggle.click()
  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
 })
+
+story("shows the empty state over a blank native page and restores navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByText('Or prompt "Open in the app browser"', { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
+
+story("keeps Stop available and hides the empty state while a blank page loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Loading page", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await root.getByRole("button", { name: "Stop", exact: true }).click()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("keeps the submitted URL visible until the browser reports navigation", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Blank page", exact: true }).click()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://example.com/")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await address.fill("https://unsubmitted.example/")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("restores the current URL when a submitted navigation is blocked", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://blocked.example/")
+  await address.press("Enter")
+  await expect(address).toHaveValue("https://blocked.example/")
+  await root.getByRole("button", { name: "Block navigation", exact: true }).click()
+  await expect(root.getByText("ERR_BLOCKED_BY_CLIENT", { exact: true })).toBeVisible()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("shows a themed failure state for only the failed tab and allows retry", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await expect(root.getByText("Check the URL and your connection, then try again.", { exact: true })).toBeVisible()
+  await expect(root.getByText("Request failed", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+  await expect(root.getByRole("textbox", { name: "Browser address", exact: true })).toHaveValue(
+    "https://alpha.example/",
+  )
+
+  await root.getByRole("button", { name: "Beta", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Beta")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Alpha", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+
+  await root.getByRole("button", { name: "Reload", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+})
+
+story("returns a failed tab to the empty state when an empty URL is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Failed page", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeVisible()
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("")
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByText("URL can't be reached", { exact: true })).toBeHidden()
+  await expect(root.getByText("Enter URL", { exact: true })).toBeVisible()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeDisabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "false")
+})
+
+story("selects the full URL when the address field gains focus", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://alpha.example/".length)
+  await address.pressSequentially("https://example.com/")
+  await expect(address).toHaveValue("https://example.com/")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await address.focus()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+  await address.press("ArrowRight")
+  await address.click()
+  await expect(address).toHaveJSProperty("selectionStart", 0)
+  await expect(address).toHaveJSProperty("selectionEnd", "https://example.com/".length)
+})
+
+story("keeps the current page visible while a submitted URL loads", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  await root.getByRole("button", { name: "Delay navigation", exact: true }).click()
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("https://example.com/")
+  await address.press("Enter")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+
+  await root.getByRole("button", { name: "Load current page", exact: true }).click()
+  await expect(root.getByRole("button", { name: "Stop", exact: true })).toBeEnabled()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await root.getByRole("button", { name: "Complete navigation", exact: true }).click()
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(address).toHaveValue("https://example.com/")
+})
+
+story("keeps the current page and restores its URL when an empty address is submitted", async ({ page }) => {
+  const root = page.getByTestId("browser-pane-fixture")
+  const address = root.getByRole("textbox", { name: "Browser address", exact: true })
+  await address.fill("")
+  await address.press("Enter")
+  await expect(address).not.toBeFocused()
+  await expect(address).toHaveValue("https://alpha.example/")
+  await expect(root.getByTestId("native-Alpha")).toHaveAttribute("data-visible", "true")
+  await expect(root.getByText("Enter URL", { exact: true })).toBeHidden()
+  await expect(root.getByRole("button", { name: "Reload", exact: true })).toBeEnabled()
+})
@@ -17,14 +17,12 @@ const milestones = [
  "electronSpawnStarted",
  "debugEndpointReady",
  "electronStarted",
+  "layersReady",
+  "windowVisible",
  "serviceEnsureStarted",
  "serviceSpawnRequested",
  "serviceReady",
-  "backgroundLoadingReady",
  "rendererViteConnected",
-  "rendererInitializationStarted",
-  "rendererInitializationReady",
-  "windowVisible",
  "homeReady",
 ] as const
 const phases = [
@@ -128,14 +126,12 @@ const milestonePatterns: ReadonlyArray<{ name: Milestone; text: string }> = [
  { name: "electronSpawnStarted", text: "starting electron app..." },
  { name: "debugEndpointReady", text: "DevTools listening on ws://" },
  { name: "electronStarted", text: "app starting" },
+  { name: "layersReady", text: "layers ready" },
+  { name: "windowVisible", text: "main window visible" },
  { name: "serviceEnsureStarted", text: "starting v2 background service" },
  { name: "serviceSpawnRequested", text: "v2 CLI background service starting" },
  { name: "serviceReady", text: "v2 CLI background service ready" },
-  { name: "backgroundLoadingReady", text: "loading task finished" },
  { name: "rendererViteConnected", text: "[vite] connected." },
-  { name: "rendererInitializationStarted", text: "awaiting server ready" },
-  { name: "rendererInitializationReady", text: "server ready" },
-  { name: "windowVisible", text: "main window visible" },
 ]

 async function createColdProfile() {
@@ -404,14 +400,12 @@ function requireMilestones(observed: Partial<Record<Milestone, number>>) {
    electronSpawnStarted: get("electronSpawnStarted"),
    debugEndpointReady: get("debugEndpointReady"),
    electronStarted: get("electronStarted"),
+    layersReady: get("layersReady"),
+    windowVisible: get("windowVisible"),
    serviceEnsureStarted: get("serviceEnsureStarted"),
    serviceSpawnRequested: get("serviceSpawnRequested"),
    serviceReady: get("serviceReady"),
-    backgroundLoadingReady: get("backgroundLoadingReady"),
    rendererViteConnected: get("rendererViteConnected"),
-    rendererInitializationStarted: get("rendererInitializationStarted"),
-    rendererInitializationReady: get("rendererInitializationReady"),
-    windowVisible: get("windowVisible"),
    homeReady: get("homeReady"),
  }
 }
@@ -20,14 +20,12 @@ describe("desktop startup benchmark", () => {
      ["electronSpawnStarted", "starting electron app..."],
      ["debugEndpointReady", "DevTools listening on ws://"],
      ["electronStarted", "app starting"],
+      ["layersReady", "layers ready"],
+      ["windowVisible", "main window visible"],
      ["serviceEnsureStarted", "starting v2 background service"],
      ["serviceSpawnRequested", "v2 CLI background service starting"],
      ["serviceReady", "v2 CLI background service ready"],
-      ["backgroundLoadingReady", "loading task finished"],
      ["rendererViteConnected", "[vite] connected."],
-      ["rendererInitializationStarted", "awaiting server ready"],
-      ["rendererInitializationReady", "server ready"],
-      ["windowVisible", "main window visible"],
    ] as const
    cases.forEach(([milestone, line]) => {
      expect(milestoneForLine(`\u001b[32m${line}\u001b[39m`)).toBe(milestone)
@@ -58,14 +56,12 @@ function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample
    electronSpawnStarted: 7,
    debugEndpointReady: 8,
    electronStarted: 9,
-    serviceEnsureStarted: 10,
-    serviceSpawnRequested: 11,
-    serviceReady: 12,
-    backgroundLoadingReady: 13,
-    rendererViteConnected: 14,
-    rendererInitializationStarted: 15,
-    rendererInitializationReady: 16,
-    windowVisible: 17,
+    layersReady: 10,
+    windowVisible: 11,
+    serviceEnsureStarted: 12,
+    serviceSpawnRequested: 13,
+    serviceReady: 14,
+    rendererViteConnected: 15,
    homeReady: commandToHomeReadyMs,
  }
  return {
@@ -80,8 +76,8 @@ function sample(run: number, commandToHomeReadyMs: number): DesktopStartupSample
      electronStartup: 2,
      serviceSpawnWait: 1,
      serviceProcessStartup: 1,
-      rendererStartup: commandToHomeReadyMs - 14,
-      visibleWindowToHome: commandToHomeReadyMs - 17,
+      rendererStartup: commandToHomeReadyMs - 15,
+      visibleWindowToHome: commandToHomeReadyMs - 11,
    },
    service: { version: "2.0.0-local-test", url: "http://127.0.0.1:3000", pid: run },
  }
@@ -0,0 +1,145 @@
+import { base64Encode } from "@opencode/util/encode"
+import { expect, test } from "@playwright/test"
+import { mockOpenCodeServer } from "../utils/mock-server"
+import { expectSessionTitle } from "../utils/waits"
+
+const directory = "C:/OpenCode/BtwSidebar"
+const projectID = "proj_btw_sidebar"
+const sessionID = "ses_btw_sidebar"
+const otherSessionID = "ses_btw_sidebar_other"
+const title = "Side question session"
+const otherTitle = "Other side question session"
+const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const sessionHref = (id: string) => `/server/${base64Encode(server)}/session/${id}`
+
+test.use({ viewport: { width: 1440, height: 900 } })
+
+test("answers /btw in the side panel without admitting a prompt", async ({ page }) => {
+  const generations: { sessionID: string; prompt: string }[] = []
+  const prompts: unknown[] = []
+  const generated = Promise.withResolvers<void>()
+  await mockOpenCodeServer(page, {
+    directory,
+    project: {
+      id: projectID,
+      worktree: directory,
+      vcs: "git",
+      name: "btw-sidebar",
+      time: { created: 1700000000000, updated: 1700000000000 },
+      sandboxes: [],
+    },
+    provider: {
+      all: [
+        {
+          id: "opencode",
+          name: "OpenCode",
+          models: { test: { id: "test", name: "Test", limit: { context: 200_000 } } },
+        },
+      ],
+      connected: ["opencode"],
+      default: { providerID: "opencode", modelID: "test" },
+    },
+    sessions: [
+      {
+        id: sessionID,
+        slug: sessionID,
+        projectID,
+        directory,
+        title,
+        version: "dev",
+        time: { created: 1700000000000, updated: 1700000000000 },
+      },
+      {
+        id: otherSessionID,
+        slug: otherSessionID,
+        projectID,
+        directory,
+        title: otherTitle,
+        version: "dev",
+        time: { created: 1700000001000, updated: 1700000001000 },
+      },
+    ],
+    pageMessages: () => ({ items: [] }),
+    vcsDiff: [],
+    onPrompt: (input) => prompts.push(input),
+    generate: async (input) => {
+      generations.push(input)
+      if (input.sessionID === otherSessionID) return { text: "This answer belongs to the **other session**." }
+      await generated.promise
+      return {
+        text: "The retry loop uses **exponential backoff** and stops after three attempts.\n\n```ts\nconst delay = 2 ** attempt\n```",
+      }
+    },
+  })
+  await page.addInitScript(
+    ({ directory, server, sessionID, otherSessionID }) => {
+      localStorage.setItem(
+        "opencode.global.dat:server",
+        JSON.stringify({
+          projects: { local: [{ worktree: directory, expanded: true }] },
+          lastProject: { local: directory },
+        }),
+      )
+      localStorage.setItem(
+        "opencode.window.browser.dat:tabs",
+        JSON.stringify([
+          { type: "session", server, sessionId: sessionID },
+          { type: "session", server, sessionId: otherSessionID },
+        ]),
+      )
+    },
+    { directory, server, sessionID, otherSessionID },
+  )
+
+  await page.goto(sessionHref(sessionID))
+  await expectSessionTitle(page, title)
+  const editor = page.locator('[data-component="composer-editor"]')
+  await expect(editor).toBeEditable()
+
+  await editor.fill("/btw")
+  const suggestion = page.locator('[data-suggestion-id="session.btw"]')
+  await expect(suggestion).toBeVisible()
+  await suggestion.click()
+  await expect(editor).toHaveText("/btw ")
+  await editor.press("Enter")
+
+  const panel = page.locator('[data-slot="session-btw-panel"]')
+  await expect(panel).toBeHidden()
+  await expect(page.getByText("Add a question after /btw", { exact: true })).toBeVisible()
+  expect(generations).toEqual([])
+  expect(prompts).toEqual([])
+
+  await editor.fill("/btw how does the retry loop work?")
+  await editor.press("Enter")
+
+  const tab = page.getByRole("tab", { name: "/btw" })
+  await expect(panel).toBeVisible()
+  await expect(panel.getByRole("textbox")).toHaveCount(0)
+  await expect(panel.getByRole("status")).toContainText("Working")
+  await expect(tab).toHaveAttribute("data-selected", "")
+  generated.resolve()
+  await expect(panel.getByText("how does the retry loop work?", { exact: true })).toBeVisible()
+  await expect(panel.getByText("exponential backoff", { exact: false })).toBeVisible()
+  await expect(panel.getByText("const delay = 2 ** attempt", { exact: true })).toBeVisible()
+  expect(generations).toHaveLength(1)
+  expect(generations[0]?.sessionID).toBe(sessionID)
+  expect(generations[0]?.prompt).toContain("how does the retry loop work?")
+  expect(prompts).toEqual([])
+  await expect(editor).toHaveText("")
+
+  await page.locator(`[data-titlebar-tab-link][href="${sessionHref(otherSessionID)}"]`).click()
+  await expectSessionTitle(page, otherTitle)
+  await editor.fill("/btw what belongs here?")
+  await editor.press("Enter")
+  await expect(panel.getByText("other session", { exact: false })).toBeVisible()
+
+  await page.locator(`[data-titlebar-tab-link][href="${sessionHref(sessionID)}"]`).click()
+  await expectSessionTitle(page, title)
+  await expect(panel.getByText("exponential backoff", { exact: false })).toBeVisible()
+  await expect(panel.getByText("other session", { exact: false })).toHaveCount(0)
+
+  await page.reload()
+  await expectSessionTitle(page, title)
+  await expect(page.getByRole("tab", { name: "/btw" })).toHaveCount(0)
+  await expect(page.locator('[data-slot="session-btw-panel"]')).toHaveCount(0)
+})
@@ -2,6 +2,8 @@ import { expect, test } from "@playwright/test"
 import { fixture, pageMessages } from "../smoke/session-timeline.fixture"
 import { mockOpenCodeServer } from "../utils/mock-server"

+test.use({ permissions: ["clipboard-read", "clipboard-write"] })
+
 test.beforeEach(async ({ page }) => {
  const sessions = fixture.sessions.map((session) => ({ ...session }))
  await mockOpenCodeServer(page, {
@@ -95,7 +97,7 @@ test("renames and closes the session tab from its context menu", async ({ page }
  await expect(tab).toBeFocused()
  await tab.press("Shift+F10")
  await page.getByRole("menuitem", { name: "Rename", exact: true }).click()
-  const input = page.locator('[data-slot="tab-title"][contenteditable="true"]')
+  const input = page.locator('[data-slot="tab-title"][contenteditable="plaintext-only"]')
  await expect(input).toBeFocused()
  await input.fill("Renamed from tab")
  await input.press("Enter")
@@ -112,6 +114,28 @@ test("renames and closes the session tab from its context menu", async ({ page }
  ).toBeVisible()
 })

+test("pastes rich text into the session tab title as plain text", async ({ page }) => {
+  const tab = page.locator('[data-slot="titlebar-tabs"] a').filter({ hasText: fixture.expected.targetTitle })
+  await tab.click({ button: "right" })
+  await page.getByRole("menuitem", { name: "Rename", exact: true }).click()
+  const input = page.locator('[data-slot="tab-title"][contenteditable="plaintext-only"]')
+  await expect(input).toBeFocused()
+  await page.evaluate(async () => {
+    await navigator.clipboard.write([
+      new ClipboardItem({
+        "text/html": new Blob(['<span style="font-size: 48px">Rich title</span>'], { type: "text/html" }),
+        "text/plain": new Blob(["Rich title"], { type: "text/plain" }),
+      }),
+    ])
+  })
+  await input.press("ControlOrMeta+A")
+  await input.press("ControlOrMeta+V")
+  await expect(input).toHaveText("Rich title")
+  await expect(input.locator("*")).toHaveCount(0)
+  await input.press("Enter")
+  await expect(page.getByRole("heading", { name: "Rich title", exact: true })).toBeVisible()
+})
+
 test("renames an inactive tab without switching sessions", async ({ page }) => {
  await page.getByRole("button", { name: "Home", exact: true }).click()
  await page.locator('[data-component="home-session-row"]').filter({ hasText: fixture.expected.sourceTitle }).click()
@@ -119,7 +143,7 @@ test("renames an inactive tab without switching sessions", async ({ page }) => {
  const tab = page.locator('[data-slot="titlebar-tabs"] a').filter({ hasText: fixture.expected.targetTitle })
  await tab.click({ button: "right" })
  await page.getByRole("menuitem", { name: "Rename", exact: true }).click()
-  const input = page.locator('[data-slot="tab-title"][contenteditable="true"]')
+  const input = page.locator('[data-slot="tab-title"][contenteditable="plaintext-only"]')
  await expect(input).toBeFocused()
  await input.fill("Inactive tab renamed")
  await input.press("Tab")
@@ -71,7 +71,7 @@ for (const direction of ["ltr", "rtl"] as const) {
    const shifted = await content.evaluate((element) => getComputedStyle(element).translate)
    await content.evaluate((element) => element.setAttribute("data-summary-motion", ""))
    // Keep issuing resize events before the idle timer expires, including crossing the width cutoff.
-    for (const width of [1520, 1280, 1600]) {
+    for (const width of [1520, 1280, 1800]) {
      await page.setViewportSize({ width, height: 900 })
      await expect(panel).toHaveAttribute("data-summary-resizing", "true")
      await page.clock.runFor(100)
@@ -84,6 +84,7 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(content).toHaveAttribute("data-summary-motion", "transitionrun,transitionend,")
    await expect(content).not.toHaveCSS("translate", shifted)
    await page.setViewportSize({ width: 1440, height: 900 })
+    await expect(panel).toHaveAttribute("data-summary-resizing", "false")
    await expect(content).toHaveCSS("translate", shifted)

    await content.evaluate((element) => element.setAttribute("data-summary-motion", ""))
@@ -112,7 +113,8 @@ for (const direction of ["ltr", "rtl"] as const) {
    await expect(summary).toBeVisible()

    await page.setViewportSize({ width: 1800, height: 900 })
-    await expect(content).toHaveCSS("translate", "0px")
+    await expect(panel).toHaveAttribute("data-summary-resizing", "false")
+    await expect(content).toHaveCSS("translate", "none")
    await expect(summary).toBeVisible()

    await page.emulateMedia({ reducedMotion: "reduce" })
@@ -116,7 +116,7 @@ test("single-server settings expose scoped pages without a server picker", async
  await expect(connection.getByRole("heading", { name: "Connection", exact: true })).toBeVisible()
  await expect(connection.locator('[data-component="settings-list"]')).toHaveCSS("padding-left", "16px")
  await expect(connection.locator(".settings-servers-row")).toHaveCSS("padding-top", "20px")
-  await expect(connection.locator(".settings-servers-lead")).toHaveCSS("column-gap", "4px")
+  await expect(connection.locator(".settings-servers-lead")).toHaveCSS("column-gap", "10px")
  await expect(connection.locator(".settings-servers-copy")).toHaveCSS("row-gap", "6px")
  await expect(settings.getByRole("heading", { name: "Preferences", exact: true })).toBeVisible()
  await expect(settings.getByText("Terminal shell", { exact: true })).toBeVisible()
@@ -197,6 +197,13 @@ const Group = HttpApiGroup.make("mock")
      success: Json,
    }),
  )
+  .add(
+    HttpApiEndpoint.post("sessionGenerate", "/api/session/:sessionID/generate", {
+      params: SessionParams,
+      payload: Schema.Struct({ prompt: Schema.String }),
+      success: Json,
+    }),
+  )
  .add(
    HttpApiEndpoint.post("sessionSwitchAgent", "/api/session/:sessionID/agent", {
      params: SessionParams,
@@ -42,6 +42,7 @@ export interface MockServerConfig {
  sessionStatus?: Record<string, unknown> | (() => Record<string, unknown>)
  inbox?: unknown[] | (() => unknown[])
  onPrompt?: (input: { sessionID: string; body: Record<string, unknown> }) => void
+  generate?: (input: { sessionID: string; prompt: string }) => { text: string } | Promise<{ text: string }>
  onInboxChange?: (input: { sessionID: string; inboxID: string; action: "cancel" | "steer" | "queue" }) => void
 }

@@ -456,6 +457,12 @@ function mockHandlers(config: MockServerConfig, state: { cursors: Map<string, st
              },
            }
          }),
+        sessionGenerate: (ctx) =>
+          Effect.promise(async () => ({
+            data: (await config.generate?.({ sessionID: ctx.params.sessionID, prompt: ctx.payload.prompt })) ?? {
+              text: "Side-question answer",
+            },
+          })),
        sessionInboxCancel: (ctx) =>
          Effect.sync(() =>
            config.onInboxChange?.({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID, action: "cancel" }),
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "description": "",
  "type": "module",
  "exports": {
@@ -10,8 +10,7 @@
    "./i18n/desktop-native": "./src/runtime/i18n/desktop-native.ts",
    "./updater": "./src/shell/updates/types.ts",
    "./wsl/types": "./src/servers/wsl/types.ts",
-    "./ssh": "./src/servers/ssh/types.ts",
-    "./ssh/schema": "./src/servers/ssh/schema.ts",
+    "./ssh": "./src/servers/ssh/types.ts",
    "./vite": "./vite.js",
    "./index.css": "./src/index.css"
  },
@@ -95,4 +94,3 @@
    "tailwindcss": "4.3.3"
  }
 }
-
@@ -0,0 +1,32 @@
+import { describe, expect, test } from "bun:test"
+import { parseClientSlashCommand } from "./client-slash-command"
+
+const options = [
+  { id: "session.btw", trigger: "btw", arguments: true, type: "builtin" as const },
+  { id: "custom.btw", trigger: "custom", type: "custom" as const },
+  { id: "model.choose", trigger: "model", type: "builtin" as const },
+]
+
+describe("parseClientSlashCommand", () => {
+  test("parses inline and multiline arguments", () => {
+    expect(parseClientSlashCommand(options, "/btw why this approach?")).toEqual({
+      id: "session.btw",
+      input: "why this approach?",
+    })
+    expect(parseClientSlashCommand(options, "/btw\nwhy this approach?")).toEqual({
+      id: "session.btw",
+      input: "why this approach?",
+    })
+  })
+
+  test("accepts a bare argument command", () => {
+    expect(parseClientSlashCommand(options, "/btw")).toEqual({ id: "session.btw", input: "" })
+  })
+
+  test("rejects prefixes, custom commands, and ordinary slash commands", () => {
+    expect(parseClientSlashCommand(options, "/btwx nope")).toBeUndefined()
+    expect(parseClientSlashCommand(options, "/custom nope")).toBeUndefined()
+    expect(parseClientSlashCommand(options, "/model opus")).toBeUndefined()
+    expect(parseClientSlashCommand(options, "ask /btw later")).toBeUndefined()
+  })
+})
@@ -0,0 +1,24 @@
+type ClientSlashCommand = {
+  id: string
+  trigger: string
+  arguments?: boolean
+  type: "builtin" | "custom"
+}
+
+export function parseSlashCommand(text: string) {
+  if (!text.startsWith("/")) return
+  const separator = text.search(/\s/)
+  const name = text.slice(1, separator === -1 ? undefined : separator)
+  return { name, input: separator === -1 ? "" : text.slice(separator).trim() }
+}
+
+export function parseClientSlashCommand(options: readonly ClientSlashCommand[], text: string) {
+  const command = parseSlashCommand(text)
+  if (!command) return
+  const option = options.find((item) => item.type === "builtin" && item.arguments && item.trigger === command.name)
+  if (!option) return
+  return {
+    id: option.id,
+    input: command.input,
+  }
+}
@@ -24,6 +24,7 @@ import { createComposerHistory } from "./history/store"
 import { composerPlaceholder } from "./placeholder"
 import { createComposerSubmit } from "./submit"
 import { useAttachmentDestination } from "./attachments/destination"
+import { parseClientSlashCommand } from "./client-slash-command"

 export type ComposerModel = ComposerEditorModel & {
  readonly model: ComposerControls["model"]
@@ -73,9 +74,7 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      return [...result, path]
    }, [])
  })
-  const attachments = createMemo(() =>
-    prompt.current().filter(isAttachment),
-  )
+  const attachments = createMemo(() => prompt.current().filter(isAttachment))
  const commentCount = createMemo(() => {
    if (mode() === "shell") return 0
    return prompt.context.items().filter((item) => !!item.comment?.trim()).length
@@ -242,6 +241,7 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
        trigger: item.slash!,
        title: item.title,
        description: item.description,
+        arguments: item.slashArguments,
        type: "builtin" as const,
      })),
  ])
@@ -299,6 +299,11 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      clear: comments.clear,
      restore: restoreHistoryComments,
    },
+    clientCommand: (text) => {
+      const selected = parseClientSlashCommand(slashCommands(), text)
+      if (!selected) return
+      return () => command.trigger(selected.id, "slash", selected.input)
+    },
  })
  const controller = createComposerEditor({
    store: prompt.store,
@@ -340,6 +345,7 @@ export function createComposerModel(adapter: ComposerAdapter, options?: { queue?
      if (item.kind !== "command") return
      const selected = slashCommands().find((entry) => entry.id === item.id)
      if (!selected || selected.type === "custom") return
+      if (selected.arguments) return
      return () => command.trigger(selected.id, "slash")
    },
    attachments: {
@@ -3,19 +3,7 @@ import { checksum } from "@opencode/util/encode"
 import { SessionMessage } from "@opencode/schema/session-message"
 import { Skill } from "@opencode/schema/skill"
 import { Persistence } from "@/runtime/persistence/schema"
-// Effect twins of workspaces/files/types until this module moves to plain codecs.
-const SelectedLineRange = Persistence.struct({
-  start: Schema.Number,
-  end: Schema.Number,
-  side: Persistence.optional(Schema.Literals(["additions", "deletions"])),
-  endSide: Persistence.optional(Schema.Literals(["additions", "deletions"])),
-})
-const FileSelection = Persistence.struct({
-  startLine: Schema.Number,
-  startChar: Schema.Number,
-  endLine: Schema.Number,
-  endChar: Schema.Number,
-})
+import { FileSelection, SelectedLineRange } from "@/workspaces/files/types"

 const PartBase = {
  content: Schema.String,
@@ -240,5 +228,3 @@ export const PromptHistoryEntry = Schema.Union([HistoryEntry, HistoryPrompt]).pi
 export type PromptHistoryEntry = typeof PromptHistoryEntry.Type

 export const PromptHistoryState = Persistence.struct({ entries: Persistence.array(PromptHistoryEntry) })
-
-
@@ -54,14 +54,17 @@ function submitInput(
  mode: "normal" | "shell" = "normal",
  commands: () => readonly { name: string }[] | undefined = () => [],
  history: string[] = [],
+  clientCommand?: (text: string) => (() => void | Promise<void>) | undefined,
 ) {
  return createComposerSubmit({
    adapter,
    mode: () => mode,
    commands,
+    clientCommand,
    editor: () => undefined,
    queueScroll() {},
-    addToHistory: (prompt) => history.push(`add:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
+    addToHistory: (prompt) =>
+      history.push(`add:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
    removeFromHistory: (prompt) =>
      history.push(`remove:${prompt.map((part) => ("content" in part ? part.content : part.type)).join("")}`),
    resetHistory() {},
@@ -118,6 +121,61 @@ function session(input: {
 }

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

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

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

 const submitting = new WeakSet<object>()

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

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

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

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

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

 async function buildSubmissionRequest(session: ComposerSession, value: ComposerSubmission) {
  const images = await Promise.all(
-    value.images.map(async (attachment) => ({ ...attachment, dataUrl: await blobDataUrl(attachment.blob, attachment.mime) })),
+    value.images.map(async (attachment) => ({
+      ...attachment,
+      dataUrl: await blobDataUrl(attachment.blob, attachment.mime),
+    })),
  )
  return buildPromptRequest({
    prompt: value.prompt,
@@ -11,15 +11,15 @@ import { Persist, persisted } from "@/runtime/persistence/storage"
 import { showToast } from "@/shell/notifications/toast"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { createResource } from "solid-js"
-import { Codec } from "@/runtime/persistence/codec"
-
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"
 import type { HomeController } from "../model"
 import { useGlobal } from "@/runtime/server/runtime"
-
+import { SessionTransfer } from "@opencode/schema/session-transfer"
 import { useSshAuthenticate } from "@/servers/ssh/authenticate"

-export const HomeServersSchema = Codec.struct({
-  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
+export const HomeServersSchema = Schema.Struct({
+  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
 })

 export function createHomeProjectsController(home: HomeController) {
@@ -114,13 +114,8 @@ export function createHomeProjectsController(home: HomeController) {
              extensions: ["json"],
            },
            async (file) => {
-              // Validating an imported file is the one place the shared Effect schema is needed here.
-              const [{ Schema }, { SessionTransfer }] = await Promise.all([
-                import("effect"),
-                import("@opencode/schema/session-transfer"),
-              ])
-              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
-                await file.text(),
+              const data = await Schema.decodeUnknownPromise(Schema.fromJsonString(SessionTransfer.Data))(
+                await file.text(),
              )
              const api = home.server.context(conn).sdk.api.session
              const imported = await api.import({
@@ -189,4 +184,3 @@ export function createHomeProjectsController(home: HomeController) {
 }

 export type HomeProjectsController = ReturnType<typeof createHomeProjectsController>
-
@@ -47,7 +47,7 @@ export function HomeCommandPalette(props: {
    state.cleanup = undefined
    dialog.close()
    if (item.type === "command") {
-      item.option?.onSelect?.("palette")
+      void item.option?.onSelect?.("palette")
      return
    }
    if (item.type === "session") props.onSelectSession(item)
@@ -65,14 +65,14 @@
  }

  /* Keep the 1000px conversation intact, with 320px for the summary and its gutters.
-     Move only as far as needed; wider panels already have enough space in the margin. */
-  @container session-chat (min-width: 1320px) {
+     When they overlap, center the conversation in the space that remains beside the summary. */
+  @container session-chat (min-width: 1320px) and (width < 1640px) {
    [data-slot="session-chat-panel"][data-summary-open="true"]
      :is([data-timeline-virtual-content], [data-component="session-composer-dock"] > div) {
-      --session-summary-translate: min(0px, calc(50cqi - 820px));
+      --session-summary-translate: -160px;

      &:dir(rtl) {
-        --session-summary-translate: max(0px, calc(820px - 50cqi));
+        --session-summary-translate: 160px;
      }
    }
  }
@@ -5,7 +5,7 @@ import { Show, Suspense, createMemo, createSignal, lazy, onMount } from "solid-j
 import { createStore } from "solid-js/store"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { debounce } from "@solid-primitives/scheduled"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
 import createPresence from "solid-presence"
 import { Composer } from "@/composer/composer"
 import { ComposerDropzone } from "@/composer/dropzone"
@@ -21,6 +21,7 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { useProviders } from "@/providers/catalog/providers"
 import { NEW_SESSION_CONTENT_WIDTH } from "@/new-session/layout"
 import { Persist, persisted } from "@/runtime/persistence/storage"
+import { Persistence } from "@/runtime/persistence/schema"
 import type { NewSessionWorkspaceController } from "./workspace/controller"
 import { NewSessionWordmark } from "./wordmark"
 import { SummaryPopover } from "@/session/summary/popover"
@@ -33,12 +34,12 @@ const NewSessionSummary = lazy(async () => {

 const providerTipDismissalDuration = 30 * 24 * 60 * 60 * 1000

-export const WorkspaceOnboardingSchema = Codec.struct({
-  used: Codec.boolean,
+export const WorkspaceOnboardingSchema = Persistence.struct({
+  used: Schema.Boolean,
 })

-export const ProviderTipSchema = Codec.struct({
-  dismissedAt: Codec.number,
+export const ProviderTipSchema = Persistence.struct({
+  dismissedAt: Schema.Finite,
 })

 export const WorkspaceTipSchema = ProviderTipSchema
@@ -266,4 +267,3 @@ function NewSessionTips(props: { workspaceEligible: boolean; onWorkspace: () =>
    </Show>
  )
 }
-
@@ -1,6 +1,7 @@
 import { useData } from "@/runtime/server/current"
 import { useServerSDK } from "@/runtime/server/client"
 import { normalizeProviderList } from "@/runtime/server/global-sync/utils"
+import { Iterable, pipe } from "effect"
 import { createEffect, createMemo, type Accessor } from "solid-js"
 import type { ProviderListResponse } from "@/runtime/server/types"
 import { useIntegrations } from "./integrations"
@@ -52,24 +53,34 @@ export function useProviders(directory: Accessor<string | undefined>) {
        .filter((integration) => popularProviderSet.has(integration.id))
        .map((integration) => ({ id: integration.id, name: integration.name }))
      const seen = new Set(catalog.map((integration) => integration.id))
-      const more = [...providers().all.values()]
-        .filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id))
-        .map((p) => ({ id: p.id, name: p.name }))
-      return [...catalog, ...more]
+      return pipe(
+        providers().all,
+        Iterable.map(([, p]) => p),
+        Iterable.filter((p) => popularProviderSet.has(p.id) && !seen.has(p.id)),
+        Iterable.map((p) => ({ id: p.id, name: p.name })),
+        (v) => [...catalog, ...v],
+      )
    },
    connected: () => {
      const connected = new Set(providers().connected)
-      return [...providers().all.values()].filter((p) => connected.has(p.id))
+      return pipe(
+        providers().all,
+        Iterable.map(([, p]) => p),
+        Iterable.filter((p) => connected.has(p.id)),
+        (v) => Array.from(v),
+      )
    },
    paid: () => {
      const connected = new Set(providers().connected)
-      const paid = [...providers().all].filter(
-        ([id]) =>
-          connected.has(id) &&
-          (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
-      )
+      const paid = [
+        ...Iterable.filter(
+          providers().all,
+          ([id]) =>
+            connected.has(id) &&
+            (id !== "opencode" || Object.values(providers().all.get(id)?.models ?? {}).some((m) => m.cost?.input)),
+        ),
+      ]
      return paid
    },
  }
 }
-
@@ -3,11 +3,12 @@ import { base64Encode } from "@opencode/util/encode"
 import { useParams } from "@solidjs/router"
 import { batch, createEffect, createMemo, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema, SchemaGetter } from "effect"
 import { useModels } from "@/providers/models/models"
 import { useSettings } from "@/settings/model"
 import { useProviders } from "@/providers/catalog/providers"
 import { Persist, persisted } from "@/runtime/persistence/storage"
+import { Persistence } from "@/runtime/persistence/schema"
 import { hasCustomAgent, resolveAgent } from "./agent"
 import { cycleModelVariant, getConfiguredAgentVariant, resolveModelVariant } from "./variant"
 import { useWorkspaceLocation } from "@/workspaces/location"
@@ -17,45 +18,46 @@ import { useServerSDK } from "@/runtime/server/client"
 import { ScopedKey, type ServerScope } from "@/runtime/server/scope"
 import { useConfiguredModel } from "./configured"

-const ModelKeySchema = Codec.struct({
-  providerID: Codec.string,
-  modelID: Codec.string,
-  variant: Codec.optional(Codec.string),
+const ModelKeySchema = Schema.Struct({
+  providerID: Schema.String,
+  modelID: Schema.String,
+  variant: Schema.optional(Schema.String),
 })
 export type ModelKey = typeof ModelKeySchema.Type

-const ChoiceSchema = Codec.struct({
-  model: Codec.lenientOptional(ModelKeySchema),
-  variant: Codec.lenientOptional(Codec.nullOr(Codec.string)),
+const ChoiceSchema = Schema.Struct({
+  model: Persistence.optional(ModelKeySchema),
+  variant: Persistence.optional(Schema.NullOr(Schema.String)),
 })
-const StateSchema = Codec.struct({
+const StateSchema = Schema.Struct({
  ...ChoiceSchema.fields,
-  agent: Codec.lenientOptional(Codec.string),
-  choices: Codec.lenientOptional(Codec.record(ChoiceSchema)),
+  agent: Persistence.optional(Schema.String),
+  choices: Persistence.optional(Schema.Record(Schema.String, ChoiceSchema)),
 })
 type State = typeof StateSchema.Type

-const SessionsSchema = Codec.record(Codec.fallback(Codec.undefinedOr(StateSchema), () => undefined))
-
-const Current = Codec.struct({ session: SessionsSchema })
-const StoredSelection = Codec.struct(
-  {
-    session: Codec.lenientOptional(Codec.record(Codec.unknown)),
-    pick: Codec.lenientOptional(Codec.record(Codec.unknown)),
-  },
-  { preserve: true },
+const SessionsSchema = Schema.Record(
+  Schema.String,
+  Schema.mutableKey(Persistence.fallback(Schema.UndefinedOr(StateSchema), () => undefined)),
 )

-export const ModelSelectionSchema = Codec.migrate(
+const Current = Persistence.struct({ session: SessionsSchema })
+
+export const ModelSelectionSchema = Persistence.migrate(
  Current,
-  Codec.transform(StoredSelection, {
-    decode: (value) => ({
-      ...value,
-      session:
-        value.session ?? Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
+  Schema.Struct({
+    session: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    pick: Persistence.optional(Schema.Record(Schema.String, Schema.Unknown)),
+  }).pipe(
+    Schema.decode({
+      decode: SchemaGetter.transform((value) => ({
+        session:
+          value.session ??
+          Object.fromEntries(Object.entries(value.pick ?? {}).filter(([key]) => key !== WORKSPACE_KEY)),
+      })),
+      encode: SchemaGetter.transform((value) => value),
    }),
-    encode: (value) => value,
-  }),
+  ),
 )

 const WORKSPACE_KEY = "__workspace__"
@@ -151,6 +151,8 @@ export const dict = {
  "command.session.compact.description": "Summarize the session to reduce context size",
  "command.session.fork": "Fork from message",
  "command.session.fork.description": "Create a new session from a previous message",
+  "command.session.btw": "Ask a side question",
+  "command.session.btw.description": "Get a one-shot answer without adding to the conversation",
  "command.session.export": "Export session",
  "command.session.export.description": "Export the full session transcript as JSON",
  "command.session.import": "Import session",
@@ -625,6 +627,16 @@ export const dict = {
  "toast.file.loadFailed.title": "Failed to load file",
  "file.error.notFound": "File not found: {{name}}",
  "toast.file.listFailed.title": "Failed to list files",
+  "file.view.preview": "Preview",
+  "file.view.source": "Source",
+  "file.view.openInBrowser": "Open in browser",
+  "file.view.binary": "Binary file · {{size}}",
+  "file.view.table.rows.one": "{{count}} row",
+  "file.view.table.rows.other": "{{count}} rows",
+  "file.view.table.columns.one": "{{count}} column",
+  "file.view.table.columns.other": "{{count}} columns",
+  "file.view.table.truncated": "Showing the first {{shown}} of {{total}} rows.",
+  "file.view.fontSample": "Sphinx of black quartz, judge my vow.",

  "toast.context.noLineSelection.title": "No line selection",
  "toast.context.noLineSelection.description": "Select a line range in a file tab first.",
@@ -746,6 +758,7 @@ export const dict = {
  "session.tab.browser": "Browser",
  "session.tab.add": "Add tab",
  "session.tab.context": "Context",
+  "session.tab.btw": "/btw",
  "session.tab.unknown": "Unknown Session",
  "session.panel.reviewAndFiles": "Review and files",
  "session.error.notFound": "This session cannot be found",
@@ -906,6 +919,10 @@ export const dict = {
  "session.browser.replaced": "Browser control moved to another desktop window.",
  "session.browser.suspended": "Browser suspended. Interact with this session to reconnect.",
  "session.browser.address.placeholder": "Enter URL",
+  "session.browser.empty.title": "Enter URL",
+  "session.browser.empty.description": 'Or prompt "Open in the app browser"',
+  "session.browser.failed.title": "URL can't be reached",
+  "session.browser.failed.description": "Check the URL and your connection, then try again.",

  "titlebar.update": "Update",
  "titlebar.tabs": "Tabs",
@@ -919,6 +936,10 @@ export const dict = {
  "common.dismiss": "Dismiss",
  "common.moreCountSuffix": " (+{{count}} more)",
  "common.requestFailed": "Request failed",
+  "session.btw.questionRequired": "Add a question after /btw",
+  "session.btw.error": "Couldn’t answer that question",
+  "session.btw.retry": "Retry",
+  "session.btw.copy": "Copy answer",
  "common.moreOptions": "More options",
  "common.learnMore": "Learn more",
  "common.rename": "Rename",
@@ -1,7 +1,7 @@
 import { flatten, resolveTemplate, translator, type Flatten } from "@solid-primitives/i18n"
 import { createEffect, createMemo, createResource, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
+import { Option, Schema, SchemaGetter } from "effect"
 import { createSimpleContext } from "@opencode/ui/context"
 import {
  I18nProvider,
@@ -12,6 +12,7 @@ import {
  type UiPluralCategory,
 } from "@opencode/ui/context/i18n"
 import { Persist, persisted } from "@/runtime/persistence/storage"
+import { Persistence } from "@/runtime/persistence/schema"
 import en from "@/runtime/i18n/en"
 import { dict } from "@opencode/ui/i18n/en"
 import {
@@ -55,9 +56,14 @@ function cookie(locale: Locale) {

 const LOCALES: readonly Locale[] = DESKTOP_NATIVE_LOCALES

-const LocaleSchema = Codec.literals(DESKTOP_NATIVE_LOCALES)
-const StoredLocaleSchema = Codec.struct({
-  locale: Codec.transform(Codec.string, { decode: normalizeLocale, encode: (locale) => locale }),
+const LocaleSchema = Schema.Literals(DESKTOP_NATIVE_LOCALES)
+const StoredLocaleSchema = Schema.Struct({
+  locale: Schema.String.pipe(
+    Schema.decodeTo(LocaleSchema, {
+      decode: SchemaGetter.transform(normalizeLocale),
+      encode: SchemaGetter.transform((locale) => locale),
+    }),
+  ),
 })

 const INTL = DESKTOP_NATIVE_LOCALE_TAGS
@@ -154,11 +160,11 @@ function detectLocale(): Locale {
 }

 export function normalizeLocale(value: string): Locale {
-  return Codec.decodeOption(LocaleSchema, value) ?? "en"
+  return Option.getOrElse(Schema.decodeUnknownOption(LocaleSchema)(value), () => "en")
 }

-export const languageSchema = Codec.struct({
-  locale: StoredLocaleSchema.fields.locale,
+export const languageSchema = Persistence.struct({
+  locale: StoredLocaleSchema.fields.locale,
 })

 function readStoredLocale() {
@@ -166,7 +172,9 @@ function readStoredLocale() {
  try {
    const raw = localStorage.getItem("opencode.global.dat:language")
    if (!raw) return
-    return Codec.decodeOption(Codec.fromJsonString(StoredLocaleSchema), raw)?.locale
+    const next = Schema.decodeUnknownOption(Schema.fromJsonString(StoredLocaleSchema))(raw)
+    if (Option.isNone(next)) return
+    return next.value.locale
  } catch {
    return
  }
@@ -288,4 +296,3 @@ export function UiI18nBridge(props: { children?: JSX.Element }) {
    </I18nProvider>
  )
 }
-
@@ -1,17 +0,0 @@
-import { expect, test } from "bun:test"
-import { Codec } from "./codec"
-
-// Type-level checks: these compile only if inference matches what `typeof schema.Type` gave callers.
-test("struct types infer optional and required fields", () => {
-  const s = Codec.struct({ id: Codec.string, tab: Codec.optional(Codec.string), n: Codec.lenientOptional(Codec.number) })
-  const value: typeof s.Type = { id: "x" }
-  const tab: string | undefined = value.tab
-  const n: number | undefined = value.n
-  const t = Codec.transform(s, { decode: (old) => old.tab ?? old.id, encode: (v) => ({ id: v }) })
-  const out: string | Codec.Invalid = t.decode({ id: "a" })
-  const onlyOptional = Codec.struct({ tab: Codec.optional(Codec.string) })
-  const empty: typeof onlyOptional.Type = {}
-  const maybe: string | undefined = empty.tab
-  const viaTransform = Codec.transform(onlyOptional, { decode: (old) => old.tab, encode: (tab) => ({ tab }) })
-  expect([tab, n, out, maybe, viaTransform.decode({})]).toEqual([undefined, undefined, "a", undefined, undefined])
-})
@@ -1,85 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Codec } from "./codec"
-
-describe("Codec", () => {
-  test("primitives reject the wrong shape and finite numbers only", () => {
-    expect(Codec.string.decode("a")).toBe("a")
-    expect(Codec.string.decode(1)).toBe(Codec.INVALID)
-    expect(Codec.number.decode(1.5)).toBe(1.5)
-    expect(Codec.number.decode(Number.NaN)).toBe(Codec.INVALID)
-    expect(Codec.nonNegativeInt.decode(-1)).toBe(Codec.INVALID)
-    expect(Codec.literals(["a", "b"]).decode("c")).toBe(Codec.INVALID)
-    expect(Codec.literal("x").decode("x")).toBe("x")
-  })
-
-  test("struct keeps optional fields absent and rejects invalid required ones", () => {
-    const codec = Codec.struct({ id: Codec.string, title: Codec.optional(Codec.string), n: Codec.lenientOptional(Codec.number) })
-    expect(codec.decode({ id: "1" })).toEqual({ id: "1" })
-    expect(codec.decode({ id: "1", title: "t", n: "bad" })).toEqual({ id: "1", title: "t" })
-    expect(codec.decode({ id: "1", title: 3 })).toBe(Codec.INVALID)
-    expect(codec.decode({ title: "t" })).toBe(Codec.INVALID)
-    expect(codec.decode([])).toBe(Codec.INVALID)
-    expect(codec.encode({ id: "1" })).toEqual({ id: "1" })
-    const value: typeof codec.Type = { id: "1", title: undefined }
-    expect(value.id).toBe("1")
-  })
-
-  test("lenient collections recover what they can", () => {
-    const items = Codec.lenientArray(Codec.struct({ id: Codec.string }))
-    expect(items.decode([{ id: "a" }, { id: 1 }, "x", { id: "b" }])).toEqual([{ id: "a" }, { id: "b" }])
-    expect(items.decode("nope")).toEqual([])
-    expect(Codec.array(Codec.string).decode(["a", 1])).toBe(Codec.INVALID)
-    const map = Codec.lenientRecord(Codec.boolean)
-    expect(map.decode({ a: true, b: "x" })).toEqual({})
-    expect(map.decode({ a: true })).toEqual({ a: true })
-  })
-
-  test("union, transform and fallback compose", () => {
-    const session = Codec.struct({ type: Codec.literal("session"), id: Codec.string })
-    const draft = Codec.struct({ type: Codec.literal("draft"), directory: Codec.string })
-    const tab = Codec.union([session, draft])
-    expect(tab.decode({ type: "draft", directory: "/x" })).toEqual({ type: "draft", directory: "/x" })
-    expect(tab.decode({ type: "other" })).toBe(Codec.INVALID)
-    const upper = Codec.transform(Codec.string, { decode: (s) => s.toUpperCase(), encode: (s) => s.toLowerCase() })
-    expect(upper.decode("ab")).toBe("AB")
-    expect(upper.encode("AB")).toBe("ab")
-    const safe = Codec.fallback(Codec.number, () => 7)
-    expect(safe.decode("x")).toBe(7)
-    expect(safe.decode(undefined)).toBe(7)
-    expect(safe.decode(2)).toBe(2)
-  })
-
-  test("brand constructs and decodes as its base", () => {
-    const Key = Codec.brand<"ServerConnection.Key">()
-    const key = Key.make("http://a")
-    expect(Key.decode(key)).toBe(key)
-    expect(Key.decode(3)).toBe(Codec.INVALID)
-  })
-
-  test("withInitial recovers field by field and merges new defaults", () => {
-    const layout = Codec.struct({
-      sidebar: Codec.struct({ opened: Codec.boolean, width: Codec.number }),
-      theme: Codec.lenientOptional(Codec.literals(["light", "dark"])),
-    })
-    const initial: typeof layout.Type = { sidebar: { opened: true, width: 240 } }
-    const codec = Codec.fromJsonString(Codec.withInitial(layout, initial))
-    expect(codec.decode(JSON.stringify({ sidebar: { opened: false, width: "wide" }, theme: "dark" }))).toEqual({
-      sidebar: { opened: false, width: 240 },
-      theme: "dark",
-    })
-    expect(codec.decode(JSON.stringify({ sidebar: 5 }))).toEqual(initial)
-    expect(codec.decode("{not json")).toBe(Codec.INVALID)
-    expect(JSON.parse(codec.encode({ sidebar: { opened: true, width: 1 } }))).toEqual({ sidebar: { opened: true, width: 1 } })
-  })
-
-  test("migrate reads the old shape first", () => {
-    const current = Codec.struct({ tabs: Codec.array(Codec.string) })
-    const previous = Codec.struct({ tab: Codec.optional(Codec.string) })
-    const read = Codec.transform(previous, {
-      decode: (old) => ({ tabs: old.tab ? [old.tab] : [] }),
-      encode: (value) => ({ tab: value.tabs[0] }),
-    })
-    const codec = Codec.withInitial(Codec.migrate(current, read), { tabs: [] })
-    expect(codec.decode({ tab: "a" })).toEqual({ tabs: ["a"] })
-  })
-})
@@ -1,366 +0,0 @@
-export * as Codec from "./codec"
-
-// Plain codecs for persisted state. They replace Effect Schema in the renderer's initial module
-// graph, where Effect's own module initialisation was the single largest startup cost that was not
-// rendering. Semantics mirror the Persistence helpers: decoding never throws, `INVALID` marks a
-// value that cannot be recovered, and the lenient combinators recover what they can.
-
-export const INVALID: unique symbol = Symbol.for("opencode/persistence/codec/invalid")
-export type Invalid = typeof INVALID
-
-const tag: unique symbol = Symbol.for("opencode/persistence/codec")
-
-export interface Of<T, E = unknown> {
-  readonly [tag]: true
-  /** Phantom: `typeof codec.Type` is the decoded type, as with Effect schemas. */
-  readonly Type: T
-  readonly Encoded: E
-  readonly optional?: boolean
-  decode(input: unknown): T | Invalid
-  encode(value: T): E
-}
-
-export type Any = Of<any, any>
-export type Type<C extends Any> = C["Type"]
-
-export function isCodec(value: unknown): value is Any {
-  return typeof value === "object" && value !== null && tag in value
-}
-
-export function make<T, E = unknown>(decode: (input: unknown) => T | Invalid, encode: (value: T) => E): Of<T, E> {
-  return { [tag]: true, decode, encode } as Of<T, E>
-}
-
-export function is<T>(codec: Of<T>, input: unknown): input is T {
-  return codec.decode(input) !== INVALID
-}
-
-export function decodeOption<T>(codec: Of<T>, input: unknown): T | undefined {
-  const value = codec.decode(input)
-  return value === INVALID ? undefined : value
-}
-
-export function decodeOrThrow<T>(codec: Of<T>, input: unknown): T {
-  const value = codec.decode(input)
-  if (value === INVALID) throw new Error("Value does not match its codec")
-  return value
-}
-
-/** Encodes and checks the result decodes, so an invalid in-memory value fails loudly instead of persisting. */
-export function encodeOrThrow<T, E>(codec: Of<T, E>, value: T): E {
-  const encoded = codec.encode(value)
-  if (codec.decode(encoded) === INVALID) throw new Error("Value does not match its codec")
-  return encoded
-}
-
-const identity = <T>(value: T) => value
-
-export const string: Of<string, string> = make((v) => (typeof v === "string" ? v : INVALID), identity)
-export const boolean: Of<boolean, boolean> = make((v) => (typeof v === "boolean" ? v : INVALID), identity)
-export const unknown: Of<unknown, unknown> = make((v) => v, identity)
-/** Finite numbers only: NaN and infinities are not JSON and never valid state. */
-export const number: Of<number, number> = make((v) => (typeof v === "number" && Number.isFinite(v) ? v : INVALID), identity)
-export const int: Of<number, number> = make((v) => (typeof v === "number" && Number.isInteger(v) ? v : INVALID), identity)
-export const nonNegativeInt: Of<number, number> = make(
-  (v) => (typeof v === "number" && Number.isInteger(v) && v >= 0 ? v : INVALID),
-  identity,
-)
-
-export function literal<const L extends string | number | boolean | null>(value: L): Of<L, L> {
-  return make((v) => (v === value ? value : INVALID), identity)
-}
-
-export function literals<const L extends ReadonlyArray<string | number | boolean | null>>(values: L): Of<L[number], L[number]> {
-  const set = new Set<unknown>(values)
-  return make((v) => (set.has(v) ? (v as L[number]) : INVALID), identity)
-}
-
-/** A string carrying a nominal brand, with the constructor Effect's `Schema.brand` gave callers. */
-export function brand<B extends string>(): Of<string & { readonly [K in B]: B }, string> & {
-  make(value: string): string & { readonly [K in B]: B }
-} {
-  return Object.assign(make<string & { readonly [K in B]: B }, string>((v) => (typeof v === "string" ? (v as never) : INVALID), identity), {
-    make: (value: string) => value as never,
-  })
-}
-
-export function nullOr<T, E>(codec: Of<T, E>): Of<T | null, E | null> {
-  return make((v) => (v === null ? null : codec.decode(v)), (v) => (v === null ? null : codec.encode(v)))
-}
-
-export function undefinedOr<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> {
-  return make((v) => (v === undefined ? undefined : codec.decode(v)), (v) => (v === undefined ? undefined : codec.encode(v)))
-}
-
-/** A struct field that may be absent. Present but invalid values make the struct invalid. */
-export function optional<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> & { readonly optional: true } {
-  return { ...undefinedOr(codec), optional: true } as never
-}
-
-/** A struct field that may be absent, and whose invalid values are dropped rather than rejected. */
-export function lenientOptional<T, E>(codec: Of<T, E>): Of<T | undefined, E | undefined> & { readonly optional: true } {
-  return {
-    ...make<T | undefined, E | undefined>(
-      (v) => {
-        if (v === undefined) return undefined
-        const value = codec.decode(v)
-        return value === INVALID ? undefined : value
-      },
-      (v) => (v === undefined ? undefined : codec.encode(v)),
-    ),
-    optional: true,
-  } as never
-}
-
-type Fields = Record<string, Any>
-type OptionalKeys<F extends Fields> = { [K in keyof F]: F[K] extends { optional: true } ? K : never }[keyof F]
-type RequiredKeys<F extends Fields> = Exclude<keyof F, OptionalKeys<F>>
-type Simplify<T> = { [K in keyof T]: T[K] } & {}
-export type StructType<F extends Fields> = Simplify<
-  { [K in RequiredKeys<F>]: F[K]["Type"] } & { [K in OptionalKeys<F>]?: F[K]["Type"] }
->
-export type StructEncoded<F extends Fields> = Simplify<
-  { [K in RequiredKeys<F>]: F[K]["Encoded"] } & { [K in OptionalKeys<F>]?: F[K]["Encoded"] }
->
-
-export interface Struct<F extends Fields> extends Of<StructType<F>, StructEncoded<F>> {
-  readonly fields: F
-}
-
-// `preserve` keeps keys the struct does not declare, for migration shapes that only describe the
-// fields they rewrite (Effect's `onExcessProperty: "preserve"`); the current schema then decides.
-export function struct<const F extends Fields>(fields: F, options?: { preserve?: boolean }): Struct<F> {
-  const entries = Object.entries(fields)
-  return {
-    ...make<StructType<F>, StructEncoded<F>>(
-      (input) => {
-        if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
-        const record = input as Record<string, unknown>
-        const out: Record<string, unknown> = options?.preserve ? { ...record } : {}
-        for (const [key, codec] of entries) {
-          const present = Object.hasOwn(record, key)
-          if (!present && codec.optional) continue
-          const value = codec.decode(record[key])
-          if (value === INVALID) return INVALID
-          if (value !== undefined || present) out[key] = value
-          else delete out[key]
-        }
-        return out as StructType<F>
-      },
-      (value) => {
-        const out: Record<string, unknown> = {}
-        for (const [key, codec] of entries) {
-          const field = (value as Record<string, unknown>)[key]
-          if (field === undefined && !Object.hasOwn(value as object, key)) continue
-          out[key] = codec.encode(field)
-        }
-        return out as StructEncoded<F>
-      },
-    ),
-    fields,
-  }
-}
-
-export function array<T, E>(codec: Of<T, E>): Of<T[], E[]> {
-  return make(
-    (input) => {
-      if (!Array.isArray(input)) return INVALID
-      const out: T[] = []
-      for (const item of input) {
-        const value = codec.decode(item)
-        if (value === INVALID) return INVALID
-        out.push(value)
-      }
-      return out
-    },
-    (value) => value.map((item) => codec.encode(item)),
-  )
-}
-
-/** Keeps the items that decode and drops the rest, like `Persistence.array`. */
-export function lenientArray<T, E>(codec: Of<T, E>): Of<T[], E[]> {
-  return make(
-    (input) => {
-      if (!Array.isArray(input)) return []
-      return input.flatMap((item) => {
-        const value = codec.decode(item)
-        return value === INVALID ? [] : [value]
-      })
-    },
-    (value) => value.map((item) => codec.encode(item)),
-  )
-}
-
-export function record<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
-  return make(
-    (input) => {
-      if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
-      const out: Record<string, T> = {}
-      for (const [key, item] of Object.entries(input)) {
-        const value = codec.decode(item)
-        if (value === INVALID) return INVALID
-        out[key] = value
-      }
-      return out
-    },
-    (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, codec.encode(item)])),
-  )
-}
-
-/** A record that drops entries whose values are invalid, the replacement for `catchDecoding` to none. */
-export function sparseRecord<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
-  return make(
-    (input) => {
-      if (typeof input !== "object" || input === null || Array.isArray(input)) return INVALID
-      const out: Record<string, T> = {}
-      for (const [key, item] of Object.entries(input)) {
-        const value = codec.decode(item)
-        if (value !== INVALID) out[key] = value
-      }
-      return out
-    },
-    (value) => Object.fromEntries(Object.entries(value).map(([key, item]) => [key, codec.encode(item)])),
-  )
-}
-
-/** An invalid record becomes empty rather than failing the whole store, like `Persistence.record`. */
-export function lenientRecord<T, E>(codec: Of<T, E>): Of<Record<string, T>, Record<string, E>> {
-  const strict = record(codec)
-  return make(
-    (input) => {
-      const value = strict.decode(input)
-      return value === INVALID ? {} : value
-    },
-    strict.encode,
-  )
-}
-
-export function union<const C extends ReadonlyArray<Any>>(codecs: C): Of<C[number]["Type"], C[number]["Encoded"]> {
-  return make(
-    (input) => {
-      for (const codec of codecs) {
-        const value = codec.decode(input)
-        if (value !== INVALID) return value
-      }
-      return INVALID
-    },
-    (value) => {
-      // Encode with the first member that accepts the value's shape; members are disjoint in practice.
-      for (const codec of codecs) if (codec.decode(value) !== INVALID) return codec.encode(value)
-      return value as C[number]["Encoded"]
-    },
-  )
-}
-
-/** Maps a decoded value into another shape, the replacement for `decodeTo` + `SchemaGetter.transform`. */
-export function transform<T, E, T2>(
-  codec: Of<T, E>,
-  options: { decode: (value: T) => T2; encode: (value: T2) => T },
-): Of<T2, E> {
-  return make(
-    (input) => {
-      const value = codec.decode(input)
-      return value === INVALID ? INVALID : options.decode(value)
-    },
-    (value) => codec.encode(options.encode(value)),
-  )
-}
-
-/** Decodes with `source`, maps, then validates with `target`: Effect's `decodeTo` with a transform. */
-export function decodeTo<T, E, T2, E2>(
-  source: Of<T, E>,
-  target: Of<T2, E2>,
-  options: { decode: (value: T) => E2; encode: (value: T2) => T },
-): Of<T2, E> {
-  return make(
-    (input) => {
-      const value = source.decode(input)
-      return value === INVALID ? INVALID : target.decode(options.decode(value))
-    },
-    (value) => source.encode(options.encode(value)),
-  )
-}
-
-/** Invalid and missing values become `value()`, like `Persistence.fallback`. */
-export function fallback<T, E>(codec: Of<T, E>, value: () => NoInfer<T>): Of<T, E> {
-  return make(
-    (input) => {
-      if (input === undefined) return value()
-      const decoded = codec.decode(input)
-      return decoded === INVALID ? value() : decoded
-    },
-    codec.encode,
-  )
-}
-
-export function fromJsonString<T, E>(codec: Of<T, E>): Of<T, string> {
-  return make(
-    (input) => {
-      if (typeof input !== "string") return INVALID
-      try {
-        return codec.decode(JSON.parse(input))
-      } catch {
-        return INVALID
-      }
-    },
-    (value) => JSON.stringify(codec.encode(value)),
-  )
-}
-
-export type Decoder = Pick<Of<unknown>, "decode">
-export type Migrated<C extends Any> = { readonly current: C; readonly read: Decoder }
-
-/** Older stored shapes go through `read` first; `current` describes what the store holds today. */
-export function migrate<C extends Any>(current: C, read: Decoder): Migrated<C> {
-  return { current, read }
-}
-
-function isMigrated<C extends Any>(definition: C | Migrated<C>): definition is Migrated<C> {
-  return !isCodec(definition) && "current" in definition
-}
-
-// Stored values recover field by field against the initial value: an object's valid fields are
-// kept, invalid or missing ones take their initial counterpart, and the result is merged over the
-// initial so new fields appear with their defaults. Mirrors `Persistence.withInitial`.
-export function withInitial<C extends Any>(definition: C | Migrated<C>, initial: Type<C>): Of<Type<C>, unknown> {
-  const codec = isMigrated(definition) ? definition.current : definition
-  const read = isMigrated(definition) ? definition.read : unknown
-  return make(
-    (input) => {
-      const stored = read.decode(input)
-      if (stored === INVALID) return INVALID
-      return merge(initial, recover(codec, stored, initial))
-    },
-    (value) => codec.encode(value),
-  )
-}
-
-function recover(codec: Any, value: unknown, initial: unknown): unknown {
-  if (value === undefined) return initial
-  if ("fields" in codec && isObject(value)) {
-    const fields = (codec as Struct<Fields>).fields
-    return Object.fromEntries(
-      Object.entries(fields).flatMap(([name, field]) => {
-        const defaults = isObject(initial) ? initial[name] : undefined
-        const next = recover(field, value[name], defaults)
-        if (next === undefined && !Object.hasOwn(value, name) && defaults === undefined) return []
-        return [[name, next]]
-      }),
-    )
-  }
-  const decoded = codec.decode(value)
-  return decoded === INVALID ? initial : decoded
-}
-
-function merge(initial: unknown, value: unknown): unknown {
-  if (value === undefined) return initial
-  if (!isObject(initial) || !isObject(value)) return value
-  return Object.fromEntries(
-    [...new Set([...Object.keys(initial), ...Object.keys(value)])].map((key) => [key, merge(initial[key], value[key])]),
-  )
-}
-
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
@@ -3,7 +3,6 @@ import { Schema } from "effect"
 import { WorkspaceOnboardingSchema, ProviderTipSchema, WorkspaceTipSchema } from "@/new-session/view"
 import { ModelSelectionSchema } from "@/providers/models/selection"
 import { Persistence } from "@/runtime/persistence/schema"
-import { Codec } from "@/runtime/persistence/codec"
 import { FileViewsSchema } from "@/workspaces/files/view-cache"
 import { languageSchema } from "@/runtime/i18n/language"
 import { HomeServersSchema } from "@/home/projects/controller"
@@ -11,9 +10,9 @@ import { ModelProvidersSchema } from "@/settings/models/models"

 describe("persisted consumer schemas", () => {
  test("onboarding and provider tip retain defaults and validate stored values", () => {
-    const onboarding = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceOnboardingSchema, { used: false }), input))
-    const tip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ProviderTipSchema, { dismissedAt: 0 }), input))
-    const workspaceTip = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }), input))
+    const onboarding = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceOnboardingSchema, { used: false }))
+    const tip = Schema.decodeUnknownSync(Persistence.withInitial(ProviderTipSchema, { dismissedAt: 0 }))
+    const workspaceTip = Schema.decodeUnknownSync(Persistence.withInitial(WorkspaceTipSchema, { dismissedAt: 0 }))
    expect(onboarding({})).toEqual({ used: false })
    expect(onboarding({ used: "true" })).toEqual({ used: false })
    expect(onboarding({ used: true })).toEqual({ used: true })
@@ -26,7 +25,7 @@ describe("persisted consumer schemas", () => {

  test("collapse records recover malformed entries without losing valid siblings", () => {
    for (const schema of [HomeServersSchema, ModelProvidersSchema]) {
-      const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(schema, { collapsed: {} }), input)
+      const decode = Schema.decodeUnknownSync(Persistence.withInitial(schema, { collapsed: {} }))
      expect(decode({})).toEqual({ collapsed: {} })
      expect(decode({ collapsed: [] })).toEqual({ collapsed: {} })
      expect(decode({ collapsed: { open: false, closed: true, invalid: "false" } })).toEqual({
@@ -36,19 +35,21 @@ describe("persisted consumer schemas", () => {
  })

  test("model selection migrates legacy picks and omits workspace state", () => {
-    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), input)
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))
    expect(decode({})).toEqual({ session: {} })
    const state = decode({ pick: { __workspace__: { agent: "plan" }, session1: { agent: "build" } } })
    expect(state.session.session1?.agent).toBe("build")
    expect(state.session.__workspace__).toBeUndefined()
-    const encoded = Codec.fromJsonString(Codec.withInitial(ModelSelectionSchema, { session: {} })).encode(state)
+    const encoded = Schema.encodeSync(
+      Schema.fromJsonString(Persistence.withInitial(ModelSelectionSchema, { session: {} })),
+    )(state)
    expect(JSON.parse(encoded)).toEqual({ session: { session1: { agent: "build" } } })
    expect(decode(JSON.parse(encoded))).toEqual(state)
  })

  test("current model selections take precedence over legacy picks", () => {
    expect(
-      Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
+      Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
        session: {},
        pick: { session1: { agent: "plan" } },
      }),
@@ -56,7 +57,7 @@ describe("persisted consumer schemas", () => {
  })

  test("model selection validates nested model keys and preserves explicit null variants", () => {
-    const state = Codec.decodeOrThrow(Codec.withInitial(ModelSelectionSchema, { session: {} }), {
+    const state = Schema.decodeUnknownSync(Persistence.withInitial(ModelSelectionSchema, { session: {} }))({
      session: {
        good: { agent: "build", model: { providerID: "provider", modelID: "model", variant: "high" }, variant: null },
        partial: { agent: "plan", model: { providerID: "provider", modelID: 42 }, variant: false },
@@ -75,7 +76,7 @@ describe("persisted consumer schemas", () => {
  })

  test("file views validate scroll positions and line sides independently", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(FileViewsSchema, { file: {} }), input))
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(FileViewsSchema, { file: {} }))
    expect(decode({})).toEqual({ file: {} })
    const state = decode({
      file: {
@@ -102,7 +103,7 @@ describe("persisted consumer schemas", () => {
  })

  test("language preserves runtime defaults and normalizes unsupported locales to English", () => {
-    const decode = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(languageSchema, { locale: "fr" }), input)
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(languageSchema, { locale: "fr" }))
    expect(decode({})).toEqual({ locale: "fr" })
    expect(decode({ locale: undefined })).toEqual({ locale: "fr" })
    expect(decode({ locale: 42 })).toEqual({ locale: "fr" })
@@ -110,6 +111,3 @@ describe("persisted consumer schemas", () => {
    expect(decode({ locale: "ar" })).toEqual({ locale: "ar" })
  })
 })
-
-
-
@@ -1,5 +1,5 @@
 import type { AsyncStorage } from "@solid-primitives/storage"
-import { Codec } from "./codec"
+import { Option, Schema } from "effect"

 export type BlobReference = { id: string; url: string }

@@ -312,12 +312,12 @@ export function createDraftStore(driver: Driver, options: { grace?: number } = {
    getItem: async (key) => {
      const value = await driver.get(key)
      if (value === null) return null
-      const parsed = Codec.fromJsonString(Codec.unknown).decode(value)
-      // Let the owning persistence codec apply its invalid-document policy.
-      if (parsed === Codec.INVALID) return value
-      // A loaded document is live in the composer: pin its images before decode mints their URLs.
-      retain(key, imageIDs(parsed), grace)
-      return JSON.stringify(await decode(parsed))
+      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)),
    setDocument,
@@ -455,4 +455,3 @@ export async function blobDataUrl(blob: BlobReference, mime: string) {
 export function createLegacyBlobReference(dataUrl: string): BlobReference {
  return { id: dataUrl, url: dataUrl }
 }
-
@@ -6,7 +6,6 @@ import { createStore, type SetStoreFunction, type Store } from "solid-js/store"
 import { Option, Schema } from "effect"
 import { pathKey } from "@/workspaces/path-key"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
-import { Codec } from "./codec"
 import { persistStore } from "./persist"
 import { Persistence } from "./schema"

@@ -473,57 +472,25 @@ export function removePersisted(
  }
 }

-type Definition<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any> =
-  | S
-  | Persistence.Migrated<Extract<S, Schema.ConstraintCodec<object, unknown>>>
-  | Codec.Migrated<Extract<S, Codec.Any>>
-
-// Persisted stores are moving from Effect Schema to the plain codecs in ./codec so the renderer
-// stops paying for Effect at startup; both are accepted while the migration is underway.
-function serializer<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
-  definition: Definition<S>,
-  initial: S["Type"],
-) {
-  if (Codec.isCodec(definition) || (!("current" in definition) ? false : Codec.isCodec(definition.current))) {
-    const codec = Codec.withInitial(definition as Codec.Any | Codec.Migrated<Codec.Any>, initial)
-    const json = Codec.fromJsonString(codec)
-    return {
-      decode: (raw: string) => Codec.decodeOption(json, raw) as S["Type"] | undefined,
-      deserialize: (raw: unknown) => Codec.decodeOrThrow(json, raw) as S["Type"],
-      serialize: (value: S["Type"]) => Codec.encodeOrThrow(json, value),
-      encode: (value: S["Type"]) => Codec.encodeOrThrow(codec, value),
-      initial: Codec.decodeOrThrow(codec, codec.encode(initial)) as S["Type"],
-    }
-  }
-  const schema = definition as Schema.ConstraintCodec<object, unknown> | Persistence.Migrated<Schema.ConstraintCodec<object, unknown>>
-  const initialized = Persistence.withInitial(schema, initial as object)
-  const json = Schema.fromJsonString(initialized)
-  const decode = Schema.decodeUnknownOption(json)
-  return {
-    decode: (raw: string) => Option.getOrUndefined(decode(raw)) as S["Type"] | undefined,
-    deserialize: Schema.decodeUnknownSync(json) as (raw: unknown) => S["Type"],
-    serialize: Schema.encodeSync(json) as (value: S["Type"]) => string,
-    encode: Schema.encodeSync(initialized) as (value: S["Type"]) => unknown,
-    initial: Schema.decodeUnknownSync(Schema.toType(initialized))(initial as object) as S["Type"],
-  }
-}
-
-export function persisted<S extends Schema.ConstraintCodec<object, unknown> | Codec.Any>(
+export function persisted<S extends Schema.ConstraintCodec<object, unknown>>(
  target: string | PersistTarget,
-  schema: Definition<S>,
+  schema: S | Persistence.Migrated<S>,
  initial: NoInfer<S["Type"]>,
  platformOverride?: Platform,
 ): PersistedWithReady<S["Type"]> {
  const platform = platformOverride ?? usePlatform()
  const config = resolveTarget(typeof target === "string" ? { key: target } : target, platform)

-  const codec = serializer<S>(schema, initial)
-  const { encode, serialize } = codec
+  const initialized = Persistence.withInitial(schema, initial)
+  const json = Schema.fromJsonString(initialized)
+  const decode = Schema.decodeUnknownOption(json)
+  const encode = Schema.encodeSync(initialized)
+  const serialize = Schema.encodeSync(json)
  const normalize = (raw: string) => {
-    const value = codec.decode(raw)
-    if (value !== undefined) return serialize(value)
+    const value = decode(raw)
+    if (Option.isSome(value)) return serialize(value.value)
  }
-  const store = createStore<S["Type"]>(codec.initial)
+  const store = createStore<S["Type"]>(Schema.decodeUnknownSync(Schema.toType(initialized))(initial))
  const isDesktop = platform.platform === "desktop" && !!platform.storage
  const draft = config.draft ? platform.draftStore : undefined
  const prefix = `${config.storage ?? "default"}:`
@@ -635,7 +602,7 @@ export function persisted<S extends Schema.ConstraintCodec<object, unknown> | Co
    name: config.key,
    storage,
    serialize,
-    deserialize: codec.deserialize,
+    deserialize: Schema.decodeUnknownSync(json),
    sync: channel ? messageSync(channel) : undefined,
    // Drafts take the encoded document itself so large text is externalized without the store
    // re-parsing the serialized form on every save.
@@ -19,6 +19,7 @@ export type BrowserPaneCommand = Browser.Action
 export type BrowserPaneState = Browser.State | null
 export type BrowserPaneEvent =
  | { type: "focus"; tabID: Browser.TabID }
+  | { type: "preview"; path: string }
  | { type: "state"; state: BrowserPaneState; error?: string }

 export type BrowserPaneRegistration = {
@@ -1,11 +0,0 @@
-import type { Brand } from "effect"
-import { Codec } from "@/runtime/persistence/codec"
-
-// The server key's brand is shared with the Effect schema in ./persistence.ts (type only, so this
-// module loads nothing of Effect), letting stores port to plain codecs one at a time.
-export type ServerKey = string & Brand.Brand<"ServerConnection.Key">
-
-export const ServerKey: Codec.Of<ServerKey, string> & { make(value: string): ServerKey } = Object.assign(
-  Codec.make<ServerKey, string>((v) => (typeof v === "string" ? (v as ServerKey) : Codec.INVALID), (v) => v),
-  { make: (value: string) => value as ServerKey },
-)
@@ -1,14 +1,15 @@
 import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
 import { IconState, ModelState, ProjectState, VcsState, serverState } from "./persistence"
 import { createRoot } from "solid-js"
 import { isServer } from "solid-js/web"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

 const initial = { list: [], hidden: {}, projects: {}, lastProject: {}, recentlyClosed: {} }

 function serverSchema(canonical?: () => string | undefined) {
-  return Codec.withInitial(serverState(canonical), initial)
+  return Persistence.withInitial(serverState(canonical), initial)
 }

 describe("server persistence schema", () => {
@@ -28,7 +29,7 @@ describe("server persistence schema", () => {
      ],
      projects: { local: [{ worktree: "/project", expanded: true }] },
    }
-    const state = Codec.decodeOrThrow(schema, input)
+    const state = Schema.decodeUnknownSync(schema)(input)
    expect(state).toEqual({
      list: [
        { type: "http", http: { url: "http://localhost:4096" } },
@@ -47,13 +48,13 @@ describe("server persistence schema", () => {
      recentlyClosed: {},
    })
    expect(input.list[1]).toHaveProperty("username", "legacy")
-    const encoded = schema.encode(state)
+    const encoded = Schema.encodeSync(schema)(state)
    expect(encoded).toEqual(state)
-    expect(Codec.decodeOrThrow(schema, encoded)).toEqual(state)
+    expect(Schema.decodeUnknownSync(schema)(encoded)).toEqual(state)
  })

  test("defaults missing or malformed fields and drops invalid entries independently", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(serverSchema(), input))
+    const decode = Schema.decodeUnknownSync(serverSchema())
    const empty = { list: [], hidden: {}, projects: {}, lastProject: {}, recentlyClosed: {} }
    expect(decode({})).toEqual(empty)
    expect(decode({ list: null, hidden: [], projects: false, lastProject: 1, recentlyClosed: "bad" })).toEqual(empty)
@@ -73,7 +74,7 @@ describe("server persistence schema", () => {

  test("moves canonical project buckets without changing server keys or unrelated scopes", () => {
    const schema = serverSchema(() => "https://opencode.example.com")
-    const state = Codec.decodeOrThrow(schema, {
+    const state = Schema.decodeUnknownSync(schema)({
      list: ["https://opencode.example.com"],
      hidden: { "https://opencode.example.com": true },
      projects: {
@@ -99,14 +100,14 @@ describe("server persistence schema", () => {
    expect(state.list[0]?.http.url).toBe("https://opencode.example.com")
    expect(state.hidden).toEqual({ "https://opencode.example.com": true })
    expect(state.recentlyClosed).toEqual({ local: ["/closed"], "https://opencode.example.com": ["/old-closed"] })
-    expect(schema.encode(state)).toEqual(state)
-    expect(Codec.decodeOrThrow(schema, state)).toEqual(state)
+    expect(Schema.encodeSync(schema)(state)).toEqual(state)
+    expect(Schema.decodeUnknownSync(schema)(state)).toEqual(state)
  })

  test("reads the latest canonical local prop on each decode", () => {
    const props: { canonicalLocalServer?: string } = {}
    const schema = serverSchema(() => props.canonicalLocalServer)
-    const decode = ((input: unknown) => Codec.decodeOrThrow(schema, input))
+    const decode = Schema.decodeUnknownSync(schema)
    const input = {
      projects: { remote: [{ worktree: "/project", expanded: true }] },
      lastProject: { remote: "/project" },
@@ -121,7 +122,7 @@ describe("server persistence schema", () => {
  })

  test("migrates a last project without a project list", () => {
-    expect(Codec.decodeOrThrow(serverSchema(() => "remote"), { lastProject: { remote: "/project" } })).toEqual({
+    expect(Schema.decodeUnknownSync(serverSchema(() => "remote"))({ lastProject: { remote: "/project" } })).toEqual({
      list: [],
      hidden: {},
      projects: {},
@@ -133,7 +134,7 @@ describe("server persistence schema", () => {

 describe("model persistence schema", () => {
  test("defaults missing state and keeps valid entries beside malformed entries", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ModelState, { user: [], recent: [], variant: {} }), input))
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ModelState, { user: [], recent: [], variant: {} }))
    expect(decode({})).toEqual({ user: [], recent: [], variant: {} })
    expect(decode({ user: null, recent: 1, variant: [] })).toEqual({ user: [], recent: [], variant: {} })
    const state = decode({
@@ -154,24 +155,24 @@ describe("model persistence schema", () => {
      recent: [{ providerID: "provider", modelID: "model" }],
      variant: { model: "high" },
    })
-    expect(ModelState.encode(state)).toEqual(state)
+    expect(Schema.encodeSync(ModelState)(state)).toEqual(state)
  })
 })

 describe("directory cache schemas", () => {
  test("defaults missing and malformed VCS caches but retains optional branch metadata", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(VcsState, { value: undefined }), input))
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(VcsState, { value: undefined }))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: null })).toEqual({ value: undefined })
    expect(decode({ value: { branch: 1 } })).toEqual({ value: undefined })
    expect(decode({ value: { default_branch: "main" } })).toEqual({ value: { default_branch: "main" } })
    const state = decode({ value: { branch: "feature", default_branch: "main", obsolete: true } })
    expect(state).toEqual({ value: { branch: "feature", default_branch: "main" } })
-    expect(VcsState.encode(state)).toEqual(state)
+    expect(Schema.encodeSync(VcsState)(state)).toEqual(state)
  })

  test("validates project name, icon overrides and startup commands", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(ProjectState, { value: undefined }), input))
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(ProjectState, { value: undefined }))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: [] })).toEqual({ value: undefined })
    expect(decode({ value: { icon: { override: 1 } } })).toEqual({ value: undefined })
@@ -184,7 +185,7 @@ describe("directory cache schemas", () => {
        commands: { start: "bun dev" },
      },
    })
-    expect(ProjectState.encode(state)).toEqual(state)
+    expect(Schema.encodeSync(ProjectState)(state)).toEqual(state)
    expect(state.value).toEqual({
      name: "Project",
      icon: { override: "data:image/png;base64,abc", color: "blue" },
@@ -193,12 +194,12 @@ describe("directory cache schemas", () => {
  })

  test("validates optional icon strings", () => {
-    const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(IconState, { value: undefined }), input))
+    const decode = Schema.decodeUnknownSync(Persistence.withInitial(IconState, { value: undefined }))
    expect(decode({})).toEqual({ value: undefined })
    expect(decode({ value: 42 })).toEqual({ value: undefined })
    expect(decode({ value: null })).toEqual({ value: undefined })
    expect(decode({ value: "" })).toEqual({ value: "" })
-    expect(IconState.encode(decode({ value: "data:image/png;base64,abc" }))).toEqual({
+    expect(Schema.encodeSync(IconState)(decode({ value: "data:image/png;base64,abc" }))).toEqual({
      value: "data:image/png;base64,abc",
    })
  })
@@ -254,7 +255,7 @@ test.skipIf(isServer)(
      const stored = values.get("opencode.global.dat:server")
      expect(stored).toBeDefined()
      if (!stored) throw new Error("server state was not written")
-      const decoded = Codec.decodeOrThrow(Codec.fromJsonString(serverSchema()), stored)
+      const decoded = Schema.decodeUnknownSync(Schema.fromJsonString(serverSchema()))(stored)
      expect(decoded.projects.local).toEqual([{ worktree: "/project", expanded: true }])
      expect(stored).not.toContain("username")
      expect(decoded.list).toEqual(root.state[0].list)
@@ -263,4 +264,3 @@ test.skipIf(isServer)(
    }
  },
 )
-
@@ -1,127 +1,136 @@
-import { Codec } from "@/runtime/persistence/codec"
-import { ServerKey } from "./key"
+import { Effect, Option, Schema, SchemaGetter } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"

-export { ServerKey }
+export const ServerKey = Schema.String.pipe(Schema.brand("ServerConnection.Key"))

-export const ServerHttpBase = Codec.struct({
-  url: Codec.string,
-  password: Codec.optional(Codec.string),
+export const ServerHttpBase = Persistence.struct({
+  url: Schema.String,
+  password: Schema.optional(Schema.String),
 })

-export const ServerHttp = Codec.struct({
-  type: Codec.literal("http"),
+export const ServerHttp = Persistence.struct({
+  type: Schema.Literal("http"),
  http: ServerHttpBase,
-  authToken: Codec.optional(Codec.boolean),
-  displayName: Codec.optional(Codec.string),
-  label: Codec.optional(Codec.string),
+  authToken: Schema.optional(Schema.Boolean),
+  displayName: Schema.optional(Schema.String),
+  label: Schema.optional(Schema.String),
 })

-// Servers were stored as a URL string, then as the HTTP block alone, before the current shape.
-const StoredServer = Codec.decodeTo(Codec.union([ServerHttp, ServerHttpBase, Codec.string]), ServerHttp, {
-  decode: (value) => {
-    if (typeof value === "string") return { type: "http" as const, http: { url: value } }
-    if ("http" in value) return value
-    return { type: "http" as const, http: value }
-  },
-  encode: (value) => value,
-})
-
-const ProjectList = Codec.lenientArray(
-  Codec.struct({
-    worktree: Codec.string,
-    expanded: Codec.fallback(Codec.boolean, () => true),
+const StoredServer = Schema.Union([ServerHttp, ServerHttpBase, Schema.String]).pipe(
+  Schema.decodeTo(ServerHttp, {
+    decode: SchemaGetter.transform((value) => {
+      if (typeof value === "string") return { type: "http", http: { url: value } }
+      if ("http" in value) return value
+      return { type: "http", http: value }
+    }),
+    encode: SchemaGetter.transform((value) => value),
  }),
 )
-const Projects = Codec.lenientRecord(ProjectList)
-const LastProject = Codec.fallback(Codec.sparseRecord(Codec.string), () => ({}))

-const State = Codec.struct({
-  list: Codec.lenientArray(StoredServer),
-  hidden: Codec.sparseRecord(Codec.boolean),
-  projects: Codec.record(ProjectList),
-  lastProject: Codec.sparseRecord(Codec.string),
-  recentlyClosed: Codec.record(Codec.lenientArray(Codec.string)),
+const ProjectList = Persistence.array(
+  Persistence.struct({
+    worktree: Schema.String,
+    expanded: Persistence.fallback(Schema.Boolean, () => true),
+  }),
+)
+const Projects = Persistence.record(ProjectList)
+const LastProject = Persistence.record(Schema.String.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none()))))
+
+const State = Persistence.struct({
+  list: Persistence.array(StoredServer),
+  hidden: Schema.Record(
+    Schema.String,
+    Schema.mutableKey(Schema.Boolean.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none())))),
+  ),
+  projects: Schema.Record(Schema.String, Schema.mutableKey(ProjectList)),
+  lastProject: Schema.Record(
+    Schema.String,
+    Schema.mutableKey(Schema.String.pipe(Schema.catchDecoding(() => Effect.succeed(Option.none())))),
+  ),
+  recentlyClosed: Schema.Record(Schema.String, Schema.mutableKey(Persistence.array(Schema.String))),
 })

-const StoredState = Codec.struct({ projects: Projects, lastProject: LastProject }, { preserve: true })
-
-// Projects and last-opened entries recorded under the canonical local server's URL move under
-// "local" when that URL is known, so they survive the server changing address.
 export function serverState(canonicalLocalServer: () => string | undefined = () => undefined) {
-  return Codec.migrate(
+  return Persistence.migrate(
    State,
-    Codec.transform(StoredState, {
-      decode: (value) => {
-        const canonical = canonicalLocalServer()
-        if (!canonical || canonical === "local") return value
-        const previous = value.projects[canonical]
-        const last = value.lastProject[canonical]
-        if (!previous && last === undefined) return value
+    Schema.Struct({ projects: Projects, lastProject: LastProject }).pipe(
+      Schema.decode({
+        decode: SchemaGetter.transform((value) => {
+          const canonical = canonicalLocalServer()
+          if (!canonical || canonical === "local") return value
+          const previous = value.projects[canonical]
+          const last = value.lastProject[canonical]
+          if (!previous && last === undefined) return value

-        const projects = { ...value.projects }
-        if (previous) {
-          const local = projects.local ?? []
-          const worktrees = new Set(local.map((project) => project.worktree))
-          projects.local = [
-            ...local,
-            ...previous.filter((project) => {
-              if (worktrees.has(project.worktree)) return false
-              worktrees.add(project.worktree)
-              return true
-            }),
-          ]
-          delete projects[canonical]
-        }
-        const lastProject = { ...value.lastProject }
-        if (last !== undefined) {
-          lastProject.local ??= last
-          delete lastProject[canonical]
-        }
-        return { ...value, projects, lastProject }
-      },
-      encode: (value) => value,
-    }),
+          const projects = { ...value.projects }
+          if (previous) {
+            const local = projects.local ?? []
+            const worktrees = new Set(local.map((project) => project.worktree))
+            projects.local = [
+              ...local,
+              ...previous.filter((project) => {
+                if (worktrees.has(project.worktree)) return false
+                worktrees.add(project.worktree)
+                return true
+              }),
+            ]
+            delete projects[canonical]
+          }
+          const lastProject = { ...value.lastProject }
+          if (last !== undefined) {
+            lastProject.local ??= last
+            delete lastProject[canonical]
+          }
+          return { ...value, projects, lastProject }
+        }),
+        encode: SchemaGetter.transform((value) => value),
+      }),
+    ),
  )
 }

-export const ModelState = Codec.struct({
-  user: Codec.lenientArray(
-    Codec.struct({
-      providerID: Codec.string,
-      modelID: Codec.string,
-      visibility: Codec.literals(["show", "hide"]),
-      favorite: Codec.optional(Codec.boolean),
+export const ModelState = Persistence.struct({
+  user: Persistence.array(
+    Persistence.struct({
+      providerID: Schema.String,
+      modelID: Schema.String,
+      visibility: Schema.Literals(["show", "hide"]),
+      favorite: Schema.optional(Schema.Boolean),
    }),
  ),
-  recent: Codec.lenientArray(Codec.struct({ providerID: Codec.string, modelID: Codec.string })),
-  variant: Codec.sparseRecord(Codec.undefinedOr(Codec.string)),
+  recent: Persistence.array(Persistence.struct({ providerID: Schema.String, modelID: Schema.String })),
+  variant: Schema.Record(
+    Schema.String,
+    Schema.mutableKey(
+      Schema.UndefinedOr(Schema.String).pipe(Schema.catchDecoding(() => Effect.succeed(Option.none()))),
+    ),
+  ),
 })

-export const VcsState = Codec.struct({
-  value: Codec.optional(
-    Codec.struct({
-      branch: Codec.optional(Codec.string),
-      default_branch: Codec.optional(Codec.string),
+export const VcsState = Persistence.struct({
+  value: Schema.optional(
+    Persistence.struct({
+      branch: Schema.optional(Schema.String),
+      default_branch: Schema.optional(Schema.String),
    }),
  ),
 })

-const ProjectMeta = Codec.struct({
-  name: Codec.optional(Codec.string),
-  icon: Codec.optional(
-    Codec.struct({
-      override: Codec.optional(Codec.string),
-      color: Codec.optional(Codec.string),
+const ProjectMeta = Persistence.struct({
+  name: Schema.optional(Schema.String),
+  icon: Schema.optional(
+    Persistence.struct({
+      override: Schema.optional(Schema.String),
+      color: Schema.optional(Schema.String),
    }),
  ),
-  commands: Codec.optional(Codec.struct({ start: Codec.optional(Codec.string) })),
+  commands: Schema.optional(Persistence.struct({ start: Schema.optional(Schema.String) })),
 })

-export const ProjectState = Codec.struct({
-  value: Codec.optional(ProjectMeta),
+export const ProjectState = Persistence.struct({
+  value: Schema.optional(ProjectMeta),
 })

-export const IconState = Codec.struct({
-  value: Codec.optional(Codec.string),
+export const IconState = Persistence.struct({
+  value: Schema.optional(Schema.String),
 })
-
@@ -1,12 +1,13 @@
 import { describe, expect, test } from "bun:test"
 import { canRemoveServer, createServerProjects, resolveServerList, ServerConnection } from "./registry"
+import { Schema } from "effect"
 import { serverState } from "./persistence"
 import { createStore } from "solid-js/store"
 import { ServerScope } from "./scope"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

 function serverSchema() {
-  return Codec.withInitial(serverState(), {
+  return Persistence.withInitial(serverState(), {
    list: [],
    hidden: {},
    projects: {},
@@ -18,7 +19,7 @@ function serverSchema() {
 describe("resolveServerList", () => {
  test("lets startup auth_token credentials override a persisted same-url server", () => {
    const list = resolveServerList({
-      stored: Codec.decodeOrThrow(serverSchema(), { list: [{ url: "https://server.example.test" }] }).list,
+      stored: Schema.decodeUnknownSync(serverSchema())({ list: [{ url: "https://server.example.test" }] }).list,
      props: [
        {
          type: "http",
@@ -43,7 +44,7 @@ describe("resolveServerList", () => {

  test("keeps persisted credentials when startup has no auth_token", () => {
    const list = resolveServerList({
-      stored: Codec.decodeOrThrow(serverSchema(), {
+      stored: Schema.decodeUnknownSync(serverSchema())({
        list: [{ url: "https://server.example.test", password: "saved" }],
      }).list,
      props: [{ type: "http", http: { url: "https://server.example.test" } }],
@@ -76,7 +77,7 @@ test("treats WSL sidecars as remote server connections", () => {
 })

 test("keeps exact persisted server identities and prevents removing provided servers", () => {
-  const stored = Codec.decodeOrThrow(serverSchema(), {
+  const stored = Schema.decodeUnknownSync(serverSchema())({
    list: ["http://localhost:4096", "http://localhost:4096/", "http://127.0.0.1:4096"],
  }).list
  expect(resolveServerList({ stored }).map((server) => String(ServerConnection.key(server)))).toEqual([
@@ -90,7 +91,7 @@ test("keeps exact persisted server identities and prevents removing provided ser
 })

 test("project actions update schema-derived state and follow dynamic server scopes", () => {
-  const [store, setStore] = createStore(Codec.decodeOrThrow(serverSchema(), {}))
+  const [store, setStore] = createStore(Schema.decodeUnknownSync(serverSchema())({}))
  const props: { server: ServerConnection.Key; canonicalLocalServer?: ServerConnection.Key } = {
    server: ServerConnection.Key.make("https://remote.example"),
  }
@@ -114,4 +115,3 @@ test("project actions update schema-derived state and follow dynamic server scop
  expect(store.projects.local).toEqual([{ worktree: "/local", expanded: true }])
  expect(store.projects[props.server]).toEqual([{ worktree: "/remote", expanded: false }])
 })
-
@@ -33,6 +33,8 @@ export type FileContent = {
  }
  encoding?: "base64"
  mimeType?: string
+  /** On-disk size when the bytes themselves are not retained. */
+  size?: number
 }

 export type Path = {
@@ -1,12 +1,12 @@
-import { Codec } from "@/runtime/persistence/codec"
+import { Option, Schema } from "effect"
 import { normalizeServerUrl } from "@/runtime/server/registry"

-const pairing = Codec.fromJsonString(
-  Codec.struct({
-    urls: Codec.array(Codec.string),
-    username: Codec.literal("opencode"),
-    password: Codec.string,
-  }),
+const pairing = Schema.fromJsonString(
+  Schema.Struct({
+    urls: Schema.Array(Schema.String),
+    username: Schema.Literal("opencode"),
+    password: Schema.String,
+  }),
 )

 export function serverAddress(value: string) {
@@ -20,10 +20,9 @@ export function serverAddress(value: string) {
 }

 export function decodePairingCode(value: string) {
-  const result = Codec.decodeOption(pairing, value)
-  if (!result) return
-  const urls = [...new Set(result.urls.map(serverAddress).filter((url) => url !== undefined))]
-  if (!urls.length) return
-  return { urls, password: result.password }
+  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 }
 }
-
@@ -1,3 +1,4 @@
+import { Effect, Fiber } from "effect"
 import { createEffect, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
 import type { SshConfig, SshItem, SshPlatform } from "./types"
@@ -23,8 +24,7 @@ export function createSshController(input: {
      | undefined
    >
  >({})
-  // One in-flight request per server; cancelling settles it immediately and ignores its outcome.
-  const tasks = new Map<string, { cancelled: boolean }>()
+  const tasks = new Map<string, Fiber.Fiber<void>>()
  const item = (id: string) => input.items().find((item) => item.config.id === id)
  const settle = (id: string) => {
    const attempt = attempts[id]
@@ -33,32 +33,31 @@ export function createSshController(input: {
    setAttempts(id, { active: false, onConnected: undefined })
    if (item(id)?.stage === "ready" && onConnected) queueMicrotask(onConnected)
  }
-  const finish = (id: string, task: { cancelled: boolean }) => {
-    if (task.cancelled) return
-    task.cancelled = true
-    if (tasks.get(id) === task) tasks.delete(id)
-    setAttempts(id, "submitting", false)
-  }
-  const interrupt = (id: string) => {
-    const task = tasks.get(id)
-    if (task) finish(id, task)
-  }
-  const run = (id: string, work: () => Promise<unknown>) => {
-    setAttempts(id, { submitting: true, error: false })
-    const task = { cancelled: false }
-    tasks.set(id, task)
-    work().then(
-      () => finish(id, task),
-      () => {
-        if (task.cancelled) return
-        setAttempts(id, "error", true)
-        if (!attempts[id]?.prompted) input.error()
-        finish(id, task)
-      },
-    )
-  }
-  onCleanup(() => {
-    for (const id of [...tasks.keys()]) interrupt(id)
+  const run = (id: string, effect: Effect.Effect<unknown, unknown>) => {
+    setAttempts(id, { submitting: true, error: false })
+    tasks.set(
+      id,
+      Effect.runFork(
+        effect.pipe(
+          Effect.asVoid,
+          Effect.catch(() =>
+            Effect.sync(() => {
+              setAttempts(id, "error", true)
+              if (!attempts[id]?.prompted) input.error()
+            }),
+          ),
+          Effect.ensuring(
+            Effect.sync(() => {
+              tasks.delete(id)
+              setAttempts(id, "submitting", false)
+            }),
+          ),
+        ),
+      ),
+    )
+  }
+  onCleanup(() => {
+    Effect.runFork(Effect.forEach([...tasks.values()], Fiber.interrupt, { discard: true }))
  })
  createEffect(() => {
    for (const item of input.items()) {
@@ -115,32 +114,40 @@ export function createSshController(input: {
        error: false,
        onConnected: options?.onConnected ?? (options?.replace ? attempts[config.id]?.onConnected : undefined),
      })
-      run(config.id, async () => {
-        await api.start({ ...config, replace: options?.replace })
-        // Observe admission before treating an older disconnected snapshot as cancellation.
-        await input.refresh()
-      })
+      run(
+        config.id,
+        Effect.gen(function* () {
+          yield* Effect.tryPromise(() => api.start({ ...config, replace: options?.replace }))
+          // Observe admission before treating an older disconnected snapshot as cancellation.
+          yield* Effect.tryPromise(input.refresh)
+        }),
+      )
    },
    respond: (id: string, prompt: string, value: string) => {
      const api = input.api
      if (!api || item(id)?.prompt?.id !== prompt || attempts[id]?.submitting) return
      if (attempts[id]?.answered === prompt && !attempts[id]?.error) return
      setAttempts(id, "answered", prompt)
-      run(id, () => api.respond(id, prompt, value))
+      run(
+        id,
+        Effect.tryPromise(() => api.respond(id, prompt, value)),
+      )
    },
-    cancel: (id: string) => {
-      const api = input.api
-      interrupt(id)
-      setAttempts(id, undefined)
-      if (!api) return
-      void api
-        .cancel(id)
-        .then(() => (item(id)?.saved ? undefined : api.forget(id)))
-        .catch(() => undefined)
+    cancel: (id: string) => {
+      const task = tasks.get(id)
+      const api = input.api
+      Effect.runFork(
+        Effect.gen(function* () {
+          if (task) yield* Fiber.interrupt(task)
+          setAttempts(id, undefined)
+          if (!api) return
+          yield* Effect.tryPromise(() => api.cancel(id))
+          if (!item(id)?.saved) yield* Effect.tryPromise(() => api.forget(id))
+        }).pipe(Effect.ignore),
+      )
    },
    restore: (config: SshConfig) => input.api?.start({ ...config, background: true }),
    disconnect: (id: string) => input.api?.disconnect(id),
    forget: (id: string) => input.api?.forget(id),
  }
 }
-
@@ -1,61 +0,0 @@
-import { Schema } from "effect"
-
-// The SSH state contract between the desktop main process and its renderer. Only the main process
-// needs the schemas (its RPC server validates with them); the renderer imports the types from ./types.
-
-export const SshConfig = Schema.Struct({ id: Schema.String, target: Schema.String, name: Schema.String })
-export type SshConfig = typeof SshConfig.Type
-export const SshHttp = Schema.Struct({ url: Schema.String, password: Schema.String })
-export type SshHttp = typeof SshHttp.Type
-export const SshStage = Schema.Literals([
-  "disconnected",
-  "connecting",
-  "checking",
-  "downloading",
-  "uploading",
-  "starting",
-  "ready",
-  "authentication",
-  "incompatible",
-  "failed",
-])
-export const SshPrompt = Schema.Struct({
-  id: Schema.String,
-  text: Schema.String,
-  confirm: Schema.Boolean,
-})
-export const SshItem = Schema.Struct({
-  config: SshConfig,
-  saved: Schema.Boolean,
-  destination: Schema.optional(Schema.String),
-  stage: SshStage,
-  http: Schema.optional(SshHttp),
-  prompt: Schema.optional(SshPrompt),
-  authenticatingElsewhere: Schema.optional(Schema.Boolean),
-  detail: Schema.String,
-  error: Schema.optional(
-    Schema.Literals([
-      "connection",
-      "input",
-      "platform",
-      "version",
-      "install",
-      "service",
-      "host-key",
-      "ssh-missing",
-      "unpublished",
-    ]),
-  ),
-})
-export type SshItem = typeof SshItem.Type
-export const SshState = Schema.Struct({ servers: Schema.Array(SshItem) })
-export type SshState = typeof SshState.Type
-export const SshStart = Schema.Struct({
-  id: Schema.String,
-  target: Schema.String,
-  name: Schema.String,
-  replace: Schema.optional(Schema.Boolean),
-  background: Schema.optional(Schema.Boolean),
-})
-export type SshStart = typeof SshStart.Type
-
@@ -1,9 +1,63 @@
-export { sshHostname, sshName } from "./name"
-export { isSshConnecting } from "./status"
-import type { SshConfig, SshHttp, SshItem, SshStart, SshState } from "./schema"
-
-export type { SshConfig, SshHttp, SshItem, SshStart, SshState }
-
+import { Schema } from "effect"
+export { sshHostname, sshName } from "./name"
+export { isSshConnecting } from "./status"
+
+export const SshConfig = Schema.Struct({ id: Schema.String, target: Schema.String, name: Schema.String })
+export type SshConfig = typeof SshConfig.Type
+export const SshHttp = Schema.Struct({ url: Schema.String, password: Schema.String })
+export type SshHttp = typeof SshHttp.Type
+export const SshStage = Schema.Literals([
+  "disconnected",
+  "connecting",
+  "checking",
+  "downloading",
+  "uploading",
+  "starting",
+  "ready",
+  "authentication",
+  "incompatible",
+  "failed",
+])
+export const SshPrompt = Schema.Struct({
+  id: Schema.String,
+  text: Schema.String,
+  confirm: Schema.Boolean,
+})
+export const SshItem = Schema.Struct({
+  config: SshConfig,
+  saved: Schema.Boolean,
+  destination: Schema.optional(Schema.String),
+  stage: SshStage,
+  http: Schema.optional(SshHttp),
+  prompt: Schema.optional(SshPrompt),
+  authenticatingElsewhere: Schema.optional(Schema.Boolean),
+  detail: Schema.String,
+  error: Schema.optional(
+    Schema.Literals([
+      "connection",
+      "input",
+      "platform",
+      "version",
+      "install",
+      "service",
+      "host-key",
+      "ssh-missing",
+      "unpublished",
+    ]),
+  ),
+})
+export type SshItem = typeof SshItem.Type
+export const SshState = Schema.Struct({ servers: Schema.Array(SshItem) })
+export type SshState = typeof SshState.Type
+export const SshStart = Schema.Struct({
+  id: Schema.String,
+  target: Schema.String,
+  name: Schema.String,
+  replace: Schema.optional(Schema.Boolean),
+  background: Schema.optional(Schema.Boolean),
+})
+export type SshStart = typeof SshStart.Type
+
 export type SshPlatform = {
  getState(): Promise<SshState>
  subscribe(callback: (state: SshState) => void): () => void
@@ -16,5 +70,3 @@ export type SshPlatform = {
  forget(id: string): Promise<void>
  openConfig(): Promise<void>
 }
-
-
@@ -1,14 +1,15 @@
-import { createEffect, createMemo, getOwner, on, onCleanup, runWithOwner } from "solid-js"
+import { batch, createEffect, createMemo, createRoot, getOwner, on, onCleanup, runWithOwner } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
 import { createSimpleContext } from "@opencode/ui/context"
-import type { Browser } from "@opencode/plugin-browser/rpc"
 import { useLanguage } from "@/runtime/i18n/language"
 import type { BrowserPaneCommand } from "@/runtime/platform/browser-pane"
 import { usePlatform } from "@/runtime/platform/platform"
 import type { useServer } from "@/runtime/server/current"
+import type { SessionStateKey } from "@/runtime/server/scope"
 import { useSettings } from "@/settings/model"
 import { findSessionTab, tabKey, useTabs } from "@/shell/tabs/tabs"
-import { useCurrentRoute } from "@/shell/state/layout"
+import { useCurrentRoute, useLayout } from "@/shell/state/layout"
+import { sessionBrowserTab } from "@/shell/state/session-tabs"
 import { createEventListener } from "@solid-primitives/event-listener"
 import { createBrowserConnection, type BrowserConnectionState } from "./connection"

@@ -35,13 +36,14 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
    const settings = useSettings()
    const language = useLanguage()
    const shellTabs = useTabs()
+    const layout = useLayout()
    const route = useCurrentRoute()
    const owner = getOwner()
    const [store, setStore] = createStore<Record<string, BrowserAttachment | undefined>>({})
    // Servers whose plugin lacks the browser RPC; sessions on them stop retrying.
    const [unsupported, setUnsupported] = createStore<Record<string, true | undefined>>({})
    const live = new Map<string, Live>()
-    const focus = new Map<string, Set<(tabID: Browser.TabID) => void>>()
+    const preview = new Map<string, Set<(path: string) => void>>()
    const key = (server: Server, sessionID: string) => `${server.key}\n${sessionID}`
    const enabled = createMemo(
      () => !!platform.browserPane && settings.ready() && settings.general.experimentalBrowser(),
@@ -87,11 +89,14 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
      enabled,
      supported: (server: Server) => !unsupported[server.key],
      state: (server: Server, sessionID: string) => store[key(server, sessionID)],
-      attach(server: Server, sessionID: string) {
+      attach(server: Server, sessionID: string, sessionKey: SessionStateKey) {
        const id = key(server, sessionID)
        if (live.has(id)) return
        const pane = platform.browserPane
        if (!pane || !enabled() || unsupported[server.key] || server.health?.incompatible) return
+        // Focus requests write to the owning session's layout even while another shell tab is routed,
+        // so the Review pane and browser tab are already selected when the user returns to it.
+        const tabs = createRoot((dispose) => ({ dispose, layout: layout.tabs(sessionKey) }), owner)
        const connection = createBrowserConnection({
          pane,
          // Resolve the current port at every wake, including after sidecar replacement.
@@ -100,7 +105,15 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
            sessionID,
            endpoint: { ...server.conn.http, url: server.ctx.sdk.url },
          }),
-          focus: (tabID) => focus.get(id)?.forEach((listener) => listener(tabID)),
+          focus: (tabID) => {
+            const tab = sessionBrowserTab(tabID)
+            batch(() => {
+              shellTabs.setPane(findSessionTab(shellTabs.store, server.key, sessionID), "review", true)
+              if (!tabs.layout.all().includes(tab)) tabs.layout.setAll([...tabs.layout.all(), tab])
+              tabs.layout.setActive(tab)
+            })
+          },
+          preview: (path) => preview.get(id)?.forEach((listener) => listener(path)),
          change: (state) => {
            if (state.error === "browser.pane.unsupported") {
              setUnsupported(server.key, true)
@@ -138,17 +151,18 @@ export const { use: useBrowserAttachments, provider: BrowserAttachmentsProvider
        entry.dispose = () => {
          unsubscribe?.forEach((dispose) => dispose())
          connection.dispose()
+          tabs.dispose()
        }
      },
-      /** Desktop focus requests for a mounted session route; nothing is replayed to routes mounted later. */
-      onFocus(server: Server, sessionID: string, listener: (tabID: Browser.TabID) => void) {
+      /** Agent requests to show a file in this session's Review pane. */
+      onPreview(server: Server, sessionID: string, listener: (path: string) => void) {
        const id = key(server, sessionID)
-        const listeners = focus.get(id) ?? new Set()
+        const listeners = preview.get(id) ?? new Set()
        listeners.add(listener)
-        focus.set(id, listeners)
+        preview.set(id, listeners)
        return () => {
          listeners.delete(listener)
-          if (!listeners.size) focus.delete(id)
+          if (!listeners.size) preview.delete(id)
        }
      },
      command(server: Server, sessionID: string, command: BrowserPaneCommand) {
@@ -28,10 +28,12 @@ function fixture() {
    commands: Browser.Action[]
  }[] = []
  const endpoint = { url: "http://localhost:4096" }
+  const previews: string[] = []
  const connection = createBrowserConnection({
    target: () => ({ serverKey: "browser-test", sessionID: "ses_browser", endpoint: { ...endpoint } }),
    change: (state) => states.push(state),
    focus: () => {},
+    preview: (path) => previews.push(path),
    pane: {
      register(target, emit) {
        const call = { target, emit, closed: false, commands: [] as Browser.Action[] }
@@ -50,9 +52,21 @@ function fixture() {
  })
  connection.wake()
  calls[0].emit({ type: "state", state: browser })
-  return { connection, calls, states, endpoint }
+  return { connection, calls, states, endpoint, previews }
 }

+test("preview requests reach the session without touching connection state", () => {
+  const app = fixture()
+  try {
+    const before = app.states.length
+    app.calls[0].emit({ type: "preview", path: "docs/report.pdf" })
+    expect(app.previews).toEqual(["docs/report.pdf"])
+    expect(app.states).toHaveLength(before)
+  } finally {
+    app.connection.dispose()
+  }
+})
+
 test("suspension retains tabs and reconnects once on demand using the current endpoint", async () => {
  const app = fixture()
  try {
@@ -19,6 +19,7 @@ export function createBrowserConnection(input: {
  target: () => BrowserPaneTarget
  change: (state: BrowserConnectionState) => void
  focus: (tabID: Browser.TabID) => void
+  preview: (path: string) => void
 }) {
  const state: BrowserConnectionState = { browser: null, suspended: false }
  let disposed = false
@@ -33,6 +34,7 @@ export function createBrowserConnection(input: {
      (event) => {
        if (disposed || state.registration !== registration) return
        if (event.type === "focus") return input.focus(event.tabID)
+        if (event.type === "preview") return input.preview(event.path)
        if (event.error === "browser.pane.unsupported" || event.error === "browser.pane.replaced") {
          blocked = true
          registration.close()
@@ -1,4 +1,4 @@
-import { batch, createEffect, createMemo, on, onCleanup } from "solid-js"
+import { batch, createEffect, createMemo, on } from "solid-js"
 import type { Browser } from "@opencode/plugin-browser/rpc"
 import { createStore } from "solid-js/store"
 import { useLanguage } from "@/runtime/i18n/language"
@@ -33,13 +33,6 @@ export function createSessionBrowser(session: SessionModel) {
      attachment()?.browser?.tabs.filter((tab) => session.layout.tabs().all().includes(sessionBrowserTab(tab.id))) ??
      [],
  )
-  const focus = (tabID: Browser.TabID) => {
-    session.layout.view().reviewPanel.open()
-    const tabs = session.layout.tabs()
-    const key = sessionBrowserTab(tabID)
-    if (!tabs.all().includes(key)) tabs.setAll([...tabs.all(), key])
-    tabs.setActive(key)
-  }
  const command = (command: BrowserPaneCommand) => {
    const sessionID = session.identity.sessionID()
    if (!sessionID) return
@@ -66,8 +59,7 @@ export function createSessionBrowser(session: SessionModel) {
  createEffect(() => {
    const sessionID = session.identity.sessionID()
    if (!sessionID) return
-    if (attachments.enabled()) attachments.attach(server, sessionID)
-    onCleanup(attachments.onFocus(server, sessionID, focus))
+    if (attachments.enabled()) attachments.attach(server, sessionID, session.layout.sessionKey())
  })
  createEffect(
    on(
@@ -20,13 +20,18 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
  const command = useCommand()
  const state = props.browser.active
  const address = () => (state()?.url === "about:blank" ? "" : (state()?.url ?? ""))
+  const failed = () => !!state()?.loadError
  const registration = props.browser.registration
  const button = { variant: "ghost", size: "large" } as const
  const [store, setStore] = createStore({
    address: "",
    editing: false,
+    submitted: false,
+    // A submitted navigation the browser has not reported yet; keeps the empty state hidden meanwhile.
+    navigating: false,
    visible: typeof document === "undefined" || document.visibilityState === "visible",
  })
+  const empty = () => !address() && !state()?.loading && !store.navigating
  let surface: HTMLDivElement | undefined
  let addressDisplay: HTMLDivElement | undefined
  let frame: number | undefined
@@ -43,7 +48,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
      title: language.t("command.browser.reload"),
      category: language.t("command.category.view"),
      keybind: "f5",
-      disabled: !props.visible || !state(),
+      disabled: !props.visible || !address(),
      onSelect: () => {
        const tab = state()
        if (tab) props.browser.command({ type: "reload", tabID: tab.id })
@@ -71,7 +76,9 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    const top = Math.round(rect.top * zoom)
    const right = Math.round(rect.right * zoom)
    const bottom = Math.round(rect.bottom * zoom)
-    const visible = props.visible && store.visible && !dialog.active && !covered(rect)
+    // The desktop page hides blank and loading documents itself; only hide here
+    // while the pane shows its own empty or failed state over the surface.
+    const visible = props.visible && store.visible && !empty() && !failed() && !dialog.active && !covered(rect)
    // The cutout exposes the app backdrop outside the rounded Review card,
    // not the browser surface inside it.
    const color = getComputedStyle(
@@ -107,7 +114,25 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
    if (frame === undefined) frame = requestAnimationFrame(tick)
  }

-  createEffect(() => !store.editing && setStore("address", address()))
+  createEffect(on([() => state()?.id, address], () => !store.editing && setStore("address", address())))
+  // Any reported movement, including a rejected or blocked request, ends the submitted navigation.
+  createEffect(
+    on(
+      [() => state()?.id, () => state()?.generation, () => state()?.loading, () => props.browser.error()],
+      () => setStore("navigating", false),
+      { defer: true },
+    ),
+  )
+  // A blocked or rejected submission leaves the page where it was; show that page's URL again.
+  createEffect(
+    on(
+      () => props.browser.error(),
+      (error) => {
+        if (error && !store.editing) setStore("address", address())
+      },
+      { defer: true },
+    ),
+  )
  createEffect(
    on(registration, (current) => {
      // Session routes can change before this pane unmounts. Hide the registration
@@ -123,6 +148,8 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        () => store.visible,
        () => props.visible,
        () => state()?.id,
+        empty,
+        failed,
        registration,
      ],
      () => {
@@ -157,7 +184,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes

  return (
    <aside id="browser-panel" class="relative size-full min-w-0 overflow-hidden bg-v2-background-bg-base flex flex-col">
-      <div class="h-10 shrink-0 flex items-center gap-1 px-2 border-b border-v2-border-border-muted">
+      <div class="h-10 shrink-0 flex items-center gap-1 px-3 border-b border-v2-border-border-muted">
        <For each={["back", "forward"] as const}>
          {(direction) => (
            <Tooltip placement="top" value={language.t(direction === "back" ? "common.goBack" : "common.goForward")}>
@@ -193,7 +220,7 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
        >
          <IconButton
            {...button}
-            disabled={!state()}
+            disabled={!state()?.loading && !address()}
            aria-label={language.t(state()?.loading ? "prompt.action.stop" : "error.page.action.reload")}
            onClick={() => {
              const tab = state()
@@ -212,8 +239,13 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          onSubmit={(event) => {
            event.preventDefault()
            const tab = state()
-            if (tab && store.address.trim())
-              props.browser.command({ type: "navigate", tabID: tab.id, url: store.address })
+            const url = store.address.trim()
+            if (!tab) return
+            if (url || failed()) {
+              setStore({ submitted: true, address: url, navigating: true })
+              props.browser.command({ type: "navigate", tabID: tab.id, url: url || "about:blank" })
+            }
+            event.currentTarget.querySelector("input")?.blur()
          }}
        >
          <input
@@ -224,8 +256,14 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
            disabled={!state()}
            placeholder={language.t("session.browser.address.placeholder")}
            aria-label={language.t("session.browser.address")}
-            onFocus={() => setStore("editing", true)}
-            onBlur={() => setStore({ editing: false, address: address() })}
+            onFocus={(event) => {
+              setStore("editing", true)
+              event.currentTarget.select()
+            }}
+            onClick={(event) => event.currentTarget.select()}
+            onBlur={() =>
+              setStore({ editing: false, address: store.submitted ? store.address : address(), submitted: false })
+            }
            onInput={(event) => setStore("address", event.currentTarget.value)}
            onScroll={(event) => {
              if (addressDisplay) addressDisplay.scrollLeft = event.currentTarget.scrollLeft
@@ -243,12 +281,27 @@ export function SessionBrowserPane(props: { browser: ReturnType<typeof createSes
          </div>
        </form>
      </div>
-      <Show when={props.browser.error()}>
+      <Show when={props.browser.error() && !failed()}>
        <div class="shrink-0 px-3 py-1.5 text-12-regular text-text-danger-base border-b border-v2-border-border-muted">
          {props.browser.error()}
        </div>
      </Show>
      <div ref={surface} class="min-h-0 flex-1 bg-v2-background-bg-base flex items-center justify-center">
+        <Show when={(empty() || failed()) && !props.browser.suspended()}>
+          {/* Add the 40px toolbar to the file empty state's 160px bottom padding to align their centers. */}
+          <div
+            dir="auto"
+            class="flex size-full flex-col items-center justify-center gap-2 p-6 pb-[200px] text-center text-text-weak"
+          >
+            <Icon name="globe" size="large" class="mb-2 shrink-0" />
+            <div class="text-[13px] font-medium leading-[var(--line-height-compact)] text-text-strong">
+              {language.t(failed() ? "session.browser.failed.title" : "session.browser.empty.title")}
+            </div>
+            <div class="text-13-regular leading-[var(--line-height-base)]">
+              {language.t(failed() ? "session.browser.failed.description" : "session.browser.empty.description")}
+            </div>
+          </div>
+        </Show>
        <Show when={props.browser.suspended()}>
          <p class="px-6 text-center text-13-regular text-v2-text-text-subtle" role="status">
            {language.t("session.browser.suspended")}
@@ -0,0 +1,114 @@
+import { createEffect, onCleanup } from "solid-js"
+import { createStore } from "solid-js/store"
+import { useLanguage } from "@/runtime/i18n/language"
+import { useServerSDK } from "@/runtime/server/client"
+import { useCommand } from "@/shell/commands/command"
+import { showToast } from "@/shell/notifications/toast"
+import { SESSION_BTW_TAB } from "@/session/helpers"
+import type { SessionModel } from "../model"
+
+const instructions = [
+  "The user is asking a quick side question about the conversation so far.",
+  "Answer directly and concisely in markdown from what you already know.",
+  "Do not call any tools and do not take any actions.",
+].join(" ")
+
+const empty = {
+  question: "",
+  answer: "",
+  error: false,
+  pending: false,
+}
+
+export function createSessionBtw(session: SessionModel) {
+  const command = useCommand()
+  const language = useLanguage()
+  const server = useServerSDK()
+  const [states, setStates] = createStore<Record<string, typeof empty>>({})
+  const requests = new Map<string, number>()
+  const controllers = new Map<string, AbortController>()
+  const state = () => states[session.identity.sessionKey()] ?? empty
+
+  createEffect(() => {
+    const key = session.identity.sessionKey()
+    onCleanup(() => {
+      const controller = controllers.get(key)
+      if (!controller) return
+      controller.abort()
+      controllers.delete(key)
+      if (states[key]?.pending) setStates(key, { pending: false, error: true })
+    })
+  })
+
+  const open = () => {
+    session.layout.view().reviewPanel.open()
+    const tabs = session.layout.tabs()
+    if (tabs.active() !== SESSION_BTW_TAB) tabs.open(SESSION_BTW_TAB)
+  }
+  const ask = (value?: string) => {
+    const question = value?.trim()
+    if (!question) {
+      showToast({ title: language.t("session.btw.questionRequired") })
+      return
+    }
+    open()
+    const sessionID = session.identity.sessionID()
+    if (!sessionID) return
+
+    const key = session.identity.sessionKey()
+    const request = (requests.get(key) ?? 0) + 1
+    requests.set(key, request)
+    controllers.get(key)?.abort()
+    const controller = new AbortController()
+    controllers.set(key, controller)
+    const owner = session.ownership.capture()
+    setStates(key, { question, answer: "", error: false, pending: true })
+    return server.api.session
+      .generate(
+        {
+          sessionID,
+          prompt: [instructions, question].join("\n\n"),
+        },
+        { signal: controller.signal },
+      )
+      .then((result) => {
+        owner.run(() => {
+          if (requests.get(key) !== request) return
+          setStates(key, { answer: result.text.trim(), pending: false })
+        })
+      })
+      .catch(() => {
+        owner.run(() => {
+          if (controller.signal.aborted || requests.get(key) !== request) return
+          setStates(key, { error: true, pending: false })
+        })
+      })
+      .finally(() => {
+        if (controllers.get(key) === controller) controllers.delete(key)
+      })
+  }
+
+  command.register("session.btw", () => [
+    {
+      id: "session.btw",
+      title: language.t("command.session.btw"),
+      description: language.t("command.session.btw.description"),
+      category: language.t("command.category.session"),
+      slash: "btw",
+      slashArguments: true,
+      hidden: true,
+      disabled: !session.isDesktop(),
+      onSelect: (_source, input) => ask(input),
+    },
+  ])
+
+  return {
+    answer: () => state().answer,
+    error: () => state().error,
+    pending: () => state().pending,
+    question: () => state().question,
+    retry: () => ask(state().question),
+  }
+}
+
+export type SessionBtwModel = ReturnType<typeof createSessionBtw>
@@ -0,0 +1,80 @@
+import { createEffect, createSignal, Match, Show, Switch } from "solid-js"
+import { Button } from "@opencode/ui/button"
+import { Icon } from "@opencode/ui/icon"
+import { IconButton } from "@opencode/ui/icon-button"
+import { ScrollView } from "@opencode/ui/scroll-view"
+import { TextShimmer } from "@opencode/ui/text-shimmer"
+import { Tooltip } from "@opencode/ui/tooltip"
+import { Markdown } from "@opencode/session-ui/markdown"
+import { useLanguage } from "@/runtime/i18n/language"
+import { usePlatform } from "@/runtime/platform/platform"
+import { showToast } from "@/shell/notifications/toast"
+import type { SessionBtwModel } from "./model"
+
+export function SessionBtwPanel(props: { btw: SessionBtwModel }) {
+  const language = useLanguage()
+  const platform = usePlatform()
+  const [copied, setCopied] = createSignal(false)
+
+  createEffect(() => {
+    props.btw.answer()
+    setCopied(false)
+  })
+
+  const copy = () => {
+    const answer = props.btw.answer()
+    if (!answer) return
+    void (platform.writeClipboardText?.(answer) ?? navigator.clipboard.writeText(answer)).then(
+      () => setCopied(true),
+      () => showToast({ title: language.t("common.requestFailed") }),
+    )
+  }
+
+  return (
+    <div class="flex h-full min-h-0 flex-col bg-v2-background-bg-base" data-slot="session-btw-panel">
+      <div class="flex shrink-0 items-start justify-between gap-3 border-b border-v2-border-border-base px-5 py-4">
+        <div class="min-w-0 text-13-regular text-text-weak">{props.btw.question()}</div>
+        <Show when={props.btw.answer()}>
+          <Tooltip value={copied() ? language.t("common.copied") : language.t("session.btw.copy")}>
+            <IconButton
+              size="small"
+              variant="ghost-muted"
+              icon={<Icon name={copied() ? "check" : "outline-copy"} />}
+              aria-label={copied() ? language.t("common.copied") : language.t("session.btw.copy")}
+              onClick={copy}
+            />
+          </Tooltip>
+        </Show>
+      </div>
+
+      <div class="relative min-h-0 flex-1">
+        <Switch>
+          <Match when={props.btw.pending()}>
+            <div
+              data-component="session-working"
+              role="status"
+              class="flex h-9 items-center px-5 pt-3 text-[13px] font-[530] leading-text-compact"
+            >
+              <TextShimmer text={language.t("session.timeline.working")} active />
+            </div>
+          </Match>
+          <Match when={props.btw.error()}>
+            <div class="flex h-full flex-col items-center justify-center gap-3 px-8 pb-24 text-center">
+              <div class="text-13-regular text-text-weak">{language.t("session.btw.error")}</div>
+              <Button size="small" variant="outline" onClick={props.btw.retry}>
+                {language.t("session.btw.retry")}
+              </Button>
+            </div>
+          </Match>
+          <Match when={props.btw.answer()}>
+            <ScrollView class="absolute inset-0">
+              <div class="px-5 py-4 pb-8">
+                <Markdown text={props.btw.answer()} class="text-14-regular" />
+              </div>
+            </ScrollView>
+          </Match>
+        </Switch>
+      </div>
+    </div>
+  )
+}
@@ -0,0 +1,94 @@
+/* The control defaults to a fixed 232px with equal segments; here it hugs its two labels. */
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2"] {
+  width: auto;
+}
+
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2-item"] {
+  flex: 0 0 auto;
+  padding: 0 14px;
+}
+
+/* Shrink-wrapped segments round the label box down a fraction; the ellipsis overflow then clips glyph edges. */
+[data-slot="artifact-toolbar"] [data-slot="segmented-control-v2-item-label"] {
+  overflow: visible;
+  max-width: none;
+}
+
+[data-slot="artifact-stage"] {
+  --artifact-check: color-mix(in oklch, var(--v2-text-text-base) 5%, transparent);
+  background-color: var(--v2-background-bg-deep);
+}
+
+[data-slot="artifact-stage"][data-checker] {
+  background-image:
+    linear-gradient(45deg, var(--artifact-check) 25%, transparent 25%),
+    linear-gradient(-45deg, var(--artifact-check) 25%, transparent 25%),
+    linear-gradient(45deg, transparent 75%, var(--artifact-check) 75%),
+    linear-gradient(-45deg, transparent 75%, var(--artifact-check) 75%);
+  background-size: 16px 16px;
+  background-position:
+    0 0,
+    0 8px,
+    8px -8px,
+    -8px 0;
+}
+
+[data-slot="artifact-media"] {
+  display: block;
+  border-radius: 4px;
+  box-shadow:
+    0 0 0 0.5px var(--v2-border-border-base),
+    0 12px 32px -12px color-mix(in oklch, var(--v2-text-text-base) 25%, transparent);
+}
+
+[data-slot="artifact-stage"][data-zoom="fit"] [data-slot="artifact-media"] {
+  max-width: 100%;
+  max-height: 100%;
+  object-fit: contain;
+}
+
+[data-slot="artifact-stage"][data-zoom="fit"][data-overflow] [data-slot="artifact-media"] {
+  cursor: zoom-in;
+}
+
+[data-slot="artifact-stage"][data-zoom="actual"] [data-slot="artifact-media"] {
+  cursor: zoom-out;
+}
+
+[data-slot="artifact-table"] {
+  border-collapse: separate;
+  border-spacing: 0;
+  font-variant-numeric: tabular-nums;
+}
+
+[data-slot="artifact-table"] th,
+[data-slot="artifact-table"] td {
+  padding: 5px 12px;
+  border-bottom: 1px solid var(--v2-border-border-muted);
+  border-inline-end: 1px solid var(--v2-border-border-muted);
+  white-space: pre;
+  max-width: 40ch;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  text-align: start;
+  line-height: var(--line-height-compact);
+}
+
+[data-slot="artifact-table"] th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: var(--v2-background-bg-layer-01);
+  font-weight: var(--font-weight-medium);
+  color: var(--v2-text-text-muted);
+}
+
+[data-slot="artifact-table"] tbody tr:hover td {
+  background: color-mix(in oklch, var(--v2-text-text-base) 3%, transparent);
+}
+
+[data-slot="artifact-table"] td[data-index] {
+  color: var(--v2-text-text-faint);
+  text-align: end;
+  user-select: none;
+}
@@ -0,0 +1,454 @@
+import { createEffect, createMemo, For, Match, on, onCleanup, Show, Switch, type JSX } from "solid-js"
+import { createStore } from "solid-js/store"
+import { createResizeObserver } from "@solid-primitives/resize-observer"
+import { Button } from "@opencode/ui/button"
+import { FileIcon } from "@opencode/ui/file-icon"
+import { SegmentedControl, SegmentedControlItem } from "@opencode/ui/segmented-control"
+import { ScrollView } from "@opencode/ui/scroll-view"
+import { Markdown } from "@opencode/session-ui/markdown"
+import { MarkdownProvider, useMarkdown } from "@opencode/session-ui/context/markdown"
+import { getDirectory, getFilename } from "@opencode/util/path"
+import type { FileContent } from "@/runtime/server/types"
+import { useLanguage } from "@/runtime/i18n/language"
+import {
+  artifactKind,
+  blobUrlFromContent,
+  contentBytes,
+  parseDelimited,
+  resolveArtifactPath,
+  type ArtifactKind,
+} from "@/workspaces/files/artifact"
+import { useArtifactOpener } from "@/session/files/open-artifact"
+import "./artifact-view.css"
+
+type ArtifactMode = "preview" | "source"
+
+/** Facts a viewer learns from the decoded media, shown in the toolbar. */
+type ArtifactInfo = { width?: number; height?: number; duration?: number; rows?: number; columns?: number }
+
+type MediaProps = {
+  path: string
+  content: FileContent
+  onInfo: (info: ArtifactInfo) => void
+  /** The browser could not decode the bytes; the host falls back to the binary placeholder. */
+  onError: () => void
+}
+
+/** Kinds that render a preview from their text and can toggle back to highlighted source. */
+const previewableKinds = new Set<ArtifactKind>(["svg", "html", "markdown", "mermaid", "table"])
+
+/**
+ * Renders a loaded non-text file: media, documents, and data get a dedicated viewer with a toolbar;
+ * previewable text kinds can switch to `source`, which the host supplies (its code view).
+ */
+export function ArtifactView(props: { path: string; content: FileContent; cacheKey?: string; source: JSX.Element }) {
+  const language = useLanguage()
+  const [state, setState] = createStore({
+    mode: "preview" as ArtifactMode,
+    info: {} as ArtifactInfo,
+    // Media the browser could not decode falls back to the binary placeholder.
+    undecodable: false,
+  })
+  createEffect(
+    on(
+      () => props.content,
+      () => setState({ mode: "preview", info: {}, undecodable: false }),
+      { defer: true },
+    ),
+  )
+
+  const kind = createMemo<ArtifactKind | "binary">(() => {
+    if (props.content.type === "binary" && !props.content.mimeType) return "binary"
+    if (state.undecodable) return "binary"
+    return artifactKind(props.path)
+  })
+  const previewable = createMemo(() => {
+    const value = kind()
+    return value !== "binary" && previewableKinds.has(value)
+  })
+  const meta = createMemo(() => {
+    const info = state.info
+    return [
+      info.width && info.height ? `${info.width} × ${info.height}` : undefined,
+      info.duration ? formatDuration(info.duration) : undefined,
+      info.rows !== undefined ? language.plural("file.view.table.rows", Math.max(0, info.rows - 1)) : undefined,
+      info.columns !== undefined ? language.plural("file.view.table.columns", info.columns) : undefined,
+      formatBytes(language.intl(), contentBytes(props.content)),
+    ].filter((item): item is string => !!item)
+  })
+
+  const media = { onInfo: (info: ArtifactInfo) => setState("info", info), onError: () => setState("undecodable", true) }
+  const rendered = () => (
+    <ScrollView class="min-h-0 flex-1">
+      <Show
+        when={kind() === "markdown"}
+        fallback={<ArtifactMermaid text={props.content.content} cacheKey={props.cacheKey} />}
+      >
+        <ArtifactMarkdown path={props.path} text={props.content.content} cacheKey={props.cacheKey} />
+      </Show>
+    </ScrollView>
+  )
+
+  return (
+    <>
+      <ArtifactToolbar
+        mode={state.mode}
+        onModeChange={previewable() ? (mode) => setState("mode", mode) : undefined}
+        meta={meta()}
+        actions={
+          <Show when={kind() === "html"}>
+            <OpenInBrowserButton path={props.path} />
+          </Show>
+        }
+      />
+      <Show when={!previewable() || state.mode === "preview"} fallback={props.source}>
+        <Switch>
+          <Match when={kind() === "image" || kind() === "svg"}>
+            <ArtifactImage path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "video"}>
+            <ArtifactVideo path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "audio"}>
+            <ArtifactAudio path={props.path} content={props.content} {...media} />
+          </Match>
+          <Match when={kind() === "pdf" || kind() === "html"}>
+            <ArtifactFrame path={props.path} content={props.content} kind={kind() === "pdf" ? "pdf" : "html"} />
+          </Match>
+          <Match when={kind() === "font"}>
+            <ArtifactFont path={props.path} content={props.content} />
+          </Match>
+          <Match when={kind() === "table"}>
+            <ArtifactTable path={props.path} text={props.content.content} onInfo={media.onInfo} />
+          </Match>
+          <Match when={kind() === "markdown" || kind() === "mermaid"}>{rendered()}</Match>
+          <Match when={kind() === "binary"}>
+            <ArtifactBinary path={props.path} size={formatBytes(language.intl(), contentBytes(props.content))} />
+          </Match>
+        </Switch>
+      </Show>
+    </>
+  )
+}
+
+function formatBytes(locale: string, bytes: number) {
+  const units = ["byte", "kilobyte", "megabyte", "gigabyte"] as const
+  const index = Math.min(units.length - 1, bytes > 0 ? Math.floor(Math.log10(bytes) / 3) : 0)
+  const value = bytes / 1000 ** index
+  return new Intl.NumberFormat(locale, {
+    style: "unit",
+    unit: units[index],
+    // "short" bytes render as the singular "byte"; the long form pluralizes correctly.
+    unitDisplay: index === 0 ? "long" : "short",
+    maximumFractionDigits: value >= 100 || index === 0 ? 0 : 1,
+  }).format(value)
+}
+
+function formatDuration(seconds: number) {
+  const total = Math.round(seconds)
+  const minutes = Math.floor(total / 60)
+  return `${minutes}:${String(total % 60).padStart(2, "0")}`
+}
+
+function ArtifactToolbar(props: {
+  mode?: ArtifactMode
+  onModeChange?: (mode: ArtifactMode) => void
+  meta: string[]
+  actions?: JSX.Element
+}) {
+  const language = useLanguage()
+  return (
+    <div data-slot="artifact-toolbar" class="flex h-10 shrink-0 items-center gap-3 px-4">
+      <Show when={props.onModeChange}>
+        <SegmentedControl
+          value={props.mode ?? "preview"}
+          onChange={(value) => {
+            if (value === "preview" || value === "source") props.onModeChange?.(value)
+          }}
+        >
+          <SegmentedControlItem value="preview">{language.t("file.view.preview")}</SegmentedControlItem>
+          <SegmentedControlItem value="source">{language.t("file.view.source")}</SegmentedControlItem>
+        </SegmentedControl>
+      </Show>
+      <div class="ms-auto flex min-w-0 items-center gap-3">
+        <div class="flex min-w-0 items-center gap-2 text-12-regular text-text-weak">
+          <For each={props.meta}>
+            {(item, index) => (
+              <>
+                <Show when={index() > 0}>
+                  <span aria-hidden class="text-text-faint">
+                    ·
+                  </span>
+                </Show>
+                <span class="truncate tabular-nums">{item}</span>
+              </>
+            )}
+          </For>
+        </div>
+        {props.actions}
+      </div>
+    </div>
+  )
+}
+
+function OpenInBrowserButton(props: { path: string }) {
+  const language = useLanguage()
+  const artifacts = useArtifactOpener()
+  return (
+    <Show when={artifacts.canOpenInBrowser(props.path)}>
+      <Button size="small" variant="ghost" icon="globe" onClick={() => artifacts.openInBrowser(props.path)}>
+        {language.t("file.view.openInBrowser")}
+      </Button>
+    </Show>
+  )
+}
+
+function createBlobUrl(content: () => FileContent) {
+  return createMemo(() => {
+    const value = blobUrlFromContent(content())
+    onCleanup(() => URL.revokeObjectURL(value))
+    return value
+  })
+}
+
+/** Images and SVG previews: fit the pane, click to inspect at 1:1 when the image is larger. */
+function ArtifactImage(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  const [state, setState] = createStore({ zoom: "fit" as "fit" | "actual", overflow: false, width: 0, height: 0 })
+  let stage: HTMLDivElement | undefined
+  const measure = () => {
+    if (!stage) return
+    setState("overflow", state.width > stage.clientWidth - 48 || state.height > stage.clientHeight - 48)
+  }
+  createResizeObserver(
+    () => stage,
+    () => measure(),
+  )
+  createEffect(() => {
+    url()
+    setState({ zoom: "fit", overflow: false })
+  })
+  return (
+    <div
+      ref={stage}
+      data-slot="artifact-stage"
+      data-checker
+      data-zoom={state.zoom}
+      data-overflow={state.overflow || undefined}
+      class="relative min-h-0 flex-1 overflow-auto"
+    >
+      <div
+        classList={{
+          "absolute inset-0 flex items-center justify-center p-6": state.zoom === "fit",
+          "flex min-h-full min-w-full w-max items-center justify-center p-6": state.zoom === "actual",
+        }}
+      >
+        <img
+          data-slot="artifact-media"
+          src={url()}
+          alt={getFilename(props.path)}
+          draggable={false}
+          onError={() => props.onError()}
+          onLoad={(event) => {
+            const image = event.currentTarget
+            setState({ width: image.naturalWidth, height: image.naturalHeight })
+            props.onInfo({ width: image.naturalWidth, height: image.naturalHeight })
+            measure()
+          }}
+          onClick={() => {
+            if (!state.overflow && state.zoom === "fit") return
+            setState("zoom", state.zoom === "fit" ? "actual" : "fit")
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function ArtifactVideo(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  return (
+    <div data-slot="artifact-stage" data-zoom="fit" class="relative min-h-0 flex-1 overflow-hidden">
+      <div class="absolute inset-0 flex items-center justify-center p-6">
+        <video
+          data-slot="artifact-media"
+          class="w-full bg-black"
+          controls
+          preload="metadata"
+          playsinline
+          onError={() => props.onError()}
+          src={url()}
+          onLoadedMetadata={(event) => {
+            const video = event.currentTarget
+            props.onInfo({ width: video.videoWidth, height: video.videoHeight, duration: video.duration })
+          }}
+        />
+      </div>
+    </div>
+  )
+}
+
+function ArtifactAudio(props: MediaProps) {
+  const url = createBlobUrl(() => props.content)
+  return (
+    <div data-slot="artifact-stage" class="relative min-h-0 flex-1 overflow-auto">
+      <div class="absolute inset-0 flex items-center justify-center p-6">
+        <div class="flex w-full max-w-lg flex-col items-center gap-5 rounded-xl border border-v2-border-border-muted bg-v2-background-bg-base px-8 py-8 shadow-[var(--v2-elevation-raised)]">
+          <div class="flex size-14 items-center justify-center rounded-full bg-v2-background-bg-layer-02">
+            <FileIcon node={{ path: props.path, type: "file" }} class="size-7" />
+          </div>
+          <div class="max-w-full truncate text-14-medium text-text-strong">{getFilename(props.path)}</div>
+          <audio
+            class="w-full"
+            onError={() => props.onError()}
+            controls
+            preload="metadata"
+            src={url()}
+            onLoadedMetadata={(event) => props.onInfo({ duration: event.currentTarget.duration })}
+          />
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function ArtifactFrame(props: { path: string; content: FileContent; kind: "pdf" | "html" }) {
+  const url = createBlobUrl(() => props.content)
+  // PDF Open Parameters: start with the thumbnail pane closed and the page fitted to the pane width.
+  const src = () => (props.kind === "pdf" ? `${url()}#navpanes=0&view=FitH` : url())
+  return (
+    <iframe
+      class="block h-full w-full flex-1 border-0 bg-white"
+      title={getFilename(props.path)}
+      src={src()}
+      // The PDF viewer is Chromium's own and does not run in a sandboxed frame. HTML runs as an
+      // opaque origin: no app storage, cookies, or credentialed requests reach it.
+      sandbox={props.kind === "html" ? "allow-scripts allow-popups allow-forms allow-modals" : undefined}
+      referrerPolicy="no-referrer"
+    />
+  )
+}
+
+function ArtifactMarkdown(props: { path: string; text: string; cacheKey?: string }) {
+  const parent = useMarkdown()
+  const artifacts = useArtifactOpener()
+  // getDirectory yields "/" for a root-level file, which would make relative links absolute.
+  const dir = createMemo(() => (props.path.includes("/") || props.path.includes("\\") ? getDirectory(props.path) : ""))
+  // Absolute references bypass the file's directory; relative ones resolve against it.
+  const resolve = (href: string) => (/^([a-z]:)?\//i.test(href) ? href : (resolveArtifactPath(dir(), href) ?? href))
+  return (
+    <MarkdownProvider
+      readImage={(src, signal) => parent?.readImage?.(resolve(src), signal) ?? Promise.resolve(undefined)}
+      openLocalFile={(href) => artifacts.open(href, dir())}
+    >
+      <div class="mx-auto w-full max-w-3xl px-8 py-6">
+        <Markdown text={props.text} cacheKey={props.cacheKey} class="select-text" />
+      </div>
+    </MarkdownProvider>
+  )
+}
+
+/** Mermaid sources render through the same fenced-block pipeline the timeline uses. */
+function ArtifactMermaid(props: { text: string; cacheKey?: string }) {
+  return (
+    <div class="mx-auto w-full max-w-4xl px-8 py-6">
+      <Markdown text={`\`\`\`mermaid\n${props.text}\n\`\`\``} cacheKey={props.cacheKey} class="select-text" />
+    </div>
+  )
+}
+
+function ArtifactTable(props: { path: string; text: string; onInfo: (info: ArtifactInfo) => void }) {
+  const language = useLanguage()
+  const parsed = createMemo(() => parseDelimited(props.text, props.path.toLowerCase().endsWith(".tsv") ? "\t" : ","))
+  createEffect(() => props.onInfo({ rows: parsed().total, columns: parsed().columns }))
+  // Pad the header to the widest row so no data column is dropped.
+  const header = () => Array.from({ length: parsed().columns }, (_, index) => parsed().rows[0]?.[index] ?? "")
+  const body = () => parsed().rows.slice(1)
+  return (
+    <div class="min-h-0 flex-1 overflow-auto">
+      <table data-slot="artifact-table" class="min-w-full text-13-regular text-text-base">
+        <thead>
+          <tr>
+            <th data-index />
+            <For each={header()}>{(cell) => <th>{cell}</th>}</For>
+          </tr>
+        </thead>
+        <tbody>
+          <For each={body()}>
+            {(row, index) => (
+              <tr>
+                <td data-index>{index() + 1}</td>
+                <For each={header()}>{(_, column) => <td>{row[column()] ?? ""}</td>}</For>
+              </tr>
+            )}
+          </For>
+        </tbody>
+      </table>
+      <Show when={parsed().total > parsed().rows.length}>
+        <div class="px-4 py-3 text-12-regular text-text-weak">
+          {language.t("file.view.table.truncated", { shown: parsed().rows.length - 1, total: parsed().total - 1 })}
+        </div>
+      </Show>
+    </div>
+  )
+}
+
+const specimenSizes = [12, 16, 24, 40, 64]
+
+function ArtifactFont(props: { path: string; content: FileContent }) {
+  const language = useLanguage()
+  const url = createBlobUrl(() => props.content)
+  const family = createMemo(() => `artifact-${Math.random().toString(36).slice(2)}`)
+  createEffect(() => {
+    const face = new FontFace(family(), `url(${url()})`)
+    document.fonts.add(face)
+    void face.load().catch(() => undefined)
+    onCleanup(() => document.fonts.delete(face))
+  })
+  return (
+    <div class="min-h-0 flex-1 overflow-auto">
+      <div class="mx-auto flex w-full max-w-3xl flex-col gap-6 px-8 py-8" style={{ "font-family": `"${family()}"` }}>
+        <div class="text-text-strong" style={{ "font-size": "56px", "line-height": "1.1" }}>
+          {getFilename(props.path).replace(/\.[^.]+$/, "")}
+        </div>
+        <div class="break-all text-text-base" style={{ "font-size": "22px", "line-height": "1.4" }}>
+          ABCDEFGHIJKLMNOPQRSTUVWXYZ
+          <br />
+          abcdefghijklmnopqrstuvwxyz
+          <br />
+          0123456789 !?&@#%(){}[]
+        </div>
+        <div class="flex flex-col gap-3 border-t border-v2-border-border-muted pt-6">
+          <For each={specimenSizes}>
+            {(size) => (
+              <div class="flex items-baseline gap-4">
+                <span
+                  class="w-8 shrink-0 text-12-regular text-text-faint tabular-nums"
+                  style={{ "font-family": "var(--font-family-mono)" }}
+                >
+                  {size}
+                </span>
+                <span class="text-text-base" style={{ "font-size": `${size}px`, "line-height": "1.25" }}>
+                  {language.t("file.view.fontSample")}
+                </span>
+              </div>
+            )}
+          </For>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function ArtifactBinary(props: { path: string; size: string }) {
+  const language = useLanguage()
+  return (
+    <div data-slot="artifact-stage" class="relative min-h-0 flex-1">
+      <div class="absolute inset-0 flex flex-col items-center justify-center gap-3 p-6 text-center">
+        <FileIcon node={{ path: props.path, type: "file" }} class="size-8 text-text-weak" />
+        <div class="text-14-medium text-text-strong">{getFilename(props.path)}</div>
+        <div class="text-13-regular text-text-weak">{language.t("file.view.binary", { size: props.size })}</div>
+      </div>
+    </div>
+  )
+}
@@ -1,4 +1,4 @@
-import { createEffect, createMemo, createSignal, Match, on, onCleanup, Switch } from "solid-js"
+import { createEffect, createMemo, createSignal, Match, on, onCleanup, Show, Switch } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Dynamic } from "solid-js/web"
 import { makeEventListener } from "@solid-primitives/event-listener"
@@ -11,8 +11,9 @@ import { LineCommentOverflowIcon } from "@opencode/ui/line-comment"
 import { Menu } from "@opencode/ui/menu"
 import { Tabs } from "@opencode/ui/tabs"
 import { ScrollView } from "@opencode/ui/scroll-view"
-import { showToast } from "@/shell/notifications/toast"
 import { selectionFromLines, useFile, type FileSelection, type SelectedLineRange } from "@/workspaces/files/model"
+import { artifactKind } from "@/workspaces/files/artifact"
+import { ArtifactView } from "@/session/files/artifact-view"
 import { useComments } from "@/composer/comments"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useComposerState } from "@/composer/persistence"
@@ -205,6 +206,11 @@ export function SessionFileView(props: SessionFileViewProps) {
  })
  const contents = createMemo(() => state()?.content?.content ?? "")
  const cacheKey = createMemo(() => sampledChecksum(contents()))
+  // Plain text keeps the code view; every other kind is rendered by ArtifactView.
+  const artifact = createMemo(() => {
+    const content = state()?.content
+    return content?.type === "binary" || artifactKind(path() ?? "") !== "text"
+  })
  const selectedLines = createMemo<SelectedLineRange | null>(() => {
    const p = path()
    if (!p) return null
@@ -433,39 +439,42 @@ export function SessionFileView(props: SessionFileViewProps) {
        }}
        search={search}
        class="select-text"
-        media={{
-          mode: "auto",
-          path: path(),
-          current: state()?.content,
-          onLoad: scrollSync.queueRestore,
-          onError: (args: { kind: "image" | "audio" | "svg" }) => {
-            if (args.kind !== "svg") return
-            showToast({
-              variant: "error",
-              title: language.t("toast.file.loadFailed.title"),
-            })
-          },
-        }}
+        // Media and previews have their own viewers below; the code view only ever shows text.
+        media={{ mode: "off" }}
      />
    </div>
  )

+  // The code view scrolls inside ScrollView so line state and scroll position persist per tab.
+  const codeView = (source: string) => (
+    <ScrollView class="min-h-0 flex-1" viewportRef={scrollSync.setViewport} onScroll={scrollSync.handleScroll}>
+      {renderFile(source)}
+    </ScrollView>
+  )
+
  const content = () => (
-    <div class="mt-3 relative h-full min-h-0">
-      <ScrollView class="h-full" viewportRef={scrollSync.setViewport} onScroll={scrollSync.handleScroll}>
-        <Switch>
-          <Match when={state()?.loaded}>{renderFile(contents())}</Match>
-          <Match when={state()?.loading}>
-            <div class="px-6 py-4 text-text-weak">{language.t("common.loading")}…</div>
-          </Match>
-          <Match when={state()?.notFound ? state()?.name : undefined}>
-            {(name) => (
-              <div class="px-6 py-4 text-text-weak">{language.t("file.error.notFound", { name: name() })}</div>
-            )}
-          </Match>
-          <Match when={state()?.error}>{(err) => <div class="px-6 py-4 text-text-weak">{err()}</div>}</Match>
-        </Switch>
-      </ScrollView>
+    <div class="mt-3 relative h-full min-h-0 flex flex-col">
+      <Switch>
+        <Match when={state()?.loaded ? state()?.content : undefined}>
+          {(value) => (
+            <Show when={artifact()} fallback={codeView(value().content)}>
+              <ArtifactView
+                path={path() ?? ""}
+                content={value()}
+                cacheKey={cacheKey()}
+                source={codeView(value().content)}
+              />
+            </Show>
+          )}
+        </Match>
+        <Match when={state()?.loading}>
+          <div class="px-6 py-4 text-text-weak">{language.t("common.loading")}…</div>
+        </Match>
+        <Match when={state()?.notFound ? state()?.name : undefined}>
+          {(name) => <div class="px-6 py-4 text-text-weak">{language.t("file.error.notFound", { name: name() })}</div>}
+        </Match>
+        <Match when={state()?.error}>{(err) => <div class="px-6 py-4 text-text-weak">{err()}</div>}</Match>
+      </Switch>
    </div>
  )

@@ -0,0 +1,105 @@
+import { createEffect, onCleanup, type ParentProps } from "solid-js"
+import { createSimpleContext } from "@opencode/ui/context"
+import { MarkdownProvider, useMarkdown } from "@opencode/session-ui/context/markdown"
+import { useBrowserAttachments } from "@/session/browser/attachments"
+import type { SessionModel } from "@/session/model"
+import { useFile } from "@/workspaces/files/model"
+import { artifactKind, resolveArtifactPath } from "@/workspaces/files/artifact"
+import { encodeFilePath } from "@/workspaces/files/path"
+import { useWorkspaceLocation } from "@/workspaces/location"
+import { useServer } from "@/runtime/server/current"
+import { ServerConnection } from "@/runtime/server/registry"
+import { useSessionLayout } from "@/session/session-layout"
+import { createOpenSessionFileTab } from "@/session/helpers"
+import type { createSessionBrowser } from "@/session/browser/model"
+
+/** Routes local links in timeline markdown to the artifact opener while keeping image loading. */
+export function ArtifactMarkdownProvider(props: ParentProps) {
+  const markdown = useMarkdown()
+  const artifacts = useArtifactOpener()
+  return (
+    <MarkdownProvider readImage={markdown?.readImage} openLocalFile={(path) => artifacts.open(path)}>
+      {props.children}
+    </MarkdownProvider>
+  )
+}
+
+/**
+ * Opens files the agent references as side-panel tabs, inside or outside the workspace, or as
+ * a browser tab for HTML when the desktop can load the file directly.
+ */
+export const { use: useArtifactOpener, provider: ArtifactOpenerProvider } = createSimpleContext({
+  name: "ArtifactOpener",
+  init: (props: { session: SessionModel; browser: ReturnType<typeof createSessionBrowser> }) => {
+    const file = useFile()
+    const server = useServer()
+    const location = useWorkspaceLocation()
+    const attachments = useBrowserAttachments()
+    const { tabs, view } = useSessionLayout()
+
+    const root = () => location().directory.replaceAll("\\", "/").replace(/\/+$/, "")
+
+    /**
+     * Turn a link into a path `useFile` can load: workspace-relative when it is under the root,
+     * otherwise absolute. Relative links resolve against `base`; ones that climb past the root
+     * become absolute too, so a `../../shared/report.pdf` still opens.
+     */
+    const resolve = (href: string, base?: string) => {
+      // Agents cite locations as path:line or path:line:col; the file is what opens.
+      const value = href.replaceAll("\\", "/").replace(/:\d+(?::\d+)?$/, "")
+      if (/^[a-z]:\//i.test(value) || value.startsWith("/")) return file.normalize(value)
+      const relative = resolveArtifactPath(base ?? "", value)
+      if (relative !== undefined) return file.normalize(relative)
+      // Climbing past the workspace root: resolve from the referencing folder's absolute location.
+      const dir = base ? `${root()}/${base.replace(/\/+$/, "")}` : root()
+      return file.normalize(resolveArtifactPath(dir, value) ?? value)
+    }
+
+    const showTab = createOpenSessionFileTab({
+      normalizeTab: (tab) => tab,
+      openTab: (tab) => tabs().open(tab),
+      pathFromTab: file.pathFromTab,
+      loadFile: () => undefined,
+      openReviewPanel: () => {
+        if (!view().reviewPanel.opened()) view().reviewPanel.open()
+      },
+      setActive: (tab) => tabs().setActive(tab),
+    })
+
+    // Inline paths are guessed from text, so confirm the file exists before a tab appears for it.
+    const openTab = (path: string) => {
+      void file.load(path).then(() => {
+        if (file.get(path)?.loaded) showTab(file.tab(path))
+      })
+    }
+
+    // The desktop's own sidecar shares this disk, and its browser pane accepts file:// URLs inside the
+    // session workspace only. Forwarded loopback servers do not qualify, matching the desktop policy.
+    const canOpenInBrowser = (path?: string) =>
+      ServerConnection.builtin(server.conn) &&
+      props.browser.available() &&
+      props.browser.attached() &&
+      (path === undefined || !file.absolute(path))
+
+    const openInBrowser = (path: string) => {
+      props.browser.command({ type: "tabs.open", url: `file://${encodeFilePath(`${root()}/${path}`)}` })
+    }
+
+    /** Open `href` as referenced from `base` (a workspace-relative directory, "" for the root). */
+    const open = (href: string, base?: string) => {
+      const path = resolve(href, base)
+      if (!path) return
+      if (artifactKind(path) === "html" && canOpenInBrowser(path)) return openInBrowser(path)
+      openTab(path)
+    }
+
+    // The agent's browser.preview tool arrives through the desktop browser pane attachment.
+    createEffect(() => {
+      const sessionID = props.session.identity.sessionID()
+      if (!sessionID) return
+      onCleanup(attachments.onPreview(server, sessionID, (path) => open(path)))
+    })
+
+    return { canOpenInBrowser, openInBrowser, open }
+  },
+})
@@ -1,8 +1,9 @@
 import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
 import { OPEN_APPS, OpenAppPreferences } from "./open-in-app"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

-const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(OpenAppPreferences, { app: "finder" }), input))
+const decode = Schema.decodeUnknownSync(Persistence.withInitial(OpenAppPreferences, { app: "finder" }))

 describe("open app preferences", () => {
  test.each([...OPEN_APPS])("preserves the %s preference", (app) => {
@@ -17,4 +18,3 @@ describe("open app preferences", () => {
    expect(decode({})).toEqual({ app: "finder" })
  })
 })
-
@@ -5,7 +5,8 @@ import { usePlatform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import { showToast } from "@/shell/notifications/toast"
 import { useServer } from "@/runtime/server/current"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"
 import { fileManagerApp } from "@/home/projects/file-manager"
 import { openInAppParentPath } from "@/session/files/open-in-app-path"

@@ -29,8 +30,8 @@ export const OPEN_APPS = [
 export type OpenApp = (typeof OPEN_APPS)[number]
 export type OpenAppOS = "macos" | "windows" | "linux" | "unknown"

-export const OpenAppPreferences = Codec.struct({
-  app: Codec.literals(OPEN_APPS),
+export const OpenAppPreferences = Persistence.struct({
+  app: Schema.Literals(OPEN_APPS),
 })

 const appExistence = new Map<string, Promise<boolean>>()
@@ -241,4 +242,3 @@ function checkAppExists(platform: ReturnType<typeof usePlatform>, app: string) {
  appExistence.set(app, request)
  return request
 }
-
@@ -173,7 +173,9 @@ export function SessionFileBrowserTab(props: {
          <SessionFilePanelV2Empty>
            <div class="flex flex-col items-center gap-2 text-center text-text-weak">
              <Icon name="file-tree" size="large" class="mb-2" />
-              <div class="text-[13px] font-medium leading-[13px] text-text-strong">{language.t("command.file.open")}</div>
+              <div class="text-[13px] font-medium leading-[13px] text-text-strong">
+                {language.t("command.file.open")}
+              </div>
              <div class="h-5 text-13-regular leading-5">{language.t("session.files.selectToOpen")}</div>
            </div>
          </SessionFilePanelV2Empty>
@@ -37,6 +37,7 @@ import { useSettings } from "@/settings/model"
 import { createFileTabListSync } from "@/session/files/file-tab-scroll"
 import {
  SESSION_OPEN_FILE_TAB,
+  SESSION_BTW_TAB,
  isSessionBrowserTab,
  sessionBrowserTab,
  createOpenSessionFileTab,
@@ -74,6 +75,7 @@ export function SessionSidePanel(props: {
  size: Sizing
  stacked?: boolean
  browser: ReturnType<typeof createSessionBrowser>
+  btwPanel: () => JSX.Element
 }) {
  const layout = useLayout()
  const settings = useSettings()
@@ -227,7 +229,7 @@ export function SessionSidePanel(props: {
  })
  const fileBrowserVisible = createMemo(() => {
    const active = activeTab()
-    return active !== "review" && active !== "context" && active !== "empty" && !isSessionBrowserTab(active)
+    return active === SESSION_OPEN_FILE_TAB || active === activeFileTab()
  })
  const openFileKeybind = createMemo(() => command.keybindParts("file.open"))
  const openBrowserKeybind = createMemo(() => command.keybindParts("browser.open"))
@@ -385,6 +387,14 @@ export function SessionSidePanel(props: {
                                  />
                                }
                              >
+                                <Match when={tab === SESSION_BTW_TAB}>
+                                  <SortableTab tab={tab} index={tabs().all().indexOf(tab)} onTabClose={tabs().close}>
+                                    <div class="flex items-center gap-1.5">
+                                      <Icon name="bubble-5" size="small" />
+                                      <span>{language.t("session.tab.btw")}</span>
+                                    </div>
+                                  </SortableTab>
+                                </Match>
                                <Match when={isSessionBrowserTab(tab)}>
                                  <Show when={props.browser.tabs().find((item) => sessionBrowserTab(item.id) === tab)}>
                                    {(item) => (
@@ -583,6 +593,12 @@ export function SessionSidePanel(props: {
                        </Tabs.Content>
                      </Show>

+                      <Show when={activeTab() === SESSION_BTW_TAB}>
+                        <Tabs.Content value={SESSION_BTW_TAB} class="flex h-full min-h-0 flex-col overflow-hidden">
+                          {props.btwPanel()}
+                        </Tabs.Content>
+                      </Show>
+
                      <Show when={props.browser.opened()}>
                        <div
                          id={browserTabPanelID}
@@ -1,6 +1,8 @@
 import { children, createMemo, Show } from "solid-js"
 import type { JSX } from "solid-js"
 import { useSortable } from "@dnd-kit/solid/sortable"
+import { Icon } from "@opencode/ui/icon"
+import { IconButton } from "@opencode/ui/icon-button"
 import { Keybind } from "@opencode/ui/keybind"
 import { Tooltip } from "@opencode/ui/tooltip"
 import { Tabs } from "@opencode/ui/tabs"
@@ -69,9 +71,19 @@ export function SortableTab(props: {
              placement="bottom"
              gutter={10}
            >
-              <Tabs.CloseButton
-                class="h-5 w-5"
-                onClick={() => props.onTabClose(props.tab)}
+              <IconButton
+                size="small"
+                variant="ghost-muted"
+                onPointerDown={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                }}
+                onClick={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  props.onTabClose(props.tab)
+                }}
+                icon={<Icon name="xmark-small" />}
                aria-label={language.t("common.closeTab")}
              />
            </Tooltip>
@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test"
 import { createMemo, createRoot } from "solid-js"
 import { createStore } from "solid-js/store"
 import {
+  SESSION_BTW_TAB,
  SESSION_BROWSER_TAB,
  sessionBrowserTab,
  SESSION_OPEN_FILE_TAB,
@@ -236,6 +237,24 @@ describe("createSessionTabs", () => {
    })
  })

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

 export {
  SESSION_BROWSER_TAB,
+  SESSION_BTW_TAB,
  SESSION_OPEN_FILE_TAB,
  sessionBrowserTab,
  isSessionBrowserTab,
@@ -63,13 +64,17 @@ export const createSessionTabs = (input: TabsInput) => {
    { equals: same },
  )
  const openedTabs = createMemo(
-    () => panelTabs().filter((tab) => tab !== SESSION_OPEN_FILE_TAB && !isSessionBrowserTab(tab)),
+    () =>
+      panelTabs().filter(
+        (tab) => tab !== SESSION_OPEN_FILE_TAB && tab !== SESSION_BTW_TAB && !isSessionBrowserTab(tab),
+      ),
    emptyTabs,
    { equals: same },
  )
  const activeTab = createMemo(() => {
    const active = input.tabs().active()
    if (active === "context") return active
+    if (active === SESSION_BTW_TAB) return active
    if (active === SESSION_OPEN_FILE_TAB && openFileOpen()) return active
    if (active && isSessionBrowserTab(active) && browser()) return active
    if (active === "review" && review()) return active
@@ -89,6 +94,7 @@ export const createSessionTabs = (input: TabsInput) => {
  const closableTab = createMemo<string | undefined>(() => {
    const active = activeTab()
    if (active === "context") return active
+    if (active === SESSION_BTW_TAB) return active
    if (active === SESSION_OPEN_FILE_TAB && openFileOpen()) return active
    if (active && isSessionBrowserTab(active) && browser()) return active
    if (!openedTabs().includes(active)) return
@@ -137,6 +137,7 @@ export function useSessionModel() {
      tabs: layout.tabs,
      view: layout.view,
      tabKey: layout.tabKey,
+      sessionKey: layout.sessionKey,
    },
    ownership: createSessionOwnership(layout.sessionKey),
    tabs: {
@@ -155,6 +155,9 @@ export function createSessionReview(input: {
  const count = () => diffs().length
  const hasChanges = () => count() > 0
  const ready = () => {
+    // A project without VCS never enables vcsQuery, so its status stays "pending" forever.
+    const project = input.session.project()
+    if (project && !project.vcs) return true
    if (mode() === "git" || mode() === "branch") return !vcsQuery.isPending
    return true
  }
@@ -5,20 +5,17 @@ import {
  type SessionReviewExpandMode,
 } from "@opencode/session-ui/v2/session-review-v2"
 import { createSignal } from "solid-js"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
 import type { Platform } from "@/runtime/platform/platform"
 import { Persist, persisted } from "@/runtime/persistence/storage"
+import { Persistence } from "@/runtime/persistence/schema"

-const ReviewPanel = Codec.struct({
-  sidebarOpened: Codec.boolean,
-  sidebarWidth: Codec.make<number, number>(
-    (v) =>
-      typeof v === "number" && v >= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN && v <= SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX
-        ? v
-        : Codec.INVALID,
-    (v) => v,
-  ),
-  expandMode: Codec.literals(["expand", "collapse"]),
+const ReviewPanel = Persistence.struct({
+  sidebarOpened: Schema.Boolean,
+  sidebarWidth: Schema.Finite.check(
+    Schema.isBetween({ minimum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN, maximum: SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX }),
+  ),
+  expandMode: Schema.Literals(["expand", "collapse"]),
 })

 export function createReviewPanelState(platform?: Platform) {
@@ -50,4 +47,3 @@ export function createReviewPanelState(platform?: Platform) {
 }

 export type ReviewPanelState = ReturnType<typeof createReviewPanelState>
-
@@ -14,6 +14,8 @@ import { ReviewPanel } from "./panel"
 import { SessionReviewTab } from "./review-tab"
 import type { ChangeMode, SessionReviewModel } from "./model"
 import type { createSessionBrowser } from "../browser/model"
+import type { SessionBtwModel } from "../btw/model"
+import { SessionBtwPanel } from "../btw/panel"

 const MobilePanelDrawer = lazy(async () => {
  const { MobilePanelDrawer } = await import("@/shell/mobile-panel-drawer")
@@ -127,6 +129,7 @@ export function SessionMobileReview(props: { review: SessionReviewModel }) {
 export function SessionDesktopReview(props: {
  review: SessionReviewModel
  browser: ReturnType<typeof createSessionBrowser>
+  btw: SessionBtwModel
  present?: boolean
 }) {
  return (
@@ -153,6 +156,7 @@ export function SessionDesktopReview(props: {
        size={props.review.screen.size}
        stacked={props.review.screen.side.layout().stacked}
        browser={props.browser}
+        btwPanel={() => <SessionBtwPanel btw={props.btw} />}
      />
    </Suspense>
  )
@@ -249,7 +253,7 @@ function ReviewTitle(props: { review: SessionReviewModel }) {
 function ReviewEmpty(props: { review: SessionReviewModel; loadingClass: string }) {
  const language = useLanguage()
  const loading = () => (props.review.mode() === "git" || props.review.mode() === "branch") && !props.review.ready()
-  const noGit = () => props.review.mode() === "turn" && props.review.noGit()
+  const noGit = () => props.review.noGit()
  const text = () => {
    if (props.review.mode() === "git") return language.t("session.review.noUncommittedChanges")
    if (props.review.mode() === "branch") return language.t("session.review.noBranchChanges")
@@ -282,7 +286,7 @@ function ReviewEmpty(props: { review: SessionReviewModel; loadingClass: string }
 function ReviewPanelEmpty(props: { review: SessionReviewModel }) {
  const language = useLanguage()
  const loading = () => (props.review.mode() === "git" || props.review.mode() === "branch") && !props.review.ready()
-  const noGit = () => props.review.mode() === "turn" && props.review.noGit()
+  const noGit = () => props.review.noGit()
  return (
    <Switch>
      <Match when={loading()}>
@@ -38,6 +38,8 @@ import { SessionReviewToggle } from "./header/session-header-actions"
 import { createAnimatedPresence } from "@/runtime/animated-presence"
 import { createSessionBrowser } from "./browser/model"
 import { createTimelineCache } from "./timeline/cache"
+import { ArtifactMarkdownProvider, ArtifactOpenerProvider } from "./files/open-artifact"
+import { createSessionBtw } from "./btw/model"

 const SessionMobileFiles = lazy(async () => {
  const { SessionMobileFiles } = await import("./files/session-mobile-files")
@@ -50,14 +52,27 @@ const SessionSummaryPanel = lazy(async () => {
 })

 export function SessionScreen(props: { session: SessionModel }) {
+  // The timeline cache captures its owner when created, so link handling must be provided above it.
+  const browser = createSessionBrowser(props.session)
+  return (
+    <ArtifactOpenerProvider session={props.session} browser={browser}>
+      <ArtifactMarkdownProvider>
+        <SessionScreenContent session={props.session} browser={browser} />
+      </ArtifactMarkdownProvider>
+    </ArtifactOpenerProvider>
+  )
+}
+
+function SessionScreenContent(props: { session: SessionModel; browser: ReturnType<typeof createSessionBrowser> }) {
  const session = props.session
+  const browser = props.browser
  const server = useServer()
  const detailsProject = createMemo(() => {
    const info = session.data.info()
    return info ? projectForSession(info, server.ctx.sync.data.project) : undefined
  })
  const isDesktop = session.isDesktop
-  const browser = createSessionBrowser(session)
+  const btw = createSessionBtw(session)
  const screen = createSessionScreenLayout(session)
  const timeline = createSessionTimelineInteraction(session)
  const timelineSearch = createTimelineSearchController({
@@ -438,7 +453,12 @@ export function SessionScreen(props: { session: SessionModel }) {
                        setStore("sideReviewPresent", false)
                      }}
                    >
-                      <SessionDesktopReview review={review} browser={browser} present={store.sideReviewPresent} />
+                      <SessionDesktopReview
+                        review={review}
+                        browser={browser}
+                        btw={btw}
+                        present={store.sideReviewPresent}
+                      />
                    </div>
                  </Show>
                </div>
@@ -2,8 +2,9 @@ import { beforeAll, describe, expect, mock, test } from "bun:test"
 import { ServerScope } from "@/runtime/server/scope"
 import { base64Encode } from "@opencode/util/encode"
 import { Persist } from "@/runtime/persistence/storage"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"
 import type { Platform } from "@/runtime/platform/platform"
+import { Schema } from "effect"

 let getWorkspaceTerminalCacheKey: typeof import("./context").getWorkspaceTerminalCacheKey
 let clearWorkspaceTerminals: typeof import("./context").clearWorkspaceTerminals
@@ -20,10 +21,10 @@ beforeAll(async () => {
  const mod = await import("./context")
  getWorkspaceTerminalCacheKey = mod.getWorkspaceTerminalCacheKey
  clearWorkspaceTerminals = mod.clearWorkspaceTerminals
-  const schema = Codec.withInitial(mod.TerminalState, { all: [] })
-  decodeTerminalState = ((input: unknown) => Codec.decodeOrThrow(schema, input))
+  const schema = Persistence.withInitial(mod.TerminalState, { all: [] })
+  decodeTerminalState = Schema.decodeUnknownSync(schema)
  roundTripTerminalState = (value) =>
-    Codec.decodeOrThrow(schema, schema.encode(Codec.decodeOrThrow(schema, value)))
+    Schema.decodeUnknownSync(schema)(Schema.encodeSync(schema)(Schema.decodeUnknownSync(schema)(value)))
 })

 describe("getWorkspaceTerminalCacheKey", () => {
@@ -140,4 +141,3 @@ describe("TerminalState", () => {
    expect(roundTripTerminalState(value)).toEqual(value)
  })
 })
-
@@ -8,20 +8,18 @@ import { base64Encode } from "@opencode/util/encode"
 import { defaultTitle, titleNumber } from "./title"
 import { Persist, persisted, removePersisted } from "@/runtime/persistence/storage"
 import { ScopedKey, ServerScope } from "@/runtime/server/scope"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"
+import { Schema, SchemaGetter } from "effect"

-const PTY = Codec.struct({
-  id: Codec.make<string, string>(
-    (v) => (typeof v === "string" && v.length > 0 ? v : Codec.INVALID),
-    (v) => v,
-  ),
-  title: Codec.fallback(Codec.string, () => ""),
-  titleNumber: Codec.fallback(Codec.number, () => 0),
-  rows: Codec.lenientOptional(Codec.number),
-  cols: Codec.lenientOptional(Codec.number),
-  buffer: Codec.lenientOptional(Codec.string),
-  scrollY: Codec.lenientOptional(Codec.number),
-  cursor: Codec.lenientOptional(Codec.number),
+const PTY = Persistence.struct({
+  id: Schema.NonEmptyString,
+  title: Persistence.fallback(Schema.String, () => ""),
+  titleNumber: Persistence.fallback(Schema.Finite, () => 0),
+  rows: Persistence.optional(Schema.Finite),
+  cols: Persistence.optional(Schema.Finite),
+  buffer: Persistence.optional(Schema.String),
+  scrollY: Persistence.optional(Schema.Finite),
+  cursor: Persistence.optional(Schema.Finite),
 })

 export type LocalPTY = typeof PTY.Type
@@ -33,26 +31,28 @@ function numberFromTitle(title: string) {
  return titleNumber(title, MAX_TERMINAL_SESSIONS)
 }

-const State = Codec.struct({
-  active: Codec.lenientOptional(Codec.string),
-  all: Codec.lenientArray(PTY),
+const State = Persistence.struct({
+  active: Persistence.optional(Schema.String),
+  all: Persistence.array(PTY),
 })

-export const TerminalState = Codec.transform(State, {
-  decode: (value): typeof State.Type => {
-    const seen = new Set<string>()
-    const all = value.all.flatMap((pty) => {
-      if (seen.has(pty.id)) return []
-      seen.add(pty.id)
-      return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
-    })
-    return {
-      active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
-      all,
-    }
-  },
-  encode: (value) => value,
-})
+export const TerminalState = State.pipe(
+  Schema.decodeTo(Schema.toType(State), {
+    decode: SchemaGetter.transform((value) => {
+      const seen = new Set<string>()
+      const all = value.all.flatMap((pty) => {
+        if (seen.has(pty.id)) return []
+        seen.add(pty.id)
+        return [{ ...pty, titleNumber: pty.titleNumber > 0 ? pty.titleNumber : (numberFromTitle(pty.title) ?? 0) }]
+      })
+      return {
+        active: value.active && seen.has(value.active) ? value.active : all[0]?.id,
+        all,
+      }
+    }),
+    encode: SchemaGetter.transform((value) => value),
+  }),
+)

 export function getWorkspaceTerminalCacheKey(dir: string, scope: ServerScope = ServerScope.local) {
  return ScopedKey.from(scope, dir, WORKSPACE_KEY)
@@ -458,5 +458,3 @@ export const { use: useTerminal, provider: TerminalProvider } = createSimpleCont
    }
  },
 })
-
-
@@ -1,40 +1,40 @@
-import { describe, expect, test } from "bun:test"
-import { GoUpsellState } from "./usage-exceeded-dialogs"
-import { Codec } from "@/runtime/persistence/codec"
-
-const schema = Codec.withInitial(GoUpsellState, {
-  go_upsell_last_seen_at: null,
-  go_upsell_dont_show: null,
-  go_upsell_account_rate_limit_last_seen_at: null,
-  go_upsell_account_rate_limit_dont_show: null,
-})
-const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
-
-describe("usage exceeded preferences", () => {
-  test("defaults unseen prompts", () => {
-    expect(decode({})).toEqual({
-      go_upsell_last_seen_at: null,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: null,
-    })
-  })
-
-  test("preserves timestamps while recovering malformed siblings", () => {
-    expect(
-      decode({
-        go_upsell_last_seen_at: 123,
-        go_upsell_dont_show: "true",
-        go_upsell_account_rate_limit_last_seen_at: Infinity,
-        go_upsell_account_rate_limit_dont_show: 456,
-      }),
-    ).toEqual({
-      go_upsell_last_seen_at: 123,
-      go_upsell_dont_show: null,
-      go_upsell_account_rate_limit_last_seen_at: null,
-      go_upsell_account_rate_limit_dont_show: 456,
-    })
-  })
-})
-
-
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { GoUpsellState } from "./usage-exceeded-dialogs"
+import { Persistence } from "@/runtime/persistence/schema"
+
+const decode = Schema.decodeUnknownSync(
+  Persistence.withInitial(GoUpsellState, {
+    go_upsell_last_seen_at: null,
+    go_upsell_dont_show: null,
+    go_upsell_account_rate_limit_last_seen_at: null,
+    go_upsell_account_rate_limit_dont_show: null,
+  }),
+)
+
+describe("usage exceeded preferences", () => {
+  test("defaults unseen prompts", () => {
+    expect(decode({})).toEqual({
+      go_upsell_last_seen_at: null,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: null,
+    })
+  })
+
+  test("preserves timestamps while recovering malformed siblings", () => {
+    expect(
+      decode({
+        go_upsell_last_seen_at: 123,
+        go_upsell_dont_show: "true",
+        go_upsell_account_rate_limit_last_seen_at: Infinity,
+        go_upsell_account_rate_limit_dont_show: 456,
+      }),
+    ).toEqual({
+      go_upsell_last_seen_at: 123,
+      go_upsell_dont_show: null,
+      go_upsell_account_rate_limit_last_seen_at: null,
+      go_upsell_account_rate_limit_dont_show: 456,
+    })
+  })
+})
@@ -2,7 +2,8 @@ import { useWorkspaceLocation } from "@/workspaces/location"
 import { Persist, persisted } from "@/runtime/persistence/storage"
 import type { SessionStatus } from "@opencode/client/promise"
 import { onCleanup } from "solid-js"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"
 import { useSessionLayout } from "./session-layout"
 import { useDialog, useI18n } from "@opencode/ui/context"
 import { DialogUsageExceeded } from "@/providers/connect/usage-exceeded"
@@ -14,11 +15,11 @@ const GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW = "go_upsell_account_rate_limit_don
 const GO_UPSELL_WINDOW = 86_400_000 // 24 hrs
 const GO_UPSELL_PROVIDERS = new Set(["opencode", "opencode-go"])

-export const GoUpsellState = Codec.struct({
-  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
-  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Codec.nullOr(Codec.number),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Codec.nullOr(Codec.number),
-  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Codec.nullOr(Codec.number),
+export const GoUpsellState = Persistence.struct({
+  [GO_UPSELL_FREE_TIER_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
+  [GO_UPSELL_FREE_TIER_DONT_SHOW]: Schema.NullOr(Schema.Finite),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_LAST_SEEN_AT]: Schema.NullOr(Schema.Finite),
+  [GO_UPSELL_ACCOUNT_RATE_LIMIT_DONT_SHOW]: Schema.NullOr(Schema.Finite),
 })

 function goUpsellKeys(status: SessionStatus) {
@@ -105,4 +106,3 @@ export function useUsageExceededDialogs() {
    }),
  )
 }
-
@@ -1,6 +1,7 @@
 import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
 import { timelinePresets } from "@opencode/session-ui/timeline/detail"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"
 import {
  settingsSchema,
  settingsPersistence,
@@ -12,9 +13,9 @@ import {
  terminalFontFamily,
 } from "./model"

-const schema = Codec.withInitial(settingsPersistence, defaultSettings)
-const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
-const encode = (value: typeof settingsSchema.Type) => schema.encode(value)
+const schema = Persistence.withInitial(settingsPersistence, defaultSettings)
+const decode = Schema.decodeUnknownSync(schema)
+const encode = Schema.encodeSync(schema)

 describe("settings timeline detail migration", () => {
  test("migrates saved switches and round trips the current settings", () => {
@@ -50,14 +51,14 @@ describe("settings schema", () => {
      general: { ...defaultSettings.general, timelineDetail: timelinePresets[4].value, autoSave: false },
      appearance: { ...defaultSettings.appearance, fontSize: 20 },
    }
-    const restore = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(settingsPersistence, initial), input)
+    const restore = Schema.decodeUnknownSync(Persistence.withInitial(settingsPersistence, initial))
    expect(restore({})).toEqual(initial)
    expect(restore({ general: { reasoningMode: "invalid", showReasoningSummaries: true } })).toEqual(initial)
    expect(restore({ general: { showReasoningSummaries: true } }).general.timelineDetail.thinking).toEqual({
      placement: "separate",
      details: "expanded",
    })
-    expect(() => Codec.decodeOrThrow(settingsSchema, {})).toThrow()
+    expect(() => Schema.decodeUnknownSync(settingsSchema)({})).toThrow()
  })

  test("supplies the existing defaults for an empty document", () => {
@@ -170,7 +171,7 @@ describe("settings schema", () => {

  test("does not silently repair invalid values during encoding", () => {
    expect(() =>
-      Codec.encodeOrThrow(settingsSchema, { ...decode({}), appearance: { fontSize: "large" } } as never),
+      Schema.encodeUnknownSync(settingsSchema)({ ...decode({}), appearance: { fontSize: "large" } }),
    ).toThrow()
  })
 })
@@ -202,6 +203,3 @@ describe("settings font families", () => {
    expect(terminalFontFamily(undefined)).toStartWith('"JetBrainsMono Nerd Font Mono", ')
  })
 })
-
-
-
@@ -5,7 +5,8 @@ import { Icon } from "@opencode/ui/icon"
 import { IconButton } from "@opencode/ui/icon-button"
 import { TextInput } from "@opencode/ui/text-input"
 import { type Component, createEffect, For, on, onCleanup, Show } from "solid-js"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useModels } from "@/providers/models/models"
 import { useServerSDK } from "@/runtime/server/client"
@@ -19,8 +20,8 @@ type ModelItem = ReturnType<ReturnType<typeof useModels>["list"]>[number]

 const PROVIDER_ICON_SIZE = 16

-export const ModelProvidersSchema = Codec.struct({
-  collapsed: Codec.lenientRecord(Codec.fallback(Codec.boolean, () => false)),
+export const ModelProvidersSchema = Schema.Struct({
+  collapsed: Persistence.record(Persistence.fallback(Schema.Boolean, () => false)),
 })

 export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }> = (props) => {
@@ -210,4 +211,3 @@ export const SettingsModels: Component<{ active?: boolean; autofocus?: boolean }
    </>
  )
 }
-
@@ -1102,10 +1102,6 @@
  padding-block: 20px;
 }

-.settings-server-connection .settings-servers-lead {
-  gap: 4px;
-}
-
 .settings-servers-row:not(:last-child) {
  padding-bottom: 16px;
  margin-bottom: 16px;
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
 import {
  activeCommandRegistrations,
  addCommandRegistration,
@@ -10,12 +10,12 @@ import {
 } from "./command"

 test("command catalog persistence validates metadata and omits executable fields", () => {
-  const decode = ((input: unknown) => Codec.decodeOrThrow(CommandCatalog, input))
+  const decode = Schema.decodeUnknownSync(CommandCatalog)
  const catalog = decode({ open: { title: "Open", keybind: "mod+o", hidden: false, onSelect: "invalid" } })
  expect(catalog).toEqual({ open: { title: "Open", keybind: "mod+o", hidden: false } })
  expect(decode({})).toEqual({})
  expect(() => decode({ open: { title: 1 } })).toThrow()
-  expect(decode(CommandCatalog.encode(catalog))).toEqual(catalog)
+  expect(decode(Schema.encodeSync(CommandCatalog)(catalog))).toEqual(catalog)
 })

 const paletteOptions: CommandOption[] = [
@@ -79,4 +79,3 @@ describe("resolveKeybindOption", () => {
    expect(resolveKeybindOption([fallback, contextual], new KeyboardEvent("keydown"))).toBe(fallback)
  })
 })
-
@@ -2,8 +2,8 @@ import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { type Accessor, batch, createEffect, createMemo, onCleanup, onMount } from "solid-js"
 import { createStore, reconcile } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
-
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"
 import { makeEventListener } from "@solid-primitives/event-listener"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
@@ -88,11 +88,12 @@ export interface CommandOption {
  category?: string
  keybind?: KeybindConfig
  slash?: string
+  slashArguments?: boolean
  suggested?: boolean
  disabled?: boolean
  hidden?: boolean
  when?: (event: KeyboardEvent) => boolean
-  onSelect?: (source?: "palette" | "keybind" | "slash") => void
+  onSelect?: (source?: "palette" | "keybind" | "slash", input?: string) => void | Promise<void>
  onHighlight?: () => (() => void) | void
 }

@@ -109,16 +110,16 @@ export function resolveKeybindOption(candidates: CommandOption[] | undefined, ev

 type CommandSource = "palette" | "keybind" | "slash"

-export const CommandCatalogItem = Codec.struct({
-  title: Codec.string,
-  description: Codec.optional(Codec.string),
-  category: Codec.optional(Codec.string),
-  keybind: Codec.optional(Codec.string),
-  slash: Codec.optional(Codec.string),
-  hidden: Codec.optional(Codec.boolean),
+export const CommandCatalogItem = Persistence.struct({
+  title: Schema.String,
+  description: Schema.optional(Schema.String),
+  category: Schema.optional(Schema.String),
+  keybind: Schema.optional(Schema.String),
+  slash: Schema.optional(Schema.String),
+  hidden: Schema.optional(Schema.Boolean),
 })
 export type CommandCatalogItem = typeof CommandCatalogItem.Type
-export const CommandCatalog = Codec.record(CommandCatalogItem)
+export const CommandCatalog = Schema.Record(Schema.String, Schema.mutableKey(CommandCatalogItem))
 export type CommandCatalog = typeof CommandCatalog.Type

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

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

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

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

    return {
      register,
-      trigger(id: string, source?: CommandSource) {
-        run(id, source)
+      trigger(id: string, source?: CommandSource, input?: string) {
+        return run(id, source, input)
      },
      keybind(id: string) {
        const config = keybindConfig(id)
@@ -480,4 +481,3 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
    }
  },
 })
-
@@ -166,7 +166,7 @@ export function createCommandPaletteModel(props: { filesOnly?: () => boolean; on
    state.cleanup = undefined
    dialog.close()
    if (item.type === "command") {
-      item.option?.onSelect?.("palette")
+      void item.option?.onSelect?.("palette")
      return
    }
    if (item.type === "session") {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Brendonovich	3178cf10dd	fix(app): paste plain text into session titles	2026-09-22 08:12:08 +00:00
opencode-agent[bot]andBrendonovich	dcfe1ec7bd	feat(app): add /btw side question panel (#49750 ) Co-authored-by: Brendonovich <Brendonovich@users.noreply.github.com>	2026-09-22 15:20:09 +08:00
opencode-agent[bot]	ceace24a3e	chore: update nix node_modules hashes	2026-09-22 05:45:49 +00:00
Aiden Cline	19e1357a06	fix(core): stop forcing a consent prompt on MCP OAuth login (#50519 )	2026-09-22 00:25:06 -05:00
opencode-agent[bot]	4b381ac6a1	fix(tui): clear the active session tab (#50524 )	2026-09-22 00:53:42 -04:00
Aiden Cline	07d48e1ffb	feat(ai): add experimental evaluation API (#50506 )	2026-09-21 23:30:38 -05:00
Aiden Cline	9fdcb8da41	fix(codemode): coerce built-in arguments as in JS instead of requiring numbers and strings (#50492 )	2026-09-21 23:04:04 -05:00
Aiden Cline	ba61ac6730	fix(ai): preserve Vertex function call ids (#50504 )	2026-09-21 23:03:24 -05:00
Aiden Cline	94b9133910	fix(core): share child prompt cache affinity (#50495 )	2026-09-21 22:44:43 -05:00
Aiden Cline	6f8c5ae0aa	fix(codemode): bind generator parameters at the call, not the first next() (#50489 )	2026-09-21 22:42:10 -05:00
Aiden Cline	60673aaef3	fix(core): run session HTTP hooks on the AI SDK route (#50487 )	2026-09-21 22:41:06 -05:00
Aiden Cline	651529d64e	fix(codemode): coerce any value to a property key (#50479 )	2026-09-21 21:35:20 -05:00
opencode-agent[bot]	532f25d0d4	feat(tui): restore sidebar onboarding (#50475 )	2026-09-21 22:17:22 -04:00
opencode-agent[bot]andjlongster	643c4c3500	fix: remove first-month Go pricing (#50473 ) Co-authored-by: jlongster <17031+jlongster@users.noreply.github.com>	2026-09-21 21:55:12 -04:00
opencode-agent[bot]andBrendonovich	9d531435b4	fix(desktop): stop signing macOS DMGs (#50469 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com>	2026-09-22 01:35:21 +00:00
opencode-agent[bot]	5b9dc35eec	feat(tui): add automatic tabs mode (#50456 )	2026-09-22 01:00:26 +00:00
Aiden Cline	1814dd9799	test: stabilize Windows CI without longer timeouts (#50454 )	2026-09-21 18:30:30 -05:00
Aiden Cline	1e1cd042ea	feat(codemode): name the closest tool in unknown-tool errors (#50455 )	2026-09-21 18:14:31 -05:00
Aiden Cline	02566f6219	fix(codemode): live Map/Set forEach, generator prototypes, repeated function declarations, delete on non-references (#50450 )	2026-09-21 18:09:45 -05:00
opencode-agent[bot]andrekram1-node	f488aa3f79	fix(tui): persist MCP sidebar state (#50447 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-09-21 17:28:23 -05:00
Aiden Cline	97457ec7a3	feat(codemode): accept tools.-prefixed namespaces in search (#50438 )	2026-09-21 16:59:31 -05:00
James Long	d62049aab4	fix(tui): set renderer listener budget to 15 (#50442 )	2026-09-21 17:55:27 -04:00
Aiden Cline	096ac95773	fix(codemode): drop the parameter name from rendered signatures (#50435 )	2026-09-21 16:44:46 -05:00
Aiden Cline	4cc9b90f27	fix(codemode): add Promise.try and surface a failing iterator close on generator return (#50419 )	2026-09-21 15:35:11 -05:00
James Long	990463aa9f	refactor(tui): favor dark theme base (#50412 )	2026-09-21 16:23:38 -04:00
opencode-agent[bot]andrekram1-node	cd39063622	test(core): stabilize browser idle attachment (#50418 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-09-21 14:45:33 -05:00
Aiden Cline	4c944a86d7	fix(core): tell the model search is synchronous (#50417 )	2026-09-21 14:35:46 -05:00
Aiden Cline	97e833a297	feat(codemode): add Iterator helpers and Iterator.from (#50410 )	2026-09-21 14:14:24 -05:00
xin zhuangandSimon Klee	b8aa08f260	fix(tui): complete Mini exit aliases (#50388 ) Co-authored-by: Simon Klee <hello@simonklee.dk>	2026-09-21 17:04:58 +00:00
Aiden Cline	3f0118022b	feat(codemode): add Promise.withResolvers, print errors in console, name values in iterable errors (#50389 )	2026-09-21 11:56:15 -05:00
Simon Klee	6f76c31ca7	tui: resize /btw dialog to terminal (#50392 )	2026-09-21 16:44:18 +00:00
Aiden Cline	f90beeb9b8	fix(core): say plainly that catalog tools and search only work inside execute (#50384 )	2026-09-21 11:13:33 -05:00
Adam	4b9a3d80fc	feat(core): enforce Console-managed policies (#49729 )	2026-09-21 11:10:57 -05:00
Aiden Cline	1316576720	refactor(codemode): type program values and let built-ins answer for themselves (#50191 )	2026-09-21 11:03:16 -05:00
opencode-agent[bot]andnexxeln	2f0c861af0	fix(cli): show actionable upgrade errors (#50346 ) Co-authored-by: nexxeln <95541290+nexxeln@users.noreply.github.com>	2026-09-21 19:09:56 +05:30
opencode-agent[bot]	4d94777d4d	chore(core): refresh bundled models.dev snapshot	2026-09-21 12:19:57 +00:00
opencode-agent[bot]	46ebde65e9	chore: update nix node_modules hashes	2026-09-21 11:58:21 +00:00
Luke Parker	932c12ad1d	chore(desktop): upgrade Electron to 44.4.3 (#50327 )	2026-09-21 21:33:49 +10:00
opencode	6f655dcbab	sync release versions for v2.0.12	2026-09-21 09:57:01 +00:00
Luke Parker	ab60f08c69	fix(app): open Review pane for browser focus in background sessions (#50284 )	2026-09-21 06:08:36 +00:00
Luke Parker	60ed84ecd1	feat(app): open agent-referenced files as rich artifact tabs (#49882 )	2026-09-21 15:20:15 +10:00
Luke Parker	8aebed170a	fix(app): show empty review state for projects without VCS (#50265 )	2026-09-21 14:54:47 +10:00
opencode-agent[bot]Brendonovich Kit Langton	14148a0ea4	fix(app): restore server status spacing (#50273 ) Co-authored-by: Brendonovich <14191578+Brendonovich@users.noreply.github.com> Co-authored-by: Kit Langton <kit.langton@gmail.com>	2026-09-21 12:37:19 +08:00
Aiden Cline	7f51fbd878	feat(codemode): rank whole-word path matches above substring matches in search (#50275 )	2026-09-20 22:59:01 -05:00
Aiden Cline	cbdd1f66da	fix(codemode): locate failures in the submitted source (#50197 )	2026-09-20 20:47:54 -05:00
Luke Parker	788eb0fa29	fix(cli): report fatal startup causes on stderr (#50240 )	2026-09-20 22:57:20 +00:00
opencode-agent[bot]andkitlangton	58fcad77a8	feat(tui): copy session ID from tab menu (#50181 ) Co-authored-by: kitlangton <7587245+kitlangton@users.noreply.github.com>	2026-09-20 19:15:37 +00:00
Aiden Cline	c555559ac1	refactor(plugin): name tool execution context (#50195 )	2026-09-20 11:36:19 -05:00
Aiden Cline	e3a3fa7108	fix(plugin): forward Promise tool cancellation (#50190 )	2026-09-20 11:22:49 -05:00
opencode-agent[bot]	6238af397e	chore(core): refresh bundled models.dev snapshot	2026-09-20 16:17:29 +00:00
Aiden Cline	7ffd75faf6	fix(core): restore anthropic budget variants (#50182 )	2026-09-20 10:50:21 -05:00
opencode-agent[bot]	1f8ab95695	chore(core): refresh bundled models.dev snapshot	2026-09-20 15:37:06 +00:00
Aiden Cline	62dc1f7696	feat(codemode): add toLocaleString, Error.isError, and Map.getOrInsert (#50098 )	2026-09-20 10:23:23 -05:00
opencode-agent[bot]	66f10ab7bf	chore(core): refresh bundled models.dev snapshot	2026-09-20 14:37:06 +00:00
opencode-agent[bot]	1ca8f63a79	chore(core): refresh bundled models.dev snapshot	2026-09-20 13:36:51 +00:00
opencode-agent[bot]	03bcdd580d	chore(core): refresh bundled models.dev snapshot	2026-09-20 12:43:39 +00:00
opencode-agent[bot]	cc502f7e5f	chore(core): refresh bundled models.dev snapshot	2026-09-20 11:37:37 +00:00
opencode-agent[bot]	64ce8771c0	chore(core): refresh bundled models.dev snapshot	2026-09-20 10:37:01 +00:00
opencode-agent[bot]	702a73d91a	chore(core): refresh bundled models.dev snapshot	2026-09-20 09:37:50 +00:00
opencode	991b727eb8	sync release versions for v2.0.11	2026-09-20 08:57:41 +00:00
opencode-agent[bot]	ba342ce227	chore(core): refresh bundled models.dev snapshot	2026-09-20 08:42:13 +00:00
David Hill	1464545665	fix(app): center timeline beside summary (#49620 )	2026-09-20 18:06:32 +10:00
David Hill	fecacc9e68	fix(app): match vertical nav tab states (#49619 )	2026-09-20 18:03:49 +10:00
David HillandLukeParkerDev	1f73b4806b	fix(desktop): polish browser panel states and navigation (#49432 ) Co-authored-by: LukeParkerDev <10430890+Hona@users.noreply.github.com>	2026-09-20 07:54:25 +00:00
opencode-agent[bot]	da2ce02596	chore(core): refresh bundled models.dev snapshot	2026-09-20 07:38:48 +00:00
opencode-agent[bot]	25f35dcfb8	chore(core): refresh bundled models.dev snapshot	2026-09-20 06:49:40 +00:00