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

Freeze session.message.content.updated at the stored shape and translate on replay, run persisted() on CLI session import, write native from the V1 migration, regenerate the OpenAPI docs, and mirror text.ended state in the client fold.
test(core): use native for text and reasoning provider blobs
2026-09-22 16:47:34 +00:00 · 2026-09-22 00:37:59 -05:00 · 2026-09-21 23:39:41 -05:00 · 2026-09-21 23:37:54 -05:00 · 2026-09-21 23:30:38 -05:00 · 2026-09-21 23:27:12 -05:00
398 changed files with 9279 additions and 4603 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-/jah4P2a0aGJNJ0aMdlFEbGHAXx33lqxHbc7UmpLFDg=",
+    "aarch64-linux": "sha256-L3SoZ24qNXicsE2FK6LATQjOmjPxY679RjugrUyO/1Y=",
+    "aarch64-darwin": "sha256-pI9NT8KWUPi+JCk6DYMqIAYmBqTbi13uL4VdNV3WS6Y=",
+    "x86_64-darwin": "sha256-rMAGhTTz46KA5Ya7E5J0af7Bn1QzTDhTaNfNJm8qfsw="
  }
 }
@@ -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"),
  }
 }
@@ -703,7 +703,7 @@ function messageContent(
    return {
      type: "reasoning",
      text: part.text,
-      state: jsonRecord(part.metadata),
+      native: jsonRecord(part.metadata),
      time: part.time
        ? { created: part.time.start, ...(part.time.end === undefined ? {} : { completed: part.time.end }) }
        : undefined,
@@ -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 },
  }
@@ -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()
@@ -1,6 +1,6 @@
 {
  "name": "@opencode/app",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "description": "",
  "type": "module",
  "exports": {
@@ -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) })
-
-
@@ -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>
-
@@ -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
    },
  }
 }
-
@@ -625,6 +625,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.",
@@ -906,6 +916,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",
@@ -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({
@@ -77,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: {
@@ -104,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" })
@@ -112,5 +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,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,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>
@@ -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>
@@ -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>
-
@@ -249,7 +249,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 +282,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,7 @@ 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"

 const SessionMobileFiles = lazy(async () => {
  const { SessionMobileFiles } = await import("./files/session-mobile-files")
@@ -50,14 +51,26 @@ 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 screen = createSessionScreenLayout(session)
  const timeline = createSessionTimelineInteraction(session)
  const timelineSearch = createTimelineSearchController({
@@ -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"
@@ -109,16 +109,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 = {
@@ -480,4 +480,3 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
    }
  },
 })
-
@@ -1,22 +1,23 @@
 import { expect, test } from "bun:test"
+import { Schema } from "effect"
 import type { ServerConnection } from "@/runtime/server/registry"
 import type { Tab } from "@/shell/tabs/tabs"
 import { NotificationStore, openNotificationSession, type Notification } from "./notification"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

 test("notification persistence validates and salvages individual notifications", () => {
  const valid: Notification[] = [
    { type: "turn-complete", time: 123, viewed: false, session: "session-1" },
    { type: "error", time: 124, viewed: true, error: { type: "api", message: "failed", status: 500 } },
  ]
-  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(NotificationStore, { list: [] }), input))
+  const decode = Schema.decodeUnknownSync(Persistence.withInitial(NotificationStore, { list: [] }))
  const store = decode({
    list: [valid[0], null, { type: "unknown", time: 123, viewed: false }, { ...valid[1], error: "invalid" }, valid[1]],
  })
  expect(store.list).toEqual(valid)
  expect(decode({})).toEqual({ list: [] })
  expect(decode({ list: {} })).toEqual({ list: [] })
-  expect(decode(NotificationStore.encode(store))).toEqual(store)
+  expect(decode(Schema.encodeSync(NotificationStore)(store))).toEqual(store)
 })

 test("opens notification sessions through the tab router", () => {
@@ -40,4 +41,3 @@ test("opens notification sessions through the tab router", () => {

  expect(calls).toEqual(["add:session-1", "route:session-1", "select:session-1"])
 })
-
@@ -1,6 +1,6 @@
 import { createStore, reconcile } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
-import type { SessionError } from "@opencode/schema/session-error"
+import { Schema } from "effect"
+import { SessionError } from "@opencode/schema/session-error"
 import { type Accessor, batch, createEffect, createMemo, createRoot, getOwner, onCleanup } from "solid-js"
 import { createSimpleContext } from "@opencode/ui/context"
 import type { ServerSDK } from "@/runtime/server/client"
@@ -10,7 +10,7 @@ import { useLanguage } from "@/runtime/i18n/language"
 import { useSettings } from "@/settings/model"
 import { decode64 } from "@/runtime/persistence/base64"
 import { Persist, persisted } from "@/runtime/persistence/storage"
-
+import { Persistence } from "@/runtime/persistence/schema"
 import { playSoundById } from "@/shell/notifications/sound"
 import type { createNotificationCoordinator } from "@/shell/notifications/coordinator"
 import { useGlobal } from "@/runtime/server/runtime"
@@ -20,28 +20,19 @@ import { requireServerKey, sessionHref } from "@/shell/routes/session"
 import type { ServerScope } from "@/runtime/server/scope"
 import { useServer } from "@/runtime/server/current"

-const NotificationBase = {
-  directory: Codec.optional(Codec.string),
-  session: Codec.optional(Codec.string),
-  metadata: Codec.optional(Codec.unknown),
-  time: Codec.number,
-  viewed: Codec.boolean,
-}
-// The error payload is whatever the server reported; shape-checking it here would load the shared
-// Effect schema into the renderer's startup path for a value the server already validated.
-const StoredSessionError = Codec.make<SessionError.Error, unknown>(
-  (value) =>
-    typeof value === "object" && value !== null && "name" in value && "message" in value
-      ? (value as unknown as SessionError.Error)
-      : Codec.INVALID,
-  (value) => value,
-)
-export const Notification = Codec.union([
-  Codec.struct({ ...NotificationBase, type: Codec.literal("turn-complete") }),
-  Codec.struct({ ...NotificationBase, type: Codec.literal("error"), error: StoredSessionError }),
+const NotificationBase = {
+  directory: Schema.optional(Schema.String),
+  session: Schema.optional(Schema.String),
+  metadata: Schema.optional(Schema.Unknown),
+  time: Schema.Finite,
+  viewed: Schema.Boolean,
+}
+export const Notification = Schema.Union([
+  Persistence.struct({ ...NotificationBase, type: Schema.Literal("turn-complete") }),
+  Persistence.struct({ ...NotificationBase, type: Schema.Literal("error"), error: SessionError.Error }),
 ])
 export type Notification = typeof Notification.Type
-export const NotificationStore = Codec.struct({ list: Codec.lenientArray(Notification) })
+export const NotificationStore = Persistence.struct({ list: Persistence.array(Notification) })

 type NotificationIndex = {
  session: {
@@ -377,5 +368,3 @@ export const useNotification = () => {
  const server = useServer()
  return server.ctx.notification
 }
-
-
@@ -1,7 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { createRoot, createSignal } from "solid-js"
+import { Schema } from "effect"
 import { ServerConnection } from "@/runtime/server/registry"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"
 import { currentRoute, initialLayout, layoutPersistence, layoutSchema } from "./layout"
 import { createSessionKeyReader, ensureSessionKey, pruneSessionKeys } from "./helpers"

@@ -10,21 +11,21 @@ test("settings has its own layout route", () => {
 })

 describe("layout persistence", () => {
-  const schema = Codec.withInitial(layoutPersistence, initialLayout(ServerConnection.Key.make("local")))
-  const decode = (input: unknown) => Codec.decodeOrThrow(schema, input)
+  const schema = Persistence.withInitial(layoutPersistence, initialLayout(ServerConnection.Key.make("local")))
+  const decode = Schema.decodeUnknownSync(schema)

  test("uses supplied initial preferences after legacy migration", () => {
    const initial = initialLayout(ServerConnection.Key.make("remote"))
    initial.sidebar.width = 420
    initial.fileTree.width = 300
    initial.review.panelOpened = true
-    const restore = (input: unknown) => Codec.decodeOrThrow(Codec.withInitial(layoutPersistence, initial), input)
+    const restore = Schema.decodeUnknownSync(Persistence.withInitial(layoutPersistence, initial))
    expect(restore({})).toEqual(initial)
    expect(restore({ sidebar: { width: "bad" } }).sidebar.width).toBe(420)
    expect(restore({ fileTree: { width: 260 } }).fileTree.width).toBe(200)
    expect(restore({ fileTree: {} }).fileTree.width).toBe(300)
    expect(restore({ review: {}, fileTree: { opened: false } }).review.panelOpened).toBe(false)
-    expect(() => Codec.decodeOrThrow(layoutSchema, {})).toThrow()
+    expect(() => Schema.decodeUnknownSync(layoutSchema)({})).toThrow()
  })

  test("restores shipped defaults for missing and invalid fields", () => {
@@ -55,8 +56,8 @@ describe("layout persistence", () => {
    expect(value.sidebar).toEqual({ opened: false, width: 344, workspaces: {}, workspacesDefault: true })
    expect(value.review).toEqual({ diffStyle: "split", panelOpened: true })
    expect(value.fileTree).toEqual({ opened: true, width: 200, tab: "changes" })
-    expect(schema.encode(value)).toEqual(value)
-    expect(decode(schema.encode(value))).toEqual(value)
+    expect(Schema.encodeSync(schema)(value)).toEqual(value)
+    expect(decode(Schema.encodeSync(schema)(value))).toEqual(value)
    expect(decode({ fileTree: { opened: true } }).review.panelOpened).toBe(false)
  })

@@ -168,4 +169,3 @@ describe("pruneSessionKeys", () => {
    expect(drop).toEqual([])
  })
 })
-
@@ -1,58 +1,63 @@
 export * as TabStorage from "./schema"

-import { Codec } from "@/runtime/persistence/codec"
-import { ServerKey } from "@/runtime/server/key"
+import { Schema, SchemaGetter } from "effect"
+import { ServerKey } from "@/runtime/server/persistence"
+import { Persistence } from "@/runtime/persistence/schema"

 export { ServerKey }

-export const Session = Codec.struct({
-  type: Codec.literal("session"),
+export const Session = Persistence.struct({
+  type: Schema.Literal("session"),
  server: ServerKey,
-  sessionId: Codec.string,
-  routeSessionId: Codec.lenientOptional(Codec.string),
-  routeParentId: Codec.lenientOptional(Codec.string),
+  sessionId: Schema.String,
+  routeSessionId: Persistence.optional(Schema.String),
+  routeParentId: Persistence.optional(Schema.String),
 })

-export const Draft = Codec.struct({
-  type: Codec.literal("draft"),
-  draftID: Codec.string,
+export const Draft = Persistence.struct({
+  type: Schema.Literal("draft"),
+  draftID: Schema.String,
  server: ServerKey,
-  directory: Codec.string,
-  worktree: Codec.lenientOptional(Codec.string),
-  branch: Codec.lenientOptional(Codec.string),
-  mcp: Codec.lenientOptional(Codec.struct({ target: Codec.string, states: Codec.lenientRecord(Codec.boolean) })),
+  directory: Schema.String,
+  worktree: Persistence.optional(Schema.String),
+  branch: Persistence.optional(Schema.String),
+  mcp: Persistence.optional(Persistence.struct({ target: Schema.String, states: Persistence.record(Schema.Boolean) })),
 })

-// A stored route that only repeats the session id carries nothing; drop it and its parent.
-const SessionCodec = Codec.transform(Session, {
-  decode: (tab) => ({
-    type: tab.type,
-    server: tab.server,
-    sessionId: tab.sessionId,
-    ...(tab.routeSessionId && tab.routeSessionId !== tab.sessionId
-      ? { routeSessionId: tab.routeSessionId, ...(tab.routeParentId ? { routeParentId: tab.routeParentId } : {}) }
-      : {}),
-  }),
-  encode: (tab) => tab,
-})
-
-export const Tab = Codec.union([Session, Draft])
-export const Tabs = Codec.lenientArray(Codec.union([SessionCodec, Draft]))
-export const Recent = Codec.struct({
-  key: Codec.optional(Codec.string),
-})
-export const Info = Codec.struct({
-  title: Codec.optional(Codec.string),
-  directory: Codec.optional(Codec.string),
-})
-export const Infos = Codec.record(Info)
-export const Panes = Codec.record(
-  Codec.struct({
-    terminal: Codec.optional(Codec.boolean),
-    review: Codec.optional(Codec.boolean),
-    terminalHeight: Codec.optional(Codec.number),
-    sessionWidth: Codec.optional(Codec.number),
+const SessionCodec = Session.pipe(
+  Schema.decodeTo(Schema.toType(Session), {
+    decode: SchemaGetter.transform((tab) => ({
+      type: tab.type,
+      server: tab.server,
+      sessionId: tab.sessionId,
+      ...(tab.routeSessionId && tab.routeSessionId !== tab.sessionId
+        ? { routeSessionId: tab.routeSessionId, ...(tab.routeParentId ? { routeParentId: tab.routeParentId } : {}) }
+        : {}),
+    })),
+    encode: SchemaGetter.transform((tab) => tab),
  }),
 )
-export const ClosedTab = Codec.struct({ tab: SessionCodec, index: Codec.nonNegativeInt })
-export const Closed = Codec.lenientArray(ClosedTab)
+
+export const Tab = Schema.Union([Session, Draft])
+export const Tabs = Persistence.array(Schema.Union([SessionCodec, Draft]))
+export const Recent = Persistence.struct({
+  key: Schema.optional(Schema.String),
+})
+export const Info = Persistence.struct({
+  title: Schema.optional(Schema.String),
+  directory: Schema.optional(Schema.String),
+})
+export const Infos = Schema.Record(Schema.String, Schema.mutableKey(Info))
+export const Panes = Schema.Record(
+  Schema.String,
+  Schema.mutableKey(
+    Persistence.struct({
+      terminal: Schema.optional(Schema.Boolean),
+      review: Schema.optional(Schema.Boolean),
+      terminalHeight: Schema.optional(Schema.Finite),
+      sessionWidth: Schema.optional(Schema.Finite),
+    }),
+  ),
+)
+export const ClosedTab = Schema.Struct({ tab: SessionCodec, index: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) })
+export const Closed = Persistence.array(ClosedTab)
@@ -3,12 +3,13 @@ import { createRoot, getOwner, onCleanup } from "solid-js"
 import { createTabMemory } from "./memory"
 import { nextTabAfterClose, pushClosedTab, removeClosedTabs, takeClosedTab, type ClosedTab } from "./closed"
 import { findSessionTab, sessionIDHasOpenTab, tabHref, tabKey, type SessionTab, type Tab } from "./tabs"
+import { Schema } from "effect"
 import { TabStorage } from "./schema"
 import type { ServerConnection } from "@/runtime/server/registry"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

 const server = "local\nhttp://localhost:4096" as ServerConnection.Key
-const decodeTabs = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Tabs, []), input))
+const decodeTabs = Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Tabs, []))

 function sessionTab(sessionId: string): SessionTab {
  return { type: "session", server, sessionId }
@@ -25,7 +26,7 @@ describe("tab migration", () => {
    }
    const restored = decodeTabs([legacy, draft])
    expect(restored).toEqual([legacy, draft])
-    expect(decodeTabs(TabStorage.Tabs.encode(restored))).toEqual([legacy, draft])
+    expect(decodeTabs(Schema.encodeSync(TabStorage.Tabs)(restored))).toEqual([legacy, draft])
  })

  test("drops null and malformed persisted tabs", () => {
@@ -63,13 +64,13 @@ describe("tab migration", () => {
      draft,
    ])
    expect(tabs).toEqual([sessionTab("root"), draft])
-    expect(TabStorage.Tabs.encode(tabs)).toEqual(tabs)
-    expect(decodeTabs(TabStorage.Tabs.encode(tabs))).toEqual(tabs)
+    expect(Schema.encodeSync(TabStorage.Tabs)(tabs)).toEqual(tabs)
+    expect(decodeTabs(Schema.encodeSync(TabStorage.Tabs)(tabs))).toEqual(tabs)
  })

  test("salvages valid closed session tabs", () => {
    expect(
-      ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Closed, []), input))([
+      Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Closed, []))([
        { tab: sessionTab("a"), index: 1 },
        { tab: sessionTab("b"), index: -1 },
        { tab: { type: "draft", server, draftID: "d", directory: "/project" }, index: 0 },
@@ -80,16 +81,16 @@ describe("tab migration", () => {

  test("validates auxiliary tab state", () => {
    expect(
-      ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(TabStorage.Recent, { key: undefined }), input))({ key: 1 }),
+      Schema.decodeUnknownSync(Persistence.withInitial(TabStorage.Recent, { key: undefined }))({ key: 1 }),
    ).toEqual({ key: undefined })
-    expect(Codec.decodeOrThrow(TabStorage.Infos, {})).toEqual({})
-    expect(Codec.decodeOrThrow(TabStorage.Panes, {})).toEqual({})
-    expect(Codec.decodeOrThrow(TabStorage.Infos, { tab: { title: "Title", directory: "/project" } })).toEqual({
+    expect(Schema.decodeUnknownSync(TabStorage.Infos)({})).toEqual({})
+    expect(Schema.decodeUnknownSync(TabStorage.Panes)({})).toEqual({})
+    expect(Schema.decodeUnknownSync(TabStorage.Infos)({ tab: { title: "Title", directory: "/project" } })).toEqual({
      tab: { title: "Title", directory: "/project" },
    })
-    const panes = Codec.decodeOrThrow(TabStorage.Panes, { tab: { terminal: true, terminalHeight: 300 } })
-    expect(TabStorage.Panes.encode(panes)).toEqual({ tab: { terminal: true, terminalHeight: 300 } })
-    expect(() => Codec.decodeOrThrow(TabStorage.Panes, { tab: { terminal: "yes" } })).toThrow()
+    const panes = Schema.decodeUnknownSync(TabStorage.Panes)({ tab: { terminal: true, terminalHeight: 300 } })
+    expect(Schema.encodeSync(TabStorage.Panes)(panes)).toEqual({ tab: { terminal: true, terminalHeight: 300 } })
+    expect(() => Schema.decodeUnknownSync(TabStorage.Panes)({ tab: { terminal: "yes" } })).toThrow()
  })
 })

@@ -208,5 +209,3 @@ describe("closed tab stack", () => {
    expect(nextTabAfterClose([sessionTab("a")], 0, true)).toBeNull()
  })
 })
-
-
@@ -9,7 +9,8 @@
  justify-content: center;
 }

-[data-titlebar-tab] {
+[data-titlebar-tab],
+[data-titlebar-tab-action] {
  --tab-base: var(--v2-background-bg-deep);
  --tab-overlay: transparent;
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
@@ -68,6 +69,14 @@
  --tab-overlay: var(--v2-overlay-simple-overlay-pressed);
 }

+[data-titlebar-tab-action]:is(:hover, :focus-visible) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-hover);
+}
+
+[data-titlebar-tab-action]:is(:active, [data-state="pressed"]) {
+  --tab-overlay: var(--v2-overlay-simple-overlay-pressed);
+}
+
 [data-titlebar-tab]:is(:hover, [data-state="pressed"]) [data-slot="tab-close"] {
  background: linear-gradient(var(--tab-overlay), var(--tab-overlay)), var(--tab-base);
 }
@@ -351,9 +351,10 @@ export function Titlebar(props: {
              >
                <button
                  type="button"
+                  data-titlebar-tab-action
                  data-action="vertical-tabs-home"
                  data-state={layout.route().type === "home" ? "pressed" : undefined}
-                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base data-[state=pressed]:bg-v2-background-bg-layer-02 data-[state=pressed]:text-v2-text-text-base"
+                  class="group mb-1 flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base data-[state=pressed]:text-v2-text-text-base"
                  onClick={toggleHome}
                  aria-label={language.t("home.title")}
                  aria-pressed={layout.route().type === "home"}
@@ -650,8 +651,9 @@ export function Titlebar(props: {
                            {homeButton(true)}
                            <button
                              type="button"
+                              data-titlebar-tab-action
                              data-action="vertical-tabs-new-session"
-                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:bg-v2-background-bg-layer-02 hover:text-v2-text-text-base"
+                              class="group flex h-7 w-full shrink-0 items-center gap-1.5 rounded-[6px] ps-1.5 pe-2 text-[13px] leading-4 text-v2-text-text-faint hover:text-v2-text-text-base"
                              onClick={openNewTab}
                              aria-label={language.t("command.session.new")}
                            >
@@ -1,13 +1,13 @@
 import { expect, test } from "bun:test"
+import { Schema } from "effect"
 import { HighlightsStore } from "./highlights"
-import { Codec } from "@/runtime/persistence/codec"
+import { Persistence } from "@/runtime/persistence/schema"

 test("highlight persistence defaults missing or invalid versions and round-trips valid versions", () => {
-  const decode = ((input: unknown) => Codec.decodeOrThrow(Codec.withInitial(HighlightsStore, { version: undefined }), input))
+  const decode = Schema.decodeUnknownSync(Persistence.withInitial(HighlightsStore, { version: undefined }))
  expect(decode({})).toEqual({ version: undefined })
  expect(decode({ version: null })).toEqual({ version: undefined })
  const value = decode({ version: "1.2.3", legacy: true })
  expect(value).toEqual({ version: "1.2.3" })
-  expect(HighlightsStore.encode(value)).toEqual(value)
+  expect(Schema.encodeSync(HighlightsStore)(value)).toEqual(value)
 })
-
@@ -1,18 +1,18 @@
 import { createEffect, onCleanup } from "solid-js"
 import { createStore } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
 import { createSimpleContext } from "@opencode/ui/context"
 import { useDialog } from "@opencode/ui/context/dialog"
 import { usePlatform } from "@/runtime/platform/platform"
 import { useSettings } from "@/settings/model"
 import { persisted } from "@/runtime/persistence/storage"
-
+import { Persistence } from "@/runtime/persistence/schema"
 import { DialogReleaseNotes, type Highlight } from "@/shell/updates/release-notes"

 const CHANGELOG_URL = "https://opencode.ai/changelog.json"

-export const HighlightsStore = Codec.struct({
-  version: Codec.undefinedOr(Codec.string),
+export const HighlightsStore = Persistence.struct({
+  version: Schema.UndefinedOr(Schema.String),
 })

 type ParsedRelease = {
@@ -233,4 +233,3 @@ export const { use: useHighlights, provider: HighlightsProvider } = createSimple
    }
  },
 })
-
@@ -0,0 +1,118 @@
+import { describe, expect, test } from "bun:test"
+import {
+  artifactKind,
+  bytesToBase64,
+  contentBytes,
+  fileContentFromBytes,
+  MAX_MEDIA_BYTES,
+  parseDelimited,
+  resolveArtifactPath,
+} from "./artifact"
+
+describe("artifactKind", () => {
+  test.each([
+    ["shot.PNG", "image"],
+    ["logo.svg", "svg"],
+    ["song.mp3", "audio"],
+    ["demo.mp4", "video"],
+    ["clip.webm", "video"],
+    ["paper.pdf", "pdf"],
+    ["out/index.html", "html"],
+    ["README.md", "markdown"],
+    ["flow.mmd", "mermaid"],
+    ["data.csv", "table"],
+    ["data.tsv", "table"],
+    ["Inter.woff2", "font"],
+    ["src/app.ts", "text"],
+    ["Makefile", "text"],
+    [".env", "text"],
+    ["archive.tar.gz", "text"],
+  ] as const)("classifies %s as %s", (path, kind) => {
+    expect(artifactKind(path)).toBe(kind)
+  })
+})
+
+describe("fileContentFromBytes", () => {
+  test("keeps media as base64 with a mime type", () => {
+    const content = fileContentFromBytes("a.png", new Uint8Array([137, 80, 78, 71]))
+    expect(content).toEqual({ type: "binary", content: "iVBORw==", encoding: "base64", mimeType: "image/png" })
+  })
+
+  test("decodes text and svg with a mime type", () => {
+    expect(fileContentFromBytes("a.svg", new TextEncoder().encode("<svg/>"))).toEqual({
+      type: "text",
+      content: "<svg/>",
+      mimeType: "image/svg+xml",
+    })
+    expect(fileContentFromBytes("a.ts", new TextEncoder().encode("const a = 1"))).toEqual({
+      type: "text",
+      content: "const a = 1",
+      mimeType: undefined,
+    })
+  })
+
+  test("keeps only the size of media above the cap", () => {
+    const content = fileContentFromBytes("big.mp4", new Uint8Array(MAX_MEDIA_BYTES + 1))
+    expect(content).toEqual({ type: "binary", content: "", size: MAX_MEDIA_BYTES + 1 })
+  })
+
+  test("marks unknown binaries without keeping bytes", () => {
+    expect(fileContentFromBytes("a.bin", new Uint8Array([1, 0, 2]))).toEqual({ type: "binary", content: "", size: 3 })
+  })
+
+  test("encodes large buffers in chunks", () => {
+    const bytes = new Uint8Array(70_000).fill(65)
+    expect(bytesToBase64(bytes)).toBe(Buffer.from(bytes).toString("base64"))
+  })
+})
+
+describe("contentBytes", () => {
+  test("recovers byte counts from base64 and text", () => {
+    expect(contentBytes({ type: "binary", content: "iVBORw==", encoding: "base64" })).toBe(4)
+    expect(contentBytes({ type: "binary", content: "iVBORwA=", encoding: "base64" })).toBe(5)
+    expect(contentBytes({ type: "text", content: "héllo" })).toBe(6)
+  })
+})
+
+describe("parseDelimited", () => {
+  test("handles quotes, embedded delimiters, newlines, and CRLF", () => {
+    const parsed = parseDelimited('name,note\r\n"Smith, J","says ""hi""\nand more"\nplain,\n', ",")
+    expect(parsed.rows).toEqual([
+      ["name", "note"],
+      ["Smith, J", 'says "hi"\nand more'],
+      ["plain", ""],
+    ])
+    expect(parsed.total).toBe(3)
+    expect(parsed.columns).toBe(2)
+  })
+
+  test("counts rows past the limit without keeping them", () => {
+    const parsed = parseDelimited("a\tb\n1\t2\n3\t4\n5\t6", "\t", 2)
+    expect(parsed.rows).toHaveLength(2)
+    expect(parsed.total).toBe(4)
+  })
+})
+
+describe("resolveArtifactPath", () => {
+  test.each([
+    ["docs", "guide.md", "docs/guide.md"],
+    ["docs", "./img/a.png", "docs/img/a.png"],
+    ["docs/api", "../index.md", "docs/index.md"],
+    ["", "src/app.ts", "src/app.ts"],
+    ["docs", "sub\\win.md", "docs/sub/win.md"],
+    ["", "docs/guide.md", "docs/guide.md"],
+    ["/tmp/notes/", "../out/a.pdf", "/tmp/out/a.pdf"],
+    ["C:/tmp/notes/", "img.png", "C:/tmp/notes/img.png"],
+    ["/repo", "../shared/report.pdf", "/shared/report.pdf"],
+  ])("resolves %s + %s", (base, href, expected) => {
+    expect(resolveArtifactPath(base, href)).toBe(expected)
+  })
+
+  test.each([
+    ["docs", "../../etc/passwd"],
+    ["", "../x"],
+    ["docs", "/abs/path"],
+  ])("rejects %s + %s", (base, href) => {
+    expect(resolveArtifactPath(base, href)).toBeUndefined()
+  })
+})
@@ -0,0 +1,211 @@
+import type { FileContent } from "@/runtime/server/types"
+
+export type ArtifactKind =
+  | "image"
+  | "svg"
+  | "audio"
+  | "video"
+  | "pdf"
+  | "html"
+  | "markdown"
+  | "mermaid"
+  | "table"
+  | "font"
+  | "text"
+
+const mimes = new Map([
+  ["png", "image/png"],
+  ["jpg", "image/jpeg"],
+  ["jpeg", "image/jpeg"],
+  ["gif", "image/gif"],
+  ["webp", "image/webp"],
+  ["avif", "image/avif"],
+  ["bmp", "image/bmp"],
+  ["ico", "image/x-icon"],
+  ["tif", "image/tiff"],
+  ["tiff", "image/tiff"],
+  ["heic", "image/heic"],
+  ["svg", "image/svg+xml"],
+  ["mp3", "audio/mpeg"],
+  ["wav", "audio/wav"],
+  ["ogg", "audio/ogg"],
+  ["oga", "audio/ogg"],
+  ["m4a", "audio/mp4"],
+  ["aac", "audio/aac"],
+  ["flac", "audio/flac"],
+  ["opus", "audio/ogg"],
+  ["weba", "audio/webm"],
+  ["mp4", "video/mp4"],
+  ["m4v", "video/mp4"],
+  ["webm", "video/webm"],
+  ["mov", "video/quicktime"],
+  ["ogv", "video/ogg"],
+  ["mkv", "video/x-matroska"],
+  ["pdf", "application/pdf"],
+  ["html", "text/html"],
+  ["htm", "text/html"],
+  ["md", "text/markdown"],
+  ["markdown", "text/markdown"],
+  ["mdx", "text/markdown"],
+  ["mmd", "text/vnd.mermaid"],
+  ["mermaid", "text/vnd.mermaid"],
+  ["csv", "text/csv"],
+  ["tsv", "text/tab-separated-values"],
+  ["ttf", "font/ttf"],
+  ["otf", "font/otf"],
+  ["woff", "font/woff"],
+  ["woff2", "font/woff2"],
+])
+
+export function artifactExtension(path: string) {
+  const name = path.split(/[\\/]/).pop() ?? ""
+  const index = name.lastIndexOf(".")
+  if (index <= 0) return ""
+  return name.slice(index + 1).toLowerCase()
+}
+
+export function artifactMime(path: string) {
+  return mimes.get(artifactExtension(path))
+}
+
+export function artifactKind(path: string): ArtifactKind {
+  const mime = artifactMime(path)
+  if (!mime) return "text"
+  if (mime === "image/svg+xml") return "svg"
+  if (mime === "application/pdf") return "pdf"
+  if (mime === "text/html") return "html"
+  if (mime === "text/markdown") return "markdown"
+  if (mime === "text/vnd.mermaid") return "mermaid"
+  if (mime === "text/csv" || mime === "text/tab-separated-values") return "table"
+  if (mime.startsWith("image/")) return "image"
+  if (mime.startsWith("audio/")) return "audio"
+  if (mime.startsWith("font/")) return "font"
+  return "video"
+}
+
+/** Kinds whose bytes are kept as base64 so media elements can play them without a text round trip. */
+const binaryKinds = new Set<ArtifactKind>(["image", "audio", "video", "pdf", "font"])
+
+/** Text files never contain NUL; a NUL in the first 8 KiB marks an unknown binary. */
+function isBinaryBytes(bytes: Uint8Array) {
+  return bytes.subarray(0, 8192).includes(0)
+}
+
+export function bytesToBase64(bytes: Uint8Array) {
+  const parts: string[] = []
+  for (let index = 0; index < bytes.length; index += 0x8000) {
+    parts.push(String.fromCharCode(...bytes.subarray(index, index + 0x8000)))
+  }
+  return btoa(parts.join(""))
+}
+
+/** Media above this stays a placeholder: base64 encoding on the main thread and the LRU budget both suffer. */
+export const MAX_MEDIA_BYTES = 25 * 1024 * 1024
+
+export function fileContentFromBytes(path: string, bytes: Uint8Array): FileContent {
+  const kind = artifactKind(path)
+  const mimeType = artifactMime(path)
+  if (binaryKinds.has(kind)) {
+    if (bytes.length > MAX_MEDIA_BYTES) return { type: "binary", content: "", size: bytes.length }
+    return { type: "binary", content: bytesToBase64(bytes), encoding: "base64", mimeType }
+  }
+  // Unknown binaries keep no bytes: the viewer only shows a placeholder for them.
+  if (kind === "text" && isBinaryBytes(bytes)) return { type: "binary", content: "", size: bytes.length }
+  return { type: "text", content: new TextDecoder().decode(bytes), mimeType }
+}
+
+/** Approximate on-disk size of loaded content. */
+export function contentBytes(content: FileContent) {
+  if (content.size !== undefined) return content.size
+  if (content.encoding === "base64") {
+    const padding = content.content.endsWith("==") ? 2 : content.content.endsWith("=") ? 1 : 0
+    return Math.floor((content.content.length * 3) / 4) - padding
+  }
+  return new TextEncoder().encode(content.content).length
+}
+
+/**
+ * Parse RFC 4180 style delimited text. Quoted fields may contain the delimiter, newlines, and
+ * doubled quotes. Rows beyond `limit` are counted but not returned.
+ */
+export function parseDelimited(text: string, delimiter: string, limit = 1000) {
+  const rows: string[][] = []
+  let row: string[] = []
+  let field = ""
+  let quoted = false
+  let total = 0
+  const endRow = () => {
+    row.push(field)
+    field = ""
+    const blank = row.length === 1 && row[0] === ""
+    if (!blank) {
+      total++
+      if (rows.length < limit) rows.push(row)
+    }
+    row = []
+  }
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index]!
+    if (quoted) {
+      if (char !== '"') {
+        field += char
+        continue
+      }
+      if (text[index + 1] === '"') {
+        field += '"'
+        index++
+        continue
+      }
+      quoted = false
+      continue
+    }
+    if (char === '"' && field === "") {
+      quoted = true
+      continue
+    }
+    if (char === delimiter) {
+      row.push(field)
+      field = ""
+      continue
+    }
+    if (char === "\r") continue
+    if (char === "\n") {
+      endRow()
+      continue
+    }
+    field += char
+  }
+  if (field !== "" || row.length > 0) endRow()
+  const columns = rows.reduce((max, current) => Math.max(max, current.length), 0)
+  return { rows, total, columns }
+}
+
+/** Build a blob URL from loaded content. Callers revoke it when the viewer unmounts. */
+export function blobUrlFromContent(content: FileContent) {
+  const type = content.mimeType ?? "application/octet-stream"
+  if (content.encoding !== "base64") return URL.createObjectURL(new Blob([content.content], { type }))
+  const raw = atob(content.content)
+  const bytes = Uint8Array.from(raw, (char) => char.charCodeAt(0))
+  return URL.createObjectURL(new Blob([bytes], { type }))
+}
+
+/**
+ * Resolve a relative link against a directory. A relative base yields a workspace-relative path and
+ * an absolute base an absolute one; undefined when the link climbs past the base's root.
+ */
+export function resolveArtifactPath(base: string, href: string) {
+  const target = href.replaceAll("\\", "/")
+  if (target.startsWith("/")) return undefined
+  const dir = base.replaceAll("\\", "/")
+  const segments = [...dir.split("/").filter(Boolean)]
+  for (const segment of target.split("/")) {
+    if (!segment || segment === ".") continue
+    if (segment !== "..") {
+      segments.push(segment)
+      continue
+    }
+    if (segments.length === 0) return undefined
+    segments.pop()
+  }
+  return `${dir.startsWith("/") ? "/" : ""}${segments.join("/")}`
+}
@@ -5,11 +5,12 @@ import { createSimpleContext } from "@opencode/ui/context"
 import { showToast } from "@/shell/notifications/toast"
 import { useParams } from "@solidjs/router"
 import { base64Encode } from "@opencode/util/encode"
-import { getFilename } from "@opencode/util/path"
+import { getDirectory, getFilename } from "@opencode/util/path"
 import { useWorkspaceLocation } from "@/workspaces/location"
 import { useLanguage } from "@/runtime/i18n/language"
 import { useLayout } from "@/shell/state/layout"
 import { createPathHelpers } from "./path"
+import { fileContentFromBytes } from "./artifact"
 import {
  approxBytes,
  evictContentLru,
@@ -185,14 +186,17 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({

      setLoading(file)

+      // Files outside the workspace are read from their own directory, like markdown images.
+      // The trailing separator from getDirectory keeps "/" and "C:/" valid, like readLocalImage.
+      const request = path.absolute(file)
+        ? { path: getFilename(file), location: { directory: getDirectory(file) } }
+        : { path: file, location: { directory } }
      const promise = serverSDK.api.file
-        .read({ path: file, location: { directory } })
+        .read(request)
        .then((data) => {
          if (scope() !== directory) return
-          const content = { type: "text" as const, content: new TextDecoder().decode(data) }
+          const content = fileContentFromBytes(file, data)
          setLoaded(file, content)
-
-          if (!content) return
          touchFileContent(file, approxBytes(content))
          evictContent(new Set([file]))
        })
@@ -281,6 +285,7 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
    return {
      ready: () => view().ready(),
      normalize: path.normalize,
+      absolute: path.absolute,
      tab: path.tab,
      pathFromTab: path.pathFromTab,
      tree: {
@@ -21,6 +21,24 @@ describe("file path helpers", () => {
    expect(path.normalize("c:\\repo\\src\\app.ts")).toBe("src\\app.ts")
  })

+  test("keeps files outside the workspace absolute and round-trips them through tabs", () => {
+    const posix = createPathHelpers(() => "/repo")
+    expect(posix.normalize("/tmp/out/report.pdf")).toBe("/tmp/out/report.pdf")
+    expect(posix.absolute("/tmp/out/report.pdf")).toBe(true)
+    expect(posix.absolute("src/app.ts")).toBe(false)
+    expect(posix.tab("/tmp/out/report.pdf")).toBe("file:///tmp/out/report.pdf")
+    expect(posix.pathFromTab("file:///tmp/out/report.pdf")).toBe("/tmp/out/report.pdf")
+    expect(posix.normalize("/repository/x.ts")).toBe("/repository/x.ts")
+
+    const windows = createPathHelpers(() => "C:\\repo")
+    expect(windows.normalize("C:\\tmp\\font.ttf")).toBe("C:\\tmp\\font.ttf")
+    expect(windows.normalize("file:///C:/tmp/font.ttf")).toBe("C:/tmp/font.ttf")
+    expect(windows.absolute("C:/tmp/font.ttf")).toBe(true)
+    expect(windows.tab("C:/tmp/font.ttf")).toBe("file:///C:/tmp/font.ttf")
+    expect(windows.pathFromTab("file:///C:/tmp/font.ttf")).toBe("C:/tmp/font.ttf")
+    expect(windows.pathFromTab("file:///C:/repo/src/app.ts")).toBe("src/app.ts")
+  })
+
  test("normalizes Windows directory separators", () => {
    const path = createPathHelpers(() => "C:\\repo")
    expect(path.normalizeDir("frontend\\")).toBe("frontend")
@@ -105,7 +105,11 @@ export function createPathHelpers(scope: () => string) {
  const normalize = (input: string) => {
    const root = scope()

-    let path = unquoteGitPath(decodeFilePath(stripQueryAndHash(stripFileProtocol(input))))
+    // file:///C:/dir becomes /C:/dir once the protocol is gone; restore the drive form.
+    let path = unquoteGitPath(decodeFilePath(stripQueryAndHash(stripFileProtocol(input)))).replace(
+      /^[/\\]([A-Za-z]:)/,
+      "$1",
+    )

    // Separator-agnostic prefix stripping for Cygwin/native Windows compatibility
    // Only case-insensitive on Windows (drive letter or UNC paths)
@@ -116,20 +120,21 @@ export function createPathHelpers(scope: () => string) {
      canonPath.startsWith(canonRoot) &&
      (canonRoot.endsWith("/") || canonPath === canonRoot || canonPath[canonRoot.length] === "/")
    ) {
-      // Slice from original path to preserve native separators
-      path = path.slice(root.length)
+      // Slice from original path to preserve native separators, then drop the separator itself.
+      path = path.slice(root.length).replace(/^[/\\]/, "")
    }

    if (path.startsWith("./") || path.startsWith(".\\")) {
      path = path.slice(2)
    }

-    if (path.startsWith("/") || path.startsWith("\\")) {
-      path = path.slice(1)
-    }
+    // An absolute path that is not under the root stays absolute; it is a file outside the workspace.
    return path
  }

+  /** Whether a normalized path points outside the workspace root. */
+  const absolute = (path: string) => /^[A-Za-z]:[/\\]/.test(path) || path.startsWith("/") || path.startsWith("\\\\")
+
  const tab = (input: string) => {
    const path = normalize(input)
    return `file://${encodeFilePath(path)}`
@@ -149,6 +154,7 @@ export function createPathHelpers(scope: () => string) {

  return {
    normalize,
+    absolute,
    tab,
    pathFromTab,
    normalizeDir,
@@ -1,19 +1,20 @@
 import type { FileContent } from "@/runtime/server/types"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
+import { Persistence } from "@/runtime/persistence/schema"

-export const FileSelection = Codec.struct({
-  startLine: Codec.number,
-  startChar: Codec.number,
-  endLine: Codec.number,
-  endChar: Codec.number,
+export const FileSelection = Persistence.struct({
+  startLine: Schema.Number,
+  startChar: Schema.Number,
+  endLine: Schema.Number,
+  endChar: Schema.Number,
 })
 export type FileSelection = typeof FileSelection.Type

-export const SelectedLineRange = Codec.struct({
-  start: Codec.number,
-  end: Codec.number,
-  side: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
-  endSide: Codec.lenientOptional(Codec.literals(["additions", "deletions"])),
+export const SelectedLineRange = Persistence.struct({
+  start: Schema.Number,
+  end: Schema.Number,
+  side: Persistence.optional(Schema.Literals(["additions", "deletions"])),
+  endSide: Persistence.optional(Schema.Literals(["additions", "deletions"])),
 })
 export type SelectedLineRange = typeof SelectedLineRange.Type

@@ -43,4 +44,3 @@ export function selectionFromLines(range: SelectedLineRange): FileSelection {
    endChar: 0,
  }
 }
-
@@ -1,7 +1,8 @@
 import { createEffect, createRoot } from "solid-js"
 import { produce } from "solid-js/store"
-import { Codec } from "@/runtime/persistence/codec"
+import { Schema } from "effect"
 import { Persist, persisted } from "@/runtime/persistence/storage"
+import { Persistence } from "@/runtime/persistence/schema"
 import { createScopedCache } from "@/runtime/server/scoped-cache"
 import { SelectedLineRange } from "./types"
 import type { ServerScope } from "@/runtime/server/scope"
@@ -10,14 +11,14 @@ const WORKSPACE_KEY = "__workspace__"
 const MAX_FILE_VIEW_SESSIONS = 20
 const MAX_VIEW_FILES = 500

-const FileViewSchema = Codec.struct({
-  scrollTop: Codec.lenientOptional(Codec.number),
-  scrollLeft: Codec.lenientOptional(Codec.number),
-  selectedLines: Codec.lenientOptional(Codec.nullOr(SelectedLineRange)),
+const FileViewSchema = Persistence.struct({
+  scrollTop: Persistence.optional(Schema.Finite),
+  scrollLeft: Persistence.optional(Schema.Finite),
+  selectedLines: Persistence.optional(Schema.NullOr(SelectedLineRange)),
 })

-export const FileViewsSchema = Codec.struct({
-  file: Codec.lenientRecord(Codec.fallback(FileViewSchema, () => ({}))),
+export const FileViewsSchema = Schema.Struct({
+  file: Persistence.record(Persistence.fallback(FileViewSchema, () => ({}))),
 })

 function normalizeSelectedLines(range: SelectedLineRange): SelectedLineRange {
@@ -149,4 +150,3 @@ export function createFileViewCache(scope: ServerScope) {
    clear: () => cache.clear(),
  }
 }
-
@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs"
+import { createRequire } from "node:module"
 import solidPlugin from "vite-plugin-solid"
 import tailwindcss from "@tailwindcss/vite"
 import { fileURLToPath } from "url"
@@ -17,6 +18,24 @@ if (tailwindGenerate && typeof tailwindHotUpdate === "function") {
  }
 }

+// The markdown worker imports these directly, so they are served unbundled to keep worker startup
+// stable. Vite applies `exclude` to every import inside a pre-bundle too, which would leave a bare
+// `import "marked"` in mermaid's chunk that the browser cannot resolve from this package.
+const workerDeps = ["@shikijs/stream", "marked", "marked-shiki", "remend"]
+
+/** @type {import("rolldown").Plugin} */
+const bundleNestedWorkerDeps = {
+  name: "opencode-desktop:bundle-nested-worker-deps",
+  resolveId(id, importer) {
+    if (!importer || !workerDeps.includes(id) || !importer.includes("node_modules")) return
+    try {
+      return createRequire(importer).resolve(id)
+    } catch {
+      return
+    }
+  },
+}
+
 export const channel = (() => {
  const raw = process.env.OPENCODE_CHANNEL
  if (raw === "local" || raw === "dev" || raw === "beta" || raw === "prod") return raw
@@ -44,8 +63,9 @@ export default [
          format: "es",
        },
        optimizeDeps: {
-          exclude: ["@shikijs/stream", "marked", "marked-shiki", "remend"],
+          exclude: workerDeps,
          include: ["@opencode/session-ui > mermaid", "@opencode/session-ui > mermaid > katex"],
+          rolldownOptions: { plugins: [bundleNestedWorkerDeps] },
        },
      }
    },
@@ -1,7 +1,7 @@
 {
  "$schema": "https://json.schemastore.org/package.json",
  "name": "@opencode/cli",
-  "version": "2.0.10",
+  "version": "2.0.12",
  "type": "module",
  "license": "MIT",
  "bin": {
@@ -55,7 +55,7 @@ try {
  if ((await pluginIDs(info.url, headers)).includes("smoke")) throw new Error("Smoke plugin existed before creation")
  const plugin = path.join(root, ".opencode", "plugins", "smoke.ts")
  await fs.writeFile(plugin, pluginSource())
-  await waitForPlugin(info.url, headers)
+  await waitForPlugin(info.url, headers, plugin)

  const unauthorizedInfo = await fetch(new URL("/api/info", info.url), {
    signal: AbortSignal.timeout(5_000),
@@ -139,7 +139,13 @@ async function waitForReady(url: string, headers: HeadersInit) {
 }

 function exitsWithin(process: Bun.Subprocess, milliseconds: number) {
-  return Promise.race([process.exited.then(() => true), Bun.sleep(milliseconds).then(() => false)])
+  return new Promise<boolean>((resolve) => {
+    const timeout = setTimeout(() => resolve(false), milliseconds)
+    process.exited.then(() => {
+      clearTimeout(timeout)
+      resolve(true)
+    })
+  })
 }

 function pluginSource() {
@@ -159,11 +165,15 @@ async function pluginIDs(url: string, headers: HeadersInit) {
  )
 }

-async function waitForPlugin(url: string, headers: HeadersInit) {
+async function waitForPlugin(url: string, headers: HeadersInit, plugin: string) {
  const deadline = Date.now() + 10_000
+  let attempt = 0
  while (Date.now() < deadline) {
    if ((await pluginIDs(url, headers)).includes("smoke")) return
    await Bun.sleep(25)
+    // Native watchers may coalesce a single creation edge. Keep changing valid source so
+    // the smoke proves that a later native event is delivered.
+    if (++attempt % 10 === 0) await fs.writeFile(plugin, `${pluginSource()}// watcher retry ${attempt}\n`)
  }
  throw new Error("Compiled service did not discover the created plugin")
 }
@@ -1,8 +1,9 @@
 import { OpenCode } from "@opencode/client"
 import { Service } from "@opencode/client/effect/service"
 import { Session } from "@opencode/schema/session"
+import { SessionMessage } from "@opencode/schema/session-message"
 import { SessionTransfer } from "@opencode/schema/session-transfer"
-import { Effect, Option, Schema } from "effect"
+import { Effect, Option, Predicate, Schema } from "effect"
 import { EOL } from "node:os"
 import path from "node:path"
 import { Commands } from "../../commands"
@@ -23,7 +24,13 @@ export default Runtime.handler(
      catch: (cause) =>
        new Error(`Failed to read session data: ${cause instanceof Error ? cause.message : String(cause)}`),
    })
-    const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(SessionTransfer.Data))(text)
+    const raw = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown))(text)
+    // Exports written before provider blobs were renamed to `native` still carry the old keys.
+    const data = yield* Schema.decodeUnknownEffect(SessionTransfer.Data)(
+      Predicate.isObject(raw) && Array.isArray(raw.messages)
+        ? { ...raw, messages: raw.messages.map(SessionMessage.persisted) }
+        : raw,
+    )
    const encoded = Schema.encodeSync(SessionTransfer.Data)(data)
    const server = yield* ServerConnection.resolve({
      server: Option.getOrUndefined(input.server),
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aiden Cline	8997d8662f	fix(schema): keep legacy blobs on replay, import, and V1 migration Freeze session.message.content.updated at the stored shape and translate on replay, run persisted() on CLI session import, write native from the V1 migration, regenerate the OpenAPI docs, and mirror text.ended state in the client fold.	2026-09-22 00:37:59 -05:00
Aiden Cline	e4dd41b033	test(core): use native for text and reasoning provider blobs	2026-09-21 23:39:41 -05:00
Aiden Cline	347bf1d749	Merge remote-tracking branch 'origin/v2' into message-native	2026-09-21 23:37:54 -05:00
Aiden Cline	07d48e1ffb	feat(ai): add experimental evaluation API (#50506 )	2026-09-21 23:30:38 -05:00
Aiden Cline	e7c4bffd38	refactor(schema): drop native migration and fix fixtures	2026-09-21 23:27:12 -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	85962e49b7	refactor(schema): rename message provider blobs to native	2026-09-20 21:41:03 -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