docs(plugin): update current API examples

2026-08-28 12:36:15 +00:00 · 2026-08-27 15:00:32 -04:00
292 changed files with 9297 additions and 12918 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Preserve provider metadata on assistant text when replaying conversation history through AI SDK providers.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/theme": patch
---
-
-Use the unread accent color by default for question and permission status indicators, while preserving explicit theme overrides.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Align the built-in review and system prompts with available documentation and code-search tools and the current Plan mode reminder.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Correct the compaction prompt to point existing summaries at the conversation history that follows them.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Correct the published Newtype documentation to recommend `Schema.decodeUnknownSync` for schema-based synchronous decoding.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": major
---
-
-Treat MCP as a word in current Core namespace exports: rename `MCP` to `Mcp`, `MCPClient` to `McpClient`, `MCPStdio` to `McpStdio`, `MCPOAuth` to `McpOAuth`, `ConfigMCPPlugin` to `ConfigMcpPlugin`, and `MCPCodeModeExclusionPlugin` to `McpCodeModeExclusionPlugin`. Direct consumers must update their imports. Module paths, Schema contracts, runtime service keys, error tags, and behavior are unchanged.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Forward plugin Session interrupt options so continuation requests reach the Session service.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Wake idle sessions when recovering background shell outcomes after a server restart. Admit shell outcomes before resuming background child sessions, while preserving restart retry budgets and completion-driven parent notifications.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Preserve explicit function tool strictness in Copilot Responses requests.
@@ -1,8 +0,0 @@
---
-"@opencode-ai/core": patch
-"@opencode-ai/app": patch
---
-
-Keep project labels stable when opening multiple clones of the same repository, while still refreshing the canonical path when its directory is renamed or removed.
-
-Worktree setup scripts receive the selected source directory as `OPENCODE_WORKTREE_BASE` rather than another clone's shared project path.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Keep Google Vertex catalog settings serializable during model projection.
@@ -41,5 +41,11 @@
    // Warn when spreading non-plain objects (Headers, class instances, etc.)
    "typescript/no-misused-spread": "warn"
  },
+  "options": {
+    "typeAware": true
+  },
+  "options": {
+    "typeAware": true
+  },
  "ignorePatterns": ["**/node_modules", "**/dist", "**/.build", "**/.sst", "**/*.d.ts", "**/sdk.gen.ts"]
 }
@@ -2,7 +2,7 @@
 exact = true
 # Only install newly resolved package versions published at least 3 days ago.
 minimumReleaseAge = 259200
-minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]
+minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron-builder", "electron-publish", "blume"]

 [test]
 root = "./do-not-run-tests-from-root"
@@ -63,8 +63,7 @@ new sst.cloudflare.StaticSite("WebApp", {
  domain: "app." + domain,
  path: "packages/app",
  build: {
-    // Preserve Sentry credentials and run source-map uploads on every deployment.
-    command: "bun run build",
+    command: "bun turbo build",
    output: "./dist",
  },
 })
@@ -4,7 +4,7 @@
  bun,
  nodejs,
  darwin,
-  callPackage,
+  electron_41,
  makeWrapper,
  writableTmpDirAsHomeHook,
  autoPatchelfHook,
@@ -13,7 +13,7 @@
  opencode,
 }:
 let
-  electron = callPackage ./electron.nix { };
+  electron = electron_41;
 in
 stdenv.mkDerivation (finalAttrs: {
  pname = "opencode-desktop";
@@ -48,7 +48,7 @@ stdenv.mkDerivation (finalAttrs: {
    desktopName = "OpenCode";
    exec = "opencode-desktop %U";
    icon = "ai.opencode.desktop";
-    # Electron derives X11 WM_CLASS from app.name.
+    # Electron 41 derives X11 WM_CLASS from app.name.
    startupWMClass = "OpenCode";
    categories = [ "Development" ];
  });
@@ -67,10 +67,12 @@ stdenv.mkDerivation (finalAttrs: {
    # https://github.com/electron/electron/issues/31121
    # mac builds use a .app bundle which doesnt have this issue
    + lib.optionalString stdenv.isLinux ''
-      substituteInPlace \
-        packages/desktop/src/main/windows/appearance.ts \
-        packages/desktop/src/main/service/desktop-cli.ts \
-        --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
+      BASE_PATH=packages/desktop
+      FILES=(src/main/windows.ts)
+      for file in "''${FILES[@]}"; do
+        substituteInPlace $BASE_PATH/$file \
+          --replace-fail "process.resourcesPath" "'$out/opt/opencode-desktop/resources'"
+      done
    '';

  preBuild = ''
@@ -1,13 +0,0 @@
-{ callPackage, path }:
-let
-  version = (builtins.fromJSON (builtins.readFile ../packages/desktop/package.json)).devDependencies.electron;
-in
-(callPackage (path + "/pkgs/development/tools/electron/binary/generic.nix") { }) version {
-  # Electron 42.10.1 SHASUMS256.txt; update with the desktop package version.
-  aarch64-linux = "20e68d6c4e47f3ebf59de7c6b1f8b8bec6a6ebda6a451132f9b465f3f13ce467";
-  x86_64-linux = "2452b27112d92387471fa2488aafac85d79ea3f2ee1216c0abd5150d6c12362b";
-  aarch64-darwin = "ac7194a3dfd81930ba35355c01620262c1254752859b42dcb8f4b9e4d174a871";
-  x86_64-darwin = "4489aba55477a0082266cb690db1c829503ba3338048599d8fd243953df37dab";
-  # fetchzip hashes the unpacked headers, not the release tarball.
-  headers = "sha256-4eUy3BZVvxTl7KUOsxio7769lL6ag/ecbeK+qLURWMI=";
-}
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-Fmwqp/fjTMX7gQW01Zgta51reLHp1S53GSQgBcJePrY=",
-    "aarch64-linux": "sha256-KLI6OIbvycMePKxt66nNKeILYJSEkufOIaSawZ/gotc=",
-    "aarch64-darwin": "sha256-go1wmrsHfYfJ3ukUIR/fveobyVba4E9G/rdsB/J2cQQ=",
-    "x86_64-darwin": "sha256-UnVYMijlG12k4RLFkTwf4Or0yXqFSwe1Ji6QCGufjzg="
+    "x86_64-linux": "sha256-agxF1Ab8P84tijHvw7jaG+9UZm/dJZhHw8CGNlQQqYc=",
+    "aarch64-linux": "sha256-Kg6CkhoEEsb+ZOGPN/rnNoirLdGSyQl6HU/Fy8t9Mqs=",
+    "aarch64-darwin": "sha256-SnxBpmcfPL2p3OYmSuG5Y/aFW8PeEOLhfQrxAs/53fs=",
+    "x86_64-darwin": "sha256-Dnxl1EcfiE7/rlHmPkko0BKc6hHVk6rQ/2h/PWuLfNo="
  }
 }
@@ -39,24 +39,24 @@
      "packages/stats/*"
    ],
    "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.112",
-      "@effect/platform-node": "4.0.0-rc.112",
-      "@effect/platform-node-shared": "4.0.0-rc.112",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.112",
+      "@effect/opentelemetry": "4.0.0-rc.111",
+      "@effect/platform-node": "4.0.0-rc.111",
+      "@effect/platform-node-shared": "4.0.0-rc.111",
+      "@effect/sql-sqlite-bun": "4.0.0-rc.111",
      "@npmcli/arborist": "9.4.0",
      "@types/bun": "1.3.13",
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.9",
-      "@opentui/keymap": "0.5.9",
-      "@opentui/solid": "0.5.9",
+      "@opentui/core": "0.5.8",
+      "@opentui/keymap": "0.5.8",
+      "@opentui/solid": "0.5.8",
      "@tanstack/solid-virtual": "3.13.37",
-      "@shikijs/stream": "4.4.3",
+      "@shikijs/stream": "4.2.0",
      "@standard-schema/spec": "1.1.0",
      "ulid": "3.0.1",
-      "@kobalte/core": "0.13.13",
+      "@kobalte/core": "0.13.11",
      "@corvu/drawer": "0.2.4",
      "@types/luxon": "3.7.1",
      "@types/node": "24.12.2",
@@ -67,16 +67,13 @@
      "@openauthjs/openauth": "0.0.0-20250322224806",
      "@pierre/diffs": "1.2.10",
      "opentui-spinner": "0.0.7",
-      "@solid-primitives/event-listener": "2.4.6",
-      "@solid-primitives/media": "2.3.6",
-      "@solid-primitives/resize-observer": "2.2.0",
-      "@solid-primitives/storage": "4.4.0",
+      "@solid-primitives/storage": "4.3.3",
      "@tailwindcss/vite": "4.1.11",
-      "diff": "8.0.4",
-      "dompurify": "3.4.14",
+      "diff": "8.0.2",
+      "dompurify": "3.3.1",
      "drizzle-kit": "1.0.0-rc.5-ab785fc",
      "drizzle-orm": "1.0.0-rc.5-169397b",
-      "effect": "4.0.0-rc.112",
+      "effect": "4.0.0-rc.111",
      "ai": "6.0.168",
      "cross-spawn": "7.0.6",
      "hono": "4.10.7",
@@ -84,9 +81,9 @@
      "fuzzysort": "3.1.0",
      "get-east-asian-width": "1.6.0",
      "luxon": "3.6.1",
-      "marked": "18.0.11",
+      "marked": "18.0.7",
      "marked-shiki": "1.2.1",
-      "remend": "1.3.1",
+      "remend": "1.3.0",
      "@playwright/test": "1.59.1",
      "semver": "7.7.4",
      "typescript": "5.8.2",
@@ -95,17 +92,17 @@
      "remeda": "2.26.0",
      "resolve.exports": "2.0.3",
      "sst": "4.13.1",
-      "shiki": "4.4.3",
+      "shiki": "4.2.0",
      "solid-list": "0.3.0",
      "string-width": "7.2.0",
      "tailwindcss": "4.1.11",
-      "vite": "7.3.6",
+      "vite": "7.1.4",
      "@solidjs/meta": "0.29.4",
-      "@solidjs/router": "1.0.0",
+      "@solidjs/router": "0.15.4",
      "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
-      "@sentry/solid": "10.71.0",
-      "@sentry/vite-plugin": "5.4.0",
-      "solid-js": "1.9.15",
+      "@sentry/solid": "10.36.0",
+      "@sentry/vite-plugin": "4.6.0",
+      "solid-js": "1.9.10",
      "solid-sonner": "0.3.1",
      "vite-plugin-solid": "2.11.10",
      "@lydell/node-pty": "1.2.0-beta.12"
@@ -161,8 +158,7 @@
    "@effect/platform-node-shared": "catalog:",
    "@types/bun": "catalog:",
    "@types/node": "catalog:",
-    "effect": "catalog:",
-    "solid-js": "catalog:"
+    "effect": "catalog:"
  },
  "patchedDependencies": {
    "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch",
@@ -170,7 +166,7 @@
    "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
    "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
    "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
-    "solid-js@1.9.15": "patches/solid-js@1.9.15.patch",
+    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
    "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
    "pacote@21.5.0": "patches/pacote@21.5.0.patch",
@@ -214,40 +214,22 @@ the requests sent by code under test:
 import { Effect } from "effect"
 import { TestLLM } from "@opencode-ai/ai/testing"

+const testLLM = TestLLM.layer({
+  fallback: TestLLM.text("Hello from the test model", "text-1"),
+})
+
+// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
 const programWithTestClient = Effect.gen(function* () {
-  const test = yield* TestLLM.Test
-  yield* test.push(TestLLM.text("Hello from the test model", "text-1"))
  const result = yield* program
-  console.log(yield* test.requests())
+  const test = yield* TestLLM.Service
+  console.log(test.requests)
  return result
-}).pipe(Effect.provide(TestLLM.testLayer()))
+}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
 ```

-`testLayer()` provides the same object under `LLMClient.Service` and `TestLLM.Test`. Production consumes the
-normal client; tests use the additional controls. Each layer build has fresh state.
-
- `test.push(...)` queues one-shot responses in execution order. Each argument is one response.
- `test.always(response)` installs a repeatable fallback. The layer's `fallback` option sets its initial value.
- `test.serve(request => response)` installs a request-dependent fallback. `always` and `serve` replace each
-  other without changing queued replies; queued replies take precedence.
- `test.requests()` returns an array snapshot. `transformRequest` changes only the recorded observation;
-  `serve` receives the original canonical request.
- `test.wait(count)` waits for request arrivals, not output or completion, and supports concurrent waiters.
- `test.gate()` returns a scoped gate with countable `started` notifications and a `release` Effect. Release
-  unblocks all requests captured by that gate; closing its scope also releases it. Effect-aware test runners
-  already provide Scope.
-
-Constructing `stream()` or `generate()` does not record a request, invoke a responder, or consume a script.
-Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
-future reply.
-
-Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
-supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
-it does not repair or truncate them.
-
-The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
-over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
-`testLayer`.
+`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
+`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
+available on the yielded `TestLLM.Service`.

 ## Caching

@@ -374,12 +374,6 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
            content.push({ reasoningContent: { redactedContent: redactedData } })
            continue
          }
-          if (signature === undefined || signature.trim().length === 0) {
-            // Interrupted streams and model switches can leave unsigned reasoning.
-            // Preserve readable history as text rather than replay invalid reasoningContent.
-            if (part.text.trim().length > 0) content.push(...textWithCache(breakpoints, part.text, part.cache))
-            continue
-          }
          content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } })
          continue
        }
@@ -388,7 +382,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
      }
-      if (content.length > 0) messages.push({ role: "assistant", content })
+      messages.push({ role: "assistant", content })
      continue
    }

@@ -1,6 +1,6 @@
 export * as TestLLM from "./testing.js"

-import { LLMClient } from "./route/client.js"
+import { LLMClient, type Interface as LLMClientShape } from "./route/client.js"
 import {
  LLMEvent,
  LLMResponse,
@@ -16,33 +16,13 @@ export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>

 export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>

-type ClientInterface = Context.Service.Shape<typeof LLMClient.Service>
-
-export type Responder = (request: LLMRequest) => Response
-
-export interface TestInterface extends ClientInterface {
-  /** Returns a snapshot of requests observed at execution time. */
-  readonly requests: () => Effect.Effect<readonly LLMRequest[]>
-  readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
-  /** Replaces the fallback without changing queued responses. */
-  readonly always: (response: Response) => Effect.Effect<void>
-  /** Answers requests after the one-shot queue is exhausted; receives the original request. */
-  readonly serve: (responder: Responder) => Effect.Effect<void>
-  /** Waits for request arrivals, not output or completion. */
-  readonly wait: (count: number) => Effect.Effect<void>
-  readonly gate: () => Effect.Effect<Gate, never, Scope.Scope>
-}
-
-export class Test extends Context.Service<Test, TestInterface>()("@opencode/ai/TestLLM/Test") {}
-
-/** @deprecated Use TestInterface through Test and testLayer. */
 export interface Interface {
  readonly requests: LLMRequest[]
  readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
  readonly always: (response: Response) => Effect.Effect<void>
  readonly wait: (count: number) => Effect.Effect<void>
  readonly gate: Effect.Effect<Gate, never, Scope.Scope>
-  readonly client: ClientInterface
+  readonly client: LLMClientShape
 }

 export interface LayerOptions {
@@ -51,7 +31,6 @@ export interface LayerOptions {
  readonly fallback?: Response
 }

-/** @deprecated Use Test and testLayer for normal client methods and test controls. */
 export class Service extends Context.Service<Service, Interface>()("@opencode/ai/TestLLM") {}

 export const complete = (
@@ -101,64 +80,59 @@ export const hangAfter = (...events: readonly LLMEvent[]) => Stream.concat(Strea

 const toStream = (response: Response) => (Stream.isStream(response) ? response : Stream.fromIterable(response))

-const make = (options: LayerOptions) =>
-  Effect.sync(() => {
-    const requests: LLMRequest[] = []
-    const responses: Response[] = []
-    let started = Deferred.makeUnsafe<void>()
-    let fallback: Response | Responder | undefined = options.fallback
-    let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
-    const wait = (count: number): Effect.Effect<void> =>
-      Effect.suspend(() =>
-        requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
-      )
+export const layer = (options: LayerOptions = {}) =>
+  Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const requests: LLMRequest[] = []
+      const responses: Response[] = []
+      let started = Deferred.makeUnsafe<void>()
+      let fallback = options.fallback
+      let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
+      const wait = (count: number): Effect.Effect<void> =>
+        Effect.suspend(() =>
+          requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
+        )

-    const stream: ClientInterface["stream"] = (request) =>
-      Stream.suspend(() => {
-        const count = requests.push(options.transformRequest?.(request) ?? request)
+      const stream = ((request: LLMRequest) => {
+        requests.push(options.transformRequest?.(request) ?? request)
        const waiting = started
        started = Deferred.makeUnsafe()
+        Deferred.doneUnsafe(waiting, Effect.void)
+        const response = responses.shift() ?? fallback
+        if (!response) return Stream.die(new Error(`TestLLM has no response for request ${requests.length}`))
+        const streamed = toStream(response)
        const gate = activeGate
-        try {
-          const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback)
-          if (!response) return Stream.die(new Error(`TestLLM has no response for request ${count}`))
-          const streamed = toStream(response)
-          if (!gate) return streamed
-          return Stream.unwrap(
-            Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
-          )
-        } finally {
-          // Waiters can resume synchronously; assign the reply and gate before notifying them.
-          Deferred.doneUnsafe(waiting, Effect.void)
-        }
+        if (!gate) return streamed
+        return Stream.unwrap(
+          Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
+        )
+      }) as LLMClientShape["stream"]
+      const client = LLMClient.Service.of({
+        stream,
+        generate: (request) =>
+          stream(request).pipe(
+            Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
+            Effect.flatMap((state) => {
+              const response = LLMResponse.complete(state)
+              if (response) return Effect.succeed(response)
+              return Effect.die("TestLLM response ended without a terminal finish event")
+            }),
+          ),
      })
-    const test = Test.of({
-      stream,
-      generate: (request) =>
-        stream(request).pipe(
-          Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
-          Effect.flatMap((state) => {
-            const response = LLMResponse.complete(state)
-            if (response) return Effect.succeed(response)
-            return Effect.die("TestLLM response ended without a terminal finish event")
+
+      return Service.of({
+        requests,
+        push: (...input) =>
+          Effect.sync(() => {
+            responses.push(...input)
          }),
-        ),
-      requests: () => Effect.sync(() => [...requests]),
-      push: (...input) =>
-        Effect.sync(() => {
-          responses.push(...input)
-        }),
-      always: (response) =>
-        Effect.sync(() => {
-          fallback = response
-        }),
-      serve: (responder) =>
-        Effect.sync(() => {
-          fallback = responder
-        }),
-      wait,
-      gate: () =>
-        Effect.gen(function* () {
+        always: (response) =>
+          Effect.sync(() => {
+            fallback = response
+          }),
+        wait,
+        gate: Effect.gen(function* () {
          const gate = {
            started: yield* Effect.acquireRelease(Queue.unbounded<void>(), Queue.shutdown),
            release: yield* Latch.make(),
@@ -173,36 +147,11 @@ const make = (options: LayerOptions) =>
            release,
          }
        }),
-    })
-
-    return { test, requests }
-  })
-
-/** Provides one shared implementation under the normal client and test-control tags. */
-export const testLayer = (options: LayerOptions = {}) =>
-  Layer.effectContext(
-    Effect.map(make(options), (implementation) =>
-      Context.make(LLMClient.Service, implementation.test).pipe(Context.add(Test, implementation.test)),
-    ),
+        client,
+      })
+    }),
  )

-/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
-export const layer = (options: LayerOptions = {}) =>
-  Layer.effect(
-    Service,
-    Effect.map(make(options), (implementation) =>
-      Service.of({
-        requests: implementation.requests,
-        push: implementation.test.push,
-        always: implementation.test.always,
-        wait: implementation.test.wait,
-        gate: implementation.test.gate(),
-        client: implementation.test,
-      }),
-    ),
-  )
-
-/** @deprecated testLayer provides LLMClient.Service directly. */
 export const clientLayer = Layer.effect(
  LLMClient.Service,
  Effect.map(Service, (service) => service.client),
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { LLM, LLMRequest, LLMResponse } from "../src/index.js"
 import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route.js"
@@ -148,13 +148,15 @@ describe("llm route", () => {
    }),
  )

-  test("builds models from configured routes", () => {
-    const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } })
+  it.effect("builds models from configured routes", () =>
+    Effect.gen(function* () {
+      const configured = fake.with({ provider: "fake-provider", endpoint: { baseURL: "https://fake.local" } })

-    expect(configured.model({ id: "fake-model" })).toMatchObject({
-      provider: "fake-provider",
-    })
-  })
+      expect(configured.model({ id: "fake-model" })).toMatchObject({
+        provider: "fake-provider",
+      })
+    }),
+  )

  it.effect("does not register duplicate route ids globally", () =>
    Effect.gen(function* () {
@@ -1,10 +1,10 @@
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Fiber, Ref, Stream } from "effect"
-import { Headers, HttpClientError, HttpClientRequest } from "effect/unstable/http"
+import { Deferred, Effect, Fiber, Layer, Ref, Stream } from "effect"
+import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { LLM, AIError, HttpContext, InvalidProviderOutputError, TransportError } from "../src/index.js"
 import { LLMClient, RequestExecutor, WebSocketTransport, type WebSocketChannelExecutor } from "../src/route.js"
-import { route } from "../src/protocols/openai-chat.js"
-import { configure } from "../src/providers/openai.js"
+import * as OpenAIChat from "../src/protocols/openai-chat.js"
+import * as OpenAI from "../src/providers/openai.js"
 import { dynamicResponse, fixedResponse, systemError } from "./lib/http.js"
 import { deltaChunk } from "./lib/openai-chunks.js"
 import { sseEvents, sseRaw } from "./lib/sse.js"
@@ -18,6 +18,47 @@ const secretRequest = HttpClientRequest.post("https://provider.test/v1/chat?api_
  HttpClientRequest.setHeaders(Headers.fromInput({ authorization: "Bearer header-secret-456" })),
 )

+const responsesLayer = (responses: ReadonlyArray<Response>) =>
+  RequestExecutor.layer.pipe(
+    Layer.provide(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const cursor = yield* Ref.make(0)
+          return Layer.succeed(
+            HttpClient.HttpClient,
+            HttpClient.make((request) =>
+              Effect.gen(function* () {
+                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
+                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
+              }),
+            ),
+          )
+        }),
+      ),
+    ),
+  )
+
+const countedResponsesLayer = (attempts: Ref.Ref<number>, responses: ReadonlyArray<Response>) =>
+  RequestExecutor.layer.pipe(
+    Layer.provide(
+      Layer.unwrap(
+        Effect.gen(function* () {
+          const cursor = yield* Ref.make(0)
+          return Layer.succeed(
+            HttpClient.HttpClient,
+            HttpClient.make((request) =>
+              Effect.gen(function* () {
+                yield* Ref.update(attempts, (value) => value + 1)
+                const index = yield* Ref.getAndUpdate(cursor, (value) => value + 1)
+                return HttpClientResponse.fromWeb(request, responses[index] ?? responses[responses.length - 1])
+              }),
+            ),
+          )
+        }),
+      ),
+    ),
+  )
+
 const expectAIError = (error: unknown) => {
  expect(error).toBeInstanceOf(AIError)
  if (!(error instanceof AIError)) throw new Error("expected AIError")
@@ -66,17 +107,19 @@ describe("RequestExecutor", () => {
        return yield* executor.execute(request).pipe(Effect.flip)
      }).pipe(
        Effect.provide(
-          fixedResponse(
-            new ReadableStream({
-              start(controller) {
-                controller.error(cause)
+          responsesLayer([
+            new Response(
+              new ReadableStream({
+                start(controller) {
+                  controller.error(cause)
+                },
+              }),
+              {
+                status: 503,
+                headers: { "x-request-id": "req_failed_body" },
              },
-            }),
-            {
-              status: 503,
-              headers: { "x-request-id": "req_failed_body" },
-            },
-          ),
+            ),
+          ]),
        ),
      )

@@ -105,14 +148,15 @@ describe("RequestExecutor", () => {
      })
    }).pipe(
      Effect.provide(
-        fixedResponse(
-          new ReadableStream({
-            start(controller) {
-              controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
-            },
-          }),
-          {},
-        ),
+        responsesLayer([
+          new Response(
+            new ReadableStream({
+              start(controller) {
+                controller.error(systemError("ECONNRESET", "disconnected query-secret-123 header-secret-456"))
+              },
+            }),
+          ),
+        ]),
      ),
    ),
  )
@@ -132,14 +176,15 @@ describe("RequestExecutor", () => {
      })
    }).pipe(
      Effect.provide(
-        fixedResponse(
-          new ReadableStream({
-            pull(controller) {
-              controller.error(new TypeError("fetch failed", { cause: systemError("ECONNRESET", "socket closed") }))
-            },
-          }),
-          {},
-        ),
+        responsesLayer([
+          new Response(
+            new ReadableStream({
+              pull(controller) {
+                controller.error(new TypeError("fetch failed", { cause: systemError("ECONNRESET", "socket closed") }))
+              },
+            }),
+          ),
+        ]),
      ),
    ),
  )
@@ -155,7 +200,7 @@ describe("RequestExecutor", () => {
      expect(error.message).toBe("plugin rejected request")
      expect(error.reason.cause).toBeInstanceOf(Error)
      expect(error.reason.http).toBeUndefined()
-    }).pipe(Effect.provide(dynamicResponse(() => Effect.die(new Error("unexpected HTTP request"))))),
+    }).pipe(Effect.provide(responsesLayer([]))),
  )

  it.effect("reports the request sent by middleware", () =>
@@ -204,9 +249,11 @@ describe("RequestExecutor", () => {
      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", classification: "context-overflow" })
    }).pipe(
      Effect.provide(
-        fixedResponse('{"error":{"code":"context_length_exceeded","message":"prompt too long"}}', {
-          status: 400,
-        }),
+        responsesLayer([
+          new Response('{"error":{"code":"context_length_exceeded","message":"prompt too long"}}', {
+            status: 400,
+          }),
+        ]),
      ),
    ),
  )
@@ -222,7 +269,7 @@ describe("RequestExecutor", () => {
        classification: "payload-too-large",
      })
      expect(error.reason.http?.status).toBe(413)
-    }).pipe(Effect.provide(fixedResponse("request too large", { status: 413 }))),
+    }).pipe(Effect.provide(responsesLayer([new Response("request too large", { status: 413 })]))),
  )

  it.effect("classifies Anthropic request_too_large as context overflow", () =>
@@ -238,9 +285,11 @@ describe("RequestExecutor", () => {
      expect(error.reason.http?.status).toBe(413)
    }).pipe(
      Effect.provide(
-        fixedResponse('{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}', {
-          status: 413,
-        }),
+        responsesLayer([
+          new Response('{"error":{"type":"request_too_large","message":"Request exceeds the maximum size"}}', {
+            status: 413,
+          }),
+        ]),
      ),
    ),
  )
@@ -254,7 +303,7 @@ describe("RequestExecutor", () => {
      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
      expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
      expect(error.message).toBe("Provider request failed with HTTP 400")
-    }).pipe(Effect.provide(fixedResponse("invalid parameter", { status: 400 }))),
+    }).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
  )

  it.effect("preserves structured provider messages from large error bodies", () =>
@@ -268,13 +317,15 @@ describe("RequestExecutor", () => {
      expect(error.reason.body).toContain(largeProviderMessage)
    }).pipe(
      Effect.provide(
-        fixedResponse(
-          JSON.stringify({
-            model: "test-model",
-            error: { type: "invalid_request", message: largeProviderMessage },
-          }),
-          { status: 400 },
-        ),
+        responsesLayer([
+          new Response(
+            JSON.stringify({
+              model: "gpt-5.6-sol",
+              error: { type: "invalid_request", message: largeProviderMessage },
+            }),
+            { status: 400 },
+          ),
+        ]),
      ),
    ),
  )
@@ -289,7 +340,7 @@ describe("RequestExecutor", () => {
        _tag: "InvalidRequest",
      })
      expect(error.message).toBe("Provider request failed with HTTP 400")
-    }).pipe(Effect.provide(fixedResponse('{"error":{"message":"  "}}', { status: 400 }))),
+    }).pipe(Effect.provide(responsesLayer([new Response('{"error":{"message":"  "}}', { status: 400 })]))),
  )

  it.effect("classifies provider rate limits hidden behind HTTP 400", () =>
@@ -301,7 +352,7 @@ describe("RequestExecutor", () => {

          expectAIError(error)
          expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-        }).pipe(Effect.provide(fixedResponse(body, { status: 400 })))
+        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))

      yield* classify("Request rate increased too quickly")
      yield* classify('{"type":"error","error":{"type":"too_many_requests"}}')
@@ -318,7 +369,7 @@ describe("RequestExecutor", () => {

          expectAIError(error)
          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-        }).pipe(Effect.provide(fixedResponse(body, { status: 400 })))
+        }).pipe(Effect.provide(responsesLayer([new Response(body, { status: 400 })])))

      yield* classify('{"code":"resource_exhausted"}')
      yield* classify('{"code":"service_unavailable"}')
@@ -348,10 +399,12 @@ describe("RequestExecutor", () => {
      expect(error.reason.body).toBe("rate limited")
    }).pipe(
      Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: { "retry-after-ms": "0", "x-request-id": "req_123", "x-api-key": "secret" },
-        }),
+        responsesLayer([
+          new Response("rate limited", {
+            status: 429,
+            headers: { "retry-after-ms": "0", "x-request-id": "req_123", "x-api-key": "secret" },
+          }),
+        ]),
      ),
    ),
  )
@@ -364,7 +417,7 @@ describe("RequestExecutor", () => {
      expectAIError(error)
      expect(error.reason.http?.headers["x-safe"]).toBe("response-secret")
    }).pipe(
-      Effect.provide(fixedResponse("bad", { status: 400, headers: { "x-safe": "response-secret" } })),
+      Effect.provide(responsesLayer([new Response("bad", { status: 400, headers: { "x-safe": "response-secret" } })])),
      Effect.provideService(Headers.CurrentRedactedNames, ["x-safe"]),
    ),
  )
@@ -384,18 +437,20 @@ describe("RequestExecutor", () => {
      })
    }).pipe(
      Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "x-ratelimit-limit-requests": "500",
-            "x-ratelimit-limit-tokens": "30000",
-            "x-ratelimit-remaining-requests": "499",
-            "x-ratelimit-remaining-tokens": "29900",
-            "x-ratelimit-reset-requests": "1s",
-            "x-ratelimit-reset-tokens": "10s",
-          },
-        }),
+        responsesLayer([
+          new Response("rate limited", {
+            status: 429,
+            headers: {
+              "retry-after-ms": "0",
+              "x-ratelimit-limit-requests": "500",
+              "x-ratelimit-limit-tokens": "30000",
+              "x-ratelimit-remaining-requests": "499",
+              "x-ratelimit-remaining-tokens": "29900",
+              "x-ratelimit-reset-requests": "1s",
+              "x-ratelimit-reset-tokens": "10s",
+            },
+          }),
+        ]),
      ),
    ),
  )
@@ -415,18 +470,20 @@ describe("RequestExecutor", () => {
      })
    }).pipe(
      Effect.provide(
-        fixedResponse("rate limited", {
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "anthropic-ratelimit-requests-limit": "100",
-            "anthropic-ratelimit-requests-remaining": "12",
-            "anthropic-ratelimit-requests-reset": "2026-05-06T12:00:00Z",
-            "anthropic-ratelimit-input-tokens-limit": "10000",
-            "anthropic-ratelimit-input-tokens-remaining": "9000",
-            "anthropic-ratelimit-input-tokens-reset": "2026-05-06T12:00:10Z",
-          },
-        }),
+        responsesLayer([
+          new Response("rate limited", {
+            status: 429,
+            headers: {
+              "retry-after-ms": "0",
+              "anthropic-ratelimit-requests-limit": "100",
+              "anthropic-ratelimit-requests-remaining": "12",
+              "anthropic-ratelimit-requests-reset": "2026-05-06T12:00:00Z",
+              "anthropic-ratelimit-input-tokens-limit": "10000",
+              "anthropic-ratelimit-input-tokens-remaining": "9000",
+              "anthropic-ratelimit-input-tokens-reset": "2026-05-06T12:00:10Z",
+            },
+          }),
+        ]),
      ),
    ),
  )
@@ -439,14 +496,10 @@ describe("RequestExecutor", () => {
        return yield* executor.execute(request).pipe(Effect.flip)
      }).pipe(
        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              const attempt = yield* Ref.getAndUpdate(attempts, (value) => value + 1)
-              return attempt === 0
-                ? input.respond("busy", { status: 503, headers: { "retry-after-ms": "0" } })
-                : input.respond("ok", { status: 200 })
-            }),
-          ),
+          countedResponsesLayer(attempts, [
+            new Response("busy", { status: 503, headers: { "retry-after-ms": "0" } }),
+            new Response("ok", { status: 200 }),
+          ]),
        ),
      )

@@ -469,10 +522,12 @@ describe("RequestExecutor", () => {
          expect(error.reason.http?.status).toBe(status)
        }).pipe(
          Effect.provide(
-            fixedResponse("provider failure", {
-              status,
-              headers: { "retry-after-ms": "0" },
-            }),
+            responsesLayer([
+              new Response("provider failure", {
+                status,
+                headers: { "retry-after-ms": "0" },
+              }),
+            ]),
          ),
        )

@@ -483,28 +538,20 @@ describe("RequestExecutor", () => {

  it.effect("preserves large authentication error bodies", () =>
    Effect.gen(function* () {
-      const attempts = yield* Ref.make(0)
-      const error = yield* Effect.gen(function* () {
-        const executor = yield* RequestExecutor.Service
-        return yield* executor.execute(request).pipe(Effect.flip)
-      }).pipe(
-        Effect.provide(
-          dynamicResponse((input) =>
-            Effect.gen(function* () {
-              const attempt = yield* Ref.getAndUpdate(attempts, (value) => value + 1)
-              return attempt === 0
-                ? input.respond("x".repeat(20_000), { status: 401 })
-                : input.respond("should not retry", { status: 200 })
-            }),
-          ),
-        ),
-      )
+      const executor = yield* RequestExecutor.Service
+      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
      expect(error.reason).toMatchObject({ _tag: "Authentication" })
      expect(error.reason.body).toHaveLength(20_000)
-      expect(yield* Ref.get(attempts)).toBe(1)
-    }),
+    }).pipe(
+      Effect.provide(
+        responsesLayer([
+          new Response("x".repeat(20_000), { status: 401 }),
+          new Response("should not retry", { status: 200 }),
+        ]),
+      ),
+    ),
  )

  it.effect("preserves response body fields", () =>
@@ -516,9 +563,11 @@ describe("RequestExecutor", () => {
      expect(error.reason.body).toBe('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}')
    }).pipe(
      Effect.provide(
-        fixedResponse('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}', {
-          status: 400,
-        }),
+        responsesLayer([
+          new Response('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}', {
+            status: 400,
+          }),
+        ]),
      ),
    ),
  )
@@ -532,7 +581,9 @@ describe("RequestExecutor", () => {
      expect(error.reason.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
    }).pipe(
      Effect.provide(
-        fixedResponse("provider echoed query-secret-123 and authorization header-secret-456", { status: 400 }),
+        responsesLayer([
+          new Response("provider echoed query-secret-123 and authorization header-secret-456", { status: 400 }),
+        ]),
      ),
    ),
  )
@@ -540,7 +591,9 @@ describe("RequestExecutor", () => {
  it.effect("does not re-execute after a successful response reaches stream parsing", () =>
    Effect.gen(function* () {
      const attempts = yield* Ref.make(0)
-      const model = route.with({ endpoint: { baseURL: "https://api.openai.test/v1" } }).model({ id: "gpt-4o-mini" })
+      const model = OpenAIChat.route
+        .with({ endpoint: { baseURL: "https://api.openai.test/v1" } })
+        .model({ id: "gpt-4o-mini" })
      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
        Effect.provide(
          dynamicResponse((input) =>
@@ -571,7 +624,7 @@ describe("RequestExecutor", () => {
 })

 describe("WebSocket channel execution", () => {
-  const model = configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
+  const model = OpenAI.configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
  const request = LLM.request({ model, prompt: "Say hello." })
  const frames = [
    JSON.stringify({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
@@ -32,8 +32,6 @@ describe("public exports", () => {
    expect(Provider.make).toBeFunction()
    expect(ProviderSubpath.make).toBe(Provider.make)
    expect(TestLLM.layer).toBeFunction()
-    expect(TestLLM.testLayer).toBeFunction()
-    expect(TestLLM.Test.of).toBeFunction()
  })

  test("route barrel exposes route-authoring APIs", () => {
@@ -44,23 +44,21 @@ describe("Tool.make (dynamic JSON Schema)", () => {
    expect(definition?.inputSchema).toEqual(jsonSchema)
  })

-  it.effect("execute receives the raw input untouched", () =>
-    Effect.gen(function* () {
-      const seen: unknown[] = []
-      const tool = Tool.make({
-        description: "echo",
-        jsonSchema: { type: "object" },
-        execute: (params) =>
-          Effect.sync(() => {
-            seen.push(params)
-            return { ok: true }
-          }),
-      })
-      const result = yield* tool.execute({ hello: "world" })
-      expect(seen).toEqual([{ hello: "world" }])
-      expect(result).toEqual({ ok: true })
-    }),
-  )
+  test("execute receives the raw input untouched", async () => {
+    const seen: unknown[] = []
+    const tool = Tool.make({
+      description: "echo",
+      jsonSchema: { type: "object" },
+      execute: (params) =>
+        Effect.sync(() => {
+          seen.push(params)
+          return { ok: true }
+        }),
+    })
+    const result = await Effect.runPromise(tool.execute({ hello: "world" }))
+    expect(seen).toEqual([{ hello: "world" }])
+    expect(result).toEqual({ ok: true })
+  })
 })

 describe("LLM.generateObject", () => {
@@ -531,104 +531,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  for (const signature of [undefined, "", "   "]) {
-    for (const cache of ["none", "auto"] as const) {
-      it.effect(`demotes unsigned reasoning to text (${JSON.stringify(signature)}, cache: ${cache})`, () =>
-        Effect.gen(function* () {
-          const prepared = yield* compileRequest(
-            LLM.request({
-              model,
-              messages: [
-                Message.user("Think"),
-                Message.assistant([
-                  {
-                    type: "reasoning",
-                    text: "Partial thought",
-                    providerMetadata: signature === undefined ? undefined : { bedrock: { signature } },
-                    cache: new CacheHint({ type: "ephemeral" }),
-                  },
-                ]),
-                Message.user("Continue"),
-              ],
-              cache,
-            }),
-          )
-          expect(prepared.body.messages[1]).toEqual({
-            role: "assistant",
-            content: [{ text: "Partial thought" }, { cachePoint: { type: "default" } }],
-          })
-        }),
-      )
-    }
-  }
-
-  it.effect("omits empty unsigned reasoning without leaving an empty or cache-only assistant", () =>
-    Effect.gen(function* () {
-      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Think"),
-            Message.assistant([
-              { type: "reasoning", text: "", cache },
-              { type: "reasoning", text: "  ", providerMetadata: { bedrock: { signature: "" } }, cache },
-            ]),
-            Message.user([{ type: "text", text: "Continue", cache }]),
-          ],
-          cache: "none",
-        }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "user",
-          content: [{ text: "Think" }, { text: "Continue" }, { cachePoint: { type: "default" } }],
-        },
-      ])
-    }),
-  )
-
-  it.effect("demotes foreign reasoning while preserving signed, redacted, text, and tool blocks", () =>
-    Effect.gen(function* () {
-      const cache = new CacheHint({ type: "ephemeral" })
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              { type: "reasoning", text: "Foreign thought", providerMetadata: { anthropic: { signature: "old" } } },
-              {
-                type: "reasoning",
-                text: "Signed thought",
-                providerMetadata: { bedrock: { signature: "sig_1" } },
-                cache,
-              },
-              { type: "reasoning", text: "", encrypted: "sig_2", cache },
-              { type: "reasoning", text: "", providerMetadata: { bedrock: { redactedData: "cmVkYWN0ZWQ=" } }, cache },
-              { type: "text", text: "Checking" },
-              ToolCallPart.make({ id: "call_1", name: "lookup", input: {} }),
-            ]),
-          ],
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-          cache: "none",
-        }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [
-            { text: "Foreign thought" },
-            { reasoningContent: { reasoningText: { text: "Signed thought", signature: "sig_1" } } },
-            { reasoningContent: { reasoningText: { text: "", signature: "sig_2" } } },
-            { reasoningContent: { redactedContent: "cmVkYWN0ZWQ=" } },
-            { text: "Checking" },
-            { toolUse: { toolUseId: "call_1", name: "lookup", input: {} } },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("preserves streamed reasoning signatures for continuation lowering", () =>
    Effect.gen(function* () {
      const body = eventStreamBody(
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMEvent } from "../../src/index.js"
@@ -136,15 +136,17 @@ describe("Cloudflare", () => {
    }),
  )

-  test("defaults AI Gateway id to default when omitted or blank", () => {
-    expect(
-      CloudflareAIGateway.configure({
-        accountId: "test-account",
-        gatewayId: "",
-        gatewayApiKey: "test-token",
-      }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL,
-    ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat")
-  })
+  it.effect("defaults AI Gateway id to default when omitted or blank", () =>
+    Effect.gen(function* () {
+      expect(
+        CloudflareAIGateway.configure({
+          accountId: "test-account",
+          gatewayId: "",
+          gatewayApiKey: "test-token",
+        }).model("workers-ai/@cf/meta/llama-3.3-70b-instruct").route.endpoint.baseURL,
+      ).toBe("https://gateway.ai.cloudflare.com/v1/test-account/default/compat")
+    }),
+  )

  it.effect("supports authenticated AI Gateway plus upstream provider auth", () =>
    Effect.gen(function* () {
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolCallPart } from "../../src/index.js"
@@ -376,9 +376,11 @@ describe("Google Vertex providers", () => {
    }),
  )

-  test("rejects tuned Gemini models in express mode", () => {
-    expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-      "Google Vertex tuned models do not support Express Mode API keys",
-    )
-  })
+  it.effect("rejects tuned Gemini models in express mode", () =>
+    Effect.sync(() => {
+      expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
+        "Google Vertex tuned models do not support Express Mode API keys",
+      )
+    }),
+  )
 })
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolDefinition } from "../../src/index.js"
@@ -31,71 +31,82 @@ import { dynamicResponse } from "../lib/http.js"
 import { sseEvents } from "../lib/sse.js"

 describe("native OpenAI-compatible providers", () => {
-  test("assigns provider-owned metadata namespaces across native routes", () => {
-    const vertex = { project: "project", accessToken: "token" }
-    const providers = [
-      [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"],
-      [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"],
-      [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"],
-      [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"],
-      [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"],
-      [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"],
-      [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"],
-      [Google.configure({ apiKey: "test" }).model("model"), "google"],
-      [GoogleVertex.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexChat.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexResponses.configure(vertex).model("model"), "vertex"],
-      [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"],
-      [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"],
-      [
-        AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"),
-        "minimax",
-      ],
-      [OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), "custom"],
-      [
-        OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"),
-        "custom",
-      ],
-      [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
-      [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
-      [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
-      [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
-      [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"],
-      [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"],
-      [XAI.configure({ apiKey: "test" }).chat("model"), "xai"],
-      [XAI.configure({ apiKey: "test" }).responses("model"), "xai"],
-    ] as const
+  it.effect("assigns provider-owned metadata namespaces across native routes", () =>
+    Effect.gen(function* () {
+      const vertex = { project: "project", accessToken: "token" }
+      const providers = [
+        [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"],
+        [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"],
+        [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"],
+        [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"],
+        [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"],
+        [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"],
+        [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"],
+        [Google.configure({ apiKey: "test" }).model("model"), "google"],
+        [GoogleVertex.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexChat.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexResponses.configure(vertex).model("model"), "vertex"],
+        [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"],
+        [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"],
+        [
+          AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"),
+          "minimax",
+        ],
+        [
+          OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"),
+          "custom",
+        ],
+        [
+          OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model(
+            "model",
+          ),
+          "custom",
+        ],
+        [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
+        [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
+        [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
+        [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
+        [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"],
+        [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"],
+        [XAI.configure({ apiKey: "test" }).chat("model"), "xai"],
+        [XAI.configure({ apiKey: "test" }).responses("model"), "xai"],
+      ] as const

-    for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key)
-  })
+      for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key)
+    }),
+  )

-  test("preserves native Together AI and Cerebras provider and route identities", () => {
-    const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B")
-    const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")
+  it.effect("preserves native Together AI and Cerebras provider and route identities", () =>
+    Effect.gen(function* () {
+      const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B")
+      const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")

-    expect(together).toMatchObject({
-      provider: "togetherai",
-      compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false },
-      route: { id: "togetherai-chat", protocol: "openai-chat" },
-    })
-    expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1")
-    expect(cerebras).toMatchObject({
-      provider: "cerebras",
-      compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false },
-      route: { id: "cerebras-chat", protocol: "openai-chat" },
-    })
-    expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1")
-  })
+      expect(together).toMatchObject({
+        provider: "togetherai",
+        compatibility: { maxTokensField: "max_tokens", supportsStore: false, supportsStrictMode: false },
+        route: { id: "togetherai-chat", protocol: "openai-chat" },
+      })
+      expect(together.route.endpoint.baseURL).toBe("https://api.together.xyz/v1")
+      expect(cerebras).toMatchObject({
+        provider: "cerebras",
+        compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning", supportsStore: false },
+        route: { id: "cerebras-chat", protocol: "openai-chat" },
+      })
+      expect(cerebras.route.endpoint.baseURL).toBe("https://api.cerebras.ai/v1")
+    }),
+  )

-  test("preserves native DeepInfra provider and route identity", () => {
-    const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it")
-    expect(deepinfra).toMatchObject({
-      provider: "deepinfra",
-      compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false },
-      route: { id: "deepinfra-chat", protocol: "openai-chat" },
-    })
-    expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai")
-  })
+  it.effect("preserves native DeepInfra provider and route identity", () =>
+    Effect.gen(function* () {
+      const deepinfra = DeepInfra.configure({ apiKey: "fixture" }).model("google/gemma-3-27b-it")
+      expect(deepinfra).toMatchObject({
+        provider: "deepinfra",
+        compatibility: { maxTokensField: "max_tokens", reasoningField: "reasoning_content", supportsStore: false },
+        route: { id: "deepinfra-chat", protocol: "openai-chat" },
+      })
+      expect(deepinfra.route.endpoint.baseURL).toBe("https://api.deepinfra.com/v1/openai")
+    }),
+  )

  it.effect("applies native provider request defaults even with a custom gateway URL", () =>
    Effect.gen(function* () {
@@ -150,35 +161,39 @@ describe("native OpenAI-compatible providers", () => {
    }),
  )

-  test("normalizes DeepInfra API roots without duplicating the OpenAI path", () => {
-    for (const baseURL of [
-      "https://gateway.example/v1",
-      "https://gateway.example/v1/",
-      "https://gateway.example/v1/openai",
-      "https://gateway.example/v1/openai/",
-    ]) {
-      expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe(
+  it.effect("normalizes DeepInfra API roots without duplicating the OpenAI path", () =>
+    Effect.gen(function* () {
+      for (const baseURL of [
+        "https://gateway.example/v1",
+        "https://gateway.example/v1/",
        "https://gateway.example/v1/openai",
-      )
-    }
-  })
+        "https://gateway.example/v1/openai/",
+      ]) {
+        expect(DeepInfra.configure({ apiKey: "fixture", baseURL }).model("gemma").route.endpoint.baseURL).toBe(
+          "https://gateway.example/v1/openai",
+        )
+      }
+    }),
+  )

-  test("maps package settings onto native executable models", () => {
-    for (const native of [TogetherAI, Cerebras]) {
-      const selected = native.model("provider-model", {
-        apiKey: "fixture",
-        baseURL: "https://gateway.example/v1",
-        headers: { "x-application": "opencode" },
-        body: { service_tier: "priority" },
-        providerOptions: { reasoningEffort: "high" },
-      })
+  it.effect("maps package settings onto native executable models", () =>
+    Effect.gen(function* () {
+      for (const native of [TogetherAI, Cerebras]) {
+        const selected = native.model("provider-model", {
+          apiKey: "fixture",
+          baseURL: "https://gateway.example/v1",
+          headers: { "x-application": "opencode" },
+          body: { service_tier: "priority" },
+          providerOptions: { reasoningEffort: "high" },
+        })

-      expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1")
-      expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
-      expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
-      expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
-    }
-  })
+        expect(selected.route.endpoint.baseURL).toBe("https://gateway.example/v1")
+        expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
+        expect(selected.route.defaults.http?.body).toEqual({ service_tier: "priority" })
+        expect(selected.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
+      }
+    }),
+  )

  it.effect("resolves provider environment credentials and preserves deprecated Together credentials", () =>
    Effect.gen(function* () {
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect, Schema } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, LLMRequest, Message, ToolCallPart, ToolChoice, ToolDefinition } from "../../src/index.js"
@@ -91,38 +91,40 @@ describe("OpenAI-compatible Chat route", () => {
    }),
  )

-  test("provides model helpers for compatible provider families", () => {
-    expect(
-      providerFamilies.map(([provider, family]) => {
-        const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`)
-        return {
-          id: String(model.id),
-          provider: String(model.provider),
-          route: model.route.id,
-          baseURL: model.route.endpoint.baseURL,
-        }
-      }),
-    ).toEqual(
-      providerFamilies.map(([provider, _, baseURL]) => ({
-        id: `${provider}-model`,
-        provider,
-        route: "openai-compatible-chat",
-        baseURL,
-      })),
-    )
+  it.effect("provides model helpers for compatible provider families", () =>
+    Effect.gen(function* () {
+      expect(
+        providerFamilies.map(([provider, family]) => {
+          const model = family.configure({ apiKey: "test-key" }).model(`${provider}-model`)
+          return {
+            id: String(model.id),
+            provider: String(model.provider),
+            route: model.route.id,
+            baseURL: model.route.endpoint.baseURL,
+          }
+        }),
+      ).toEqual(
+        providerFamilies.map(([provider, _, baseURL]) => ({
+          id: `${provider}-model`,
+          provider,
+          route: "openai-compatible-chat",
+          baseURL,
+        })),
+      )

-    const custom = OpenAICompatible.deepseek
-      .configure({
-        apiKey: "test-key",
-        baseURL: "https://custom.deepseek.test/v1",
+      const custom = OpenAICompatible.deepseek
+        .configure({
+          apiKey: "test-key",
+          baseURL: "https://custom.deepseek.test/v1",
+        })
+        .model("deepseek-chat")
+      expect(custom).toMatchObject({
+        provider: "deepseek",
+        route: { id: "openai-compatible-chat" },
      })
-      .model("deepseek-chat")
-    expect(custom).toMatchObject({
-      provider: "deepseek",
-      route: { id: "openai-compatible-chat" },
-    })
-    expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1")
-  })
+      expect(custom.route.endpoint.baseURL).toBe("https://custom.deepseek.test/v1")
+    }),
+  )

  it.effect("matches AI SDK compatible basic request body fixture", () =>
    Effect.gen(function* () {
@@ -26,7 +26,6 @@ import {
  Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
-import { it } from "./lib/effect.js"

 const model = new LanguageModel({
  id: ModelID.make("fake-model"),
@@ -102,48 +101,49 @@ describe("AI.Usage", () => {
    expect(ProviderShared.sumTokens()).toBeUndefined()
  })

-  it.effect("sseFraming maps decoder failures to AI errors", () =>
-    Effect.gen(function* () {
-      const error = yield* ProviderShared.sseFraming(
-        Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`)),
-      ).pipe(Stream.runCollect, Effect.flip)
+  test("sseFraming maps decoder failures to AI errors", async () => {
+    const error = await Effect.runPromise(
+      ProviderShared.sseFraming(Stream.make(new TextEncoder().encode(`data: ${"x".repeat(10 * 1024 * 1024)}`))).pipe(
+        Stream.runCollect,
+        Effect.flip,
+      ),
+    )

-      expect(error).toBeInstanceOf(AIError)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-    }),
-  )
+    expect(error).toBeInstanceOf(AIError)
+    expect(error.reason._tag).toBe("InvalidProviderOutput")
+  })

-  it.effect("sseFraming ignores retry directives without ending the stream", () =>
-    Effect.gen(function* () {
-      const encoder = new TextEncoder()
-      const frames = yield* ProviderShared.sseFraming(
+  test("sseFraming ignores retry directives without ending the stream", async () => {
+    const encoder = new TextEncoder()
+    const frames = await Effect.runPromise(
+      ProviderShared.sseFraming(
        Stream.make(
          encoder.encode("retry: 1000\n\n"),
          encoder.encode('data: {"first":true}\n\n'),
          encoder.encode("retry: 2000\n\n"),
          encoder.encode('data: {"second":true}\n\n'),
        ).pipe(Stream.rechunk(1)),
-      ).pipe(Stream.runCollect)
+      ).pipe(Stream.runCollect),
+    )

-      expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}'])
-    }),
-  )
+    expect(Array.from(frames)).toEqual(['{"first":true}', '{"second":true}'])
+  })

-  it.effect("sseFraming preserves event data around retry directives", () =>
-    Effect.gen(function* () {
-      const encoder = new TextEncoder()
-      const frames = yield* ProviderShared.sseFraming(
+  test("sseFraming preserves event data around retry directives", async () => {
+    const encoder = new TextEncoder()
+    const frames = await Effect.runPromise(
+      ProviderShared.sseFraming(
        Stream.make(
          encoder.encode("event: update\ndata: first\n"),
          encoder.encode("retry: 1000\n"),
          encoder.encode("data: second\n\n"),
        ).pipe(Stream.rechunk(1)),
        new Set(["update"]),
-      ).pipe(Stream.runCollect)
+      ).pipe(Stream.runCollect),
+    )

-      expect(Array.from(frames)).toEqual(["first\nsecond"])
-    }),
-  )
+    expect(Array.from(frames)).toEqual(["first\nsecond"])
+  })

  test("visibleOutputTokens clamps reasoning > output to zero", () => {
    expect(new Usage({ outputTokens: 10, reasoningTokens: 4 }).visibleOutputTokens).toBe(6)
@@ -153,18 +153,18 @@ describe("AI.Usage", () => {
  })
 })

-it.effect("AI errors expose the shared runtime tag", () =>
-  Effect.gen(function* () {
-    const error = new AIError({
-      reason: new InvalidRequestError({ message: "invalid" }),
-    })
-    expect(error._tag).toBe("AI.Error")
-    expect(error.message).toBe("invalid")
-    expect(error.cause).toBe(error.reason)
-    expect(error.reason.cause).toBeUndefined()
-    expect(yield* Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))).toBe("caught")
-  }),
-)
+test("AI errors expose the shared runtime tag", async () => {
+  const error = new AIError({
+    reason: new InvalidRequestError({ message: "invalid" }),
+  })
+  expect(error._tag).toBe("AI.Error")
+  expect(error.message).toBe("invalid")
+  expect(error.cause).toBe(error.reason)
+  expect(error.reason.cause).toBeUndefined()
+  expect(
+    await Effect.runPromise(Effect.fail(error).pipe(Effect.catchTag("AI.Error", () => Effect.succeed("caught")))),
+  ).toBe("caught")
+})

 test("transport errors serialize execution facts", () => {
  const reason = new TransportError({
@@ -1,331 +0,0 @@
-import { describe, expect } from "bun:test"
-import { AIError, LanguageModel, LLM, LLMClient, LLMEvent, LLMRequest, RateLimitError } from "../src/index.js"
-import { OpenAIChat } from "../src/protocols/openai-chat.js"
-import { TestLLM } from "../src/testing.js"
-import { Effect, Fiber, Latch, Stream } from "effect"
-import { testEffect } from "./lib/effect.js"
-
-const request = LLM.request({
-  model: LanguageModel.make({ id: "fictional-model", provider: "fixture", route: OpenAIChat.route }),
-  prompt: "Say hello",
-})
-const legacy = testEffect(TestLLM.layer())
-const it = testEffect(TestLLM.testLayer())
-
-describe("TestLLM legacy client", () => {
-  legacy.effect("does not observe requests or consume responses until execution", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Service
-      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
-
-      llm.client.stream(request)
-      llm.client.generate(request)
-      expect(llm.requests).toEqual([])
-
-      expect((yield* llm.client.generate(request)).text).toBe("first")
-      expect((yield* llm.client.generate(request)).text).toBe("second")
-      expect(llm.requests).toEqual([request, request])
-    }),
-  )
-
-  legacy.effect("assigns and records a fresh response for each execution", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Service
-      yield* llm.push(
-        TestLLM.text("first", "first"),
-        TestLLM.text("second", "second"),
-        TestLLM.text("third", "third"),
-        TestLLM.text("fourth", "fourth"),
-      )
-      const stream = llm.client.stream(request)
-      const generate = llm.client.generate(request)
-
-      expect(yield* Stream.runCollect(stream)).toEqual(TestLLM.text("first", "first"))
-      expect(yield* Stream.runCollect(stream)).toEqual(TestLLM.text("second", "second"))
-      expect((yield* generate).text).toBe("third")
-      expect((yield* generate).text).toBe("fourth")
-      expect(llm.requests).toEqual([request, request, request, request])
-    }),
-  )
-
-  legacy.effect("keeps module-level controls and clientLayer on the same backing state", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Service
-      const requests = llm.requests
-      yield* TestLLM.push(TestLLM.text("queued", "queued"))
-      yield* TestLLM.always(TestLLM.text("fallback", "fallback"))
-      expect((yield* LLMClient.generate(request).pipe(Effect.provide(TestLLM.clientLayer))).text).toBe("queued")
-      yield* TestLLM.wait(1)
-      expect(requests).toEqual([request])
-      requests.length = 0
-      expect((yield* llm.client.generate(request)).text).toBe("fallback")
-      expect(llm.requests).toBe(requests)
-      expect(requests).toEqual([request])
-    }),
-  )
-})
-
-describe("TestLLM first-class client", () => {
-  it.effect("provides the same object under normal and test tags with snapshot observations", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const client = yield* LLMClient.Service
-      expect(client).toBe(llm)
-      const before = yield* llm.requests()
-      yield* llm.push(TestLLM.text("hello", "answer"))
-      const generate = client.generate(request)
-      client.stream(request)
-      expect(yield* llm.requests()).toEqual([])
-
-      expect((yield* generate).text).toBe("hello")
-      expect(before).toEqual([])
-      expect(yield* llm.requests()).toEqual([request])
-      expect(yield* llm.requests()).not.toBe(yield* llm.requests())
-    }),
-  )
-
-  it.effect("prioritizes queued replies over request-dependent and constant fallbacks", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const served: LLMRequest[] = []
-      yield* llm.always(TestLLM.text("old fallback", "old"))
-      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
-      yield* llm.serve((request) => {
-        served.push(request)
-        return TestLLM.text(request.promptCacheKey ?? "default", "served")
-      })
-
-      expect((yield* LLMClient.generate(request)).text).toBe("first")
-      expect((yield* LLMClient.generate(request)).text).toBe("second")
-      expect(served).toEqual([])
-      const selected = LLMRequest.update(request, { promptCacheKey: "selected" })
-      expect((yield* LLMClient.generate(selected)).text).toBe("selected")
-      expect((yield* LLMClient.generate(request)).text).toBe("default")
-      expect(served).toEqual([selected, request])
-
-      yield* llm.push(TestLLM.text("queued again", "queued"))
-      yield* llm.always(TestLLM.text("constant", "constant"))
-      expect((yield* LLMClient.generate(request)).text).toBe("queued again")
-      expect((yield* LLMClient.generate(request)).text).toBe("constant")
-      expect((yield* LLMClient.generate(request)).text).toBe("constant")
-      expect(served).toEqual([selected, request])
-    }),
-  )
-
-  testEffect(
-    TestLLM.testLayer({
-      transformRequest: (request) => LLMRequest.update(request, { promptCacheKey: "observation" }),
-    }),
-  ).effect("transforms observations without changing the request passed to the responder", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.serve((input) => {
-        expect(input).toBe(request)
-        return TestLLM.text("original", "answer")
-      })
-      const generate = llm.generate(request)
-      expect(yield* llm.requests()).toEqual([])
-      expect((yield* generate).text).toBe("original")
-      expect(yield* llm.requests()).toEqual([LLMRequest.update(request, { promptCacheKey: "observation" })])
-    }),
-  )
-
-  it.effect("broadcasts request-arrival waits and satisfies waits registered afterward", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.always(TestLLM.stop())
-      const first = yield* llm.wait(2).pipe(Effect.forkChild({ startImmediately: true }))
-      const second = yield* llm.wait(2).pipe(Effect.forkChild({ startImmediately: true }))
-      yield* llm.generate(request)
-      expect(first.pollUnsafe()).toBeUndefined()
-      expect(second.pollUnsafe()).toBeUndefined()
-      yield* llm.generate(request)
-      yield* Fiber.join(first)
-      yield* Fiber.join(second)
-      yield* llm.wait(2)
-      expect(yield* llm.requests()).toHaveLength(2)
-    }),
-  )
-  ;(["queued", "served"] as const).forEach((mode) => {
-    it.effect(`assigns ${mode} replies before resuming request-arrival continuations`, () =>
-      Effect.gen(function* () {
-        const llm = yield* TestLLM.Test
-        const responses = [TestLLM.text("first", "first"), TestLLM.text("second", "second")]
-        yield* mode === "queued" ? llm.push(...responses) : llm.serve(() => responses.shift() ?? [])
-        const later = yield* llm
-          .wait(1)
-          .pipe(Effect.andThen(llm.generate(request)), Effect.forkChild({ startImmediately: true }))
-
-        expect((yield* llm.generate(request)).text).toBe("first")
-        expect((yield* Fiber.join(later)).text).toBe("second")
-        expect(yield* llm.requests()).toEqual([request, request])
-      }),
-    )
-  })
-
-  it.effect("notifies arrival waiters even when the responder defects", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const defect = new Error("Broken fixture responder")
-      yield* llm.serve(() => {
-        throw defect
-      })
-      const waiter = yield* llm.wait(1).pipe(Effect.forkChild({ startImmediately: true }))
-      expect(yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
-      yield* Fiber.join(waiter)
-    }),
-  )
-
-  it.effect("builds independent state even when the same layer is provided concurrently", () => {
-    const layer = TestLLM.testLayer()
-    const run = Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      expect(yield* llm.requests()).toEqual([])
-      yield* llm.push(TestLLM.text("one", "answer"))
-      expect((yield* LLMClient.generate(request)).text).toBe("one")
-      return yield* llm.requests()
-    }).pipe(Effect.provide(layer))
-    return Effect.gen(function* () {
-      expect(yield* Effect.all([run, run], { concurrency: "unbounded" })).toEqual([[request], [request]])
-    })
-  })
-
-  it.effect("counts concurrent starts on one gate without serializing their response assignment", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
-      const generate = llm.generate(request)
-      const gate = yield* llm.gate()
-      const first = yield* generate.pipe(Effect.forkChild({ startImmediately: true }))
-      yield* gate.started
-      const second = yield* generate.pipe(Effect.forkChild({ startImmediately: true }))
-      yield* gate.started
-      yield* llm.wait(2)
-      expect(first.pollUnsafe()).toBeUndefined()
-      expect(second.pollUnsafe()).toBeUndefined()
-      yield* gate.release
-      expect((yield* Fiber.join(first)).text).toBe("first")
-      expect((yield* Fiber.join(second)).text).toBe("second")
-    }),
-  )
-
-  it.effect("does not clear a replacement gate when the previous gate is released", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.always(TestLLM.stop())
-      const previous = yield* llm.gate()
-      const first = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
-      yield* previous.started
-      const next = yield* llm.gate()
-      yield* previous.release
-      yield* Fiber.join(first)
-
-      const second = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
-      yield* next.started
-      expect(second.pollUnsafe()).toBeUndefined()
-      yield* next.release
-      yield* Fiber.join(second)
-    }),
-  )
-
-  it.effect("releases a gate when its deliberately narrower scope closes", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.always(TestLLM.stop())
-      // Only the gate is scoped here; its release must happen before the test ends.
-      const run = yield* Effect.scoped(
-        Effect.gen(function* () {
-          const gate = yield* llm.gate()
-          const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
-          yield* gate.started
-          return run
-        }),
-      )
-      yield* Fiber.join(run)
-      yield* llm.generate(request)
-      expect(yield* llm.requests()).toHaveLength(2)
-    }),
-  )
-
-  it.effect("keeps an executed response consumed after interruption and permits later requests", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      yield* llm.push(TestLLM.text("interrupted", "first"), TestLLM.text("next", "second"))
-      const gate = yield* llm.gate()
-      const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
-      yield* gate.started
-      yield* Fiber.interrupt(run)
-      yield* gate.release
-      expect((yield* llm.generate(request)).text).toBe("next")
-      expect(yield* llm.requests()).toHaveLength(2)
-    }),
-  )
-
-  it.effect("consumes a supplied stream's post-finish tail and runs its finalizer", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const tail = yield* Latch.make()
-      const release = yield* Latch.make()
-      const finalized = yield* Latch.make()
-      yield* llm.push(
-        Stream.unwrap(
-          Effect.gen(function* () {
-            yield* Effect.addFinalizer(() => finalized.open)
-            return Stream.fromIterable(TestLLM.text("complete", "answer")).pipe(
-              Stream.concat(Stream.fromEffect(tail.open.pipe(Effect.andThen(release.await))).pipe(Stream.drain)),
-            )
-          }),
-        ),
-      )
-      const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
-      yield* tail.await
-      expect(run.pollUnsafe()).toBeUndefined()
-      yield* release.open
-      expect((yield* Fiber.join(run)).text).toBe("complete")
-      yield* finalized.await
-    }),
-  )
-
-  it.effect("preserves irregular events, ordinary EOF, typed failures, and responder defects", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const events = [LLMEvent.textDelta({ id: "without-start", text: "partial" })]
-      yield* llm.push(events, [])
-      expect(yield* Stream.runCollect(llm.stream(request))).toEqual(events)
-      expect(yield* Stream.runCollect(llm.stream(request))).toEqual([])
-
-      const failure = new AIError({ reason: new RateLimitError({ message: "Try later" }) })
-      const observed: LLMEvent[] = []
-      yield* llm.serve(() => TestLLM.failAfter(failure, ...events))
-      expect(
-        yield* llm.stream(request).pipe(
-          Stream.runForEach((event) => Effect.sync(() => observed.push(event))),
-          Effect.flip,
-        ),
-      ).toBe(failure)
-      expect(observed).toEqual(events)
-      expect(yield* llm.generate(request).pipe(Effect.flip)).toBe(failure)
-
-      const defect = new Error("Broken fixture responder")
-      yield* llm.serve(() => {
-        throw defect
-      })
-      expect(yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
-      yield* llm.push(TestLLM.text("recovered", "answer"))
-      expect((yield* llm.generate(request)).text).toBe("recovered")
-    }),
-  )
-
-  it.effect("defects on unexpected requests instead of waiting for a late script", () =>
-    Effect.gen(function* () {
-      const llm = yield* TestLLM.Test
-      const defect = yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))
-      expect(defect).toBeInstanceOf(Error)
-      if (!(defect instanceof Error)) return
-      expect(defect.message).toBe("TestLLM has no response for request 1")
-      expect(yield* llm.requests()).toEqual([request])
-      yield* llm.push(TestLLM.stop())
-      yield* llm.generate(request)
-    }),
-  )
-})
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Content } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import {
@@ -277,61 +277,65 @@ describe("LLMClient tools", () => {
    }),
  )

-  test("models canonical tool files with URIs", () => {
-    const decode = Schema.decodeUnknownSync(Content)
+  it.effect("models canonical tool files with URIs", () =>
+    Effect.sync(() => {
+      const decode = Schema.decodeUnknownSync(Content)

-    expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "data:image/png;base64,AAAA",
-      mime: "image/png",
-    })
-    expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "https://example.test/image.png",
-      mime: "image/png",
-    })
-    expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({
-      type: "file",
-      uri: "file:///tmp/image.png",
-      mime: "image/png",
-    })
-  })
+      expect(decode({ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "data:image/png;base64,AAAA",
+        mime: "image/png",
+      })
+      expect(decode({ type: "file", uri: "https://example.test/image.png", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "https://example.test/image.png",
+        mime: "image/png",
+      })
+      expect(decode({ type: "file", uri: "file:///tmp/image.png", mime: "image/png" })).toEqual({
+        type: "file",
+        uri: "file:///tmp/image.png",
+        mime: "image/png",
+      })
+    }),
+  )

-  test("preserves canonical tool file URIs", () => {
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.toResultValue(
-        ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]),
-      ),
-    ).toEqual({
-      type: "content",
-      value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }],
-    })
-    expect(
-      ToolOutput.fromResultValue({
+  it.effect("preserves canonical tool file URIs", () =>
+    Effect.sync(() => {
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }]),
+        ),
+      ).toEqual({
+        type: "content",
+        value: [{ type: "file", uri: "data:image/png;base64,AAAA", mime: "image/png" }],
+      })
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }]),
+        ),
+      ).toEqual({
        type: "content",
        value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-      }),
-    ).toEqual({
-      structured: {},
-      content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
-    })
-  })
+      })
+      expect(
+        ToolOutput.toResultValue(
+          ToolOutput.make({}, [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }]),
+        ),
+      ).toEqual({
+        type: "content",
+        value: [{ type: "file", uri: "file:///tmp/image.png", mime: "image/png" }],
+      })
+      expect(
+        ToolOutput.fromResultValue({
+          type: "content",
+          value: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
+        }),
+      ).toEqual({
+        structured: {},
+        content: [{ type: "file", uri: "https://example.test/image.png", mime: "image/png" }],
+      })
+    }),
+  )

  it.effect("settles projected URL files as canonical tool results", () =>
    Effect.gen(function* () {
@@ -360,22 +364,24 @@ describe("LLMClient tools", () => {
    }),
  )

-  test("derives typed output schemas and preserves dynamic output schemas", () => {
-    const [typed] = toDefinitions({ get_weather })
-    const schema = { type: "object", properties: { result: { type: "string" } } } as const
-    const [dynamic] = toDefinitions({
-      dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }),
-    })
+  it.effect("derives typed output schemas and preserves dynamic output schemas", () =>
+    Effect.sync(() => {
+      const [typed] = toDefinitions({ get_weather })
+      const schema = { type: "object", properties: { result: { type: "string" } } } as const
+      const [dynamic] = toDefinitions({
+        dynamic: Tool.make({ description: "Dynamic tool.", jsonSchema: { type: "object" }, outputSchema: schema }),
+      })

-    expect(typed?.outputSchema).toMatchObject({
-      type: "object",
-      properties: { condition: { type: "string" } },
-      required: ["temperature", "condition"],
-      additionalProperties: false,
-    })
-    expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined()
-    expect(dynamic?.outputSchema).toEqual(schema)
-  })
+      expect(typed?.outputSchema).toMatchObject({
+        type: "object",
+        properties: { condition: { type: "string" } },
+        required: ["temperature", "condition"],
+        additionalProperties: false,
+      })
+      expect(Reflect.get(Reflect.get(typed?.outputSchema ?? {}, "properties") as object, "temperature")).toBeDefined()
+      expect(dynamic?.outputSchema).toEqual(schema)
+    }),
+  )

  it.effect("preserves content tool results from dynamic tools", () =>
    Effect.gen(function* () {
@@ -1,4 +1,4 @@
-import { describe, expect, test } from "bun:test"
+import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { AIError } from "../src/schema/index.js"
 import { ToolStream } from "../src/protocols/utils/tool-stream.js"
@@ -38,40 +38,44 @@ describe("ToolStream", () => {
    }),
  )

-  test("exposes cumulative partial string values", () => {
-    const result = ToolStream.appendOrStart(
-      ADAPTER,
-      ToolStream.empty<number>(),
-      0,
-      { id: "call_1", name: "lookup", text: '{"query":"wea' },
-      "missing tool",
-    )
-    if (ToolStream.isError(result)) throw result
+  it.effect("exposes cumulative partial string values", () =>
+    Effect.gen(function* () {
+      const result = ToolStream.appendOrStart(
+        ADAPTER,
+        ToolStream.empty<number>(),
+        0,
+        { id: "call_1", name: "lookup", text: '{"query":"wea' },
+        "missing tool",
+      )
+      if (ToolStream.isError(result)) return yield* result

-    expect(result.events.at(-1)).toEqual({
-      type: "tool-input-delta",
-      id: "call_1",
-      name: "lookup",
-      text: '{"query":"wea',
-      input: { query: "wea" },
-    })
-  })
+      expect(result.events.at(-1)).toEqual({
+        type: "tool-input-delta",
+        id: "call_1",
+        name: "lookup",
+        text: '{"query":"wea',
+        input: { query: "wea" },
+      })
+    }),
+  )

-  test("defaults partial input to an empty object when the accumulated value cannot be parsed", () => {
-    const result = ToolStream.appendOrStart(
-      ADAPTER,
-      ToolStream.empty<number>(),
-      0,
-      { id: "call_1", name: "lookup", text: "x" },
-      "missing tool",
-    )
-    if (ToolStream.isError(result)) throw result
+  it.effect("defaults partial input to an empty object when the accumulated value cannot be parsed", () =>
+    Effect.gen(function* () {
+      const result = ToolStream.appendOrStart(
+        ADAPTER,
+        ToolStream.empty<number>(),
+        0,
+        { id: "call_1", name: "lookup", text: "x" },
+        "missing tool",
+      )
+      if (ToolStream.isError(result)) return yield* result

-    expect(result.events).toEqual([
-      { type: "tool-input-start", id: "call_1", name: "lookup" },
-      { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
-    ])
-  })
+      expect(result.events).toEqual([
+        { type: "tool-input-start", id: "call_1", name: "lookup" },
+        { type: "tool-input-delta", id: "call_1", name: "lookup", text: "x", input: {} },
+      ])
+    }),
+  )

  it.effect("keeps accumulated identity when later deltas contain empty strings", () =>
    Effect.gen(function* () {
@@ -100,12 +104,14 @@ describe("ToolStream", () => {
    }),
  )

-  test("fails appendExisting when the provider skipped the tool start", () => {
-    const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty<number>(), 0, "{}", "missing tool")
+  it.effect("fails appendExisting when the provider skipped the tool start", () =>
+    Effect.gen(function* () {
+      const error = ToolStream.appendExisting(ADAPTER, ToolStream.empty<number>(), 0, "{}", "missing tool")

-    expect(error).toBeInstanceOf(AIError)
-    if (ToolStream.isError(error)) expect(error.message).toBe("missing tool")
-  })
+      expect(error).toBeInstanceOf(AIError)
+      if (ToolStream.isError(error)) expect(error.message).toBe("missing tool")
+    }),
+  )

  it.effect("uses final input override without losing accumulated deltas", () =>
    Effect.gen(function* () {
@@ -5,5 +5,5 @@
    "noEmit": true,
    "rootDir": "."
  },
-  "include": ["test/**/*.types.ts", "test/testing.test.ts"]
+  "include": ["test/**/*.types.ts"]
 }
@@ -25,7 +25,6 @@ for (const viewport of [
    const mock = await openDraft(page)
    const pending = await submitPending(page, mock)

-    expect(mock.worktreeRequests).toEqual([expect.objectContaining({ from: directory })])
    await expect(pending.message).toBeInViewport()
    await expect(pending.shimmer).toBeInViewport()
    await testInfo.attach("creating-worktree", {
@@ -185,7 +184,6 @@ test("restores the draft after closing and revisiting a pending session that fai
 async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
  const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
  const calls: string[] = []
-  const worktreeRequests: Record<string, unknown>[] = []
  const creates: Record<string, unknown>[] = []
  const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
  const project = {
@@ -218,10 +216,7 @@ async function openDraft(page: Page, options?: { failSessionCreate?: boolean })
  page.on("request", (request) => {
    if (request.method() !== "POST") return
    const path = new URL(request.url()).pathname
-    if (path === `/api/worktree/${projectID}`) {
-      calls.push("worktree")
-      worktreeRequests.push(request.postDataJSON())
-    }
+    if (path === `/api/worktree/${projectID}`) calls.push("worktree")
    if (path === "/api/session") calls.push("session")
    if (/^\/api\/session\/[^/]+\/prompt$/.test(path)) calls.push("prompt")
  })
@@ -279,7 +274,7 @@ async function openDraft(page: Page, options?: { failSessionCreate?: boolean })
  await page.getByRole("menuitem", { name: "New workspace", exact: true }).click()
  await expect(page.getByRole("button", { name: "New workspace", exact: true })).toBeVisible()
  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  return { worktree, worktreeRequests, calls, creates, prompts }
+  return { worktree, calls, creates, prompts }
 }

 async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
@@ -308,8 +308,8 @@ for (const delivery of ["steer", "queue"] as const) {
    })
    const tools = page.locator('[data-timeline-part-ids="tool_queue_read,tool_queue_grep"]')
    await expect(tools).toBeVisible()
-    await expect(tools).toHaveText(/^Used\s*2 Read, Grep$/)
-    await expect(tools.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Read, Grep")
+    await expect(tools).toContainText(/Used\s*Read, Grep/)
+    await expect(tools.locator('[data-component="tag"]')).toHaveText("2")
    await expect(thinking).toHaveCount(0)
    await expect(pending).toBeVisible()
    expect(mock.rows.map((row) => ({ id: row.id, delivery: row.delivery }))).toEqual([
@@ -318,7 +318,7 @@ for (const delivery of ["steer", "queue"] as const) {
    await transcript.screenshot({ path: testInfo.outputPath("pending-steer.png") })

    // Soft assertions let delivery run too, even when the pending ordering regresses.
-    await expect.soft(tools.or(pending)).toHaveText([/^Used\s*2 Read, Grep$/, /U2: Also check the retry path\./])
+    await expect.soft(tools.or(pending)).toHaveText([/Used\s*Read, Grep/, /U2: Also check the retry path\./])
    await expect
      .soft(transcript.locator('[data-timeline-row="AssistantPart"]').filter({ has: tools }))
      .toHaveAttribute("data-message-id", userID)
@@ -350,7 +350,7 @@ for (const delivery of ["steer", "queue"] as const) {
    await expect(response).toHaveAttribute("data-message-id", inboxID)
    await expect(thinking).toHaveCount(0)
    await expect(tools.or(pending).or(response)).toHaveText([
-      /^Used\s*2 Read, Grep$/,
+      /Used\s*Read, Grep/,
      /U2: Also check the retry path\./,
      /A3: Now checking the retry path for U2\./,
    ])
@@ -25,7 +25,7 @@ test("space activates a focused timeline button instead of scrolling", async ({
    seedHistory: true,
  })
  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-  const trigger = page.getByRole("button", { name: "Used 1 Shell", exact: true })
+  const trigger = page.getByRole("button", { name: "Used Shell" })
  await expect
    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight))
    .toBeGreaterThan(300)
@@ -93,8 +93,7 @@ test.describe("regression: session timeline local row state", () => {
    await expectSessionTitle(page, title)

    const group = page.locator('[data-component="collapsed-tool-group"]')
-    const summary = group.getByRole("button", { name: /^Used \d+ Patch$/ })
-    await expect(summary).toHaveAccessibleName("Used 1 Patch")
+    const summary = group.getByRole("button", { name: "Used Patch", exact: true })
    await summary.click()
    await group.locator(`[data-timeline-part-id="${editPartID}"]`).evaluate((element) => {
      element.setAttribute("data-disclosure-probe", "existing")
@@ -110,8 +109,7 @@ test.describe("regression: session timeline local row state", () => {
      if (count === 3) await trigger.click()
      const id = `prt_patch_${count}`
      events.push(...toolEvents({ ...part, id, callID: id }))
-      await expect(summary).toHaveAccessibleName(`Used ${count} Patch`)
-      await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText(`${count} Patch`)
+      await expect(group.locator('[data-component="tag"]')).toHaveText(String(count))
      await expect(group).toHaveAttribute("data-timeline-part-ids", new RegExp(`${id}$`))
      await expect(trigger).toHaveAttribute("aria-expanded", String(count === 2))
      await expect(summary).toHaveAttribute("aria-expanded", "true")
@@ -55,7 +55,7 @@ test.describe("regression: session timeline context group resize", () => {
    await devtools.send("Emulation.setCPUThrottlingRate", { rate: 4 })
    const context = page.locator(`[data-timeline-part-ids="${contextIDs.join(",")}"]`).first()
    await expectAppVisible(context)
-    await expect(context.getByRole("button")).toHaveAccessibleName("Used 4 Read, Glob, Grep, List")
+    await expect(context.getByRole("button")).toHaveAccessibleName("Used Read, Glob, Grep, List")

    const contextSelector = `[data-timeline-part-ids="${contextIDs.join(",")}"]`
    const regions = defineVisualRegions({
@@ -88,7 +88,7 @@ test.describe("regression: session timeline context group resize", () => {
      await page.waitForTimeout(delay)
    }

-    await expect(context.getByRole("button")).toHaveAccessibleName("Used 4 Read, Glob, Grep, List")
+    await expect(context.getByRole("button")).toHaveAccessibleName("Used Read, Glob, Grep, List")
    await page.waitForTimeout(700)
    const trace = await stopVisualProbe<keyof typeof regions>(page)
    const labels = trace.samples
@@ -107,7 +107,7 @@ test.describe("regression: session timeline context group resize", () => {
      ]),
    )

-    expect(labels).toEqual(["Used 4 Read, Glob, Grep, List"])
+    expect(labels).toEqual(["Used Read, Glob, Grep, List"])
    expect(issues, JSON.stringify(trace.samples, null, 2)).toEqual([])
  })
 })
@@ -28,7 +28,7 @@ for (const expanded of [false, true]) {
    })
    const trigger = expanded
      ? page.locator(`[data-timeline-part-id="${id}"] [data-slot="collapsible-trigger"]`)
-      : page.getByRole("button", { name: "Used 1 Shell", exact: true })
+      : page.getByRole("button", { name: "Used Shell" })
    await expect(trigger).toHaveAttribute("aria-expanded", String(expanded))
    await trigger.click()
    await expect(trigger).toHaveAttribute("aria-expanded", String(!expanded))
@@ -141,7 +141,7 @@ for (const open of [false, true]) {
    await timeline.send(partUpdated(shell(shellID, "completed", "done")))
    await timeline.send(messageUpdated(completedAssistantInfo(assistant)))
    await timeline.send(status("idle"))
-    const used = group.getByRole("button", { name: "Used 1 Shell", exact: true })
+    const used = group.getByRole("button", { name: "Used Shell", exact: true })
    await expect(used).toHaveAttribute("aria-expanded", "false")
    await used.click()
    await expect(used).toHaveAttribute("aria-expanded", "true")
@@ -150,7 +150,7 @@ for (const open of [false, true]) {
      "aria-expanded",
      String(open),
    )
-    await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Shell")
+    await expect(group.locator('[data-component="tag"]')).toHaveText("1")
    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
    await expect(used).toHaveAttribute("aria-expanded", "true")
    if (!open) await thought.click()
@@ -16,9 +16,8 @@ for (const locale of ["de", "ar"] as const) {
    })

    const group = page.locator(`[data-timeline-part-ids="${ids.join(",")}"]`)
-    const names = locale === "de" ? "Lesen, Glob" : "\u0642\u0631\u0627\u0621\u0629, Glob"
-    await expect(group.getByRole("button")).toHaveAccessibleName(`Used 2 ${names}`)
-    await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toHaveText(`2 ${names}`)
+    await expect(group.getByRole("button")).toHaveAccessibleName(/^Used /)
+    await expect(group.locator('[data-component="tag"]')).toHaveText("2")
    await expect(page.locator("html")).toHaveAttribute("lang", locale)
  })
 }
@@ -105,10 +105,10 @@ for (const summaries of [false, true]) {
      if (profile === "tool") {
        const group = page.locator('[data-component="collapsed-tool-group"]')
        const used = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-        await expect(used).toHaveText(/^Used\s*1 Skill$/)
+        await expect(used).toContainText("UsedSkill")
        await expect(used).toHaveAttribute("aria-expanded", "false")
        await expect(page.getByText("Inspecting stability", { exact: true })).toBeHidden()
-        await expect(used.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("1 Skill")
+        await expect(group.locator('[data-component="tag"]')).toHaveText("1")
        await used.click()
        await expect(used).toHaveAttribute("aria-expanded", "true")
        await expect(group.locator(`[data-timeline-part-id="prt_reasoning_tool_${summaries}"]`)).toBeVisible()
@@ -45,11 +45,10 @@ test("expands a mixed collapsed tool stack without expanding its individual call
  const group = page.locator(
    '[data-timeline-part-ids="prt_stack_shell_1,prt_stack_explore,prt_stack_patch,prt_stack_shell_2"]',
  )
-  const summary = group.getByRole("button", { name: "Used 4 Shell, Agent, Patch", exact: true })
+  const summary = group.getByRole("button", { name: "Used Shell, Agent, Patch" })
  await expect(summary).toHaveAttribute("aria-expanded", "false")
  await expect(summary).toHaveCSS("height", "28px")
-  await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("4 Shell, Agent, Patch")
-  await expect(summary.locator('[data-component="tag"]')).toHaveCount(0)
+  await expect(group.locator('[data-component="tag"]')).toHaveText("4")
  await summary.click()
  await expect(summary).toHaveAttribute("aria-expanded", "true")
  await expect(group.locator('[data-slot="context-tool-group-item"]')).toHaveCount(4)
@@ -75,8 +74,8 @@ test("leaves tools expanded by settings outside the collapsed stack", async ({ p

  await expect(page.locator('[data-timeline-part-id="prt_expanded_shell"]')).toBeVisible()
  const group = page.locator('[data-timeline-part-ids="prt_collapsed_patch,prt_collapsed_read"]')
-  await expect(group.getByRole("button", { name: "Used 2 Patch, Read", exact: true })).toBeVisible()
-  await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Patch, Read")
+  await expect(group.getByRole("button", { name: "Used Patch, Read" })).toBeVisible()
+  await expect(group.locator('[data-component="tag"]')).toHaveText("2")
  await expect(page.locator('[data-timeline-spacing="tool"]')).toHaveCSS("padding-top", "8px")
 })

@@ -114,7 +113,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
    ],
  })
  const group = page.locator('[data-component="collapsed-tool-group"]')
-  await group.getByRole("button", { name: "Used 2 Shell, Patch", exact: true }).click()
+  await group.getByRole("button", { name: "Used Shell, Patch", exact: true }).click()
  await expect(group.getByText("2 files", { exact: true })).toBeVisible()
  await timeline.send(
    partUpdated(
@@ -129,10 +128,7 @@ test("combines follow-up patches into one three-file stack inside Used", async (
      ),
    ),
  )
-  await expect(group.getByRole("button", { name: "Used 3 Shell, Patch", exact: true })).toHaveAttribute(
-    "aria-expanded",
-    "true",
-  )
+  await expect(group.locator('[data-component="tag"]')).toHaveText("3")
  await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
  await expect(group.getByText("3 files", { exact: true })).toBeVisible()
  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts", "c.ts"])
@@ -162,8 +158,8 @@ test("keeps failed search calls and their error cards inside the collapsed stack
  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })

  const group = page.locator('[data-timeline-part-ids="prt_error_glob,prt_error_grep"]')
-  const summary = group.getByRole("button", { name: "Used 2 Glob, Grep", exact: true })
-  await expect(summary.locator('[data-slot="basic-tool-tool-title"]')).toHaveText("2 Glob, Grep")
+  const summary = group.getByRole("button", { name: "Used Glob, Grep" })
+  await expect(group.locator('[data-component="tag"]')).toHaveText("2")
  await summary.click()
  await expect(group.locator('[data-kind="tool-error-card"]')).toHaveCount(2)
  const glob = group.locator('[data-timeline-part-id="prt_error_glob"]')
@@ -52,7 +52,7 @@ test("shows parent lineage while the child timeline loads", async ({ page }) =>

  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)
-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()
  await page.locator(`a[href="${sessionHref(childID)}"]`).click()
  await Promise.all([requested.promise, expect(page).toHaveURL(sessionHref(childID))])
  await Promise.all([
@@ -77,7 +77,7 @@ test("keeps the parent visible while the child session resolves", async ({ page
  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)

-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()
  await page.locator(`a[href="${sessionHref(childID)}"]`).click()
  await requested.promise
  await Promise.all([expect(page).toHaveURL(sessionHref(parentID)), expectSessionTitle(page, parentTitle)]).finally(
@@ -195,7 +195,7 @@ async function setup(page: Page, events?: () => OpenCodeEvent[]) {
 async function openChildFromParent(page: Page) {
  await page.goto(sessionHref(parentID))
  await expectSessionTitle(page, parentTitle)
-  await page.getByRole("button", { name: "Used 1 Agent", exact: true }).click()
+  await page.getByRole("button", { name: "Used Agent" }).click()

  const card = page.locator(`a[href="${sessionHref(childID)}"]`)
  await expect(card).toBeVisible()
@@ -209,29 +209,6 @@ test("appearance experimental setting switches tab orientation", async ({ page }
  await page.setViewportSize({ width: 390, height: 360 })
  await version.scrollIntoViewIfNeeded()
  await expect(version).toBeInViewport()
-
-  // Reload the UI-selected preference without seeding settings storage.
-  await page.reload()
-  const href = `/server/${base64Encode(server)}/session/${sessionA.id}`
-  await expect(
-    page
-      .locator('[data-slot="titlebar-tabs"]')
-      .locator(`[data-titlebar-tab-link][href="${href}"]`)
-      .getByText(sessionA.title, { exact: true }),
-  ).toBeVisible()
-  await expect(page.locator('[data-slot="vertical-tabs-sidebar"]')).toHaveCount(0)
-
-  await page.setViewportSize({ width: 1280, height: 720 })
-  await expect(
-    page
-      .locator('[data-slot="vertical-tabs-sidebar"]')
-      .locator(`[data-titlebar-tab-link][href="${href}"]`)
-      .getByText(sessionA.title, { exact: true }),
-  ).toBeVisible()
-  await expect(page.locator('[data-slot="titlebar-tabs"]')).toHaveCount(0)
-  await page.keyboard.press("Control+,")
-  await settings.getByRole("tab", { name: "Appearance" }).click()
-  await expect(layout).toContainText("Vertical")
 })

 test("vertical tab preference falls back to horizontal on mobile", async ({ page }) => {
@@ -198,10 +198,6 @@ fixture(
 fixture(
  "precaches public files of every type and size, excluding deployment metadata and source maps",
  async ({ page, site, builds, context }) => {
-    for (const output of Object.values(builds)) {
-      expect(output["/sw.js.map"]).toBeUndefined()
-      expect(Object.keys(output).some((path) => path.startsWith("/_assets/") && path.endsWith(".map"))).toBe(true)
-    }
    await install(page, site.url)
    const files = ["/nested/data.json", "/nested/font.woff2", "/nested/module.wasm", "/large.bin"]
    await context.setOffline(true)
@@ -42,18 +42,21 @@
    "@playwright/test": "catalog:",
    "@sentry/vite-plugin": "catalog:",
    "@tailwindcss/vite": "4.3.3",
+    "@tsconfig/bun": "1.0.9",
    "@types/bun": "catalog:",
    "@types/luxon": "catalog:",
    "@types/node": "catalog:",
    "@typescript/native-preview": "catalog:",
-    "diff": "catalog:",
    "happy-dom": "20.11.1",
    "tw-animate-css": "1.4.0",
-    "vite": "8.2.2",
+    "typescript": "catalog:",
+    "vite": "8.2.1",
+    "vite-plugin-icons-spritesheet": "3.0.1",
    "vite-plugin-pwa": "1.3.0",
    "vite-plugin-solid": "2.11.14"
  },
  "dependencies": {
+    "@corvu/drawer": "catalog:",
    "@dnd-kit/abstract": "0.5.0",
    "@dnd-kit/dom": "0.5.0",
    "@dnd-kit/helpers": "0.5.0",
@@ -68,23 +71,28 @@
    "@pierre/trees": "1.0.0-beta.4",
    "@sentry/solid": "catalog:",
    "@solid-primitives/event-bus": "1.1.2",
-    "@solid-primitives/event-listener": "catalog:",
+    "@solid-primitives/event-listener": "2.4.5",
    "@solid-primitives/i18n": "2.2.1",
    "@solid-primitives/keyed": "1.5.3",
-    "@solid-primitives/media": "catalog:",
-    "@solid-primitives/resize-observer": "catalog:",
+    "@solid-primitives/media": "2.3.3",
+    "@solid-primitives/resize-observer": "2.1.5",
    "@solid-primitives/scheduled": "1.5.3",
    "@solid-primitives/storage": "catalog:",
    "@solidjs/meta": "catalog:",
    "@solidjs/router": "catalog:",
    "@tanstack/solid-query": "5.91.4",
    "@tanstack/solid-virtual": "catalog:",
+    "diff": "catalog:",
    "effect": "catalog:",
    "fuzzysort": "catalog:",
    "ghostty-web": "github:anomalyco/ghostty-web#83c0a07b8628b748aed073b232cb4b52a6ca11c1",
    "luxon": "catalog:",
+    "marked": "catalog:",
+    "marked-shiki": "catalog:",
    "remeda": "catalog:",
+    "shiki": "catalog:",
    "solid-js": "catalog:",
+    "solid-list": "catalog:",
    "solid-presence": "0.2.0",
    "tailwindcss": "4.3.3"
  }
@@ -1,4 +1,5 @@
 import { base64Encode } from "@opencode-ai/util/encode"
+import { getDirectory } from "@opencode-ai/util/path"
 import type { SessionMessageUser } from "@opencode-ai/client/promise"
 import { Session } from "@opencode-ai/schema/session"
 import { startTransition } from "solid-js"
@@ -12,7 +13,6 @@ import { useData, useServer } from "@/runtime/server/current"
 import { type ServerSDK, useServerSDK } from "@/runtime/server/client"
 import { useTabs } from "@/shell/tabs/tabs"
 import { useWorkspaceLocation } from "@/workspaces/location"
-import { createWorktree } from "@/workspaces/create"
 import { useSessionKey } from "@/session/session-layout"
 import { showToast } from "@/shell/notifications/toast"
 import { SessionRouteKey, SessionStateKey } from "@/runtime/server/scope"
@@ -192,17 +192,25 @@ async function resolveSessionDirectory(input: {
  if (input.worktree === "main") return input.projectDirectory
  if (input.worktree !== "create") return input.worktree

-  return createWorktree({
-    api: input.serverSDK.api,
-    directory: input.projectDirectory,
-    project: input.data.location.info({ directory: input.projectDirectory })?.project,
-    branch: input.branch,
-  }).catch((error) => {
-    showToast({
-      title: input.language.t("prompt.toast.worktreeCreateFailed.title"),
-      description: errorMessage(input.language, error),
+  return input.serverSDK.api.worktree
+    .create({
+      projectID: input.data.location.info({ directory: input.projectDirectory })?.project.id ?? "",
+      strategy: "git",
+      branch: input.branch,
+      directory: getDirectory(
+        input.data.location.info({ directory: input.projectDirectory })?.project.directory ?? input.projectDirectory,
+      ),
+    })
+    .then(async (created) => {
+      await input.serverSDK.api.location.get({ location: { directory: created.directory } })
+      return created.directory
+    })
+    .catch((error) => {
+      showToast({
+        title: input.language.t("prompt.toast.worktreeCreateFailed.title"),
+        description: errorMessage(input.language, error),
+      })
    })
-  })
 }

 function errorMessage(language: ReturnType<typeof useLanguage>, error: unknown) {
@@ -644,7 +644,7 @@ export function persisted<T>(
      : undefined
  if (channel) onCleanup(() => channel.close())

-  const [state, setState, init] = makePersisted<T, typeof store>(store, {
+  const [state, setState, init] = makePersisted(store, {
    name: config.key,
    storage,
    sync: channel ? messageSync(channel) : undefined,
@@ -1,135 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { createApiForServer } from "./api"
-import { readLocalImage } from "./image"
-
-function setup(
-  respond: (init?: RequestInit) => Response | Promise<Response> = () => new Response(new Uint8Array([0, 127, 255])),
-) {
-  const requests: Array<{ url: URL; init?: RequestInit }> = []
-  const api = createApiForServer({
-    server: { url: "https://server.example:4096", username: "image-user", password: "secret" },
-    fetch: (async (input: string | URL | Request, init?: RequestInit) => {
-      requests.push({ url: new URL(input instanceof Request ? input.url : input), init })
-      return respond(init)
-    }) as typeof fetch,
-  })
-  return { api, requests }
-}
-
-describe("readLocalImage", () => {
-  test.each([
-    ["images/screen #1 + 50% ?.PNG", "/workspace/project", "images/screen%20%231%20%2B%2050%25%20%3F.PNG"],
-    ["C:/tmp/opencode/screen #1.png", "C:/tmp/opencode/", "screen%20%231.png"],
-    ["d:/screen.png", "d:/", "screen.png"],
-    ["D:/charts/screen.png", "D:/charts/", "screen.png"],
-    ["Z:/charts/screen.png", "Z:/charts/", "screen.png"],
-    ["/tmp/opencode/screen #1.png", "/tmp/opencode/", "screen%20%231.png"],
-    ["/screen.png", "/", "screen.png"],
-  ])("reads %s with the correct location and authentication", async (path, directory, encoded) => {
-    const { api, requests } = setup()
-    const signal = new AbortController().signal
-    const blob = await readLocalImage(api, "/workspace/project", path, signal)
-
-    expect(blob).toBeInstanceOf(Blob)
-    expect(blob?.type).toBe("image/png")
-    expect(new Uint8Array(await blob!.arrayBuffer())).toEqual(new Uint8Array([0, 127, 255]))
-    expect(requests).toHaveLength(1)
-    expect(requests[0].url.origin).toBe("https://server.example:4096")
-    expect(requests[0].url.pathname).toBe(`/api/fs/read/${encoded}`)
-    expect([...requests[0].url.searchParams]).toEqual([["location[directory]", directory]])
-    expect(requests[0].init?.method).toBe("GET")
-    expect(new Headers(requests[0].init?.headers).get("authorization")).toBe(`Basic ${btoa("image-user:secret")}`)
-    expect(requests[0].init?.signal).toBe(signal)
-  })
-
-  test("preserves literal percent escapes and encodes the supplied relative location", async () => {
-    const { api, requests } = setup()
-    await readLocalImage(api, "C:/project #1 + 50%", "images/literal%20name.png", new AbortController().signal)
-
-    expect(requests[0].url.href).toBe(
-      "https://server.example:4096/api/fs/read/images/literal%2520name.png?location%5Bdirectory%5D=C%3A%2Fproject+%231+%2B+50%25",
-    )
-  })
-
-  test.each([
-    ["png", "image/png"],
-    ["jpeg", "image/jpeg"],
-    ["JPG", "image/jpeg"],
-    ["gif", "image/gif"],
-    ["webp", "image/webp"],
-    ["SVG", "image/svg+xml"],
-    ["avif", "image/avif"],
-    ["bmp", "image/bmp"],
-    ["ico", "image/x-icon"],
-  ])("uses the MIME type for .%s rather than the response header", async (extension, type) => {
-    const { api } = setup(
-      () => new Response("image bytes", { headers: { "content-type": "application/octet-stream" } }),
-    )
-    const blob = await readLocalImage(api, "/repo", `image.${extension}`, new AbortController().signal)
-    expect(blob?.type).toBe(type)
-    expect(await blob?.text()).toBe("image bytes")
-  })
-
-  test.each([
-    "https://example.com/image.png",
-    "HTTP://example.com/image.png",
-    "file:///tmp/image.png",
-    "data:image/png;base64,image.png",
-    "blob:https://example.com/image.png",
-    "custom+scheme:image.png",
-    "C:image.png",
-    "//server/share/image.png",
-    "\\\\server\\share\\image.png",
-    "//?/C:/image.png",
-    "///server/share/image.png",
-    "image.txt",
-    "image.html",
-    "image.constructor",
-    "image.png.txt",
-    "image",
-    "images.png/image",
-    "image.png/",
-    "",
-  ])("does not request unsupported input %s", async (path) => {
-    const { api, requests } = setup()
-    expect(await readLocalImage(api, "/repo", path, new AbortController().signal)).toBeUndefined()
-    expect(requests).toHaveLength(0)
-  })
-
-  test.each([400, 401])("propagates declared API errors (%s)", async (status) => {
-    const error = { _tag: "RequestError", message: "Cannot read image" }
-    const { api } = setup(() => Response.json(error, { status }))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toEqual(error)
-  })
-
-  test.each([404, 500])("does not turn an unexpected HTTP status (%s) into a Blob", async (status) => {
-    const { api } = setup(() => new Response("Not an image", { status }))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toMatchObject({
-      reason: "UnexpectedStatus",
-      cause: { status },
-    })
-  })
-
-  test("propagates transport failures", async () => {
-    const error = new Error("Connection lost")
-    const { api } = setup(() => Promise.reject(error))
-    await expect(readLocalImage(api, "/repo", "image.png", new AbortController().signal)).rejects.toMatchObject({
-      reason: "Transport",
-      cause: error,
-    })
-  })
-
-  test("forwards cancellation to an in-flight fetch", async () => {
-    const controller = new AbortController()
-    const { api, requests } = setup(
-      (init) =>
-        new Promise((_resolve, reject) => {
-          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true })
-        }),
-    )
-    const result = readLocalImage(api, "/repo", "image.png", controller.signal)
-    expect(requests[0].init?.signal).toBe(controller.signal)
-    controller.abort()
-    await expect(result).rejects.toMatchObject({ reason: "Transport", cause: controller.signal.reason })
-  })
-})
@@ -1,36 +0,0 @@
-import { getDirectory, getFilename } from "@opencode-ai/util/path"
-import type { OpenCodeClient } from "@opencode-ai/client/promise"
-
-const types = new Map([
-  ["png", "image/png"],
-  ["jpeg", "image/jpeg"],
-  ["jpg", "image/jpeg"],
-  ["gif", "image/gif"],
-  ["webp", "image/webp"],
-  ["svg", "image/svg+xml"],
-  ["avif", "image/avif"],
-  ["bmp", "image/bmp"],
-  ["ico", "image/x-icon"],
-])
-
-export async function readLocalImage(
-  api: Pick<OpenCodeClient, "file">,
-  directory: string,
-  path: string,
-  signal: AbortSignal,
-): Promise<Blob | undefined> {
-  const drive = /^[a-z]:\//i.test(path)
-  if (/^[\\/]{2}/.test(path) || (!drive && /^[a-z][a-z\d+.-]*:/i.test(path))) return
-  const type = types.get(path.match(/\.([^./]+)$/)?.[1]?.toLowerCase() ?? "")
-  if (!type) return
-  const absolute = drive || path.startsWith("/")
-  // Scope absolute images to their parent, including files outside the project.
-  const bytes = await api.file.read(
-    {
-      path: absolute ? getFilename(path) : path,
-      location: { directory: absolute ? getDirectory(path) : directory },
-    },
-    { signal },
-  )
-  return new Blob([new Uint8Array(bytes)], { type })
-}
@@ -1,6 +1,6 @@
 import { Menu } from "@opencode-ai/ui/menu"
 import { Icon } from "@opencode-ai/ui/icon"
-import { getFilename } from "@opencode-ai/util/path"
+import { getDirectory, getFilename } from "@opencode-ai/util/path"
 import { createStore } from "solid-js/store"
 import { createSignal, For, Show, type ComponentProps, type JSX } from "solid-js"
 import type { Project } from "@/runtime/server/types"
@@ -11,7 +11,6 @@ import { useSettingsDialog } from "@/settings/command"
 import { pathKey } from "@/workspaces/path-key"
 import { showToast } from "@/shell/notifications/toast"
 import { containsDirectory, sameDirectory, workspaceDirectories } from "@/workspaces/paths"
-import { createWorktree } from "@/workspaces/create"

 export function SessionWorkspaceMenu(props: {
  eligible?: boolean
@@ -56,14 +55,7 @@ export function SessionWorkspaceMenu(props: {
    setStore("selected", selection)

    try {
-      const destination =
-        selection === "create"
-          ? await createWorktree({
-              api: sdk.api,
-              directory: props.directory,
-              project: data.location.info({ directory: props.directory })?.project,
-            })
-          : selection
+      const destination = selection === "create" ? await createWorkspace(props.project, sdk) : selection
      if (!destination) return

      await sdk.api.session.move({ sessionID, directory: destination })
@@ -132,3 +124,13 @@ export function SessionWorkspaceMenu(props: {
    </Menu>
  )
 }
+
+async function createWorkspace(project: Project, serverSDK: ReturnType<typeof useServerSDK>) {
+  const created = await serverSDK.api.worktree.create({
+    projectID: project.id,
+    strategy: "git",
+    directory: getDirectory(project.worktree),
+  })
+  await serverSDK.api.location.get({ location: { directory: created.directory } })
+  return created.directory
+}
@@ -1,5 +1,5 @@
 import { TextField } from "@opencode-ai/ui/text-field"
-import type { captureException } from "@sentry/solid"
+import { captureException, isEnabled } from "@sentry/solid"
 import { Logo } from "@opencode-ai/ui/logo"
 import { Button } from "@opencode-ai/ui/button"
 import { Component, createSignal, onMount, Show } from "solid-js"
@@ -227,7 +227,6 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {
  let recordedFatalError: Promise<void> | undefined
  const [store, setStore] = createStore({
    actionError: undefined as string | undefined,
-    captureException: undefined as typeof captureException | undefined,
  })

  function ensureFatalErrorRecorded() {
@@ -244,11 +243,6 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {

  onMount(() => {
    void ensureFatalErrorRecorded().catch(() => undefined)
-    void import("@sentry/solid")
-      .then(({ captureException, isEnabled }) => {
-        if (isEnabled()) setStore("captureException", () => captureException)
-      })
-      .catch(() => undefined)
  })

  async function checkForUpdates() {
@@ -317,15 +311,15 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {
              {language.t("error.page.action.exportLogs")}
            </Button>
          </Show>
-          <Show when={store.captureException}>
-            {(capture) => {
+          <Show when={isEnabled}>
+            {(_) => {
              const [reported, setReported] = createSignal(false)
              return (
                <Button
                  size="large"
                  disabled={reported()}
                  onClick={() => {
-                    capture()(props.error)
+                    captureException(props.error)
                    setReported(true)
                  }}
                >
@@ -1,5 +1,4 @@
 import { DataProvider } from "@opencode-ai/session-ui/context"
-import { MarkdownProvider, type ReadMarkdownImage } from "@opencode-ai/session-ui/context/markdown"
 import { useNavigate, useParams } from "@solidjs/router"
 import { createMemo, type ParentProps } from "solid-js"
 import { useProviders } from "@/providers/catalog/providers"
@@ -9,7 +8,6 @@ import { sessionHref } from "@/shell/routes/session"
 import { useData } from "@/runtime/server/current"
 import { useServerSDK } from "@/runtime/server/client"
 import { useTabs } from "@/shell/tabs/tabs"
-import { readLocalImage } from "@/runtime/server/image"

 export function SessionUIProvider(
  props: ParentProps<{
@@ -23,10 +21,6 @@ export function SessionUIProvider(
  const serverSDK = useServerSDK()
  const tabs = useTabs()
  const directory = () => props.directory
-  const readImage = createMemo<ReadMarkdownImage>(() => {
-    const dir = directory()
-    return (path, signal) => readLocalImage(serverSDK.api, dir, path, signal)
-  })
  const href = (sessionID: string) => sessionHref(props.server, sessionID)
  const navigateToSession = async (sessionID: string) => {
    const tab = tabs.store.find(
@@ -66,9 +60,7 @@ export function SessionUIProvider(
      onNavigateToSession={navigateToSession}
      onSessionHref={href}
    >
-      <MarkdownProvider readImage={readImage()}>
-        <LocalProvider>{props.children}</LocalProvider>
-      </MarkdownProvider>
+      <LocalProvider>{props.children}</LocalProvider>
    </DataProvider>
  )
 }
@@ -1,90 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { OpenCode } from "@opencode-ai/client/promise"
-import { createWorktree } from "./create"
-
-describe("worktree creation", () => {
-  test.each(
-    [
-      { name: "clone", directory: "/copies/repo", root: "/copies/repo", canonical: "/copies/repo", parent: "/copies/" },
-      {
-        name: "clone subdirectory",
-        directory: "/copies/repo/packages/app",
-        root: "/copies/repo",
-        canonical: "/copies/repo",
-        parent: "/copies/",
-      },
-      {
-        name: "linked worktree subdirectory",
-        directory: "/linked/task/packages/app",
-        root: "/linked/task",
-        canonical: "/copies/repo",
-        parent: "/copies/",
-      },
-      {
-        name: "Windows clone",
-        directory: "C:\\copies\\repo\\packages\\app",
-        root: "C:\\copies\\repo",
-        canonical: "C:\\copies\\repo",
-        parent: "C:/copies/",
-      },
-    ].flatMap((input) => [true, false].map((cached) => ({ ...input, cached }))),
-  )("uses the clone-local main for $name (cached: $cached)", async (input) => {
-    const project = { id: "proj_clone", directory: input.root, canonical: input.canonical }
-    const requests: Request[] = []
-    const api = OpenCode.make({
-      baseUrl: "http://localhost:3000",
-      fetch: Object.assign(
-        async (input: RequestInfo | URL, init?: RequestInit) => {
-          const request = new Request(input, init)
-          requests.push(request)
-          if (request.method === "POST") return Response.json({ directory: "/created" })
-          return Response.json({ directory: new URL(request.url).searchParams.get("location[directory]"), project })
-        },
-        { preconnect() {} },
-      ),
-    })
-
-    expect(
-      await createWorktree({
-        api,
-        directory: input.directory,
-        project: input.cached ? project : undefined,
-        branch: "clone-only",
-      }),
-    ).toBe("/created")
-    expect(await requests.find((request) => request.method === "POST")?.json()).toEqual({
-      strategy: "git",
-      from: input.canonical,
-      branch: "clone-only",
-      directory: input.parent,
-    })
-    expect(requests.find((request) => request.method === "POST")?.url).toBe(
-      "http://localhost:3000/api/worktree/proj_clone",
-    )
-    expect(
-      requests
-        .filter((request) => request.method === "GET")
-        .map((request) => new URL(request.url).searchParams.get("location[directory]")),
-    ).toEqual(input.cached ? ["/created"] : [input.directory, "/created"])
-  })
-
-  test("does not fall back to a shared project when location lookup fails", async () => {
-    const requests: Request[] = []
-    const api = OpenCode.make({
-      baseUrl: "http://localhost:3000",
-      fetch: Object.assign(
-        async (input: RequestInfo | URL, init?: RequestInit) => {
-          requests.push(new Request(input, init))
-          return Response.json({ message: "unavailable" }, { status: 503 })
-        },
-        { preconnect() {} },
-      ),
-    })
-
-    await expect(createWorktree({ api, directory: "/copies/repo" })).rejects.toMatchObject({
-      reason: "UnexpectedStatus",
-      cause: { status: 503 },
-    })
-    expect(requests.map((request) => request.method)).toEqual(["GET"])
-  })
-})
@@ -1,20 +0,0 @@
-import type { LocationGetOutput, OpenCodeClient } from "@opencode-ai/client/promise"
-import { getDirectory } from "@opencode-ai/util/path"
-
-export async function createWorktree(input: {
-  api: Pick<OpenCodeClient, "location" | "worktree">
-  directory: string
-  project?: LocationGetOutput["project"]
-  branch?: string
-}) {
-  const project = input.project ?? (await input.api.location.get({ location: { directory: input.directory } })).project
-  const created = await input.api.worktree.create({
-    projectID: project.id,
-    strategy: "git",
-    from: project.canonical,
-    branch: input.branch,
-    directory: getDirectory(project.canonical),
-  })
-  await input.api.location.get({ location: { directory: created.directory } })
-  return created.directory
-}
@@ -1,85 +0,0 @@
-import { expect, test } from "bun:test"
-import { MemoryRouter, Route, createMemoryHistory, useNavigate, useParams } from "@solidjs/router"
-import { createEffect, onCleanup } from "solid-js"
-import { createComponent, render } from "solid-js/web"
-import { createSessionOwnership } from "@/session/session-ownership"
-
-test("session ownership follows navigation, back, forward, replacement, and route disposal", async () => {
-  const host = document.createElement("div")
-  const history = createMemoryHistory()
-  history.set({ value: "/session/A", replace: true, scroll: false })
-  const captured: ReturnType<ReturnType<typeof createSessionOwnership>["capture"]>[] = []
-  const navigate: ReturnType<typeof useNavigate>[] = []
-  const cleaned: string[] = []
-  const settle = () => new Promise((resolve) => setTimeout(resolve, 0))
-
-  const Session = () => {
-    const params = useParams<{ id: string }>()
-    const ownership = createSessionOwnership(() => params.id)
-    const label = document.createElement("div")
-    navigate.push(useNavigate())
-    createEffect(() => {
-      label.textContent = params.id
-      captured.push(ownership.capture())
-    })
-    onCleanup(() => cleaned.push("session"))
-    return label
-  }
-
-  const dispose = render(
-    () =>
-      createComponent(MemoryRouter, {
-        history,
-        get children() {
-          return [
-            createComponent(Route, { path: "/", component: () => "Home" }),
-            createComponent(Route, { path: "/session/:id", component: Session }),
-          ]
-        },
-      }),
-    host,
-  )
-
-  try {
-    expect(host.textContent).toBe("A")
-    expect(captured[0].current()).toBe(true)
-
-    navigate[0]("/session/B")
-    await settle()
-    expect(host.textContent).toBe("B")
-    expect(captured[0].current()).toBe(false)
-    expect(captured[1].current()).toBe(true)
-
-    history.back()
-    await settle()
-    expect(host.textContent).toBe("A")
-    expect(captured[0].current()).toBe(false)
-    expect(captured[1].current()).toBe(false)
-    expect(captured[2].current()).toBe(true)
-
-    history.forward()
-    await settle()
-    expect(host.textContent).toBe("B")
-    expect(captured[2].current()).toBe(false)
-    expect(captured[3].current()).toBe(true)
-    expect(navigate).toHaveLength(1)
-    expect(cleaned).toEqual([])
-
-    navigate[0]("/", { replace: true })
-    await settle()
-    expect(host.textContent).toBe("Home")
-    expect(captured.every((owner) => !owner.current())).toBe(true)
-    expect(cleaned).toEqual(["session"])
-
-    history.back()
-    await settle()
-    expect(host.textContent).toBe("A")
-    expect(captured[4].current()).toBe(true)
-    expect(navigate).toHaveLength(2)
-  } finally {
-    dispose()
-  }
-
-  expect(captured.every((owner) => !owner.current())).toBe(true)
-  expect(cleaned).toEqual(["session", "session"])
-})
@@ -1,89 +0,0 @@
-import { expect, test } from "bun:test"
-import {
-  createComputed,
-  createMemo,
-  createResource,
-  createRoot,
-  createSignal,
-  onCleanup,
-  startTransition,
-  Suspense,
-  type Accessor,
-  type JSX,
-} from "solid-js"
-import { createComponent, render } from "solid-js/web"
-
-// Solid 1.9.15 includes the former transition patch for solidjs/solid#2046.
-test("a memo created during a paused transition has a committed value", async () => {
-  const host = document.createElement("div")
-  const loaded = Promise.withResolvers<string>()
-  const started = Promise.withResolvers<void>()
-  const memos: Accessor<string>[] = []
-  const [session, setSession] = createSignal(false)
-  const dispose = render(
-    () =>
-      createComponent(Suspense, {
-        fallback: "Loading",
-        get children() {
-          return createMemo(() => {
-            if (!session()) return "Home"
-            memos.push(createMemo(() => "Session"))
-            const [data] = createResource(() => loaded.promise)
-            started.resolve()
-            return createMemo(() => data() ?? "")
-          }) as unknown as JSX.Element
-        },
-      }),
-    host,
-  )
-
-  try {
-    expect(host.textContent).toBe("Home")
-    const pending = startTransition(() => setSession(true))
-    await started.promise
-    expect(host.textContent).toBe("Home")
-    expect(memos).toHaveLength(1)
-    expect(memos[0]()).toBe("Session")
-
-    loaded.resolve("Session loaded")
-    await pending
-    expect(host.textContent).toBe("Session loaded")
-    expect(memos[0]()).toBe("Session")
-  } finally {
-    loaded.resolve("Session loaded")
-    dispose()
-  }
-})
-
-// Exercise each patched bundle independently; importing both dev formats emits Solid's duplicate-runtime warning.
-test.each(["solid.js", "solid.cjs", "dev.js", "dev.cjs", "server.js", "server.cjs"])(
-  "%s reentrant disposal cleans owned computations and callbacks exactly once",
-  async (file) => {
-    const runtime: {
-      createRoot: typeof createRoot
-      createComputed: typeof createComputed
-      onCleanup: typeof onCleanup
-    } = await import(`solid-js/dist/${file}`)
-    const cleaned: string[] = []
-    const dispose = runtime.createRoot((dispose) => {
-      runtime.onCleanup(() => cleaned.push("root"))
-      runtime.createComputed(() => {
-        runtime.onCleanup(() => cleaned.push("first"))
-      })
-      runtime.createComputed(() => {
-        runtime.onCleanup(() => cleaned.push("second"))
-        runtime.onCleanup(() => {
-          cleaned.push("reentrant")
-          // Bound the regression so an unpatched runtime fails without overflowing the stack.
-          if (cleaned.filter((item) => item === "reentrant").length === 1) dispose()
-        })
-      })
-      return dispose
-    })
-
-    expect(dispose).not.toThrow()
-    expect(cleaned.toSorted()).toEqual(["first", "reentrant", "root", "second"])
-    dispose()
-    expect(cleaned).toHaveLength(4)
-  },
-)
@@ -10,8 +10,6 @@ export function serviceWorker(directory: string) {
    injectRegister: false,
    manifest: false,
    workbox: {
-      // Workbox runs after Sentry's upload and cleanup, so do not publish an unuploaded map.
-      sourcemap: false,
      globDirectory: directory,
      clientsClaim: false,
      // Keep each open tab on its complete build until all old clients close.
@@ -1,58 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { Global } from "@opencode-ai/util/global"
-import { AppProcess } from "@opencode-ai/util/process"
-import { Effect, FileSystem, Layer, Stream } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import assert from "node:assert/strict"
-import path from "node:path"
-import { Updater } from "../updater"
-
-const latest = { version: "0.0.0-beta-17498" }
-const installs: string[] = []
-
-// This fixture runs in its own process; no real update requests or installs occur.
-globalThis.fetch = Object.assign(async () => Response.json(latest), { preconnect() {} })
-
-await Effect.runPromise(
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const directory = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-updater-" })
-    const dependencies = Layer.mergeAll(
-      Layer.succeed(FileSystem.FileSystem, fs),
-      Layer.succeed(
-        Global.Service,
-        Global.make({ home: directory, config: directory, cache: path.join(directory, "cache") }),
-      ),
-      Layer.succeed(AppProcess.Service, {
-        ...ChildProcessSpawner.make(() => Effect.die("Unexpected process spawn")),
-        runStream: () => Stream.die("Unexpected streaming process"),
-        run: (command) => {
-          assert.equal(command._tag, "StandardCommand")
-          if (command.command === "npm" && command.args[0] === "install") {
-            assert.ok(command.args.includes("--global"))
-            installs.push(command.args.at(-1)!)
-          }
-          return Effect.succeed({
-            command: command.command,
-            exitCode: 0,
-            stdout: Buffer.from(command.command === "npm" ? "@opencode-ai/cli" : ""),
-            stderr: Buffer.alloc(0),
-            stdoutTruncated: false,
-            stderrTruncated: false,
-          })
-        },
-      }),
-    )
-    yield* Effect.gen(function* () {
-      const updater = yield* Updater.Service
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498"])
-      yield* updater.check()
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498"])
-      latest.version = "0.0.0-beta-17499"
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498", "@opencode-ai/cli@0.0.0-beta-17499"])
-    }).pipe(Effect.provide(Updater.layer.pipe(Layer.provide(dependencies))))
-  }).pipe(Effect.scoped, Effect.provide(NodeFileSystem.layer)),
-)
@@ -5,9 +5,9 @@ const maximumComponent = "9007199254740991"
 const versionPattern =
  /^v?([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/

-export function action(current: string, latest: string, policy: Policy, installed = current): Action {
+export function action(current: string, latest: string, policy: Policy): Action {
  if (policy === false) return "none"
-  const currentVersion = parseReleaseVersion(installed)
+  const currentVersion = parseReleaseVersion(current)
  const latestVersion = parseReleaseVersion(latest)
  if (!currentVersion || !latestVersion || sameRelease(currentVersion, latestVersion)) return "none"
  // Major upgrades are never installed automatically.
@@ -1,30 +1,8 @@
 import { describe, expect, test } from "bun:test"
-import path from "node:path"
 import { action } from "./updater-action"
 import { decodePolicy } from "./updater"

 describe("updater", () => {
-  test("remembers successful installs across checks and accepts the next release", async () => {
-    // Isolate compiled version constants and the update endpoint from other tests.
-    const child = Bun.spawn(
-      [
-        process.execPath,
-        "--define",
-        'OPENCODE_VERSION="0.0.0-next-16473"',
-        "--define",
-        'OPENCODE_CHANNEL="beta"',
-        path.join(import.meta.dir, "fixtures/updater.ts"),
-      ],
-      { env: { ...process.env, OPENCODE_DISABLE_AUTOUPDATE: "" }, stdout: "pipe", stderr: "pipe" },
-    )
-    const [code, stdout, stderr] = await Promise.all([
-      child.exited,
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-    ])
-    expect(code, stdout + stderr).toBe(0)
-  })
-
  test("reads autoupdate from JSONC", () => {
    expect(decodePolicy('{ // preference\n "autoupdate": "notify",\n}')).toBe("notify")
    expect(decodePolicy('{ "autoupdate": false }')).toBe(false)
@@ -54,14 +32,6 @@ describe("updater", () => {
    expect(action("1.2.3", "1.2.3", true)).toBe("none")
  })

-  test("skips an installed update but still accepts the next release", () => {
-    const current = "0.0.0-next-16473"
-    const installed = "0.0.0-beta-17498"
-    expect(action(current, installed, true)).toBe("upgrade")
-    expect(action(current, installed, true, installed)).toBe("none")
-    expect(action(current, "0.0.0-beta-17499", true, installed)).toBe("upgrade")
-  })
-
  test("upgrades when latest is lower (rollback)", () => {
    expect(action("1.2.4", "1.2.3", true)).toBe("upgrade")
  })
@@ -1,7 +1,7 @@
 import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
 import { OPENCODE_CHANNEL, OPENCODE_LOCAL, OPENCODE_VERSION } from "../version"
-import { Context, Duration, Effect, FileSystem, Layer, Ref } from "effect"
+import { Context, Duration, Effect, FileSystem, Layer } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
@@ -38,7 +38,6 @@ export const layer = Layer.effect(
    const fs = yield* FileSystem.FileSystem
    const global = yield* Global.Service
    const appProcess = yield* AppProcess.Service
-    const installed = yield* Ref.make(OPENCODE_VERSION)
    const channel = OPENCODE_CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-")

    const readPolicy = Effect.fnUntraced(function* () {
@@ -113,20 +112,18 @@ export const layer = Layer.effect(

    const upgrade = Effect.fnUntraced(function* (method: Method, version: string) {
      const target = `${packageName}@${version}`
-      const commands: Record<Exclude<Method, "bun" | "curl" | "npm">, string[]> = {
+      const commands: Record<Exclude<Method, "bun" | "curl">, string[]> = {
+        npm: ["npm", "install", "--global", target],
        pnpm: ["pnpm", "add", "--global", `--allow-build=${packageName}`, target],
        yarn: ["yarn", "global", "add", target],
      }
      const result = yield* Effect.scoped(
        Effect.gen(function* () {
-          if (method === "bun" || method === "npm") {
+          if (method === "bun") {
+            // Bun does not prune old versions from its shared package cache.
            yield* fs.makeDirectory(global.cache, { recursive: true })
            const cache = yield* fs.makeTempDirectoryScoped({ directory: global.cache, prefix: "update-" })
-            const command =
-              method === "bun"
-                ? ["bun", "install", "--global", "--trust", "--cache-dir", cache, target]
-                : ["npm", "install", "--global", "--cache", cache, target]
-            return yield* run(command, "5 minutes")
+            return yield* run(["bun", "install", "--global", "--trust", "--cache-dir", cache, target], "5 minutes")
          }
          if (method === "curl") {
            yield* fs.makeDirectory(global.cache, { recursive: true })
@@ -159,19 +156,18 @@ export const layer = Layer.effect(

        return yield* Effect.gen(function* () {
          const version = yield* latest()
-          const current = yield* Ref.get(installed)
          yield* Effect.logInfo("update check", {
-            current,
+            current: OPENCODE_VERSION,
            latest: version,
          })
-          const next = action(OPENCODE_VERSION, version, policy, current)
+          const next = action(OPENCODE_VERSION, version, policy)
          if (next === "none") return yield* Effect.logInfo("update check done", { action: "up-to-date" })
-          if (next === "notify") return yield* Effect.logInfo("OpenCode update available", { current, latest: version })
+          if (next === "notify")
+            return yield* Effect.logInfo("OpenCode update available", { current: OPENCODE_VERSION, latest: version })
          const detected = yield* method()
          if (!detected) return yield* Effect.logWarning("automatic update skipped: installation method not found")
          yield* upgrade(detected, version)
-          yield* Ref.set(installed, version)
-          yield* Effect.logInfo("updated OpenCode", { from: current, to: version, method: detected })
+          yield* Effect.logInfo("updated OpenCode", { from: OPENCODE_VERSION, to: version, method: detected })
        })
      },
      Effect.catchCause((cause) => Effect.logWarning("automatic update failed", { cause })),
@@ -37,7 +37,7 @@
    "@opencode-ai/protocol": "workspace:*"
  },
  "peerDependencies": {
-    "effect": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.111",
    "solid-js": ">=1.9.0"
  },
  "peerDependenciesMeta": {
@@ -183,7 +183,6 @@ export type SessionCreateInput = {
  readonly agent?: Agent.ID | undefined
  readonly model?: Model.Ref | undefined
  readonly location?: Location.Ref | undefined
-  readonly metadata?: Session.Metadata | undefined
 }
 export type SessionCreateOutput = Session.Info
 export type SessionCreateOperation<E = never> = (input?: SessionCreateInput) => Effect.Effect<SessionCreateOutput, E>
@@ -411,7 +410,6 @@ export type SessionLogOutput =
            readonly title?: string | undefined
            readonly agent?: Agent.ID | undefined
            readonly model?: Model.Ref | undefined
-            readonly metadata?: Session.Metadata | undefined
            readonly version: string
          }
        }
@@ -360,7 +360,6 @@ const EndpointSessionCreate = (raw: RawClient["server.session"]) => (input?: Ses
        agent: input?.["agent"],
        model: input?.["model"],
        location: input?.["location"],
-        metadata: input?.["metadata"],
      },
    }).pipe(
      Effect.mapError(mapClientError),
@@ -513,7 +513,6 @@ export function make(options: ClientOptions) {
              agent: input?.["agent"],
              model: input?.["model"],
              location: input?.["location"],
-              metadata: input?.["metadata"],
            },
            successStatus: 200,
            declaredStatuses: [401, 400],
@@ -29,8 +29,6 @@ export type TokenUsageInfo = {

 export type LocationRef = { directory: string; workspaceID?: string }

-export type SessionMetadata = { [x: string]: JsonValue }
-
 export type FileDiffInfo = {
  file: string
  patch: string
@@ -550,7 +548,6 @@ export type SessionCreated = {
    title?: string
    agent?: string
    model?: ModelRef
-    metadata?: SessionMetadata
    version: string
  }
 }
@@ -1645,7 +1642,6 @@ export type SessionInfo = {
  title?: string
  location: LocationRef
  subpath?: string
-  metadata?: SessionMetadata
  revert?: SessionRevert
 }

@@ -2691,7 +2687,6 @@ export type SessionCreateInput = {
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
  }["id"]
  readonly title?: {
    readonly id?: string | null
@@ -2699,7 +2694,6 @@ export type SessionCreateInput = {
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
  }["title"]
  readonly agent?: {
    readonly id?: string | null
@@ -2707,7 +2701,6 @@ export type SessionCreateInput = {
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
  }["agent"]
  readonly model?: {
    readonly id?: string | null
@@ -2715,7 +2708,6 @@ export type SessionCreateInput = {
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
  }["model"]
  readonly location?: {
    readonly id?: string | null
@@ -2723,16 +2715,7 @@ export type SessionCreateInput = {
    readonly agent?: string | null
    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
  }["location"]
-  readonly metadata?: {
-    readonly id?: string | null
-    readonly title?: string | null
-    readonly agent?: string | null
-    readonly model?: { readonly id: string; readonly providerID: string; readonly variant?: string } | null
-    readonly location?: { readonly directory: string; readonly workspaceID?: string } | null
-    readonly metadata?: { readonly [x: string]: JsonValue } | null
-  }["metadata"]
 }

 export type SessionCreateOutput = { data: SessionInfo }["data"]
@@ -2769,7 +2752,6 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
-      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3046,7 +3028,6 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
-      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3323,7 +3304,6 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
-      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -12,9 +12,7 @@ import { AbsolutePath } from "../src/schema"
 const args = process.argv.slice(2)
 const iterationsIndex = args.indexOf("--iterations")
 const iterations = iterationsIndex === -1 ? 10 : Number(args[iterationsIndex + 1])
-const directory =
-  args.find((arg, index) => !arg.startsWith("--") && (iterationsIndex === -1 || index !== iterationsIndex + 1)) ??
-  process.cwd()
+const directory = args.find((arg, index) => !arg.startsWith("--") && index !== iterationsIndex + 1) ?? process.cwd()

 if (!Number.isInteger(iterations) || iterations < 1) {
  console.error("--iterations must be a positive integer")
@@ -514,7 +514,7 @@ function userPart(part: ContentPart): UserContent {
 function assistantPart(part: ContentPart): AssistantContent {
  switch (part.type) {
    case "text":
-      return [{ type: "text", text: part.text, providerOptions: metadataProviderOptions(part.providerMetadata) }]
+      return [{ type: "text", text: part.text }]
    case "media":
      return [{ type: "file", mediaType: part.mediaType, data: part.data, filename: part.filename }]
    case "reasoning":
@@ -3,7 +3,7 @@ export * as CodeModeTool from "./tool.js"
 import { CodeMode, Tool, toolError } from "@opencode-ai/codemode"
 import type { Content, Context, Error, Info, Metadata, Result } from "@opencode-ai/schema/tool"
 import { Effect, Ref, Schema, Semaphore } from "effect"
-import { definition, normalizedName } from "../tool/runtime.js"
+import { definition } from "../tool/runtime.js"

 const ExecuteFile = Schema.Struct({
  data: Schema.String,
@@ -165,7 +165,7 @@ function runtime(
 }

 function qualifiedName(registration: Info) {
-  const normalized = normalizedName(registration)
+  const normalized = registration.name.replace(/[^a-zA-Z0-9_-]/g, "_")
  if (registration.options?.namespace === undefined) return normalized
  return `${registration.options.namespace}.${normalized}`
 }
@@ -53,9 +53,6 @@ export class UpdateError extends Schema.TaggedError<UpdateError>()("Config.Updat

 export const Options = Schema.Struct({
  project: Schema.optional(Schema.Boolean),
-  // false skips the global config dir, ~/.claude, and ~/.agents; wellknown,
-  // file, and content entries still load.
-  global: Schema.optional(Schema.Boolean),
  file: Schema.optional(Schema.String),
  content: Schema.optional(Schema.String),
 })
@@ -84,13 +81,12 @@ export const testLayer = (initial: Entry[] = []) =>
          Effect.gen(function* () {
            const current = yield* Ref.get(entries)
            const index = current.findIndex((entry) => entry.type === "document" && entry.path !== undefined)
+            if (index === -1)
+              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
            const entry = current[index]
            if (!entry || entry.type !== "document")
              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const info = yield* Effect.try({
-              try: () => produce(entry.info, update),
-              catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
-            })
+            const info = produce(entry.info, update)
            yield* Ref.set(entries, current.with(index, new Document({ type: "document", path: entry.path, info })))
            return info
          }),
@@ -223,39 +219,28 @@ export const layer = (options?: Options) =>
                })
                .pipe(Effect.orDie)

-        const globalEnabled = options?.global !== false
-        // A walked path that resolves into a global root is global config
-        // however the walk reached it (home above the project, or a location
-        // beneath the global config dir), so global: false excludes it
-        // uniformly — classified once here, not per consumer below.
-        const globalRoots = [globalDirectory, globalClaudeDirectory, globalAgentsDirectory].map((item) =>
-          path.resolve(item),
-        )
-        const visible = globalEnabled
-          ? discovered
-          : discovered.filter((item) => {
-              const resolved = path.resolve(item)
-              return !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
-            })
        // We load certain files from a few other folders in the ecosystem
        const claude = [
          ...new Set([
-            ...(globalEnabled && (yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : []),
-            ...visible.filter((item) => path.basename(item) === ".claude").toReversed(),
+            ...((yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : []),
+            ...discovered.filter((item) => path.basename(item) === ".claude").toReversed(),
          ]),
        ].map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) }))
        const agents = [
          ...new Set([
-            ...(globalEnabled && (yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : []),
-            ...visible.filter((item) => path.basename(item) === ".agents").toReversed(),
+            ...((yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : []),
+            ...discovered.filter((item) => path.basename(item) === ".agents").toReversed(),
          ]),
        ].map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) }))

-        const projectDirectories = visible
-          .filter((item) => path.basename(item) === ".opencode")
-          .toReversed()
-          .map((directory) => AbsolutePath.make(directory))
-        const directPaths = visible
+        const directories = [
+          globalDirectory,
+          ...discovered
+            .filter((item) => path.basename(item) === ".opencode")
+            .toReversed()
+            .map((directory) => AbsolutePath.make(directory)),
+        ]
+        const directPaths = discovered
          .filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item)))
          .toReversed()
        fileTargets.clear()
@@ -287,21 +272,15 @@ export const layer = (options?: Options) =>
              )
            : []

-        // Global entries sit below explicit and direct files; project
-        // directories rank above them.
-        const globalSupplementary = globalEnabled ? yield* loadDirectory(globalDirectory).pipe(Effect.orDie) : []
-        const projectSupplementary = yield* Effect.forEach(projectDirectories, loadDirectory).pipe(
-          Effect.orDie,
-          Effect.map((entries) => entries.flat()),
-        )
+        const supplementary = yield* Effect.forEach(directories, loadDirectory).pipe(Effect.orDie)
        return [
          ...(yield* loadWellknown().pipe(Effect.orDie)),
          ...claude,
          ...agents,
-          ...globalSupplementary,
+          ...(supplementary[0] ?? []),
          ...explicit,
          ...direct,
-          ...projectSupplementary,
+          ...supplementary.slice(1).flat(),
          ...content,
        ]
      })
@@ -1,7 +1,6 @@
 export * as ConfigNormalize from "./normalize.js"

 import { isDeepStrictEqual } from "node:util"
-import { isRecord } from "@opencode-ai/ai/utils/record"
 import { Option, Schema } from "effect"
 import { Info } from "@opencode-ai/schema/config"
 import { ConfigAgent } from "@opencode-ai/schema/config/agent"
@@ -783,6 +782,10 @@ function isEnabledOnlyMcp(value: unknown) {
  return isRecord(value) && !own(value, "type") && typeof value.enabled === "boolean"
 }

+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
  if (!isRecord(value)) return false
  const prototype = Object.getPrototypeOf(value)
@@ -19,9 +19,6 @@ export const Plugin = define({
  id: "opencode.config.instruction",
  effect: Effect.fn(function* () {
    const discovery = yield* InstructionDiscovery.Service
-    // Nothing this plugin watches or loads can contribute when both scopes
-    // are disabled; skip the resolves, the watcher fiber, and the transform.
-    if (!discovery.project && !discovery.global) return
    yield* Effect.gen(function* () {
      const fs = yield* FSUtil.Service
      const global = yield* Global.Service
@@ -38,15 +35,9 @@ export const Plugin = define({
      const loaded: { current: Loaded } = { current: { type: "available", files: [] } }

      const publish = (update: Watcher.Update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid)
-      // The ancestor walk can reach the global file when the location sits
-      // beneath the global config dir; global: false excludes it there too.
      const candidates = [
-        ...(discovery.global ? [globalFile] : []),
-        ...(project
-          ? ancestorDirectories(start, stop)
-              .map((directory) => join(directory, "AGENTS.md"))
-              .filter((file) => discovery.global || file !== globalFile)
-          : []),
+        globalFile,
+        ...(project ? ancestorDirectories(start, stop).map((directory) => join(directory, "AGENTS.md")) : []),
      ]
      for (const path of new Set(candidates)) {
        const updates = yield* watcher.subscribe({ path, type: "file" })
@@ -60,15 +51,15 @@ export const Plugin = define({
      })

      const globalSource = Effect.fn("ConfigInstructionPlugin.globalSource")(function* () {
-        if (!discovery.global) return []
        const file = yield* read(globalFile)
        return file ? [file] : []
      })

      const projectSource = Effect.fn("ConfigInstructionPlugin.projectSource")(function* () {
        if (!project) return []
-        const walked = yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve)
-        const discovered = new Set(walked.filter((file) => discovery.global || file !== globalFile))
+        const discovered = new Set(
+          yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve),
+        )
        const files = yield* Effect.forEach(discovered, read, { concurrency: "unbounded" })
        if (files.some((file) => file === undefined)) return Instructions.unavailable
        return files.filter((file): file is InstructionDiscovery.File => file !== undefined)
@@ -1,11 +1,11 @@
-export * as ConfigMcpPlugin from "./mcp.js"
+export * as ConfigMCPPlugin from "./mcp.js"

 import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Document, type Entry } from "@opencode-ai/schema/config"
-import type { ServerConfig } from "@opencode-ai/schema/mcp"
+import { Mcp } from "@opencode-ai/schema/mcp"
 import { Effect, Stream } from "effect"
 import { Config } from "../../config.js"
-import { Mcp } from "../../mcp/index.js"
+import { MCP } from "../../mcp/index.js"

 export const Plugin = define({
  id: "opencode.config.mcp",
@@ -18,7 +18,7 @@ export const register = Effect.fn("ConfigMCPPlugin.register")(function* (
  events: Stream.Stream<{ readonly type: string }, unknown>,
 ) {
  const config = yield* Config.Service
-  const mcp = yield* Mcp.Service
+  const mcp = yield* MCP.Service
  const loaded = { entries: [] as Entry[] }

  yield* events.pipe(
@@ -43,7 +43,7 @@ export const register = Effect.fn("ConfigMCPPlugin.register")(function* (
      {},
      ...documents.flatMap((entry) => (entry.info.mcp?.timeout ? [entry.info.mcp.timeout] : [])),
    )
-    const servers = new Map<string, ServerConfig>()
+    const servers = new Map<string, Mcp.ServerConfig>()
    for (const document of documents) {
      for (const [name, server] of Object.entries(document.info.mcp?.servers ?? {})) {
        servers.set(name, { ...server, timeout: { ...timeout, ...server.timeout } })
@@ -5,7 +5,7 @@ import path from "path"
 import { Clock, Context, Deferred, Duration, Effect, Layer, Schema, Scope } from "effect"
 import { Fff } from "#fff"
 import fuzzysort from "fuzzysort"
-import { FileSystem } from "@opencode-ai/schema/filesystem"
+import { FileSystem } from "../filesystem.js"
 import { Location } from "../location.js"
 import { Ripgrep } from "../ripgrep.js"
 import { RelativePath } from "../schema.js"
@@ -7,16 +7,16 @@ import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect"
 import { lazy } from "../util/lazy.js"
-import { watch } from "node:fs"
+import { watch as watchFileSystem } from "node:fs"
 import path from "path"
 import loadBinding from "./watcher-binding.js"

 const SUBSCRIBE_TIMEOUT_MS = 10_000
 export const Event = { Updated: FileSystem.Event.Changed }

-const watcher = lazy((): typeof ParcelWatcher | undefined => {
+const watcher = lazy((): typeof import("@parcel/watcher") | undefined => {
  try {
-    return createWrapper(loadBinding()) as typeof ParcelWatcher
+    return createWrapper(loadBinding()) as typeof import("@parcel/watcher")
  } catch {
    return
  }
@@ -192,7 +192,7 @@ export const nativeLayer = Layer.succeed(
      if (input.type === "file") {
        return Effect.sync(() => {
          const directory = path.dirname(input.target)
-          const subscription = watch(directory, { recursive: false }, (_event, file) => {
+          const subscription = watchFileSystem(directory, { recursive: false }, (_event, file) => {
            if (file && path.resolve(directory, file.toString()) !== input.target) return
            input.publish({ path: input.target, type: "update" } satisfies Update)
          })
@@ -218,7 +218,7 @@ export function configured(options?: Options) {
 export const node = configured()

 function subscribeDirectory(
-  native: typeof ParcelWatcher | undefined,
+  native: typeof import("@parcel/watcher") | undefined,
  backend: ParcelWatcher.BackendType | undefined,
  directory: string,
  ignore: readonly string[],
@@ -311,7 +311,7 @@ function validateField(field: InputField, value: Form.Value): string | undefined
    }
    if (field.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
      return `Expected email for form field: ${field.key}`
-    if (field.format === "uri" && !URL.canParse(value)) return `Expected URI for form field: ${field.key}`
+    if (field.format === "uri" && !isUri(value)) return `Expected URI for form field: ${field.key}`
    if (field.format === "date" && !isDate(value)) return `Expected date for form field: ${field.key}`
    if (field.format === "date-time" && !isDateTime(value)) return `Expected date-time for form field: ${field.key}`
    if (field.options && !field.custom && !field.options.some((option) => option.value === value)) {
@@ -347,6 +347,15 @@ function isStringArray(value: Form.Value): value is ReadonlyArray<string> {
  return Array.isArray(value) && value.every((item): item is string => typeof item === "string")
 }

+function isUri(value: string) {
+  try {
+    new URL(value)
+    return true
+  } catch {
+    return false
+  }
+}
+
 function isDate(value: string) {
  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false
  const date = new Date(`${value}T00:00:00.000Z`)
@@ -37,19 +37,20 @@ export const layer = Layer.effect(

    const runText = Effect.fn("Generate.text")(function* (input: TextInput) {
      const resolved = yield* resolver.resolve(input.model).pipe(
-        Effect.catchTag(
-          [
-            "SessionRunnerModel.VariantUnavailableError",
-            "SessionRunnerModel.UnsupportedPackageError",
-            "SessionRunnerModel.UnresolvedProviderVariablesError",
-          ],
-          (error) => {
-            const mapped: Error = input.model
+        Effect.catchTags({
+          "SessionRunnerModel.VariantUnavailableError": (error) =>
+            input.model
              ? new ModelSelectionError({ message: error.message })
-              : new UnavailableError({ message: error.message, service: error.providerID })
-            return Effect.fail(mapped)
-          },
-        ),
+              : new UnavailableError({ message: error.message, service: error.providerID }),
+          "SessionRunnerModel.UnsupportedPackageError": (error) =>
+            input.model
+              ? new ModelSelectionError({ message: error.message })
+              : new UnavailableError({ message: error.message, service: error.providerID }),
+          "SessionRunnerModel.UnresolvedProviderVariablesError": (error) =>
+            input.model
+              ? new ModelSelectionError({ message: error.message })
+              : new UnavailableError({ message: error.message, service: error.providerID }),
+        }),
      )
      if (!resolved)
        return yield* new ModelSelectionError({
@@ -330,6 +330,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {

    const toolCalls: Array<{
      id: string
+      type: "function"
      function: {
        name: string
        arguments: string
@@ -559,6 +560,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV3 {

                  toolCalls[index] = {
                    id: toolCallDelta.id,
+                    type: "function",
                    function: {
                      name: toolCallDelta.function.name,
                      arguments: toolCallDelta.function.arguments ?? "",
@@ -1,4 +1,9 @@
-import { type LanguageModelV3Prompt, type SharedV3Warning, UnsupportedFunctionalityError } from "@ai-sdk/provider"
+import {
+  type LanguageModelV3Prompt,
+  type LanguageModelV3ToolCallPart,
+  type SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
 import { convertToBase64, parseProviderOptions } from "@ai-sdk/provider-utils"
 import { z } from "zod/v4"
 import type { OpenAIResponsesInput, OpenAIResponsesReasoning } from "./openai-responses-api-types.js"
@@ -111,6 +116,7 @@ export async function convertToOpenAIResponsesInput({

      case "assistant": {
        const reasoningMessages: Record<string, OpenAIResponsesReasoning> = {}
+        const toolCallParts: Record<string, LanguageModelV3ToolCallPart> = {}

        for (const part of content) {
          switch (part.type) {
@@ -123,6 +129,8 @@ export async function convertToOpenAIResponsesInput({
              break
            }
            case "tool-call": {
+              toolCallParts[part.toolCallId] = part
+
              if (part.providerExecuted) {
                break
              }
@@ -16,7 +16,7 @@ export const openaiErrorDataSchema = z.object({

 export type OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>

-export const openaiFailedResponseHandler = createJsonErrorResponseHandler({
+export const openaiFailedResponseHandler: any = createJsonErrorResponseHandler({
  errorSchema: openaiErrorDataSchema,
  errorToMessage: (data) => data.error.message,
 })
@@ -792,6 +792,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
    const ongoingToolCalls: Record<
      number,
      | {
+          toolName: string
          toolCallId: string
          codeInterpreter?: {
            containerId: string
@@ -850,6 +851,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
            if (isResponseOutputItemAddedChunk(value)) {
              if (value.item.type === "function_call") {
                ongoingToolCalls[value.output_index] = {
+                  toolName: value.item.name,
                  toolCallId: value.item.call_id,
                }

@@ -860,6 +862,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                })
              } else if (value.item.type === "web_search_call") {
                ongoingToolCalls[value.output_index] = {
+                  toolName: webSearchToolName ?? "web_search",
                  toolCallId: value.item.id,
                }

@@ -870,6 +873,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                })
              } else if (value.item.type === "computer_call") {
                ongoingToolCalls[value.output_index] = {
+                  toolName: "computer_use",
                  toolCallId: value.item.id,
                }

@@ -880,6 +884,7 @@ export class OpenAIResponsesLanguageModel implements LanguageModelV3 {
                })
              } else if (value.item.type === "code_interpreter_call") {
                ongoingToolCalls[value.output_index] = {
+                  toolName: "code_interpreter",
                  toolCallId: value.item.id,
                  codeInterpreter: {
                    containerId: value.item.container_id,
@@ -47,7 +47,7 @@ export function prepareResponsesTools({
          name: tool.name,
          description: tool.description,
          parameters: tool.inputSchema,
-          strict: tool.strict ?? strictJsonSchema,
+          strict: strictJsonSchema,
        })
        break
      case "provider": {
@@ -1,170 +0,0 @@
-import { Effect, Layer } from "effect"
-import { Agent } from "./agent.js"
-import { AISDK } from "./aisdk.js"
-import { Catalog } from "./catalog.js"
-import { Command } from "./command.js"
-import { Config } from "./config.js"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Node } from "@opencode-ai/util/effect/app-node"
-import { FileMutation } from "./file-mutation.js"
-import { Environment } from "./environment/index.js"
-import { Formatter } from "./formatter.js"
-import { FileSystem } from "./filesystem.js"
-import { FileSystemSearch } from "./filesystem/search.js"
-import { Generate } from "./generate.js"
-import { Form } from "./form.js"
-import { Image } from "./image.js"
-import { LocationWatcher } from "./filesystem/location-watcher.js"
-import { Integration } from "./integration.js"
-import { Location } from "./location.js"
-import { LocationMutation } from "./location-mutation.js"
-import { ModelResolver } from "./model-resolver.js"
-import { Mcp } from "./mcp/index.js"
-import { Permission } from "./permission.js"
-import { Plugin } from "./plugin.js"
-import { PluginHooks } from "./plugin/hooks.js"
-import { InstancePlugins } from "./plugin/instance.js"
-import { PluginSupervisor } from "./plugin/supervisor.js"
-import { Worktree } from "./worktree.js"
-import { Pty } from "./pty.js"
-import { Shell } from "./shell.js"
-import { ShellSelect } from "./shell/select.js"
-import { Reference } from "./reference.js"
-import { WebSearch } from "./websearch.js"
-import { ReferenceInstructions } from "./reference/instructions.js"
-import { SessionRunnerLLM } from "./session/runner/llm.js"
-import { SessionRunnerModel } from "./session/runner/model.js"
-import { SessionModelTransport } from "./session/model-transport.js"
-import { SessionCompaction } from "./session/compaction.js"
-import { SessionTitle } from "./session/title.js"
-import { Skill } from "./skill.js"
-import { SkillInstructions } from "./skill/instructions.js"
-import { Snapshot } from "./snapshot.js"
-import { InstructionDiscovery } from "./instruction-discovery.js"
-import { InstructionBuiltIns } from "./instructions/builtins.js"
-import { InstructionEntry } from "./session/instruction-entry.js"
-import { SessionInstructions } from "./session/instructions.js"
-import { SessionGenerateNode } from "./session/generate-node.js"
-import { McpTool } from "./tool/mcp.js"
-import { ReadToolFileSystem } from "./tool/read-filesystem.js"
-import { Tool } from "./tool.js"
-import { ToolOutput } from "./tool-output.js"
-import { Vcs } from "./vcs.js"
-
-export * as Instance from "./instance.js"
-
-const nodes = [
-  Location.node,
-  Environment.node,
-  Config.node,
-  Agent.node,
-  Command.node,
-  Reference.node,
-  WebSearch.node,
-  Integration.node,
-  Catalog.node,
-  ModelResolver.node,
-  AISDK.node,
-  Plugin.node,
-  PluginHooks.node,
-  InstancePlugins.node,
-  PluginSupervisor.node,
-  Worktree.refreshNode,
-  FileSystemSearch.node,
-  FileSystem.node,
-  ShellSelect.node,
-  Pty.node,
-  Shell.node,
-  Skill.node,
-  InstructionBuiltIns.node,
-  InstructionDiscovery.node,
-  LocationMutation.node,
-  FileMutation.node,
-  Formatter.node,
-  Mcp.node,
-  Permission.node,
-  Tool.node,
-  ToolOutput.node,
-  Image.node,
-  SkillInstructions.node,
-  ReferenceInstructions.node,
-  InstructionEntry.node,
-  Form.node,
-  Generate.node,
-  SessionGenerateNode.node,
-  ReadToolFileSystem.node,
-  McpTool.node,
-  SessionInstructions.node,
-  SessionRunnerModel.node,
-  SessionModelTransport.node,
-  SessionCompaction.node,
-  SessionTitle.node,
-  Snapshot.node,
-  SessionRunnerLLM.node,
-  Vcs.node,
-  // Start repository watches only after boot-critical filesystem and Git work.
-  LocationWatcher.node,
-] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
-
-export const graph = LayerNode.group<typeof nodes>(nodes)
-
-export type Services = LayerNode.Output<typeof graph>
-export type Error = LayerNode.Error<typeof graph>
-
-export interface Options {
-  // Plugins this instance is born with; empty and absent are equivalent.
-  readonly plugins?: InstancePlugins.List
-  // Filesystem config discovery; true (default) is today's behavior. When
-  // false the instance boots vanilla: no upward config scan, no global config
-  // dir, no plugin-dir loading or ambient plugin module imports, no boot-time
-  // AGENTS.md discovery. Wellknown integration config and host-injected values
-  // still apply, and a config value that explicitly names something
-  // file-backed (a skill path, an MCP command) is a request, not discovery.
-  // Use-triggered behavior also stays: reading a file still injects nested
-  // AGENTS.md instructions — that is session-time context, not boot-time
-  // population.
-  readonly discovery?: boolean
-  readonly replacements?: LayerNode.Replacements
-}
-
-// Vanilla neutralizes the discovery inputs; the plugin list stays untouched.
-// These are defaults ahead of caller replacements: a host that replaces a
-// gated node itself owns that node's discovery flags. Plugin-directory
-// discovery needs no swap here — implicit scanning only triggers on Directory
-// config entries, which a no-scan Config never produces, and the default
-// source still honors explicit plugin operations from wellknown and
-// host-injected config.
-const vanillaReplacements: LayerNode.Replacements = [
-  [Config.node, Config.configured({ project: false, global: false })],
-  [InstructionDiscovery.node, InstructionDiscovery.configured({ project: false, global: false })],
-]
-
-// One instance is one compiled, fresh copy of the graph standing on a directory.
-export function layer(ref: Location.Ref, options: Options = {}) {
-  const startedAt = performance.now()
-  // Ordered: vanilla defaults, then caller replacements (which win over the
-  // defaults), then bound pairs (which win over everything).
-  const allReplacements: LayerNode.Replacements = [
-    ...(options.discovery === false ? vanillaReplacements : []),
-    ...(options.replacements ?? []),
-    [Location.node, Location.boundNode(ref, { discovery: options.discovery })],
-    [InstancePlugins.node, InstancePlugins.bound(options.plugins ?? [])],
-  ]
-  // Apply replacements during hoist, not afterward: replacements can
-  // introduce new tagged dependencies (Location.boundNode depends on
-  // Project), and the hoist walk is the only pass that can still slice
-  // those back out.
-  const location = LayerNode.hoist(graph, Node.tags.values.global, allReplacements)
-
-  return LayerNode.compile(location.node).pipe(
-    Layer.fresh,
-    Layer.tap(() =>
-      Effect.logInfo("location services booted", {
-        directory: ref.directory,
-        workspaceID: ref.workspaceID,
-        durationMs: Math.round(performance.now() - startedAt),
-      }),
-    ),
-    Layer.provide(LayerNode.compile(location.hoisted)),
-  )
-}
@@ -39,14 +39,12 @@ export interface Interface extends State.Transformable<Draft> {
  // Discovery policy lives here because internal plugins have no per-composition options channel.
  // Move it into plugin config once plugins can consume their own options.
  readonly project: boolean
-  readonly global: boolean
  readonly list: () => Effect.Effect<File[] | Instructions.Unavailable>
  readonly load: () => Effect.Effect<Instructions.List>
 }

 export const Options = Schema.Struct({
  project: Schema.optional(Schema.Boolean),
-  global: Schema.optional(Schema.Boolean),
 })
 export type Options = typeof Options.Type

@@ -97,7 +95,6 @@ export const layer = (options?: Options) =>

      return Service.of({
        project: options?.project !== false,
-        global: options?.global !== false,
        transform: state.transform,
        reload: state.reload,
        list,
@@ -719,7 +719,16 @@ const layer = Layer.effect(
            }),
          })
        }),
-        activate: Effect.fn("Integration.connection.activate")((credentialID) => credentials.activate(credentialID)),
+        activate: Effect.fn("Integration.connection.activate")(function* (credentialID) {
+          const credential = yield* credentials.get(credentialID)
+          if (!credential) return
+          const active = resolveConnections(
+            state.get().integrations.get(credential.integrationID),
+            yield* credentials.list(credential.integrationID),
+          )[0]
+          if (active?.type === "credential" && active.id === credentialID) return
+          yield* credentials.activate(credentialID)
+        }),
        update: Effect.fn("Integration.connection.update")((credentialID, updates) =>
          credentials.update(credentialID, updates),
        ),
@@ -16,8 +16,7 @@ export type Kind = typeof Kind.Type
 /**
 * Mutation paths do not accept project references. A leading `~` expands to
 * the home directory; other relative paths resolve from the active Location.
- * Paths outside it and its non-root project worktree require separate
- * `external_directory` approval.
+ * Paths outside it require separate `external_directory` approval.
 */
 export const ResolveInput = Schema.Struct({
  path: Schema.String,
@@ -53,24 +52,22 @@ export interface Interface {
  /**
   * Resolve a path and derive its permission resources. A leading `~` expands
   * to the home directory; other relative paths resolve from the Location.
-   * Paths outside it and its non-root project worktree require separate
-   * `external_directory` approval. This does not approve the mutation.
+   * Paths outside it require separate `external_directory` approval. This does
+   * not approve the mutation.
   */
  readonly resolve: (input: ResolveInput) => Effect.Effect<Target, FSUtil.Error>
 }

-/** Lexical absolute path, normalizing Windows shell paths and expanding `~` before resolution. */
-export const resolvePath = (directory: string, input: string, home = Global.Path.home) => {
-  const normalized = FSUtil.windowsPath(input)
-  return path.resolve(
+/** Lexical absolute path, expanding a leading `~` before resolving against `directory`. */
+export const resolvePath = (directory: string, input: string, home = Global.Path.home) =>
+  path.resolve(
    directory,
-    normalized === "~"
+    input === "~"
      ? home
-      : normalized.startsWith("~/") || (process.platform === "win32" && normalized.startsWith("~\\"))
-        ? path.join(home, normalized.slice(2))
-        : normalized,
+      : input.startsWith("~/") || (process.platform === "win32" && input.startsWith("~\\"))
+        ? path.join(home, input.slice(2))
+        : input,
  )
-}

 export class Service extends Context.Service<Service, Interface>()("@opencode/LocationMutation") {}

@@ -85,11 +82,7 @@ const layer = Layer.effect(

    const resolve = Effect.fnUntraced(function* (input: ResolveInput) {
      const absolute = resolvePath(location.directory, input.path)
-      const worktree = path.resolve(location.project.directory)
-      const internal =
-        FSUtil.contains(location.directory, absolute) ||
-        (worktree !== path.parse(worktree).root && FSUtil.contains(worktree, absolute))
-      if (internal) {
+      if (FSUtil.contains(location.directory, absolute)) {
        return {
          absolute,
          resource: slash(path.relative(location.directory, absolute) || "."),
@@ -127,6 +120,6 @@ const layer = Layer.effect(

 export const node = makeLocationNode({
  service: Service,
-  layer,
+  layer: layer.pipe(Layer.orDie),
  deps: [FSUtil.node, Location.node, ProjectMarkers.node],
 })
@@ -2,11 +2,11 @@ import { Context, Effect, Layer, LayerMap } from "effect"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Node } from "@opencode-ai/util/effect/app-node"
 import { Location } from "./location.js"
-import type { Instance } from "./instance.js"
+import type { LocationError, LocationServices } from "./location-services.js"

 export class Service extends Context.Service<
  Service,
-  LayerMap.LayerMap<Location.Ref, Instance.Services, Instance.Error>
+  LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>
 >()("@opencode/example/LocationServiceMap") {
  static get(ref: Location.Ref) {
    return Layer.unwrap(Effect.map(Service, (locations) => locations.get(ref)))
@@ -1,16 +1,118 @@
 import { Duration, Effect, Layer, LayerMap } from "effect"
 import { existsSync } from "fs"
 import path from "path"
+import { Agent } from "./agent.js"
+import { AISDK } from "./aisdk.js"
+import { Catalog } from "./catalog.js"
+import { Command } from "./command.js"
+import { Config } from "./config.js"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Instance } from "./instance.js"
+import { Node } from "@opencode-ai/util/effect/app-node"
+import { Bus } from "./bus.js"
+import { FileMutation } from "./file-mutation.js"
+import { Environment } from "./environment/index.js"
+import { Formatter } from "./formatter.js"
+import { FileSystem } from "./filesystem.js"
+import { FileSystemSearch } from "./filesystem/search.js"
+import { Generate } from "./generate.js"
+import { Form } from "./form.js"
+import { Image } from "./image.js"
+import { LocationWatcher } from "./filesystem/location-watcher.js"
+import { Integration } from "./integration.js"
 import { Location } from "./location.js"
+import { LocationMutation } from "./location-mutation.js"
 import { LocationServiceMap } from "./location-service-map.js"
+import { ModelResolver } from "./model-resolver.js"
+import { MCP } from "./mcp/index.js"
+import { Permission } from "./permission.js"
+import { Plugin } from "./plugin.js"
+import { PluginHooks } from "./plugin/hooks.js"
+import { PluginSupervisor } from "./plugin/supervisor.js"
+import { Worktree } from "./worktree.js"
+import { Pty } from "./pty.js"
+import { Shell } from "./shell.js"
+import { ShellSelect } from "./shell/select.js"
+import { Reference } from "./reference.js"
+import { WebSearch } from "./websearch.js"
+import { ReferenceInstructions } from "./reference/instructions.js"
+import { SessionRunnerLLM } from "./session/runner/llm.js"
+import { SessionRunnerModel } from "./session/runner/model.js"
+import { SessionModelTransport } from "./session/model-transport.js"
+import { SessionCompaction } from "./session/compaction.js"
+import { SessionTitle } from "./session/title.js"
+import { Skill } from "./skill.js"
+import { SkillInstructions } from "./skill/instructions.js"
+import { Snapshot } from "./snapshot.js"
+import { InstructionDiscovery } from "./instruction-discovery.js"
+import { InstructionBuiltIns } from "./instructions/builtins.js"
+import { InstructionEntry } from "./session/instruction-entry.js"
+import { SessionInstructions } from "./session/instructions.js"
+import { SessionGenerateNode } from "./session/generate-node.js"
+import { McpTool } from "./tool/mcp.js"
+import { ReadToolFileSystem } from "./tool/read-filesystem.js"
+import { Tool } from "./tool.js"
+import { ToolOutput } from "./tool-output.js"
+import { Vcs } from "./vcs.js"
 import { AbsolutePath } from "./schema.js"

 export { LocationServiceMap } from "./location-service-map.js"

-export type LocationServices = Instance.Services
-export type LocationError = Instance.Error
+const locationServiceNodes = [
+  Location.node,
+  Environment.node,
+  Config.node,
+  Agent.node,
+  Command.node,
+  Reference.node,
+  WebSearch.node,
+  Integration.node,
+  Catalog.node,
+  ModelResolver.node,
+  AISDK.node,
+  Plugin.node,
+  PluginHooks.node,
+  PluginSupervisor.node,
+  Worktree.refreshNode,
+  FileSystemSearch.node,
+  FileSystem.node,
+  ShellSelect.node,
+  Pty.node,
+  Shell.node,
+  Skill.node,
+  InstructionBuiltIns.node,
+  InstructionDiscovery.node,
+  LocationMutation.node,
+  FileMutation.node,
+  Formatter.node,
+  MCP.node,
+  Permission.node,
+  Tool.node,
+  ToolOutput.node,
+  Image.node,
+  SkillInstructions.node,
+  ReferenceInstructions.node,
+  InstructionEntry.node,
+  Form.node,
+  Generate.node,
+  SessionGenerateNode.node,
+  ReadToolFileSystem.node,
+  McpTool.node,
+  SessionInstructions.node,
+  SessionRunnerModel.node,
+  SessionModelTransport.node,
+  SessionCompaction.node,
+  SessionTitle.node,
+  Snapshot.node,
+  SessionRunnerLLM.node,
+  Vcs.node,
+  // Start repository watches only after boot-critical filesystem and Git work.
+  LocationWatcher.node,
+] as const satisfies readonly Node.LocationNode<unknown, unknown>[]
+
+export const locationServices = LayerNode.group<typeof locationServiceNodes>(locationServiceNodes)
+
+export type LocationServices = LayerNode.Output<typeof locationServices>
+export type LocationError = LayerNode.Error<typeof locationServices>

 export function buildLocationServiceMap(
  replacements: LayerNode.Replacements = [],
@@ -25,14 +127,37 @@ export function buildLocationServiceMap(
  return Layer.effect(
    LocationServiceMap.Service,
    Effect.map(
-      LayerMap.make((ref: Location.Ref) => Instance.layer(ref, { replacements }), {
-        // Workspace-placed directories exist only inside the workspace, so a
-        // local stat consults the wrong filesystem. Workspace liveness is
-        // owned by placement; do not probe the sandbox here, which would
-        // provision lazily-idle workspaces.
-        idleTimeToLive: (ref) =>
-          ref.workspaceID !== undefined || existsSync(ref.directory) ? Duration.infinity : Duration.zero,
-      }),
+      LayerMap.make(
+        (ref: Location.Ref) => {
+          const startedAt = performance.now()
+          const allReplacements = replacements.concat([[Location.node, Location.boundNode(ref)]])
+          // Apply replacements during hoist, not afterward: replacements can
+          // introduce new tagged dependencies (Location.boundNode depends on
+          // Project), and the hoist walk is the only pass that can still slice
+          // those back out.
+          const location = LayerNode.hoist(locationServices, Node.tags.values.global, allReplacements)
+
+          return LayerNode.compile(location.node).pipe(
+            Layer.fresh,
+            Layer.tap(() =>
+              Effect.logInfo("location services booted", {
+                directory: ref.directory,
+                workspaceID: ref.workspaceID,
+                durationMs: Math.round(performance.now() - startedAt),
+              }),
+            ),
+            Layer.provide(LayerNode.compile(location.hoisted)),
+          )
+        },
+        {
+          // Workspace-placed directories exist only inside the workspace, so a
+          // local stat consults the wrong filesystem. Workspace liveness is
+          // owned by placement; do not probe the sandbox here, which would
+          // provision lazily-idle workspaces.
+          idleTimeToLive: (ref) =>
+            ref.workspaceID !== undefined || existsSync(ref.directory) ? Duration.infinity : Duration.zero,
+        },
+      ),
      (inner) => ({
        ...inner,
        get: (ref: Location.Ref) => inner.get(canonical(ref)),
@@ -17,12 +17,12 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Lo

 export const node = LayerNode.unbound(Service, tags.values.location)

-const layer = (ref: Ref, options?: { readonly discovery?: boolean }) =>
+const layer = (ref: Ref) =>
  Layer.effect(
    Service,
    Effect.gen(function* () {
      const project = yield* Project.Service
-      const resolved = yield* project.resolve(ref.directory, options)
+      const resolved = yield* project.resolve(ref.directory)
      return Service.of({
        directory: ref.directory,
        workspaceID: ref.workspaceID,
@@ -33,9 +33,9 @@ const layer = (ref: Ref, options?: { readonly discovery?: boolean }) =>
    }),
  )

-export const boundNode = (ref: Ref, options?: { readonly discovery?: boolean }) =>
+export const boundNode = (ref: Ref) =>
  makeLocationNode({
    service: Service,
-    layer: layer(ref, options),
+    layer: layer(ref),
    deps: [Project.node],
  })
@@ -1,4 +1,4 @@
-export * as McpClient from "./client.js"
+export * as MCPClient from "./client.js"

 import path from "node:path"
 import { pathToFileURL } from "node:url"
@@ -29,7 +29,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js"
 import { Cause, Effect, Exit, Schema } from "effect"
 import { ConfigMCP } from "@opencode-ai/schema/config/mcp"
-import { McpStdio } from "./stdio.js"
+import { MCPStdio } from "./stdio.js"

 const DEFAULT_STARTUP_TIMEOUT = 30_000
 const DEFAULT_CATALOG_TIMEOUT = 30_000
@@ -222,7 +222,7 @@ export const connect = Effect.fnUntraced(function* (
  const exit = yield* Effect.gen(function* () {
    if (config.type === "local") {
      const [command, ...args] = config.command
-      const transport = yield* McpStdio.make({
+      const transport = yield* MCPStdio.make({
        server,
        command,
        args,
@@ -1,4 +1,4 @@
-export * as Mcp from "./index.js"
+export * as MCP from "./index.js"

 import { Mcp } from "@opencode-ai/schema/mcp"
 import { McpEvent } from "@opencode-ai/schema/mcp-event"
@@ -16,7 +16,7 @@ import { KeyedMutex } from "../effect/keyed-mutex.js"
 import { Location } from "../location.js"
 import { waitForAbort } from "@opencode-ai/util/process"
 import { State } from "../state.js"
-import type { McpClient } from "./client.js"
+import type { MCPClient } from "./client.js"

 export const ServerName = Schema.String.pipe(Schema.brand("MCP.ServerName"))
 export const PromptsChanged = ephemeral({ type: "mcp.prompts.changed", schema: { server: Schema.String } })
@@ -114,7 +114,7 @@ type ServerEntry = {
  status: Status
  readonly startup: Latch.Latch
  scope?: Scope.Closeable
-  client?: McpClient.Connection
+  client?: MCPClient.Connection
  tools?: ReadonlyArray<Tool>
  prompts?: ReadonlyArray<Prompt>
  // Set when a remote server is registered as an OAuth integration; the credential lives in the global store.
@@ -235,8 +235,8 @@ export const layer = (options?: Options) =>
              method: { id: methodID, type: "oauth", label: name },
              authorize: () =>
                Effect.gen(function* () {
-                  const { McpOAuth } = yield* Effect.promise(() => import("./oauth.js"))
-                  return yield* McpOAuth.authorize({ name, config: remote, methodID })
+                  const { MCPOAuth } = yield* Effect.promise(() => import("./oauth.js"))
+                  return yield* MCPOAuth.authorize({ name, config: remote, methodID })
                }),
            })
          })
@@ -254,7 +254,7 @@ export const layer = (options?: Options) =>
      // opens a browser, so an auth-gated connect ends in UnauthorizedError -> needs_auth rather than a redirect.
      const connectProvider = Effect.fnUntraced(function* (entry: ServerEntry) {
        if (entry.config.type !== "remote" || !entry.integrationID) return undefined
-        const { McpOAuth } = yield* Effect.promise(() => import("./oauth.js"))
+        const { MCPOAuth } = yield* Effect.promise(() => import("./oauth.js"))
        const remote = entry.config
        const oauth = remote.oauth || undefined
        const base = {
@@ -270,17 +270,19 @@ export const layer = (options?: Options) =>
          // ends in UnauthorizedError -> needs_auth. Returning no provider instead would let the transport throw
          // a raw HTTP error, hiding the auth requirement behind a generic failed status. Anonymous servers are
          // unaffected: tokens() returns undefined, so no auth header is sent and the SDK never calls auth().
-          return McpOAuth.provider({ ...base, store: McpOAuth.memoryStore() })
+          return MCPOAuth.provider({ ...base, store: MCPOAuth.memoryStore() })
        const credentialID = found.id
        const methodID = found.value.methodID
+        const integrationID = entry.integrationID
        // Tracks the refresh token this provider last presented, so invalidate can tell whether the SDK
        // rejected the currently-stored credential or a snapshot another connection has already rotated past.
        let presented = found.value.refresh
        const readOAuthCredential = async () => {
-          const stored = await Effect.runPromise(credentials.get(credentialID))
-          return stored?.value.type === "oauth" ? stored.value : undefined
+          const stored = await Effect.runPromise(credentials.list(integrationID))
+          const match = stored.find((credential) => credential.id === credentialID)
+          return match && match.value.type === "oauth" ? match.value : undefined
        }
-        return McpOAuth.provider({
+        return MCPOAuth.provider({
          ...base,
          // Drop a credential the SDK rejected so the next connect cleanly reports needs_auth — but only if it is
          // still the stored one. Rotating servers hand out a fresh refresh token per use, so a concurrent
@@ -301,22 +303,22 @@ export const layer = (options?: Options) =>
              const oauth = await readOAuthCredential()
              if (!oauth) return undefined
              presented = oauth.refresh
-              return McpOAuth.toTokens(oauth)
+              return MCPOAuth.toTokens(oauth)
            },
            saveTokens: async (tokens) => {
              const previous = await readOAuthCredential()
-              const value = McpOAuth.toCredential({
+              const value = MCPOAuth.toCredential({
                methodID,
                serverUrl: remote.url,
                tokens,
-                client: previous ? McpOAuth.clientFromCredential(previous) : undefined,
+                client: previous ? MCPOAuth.clientFromCredential(previous) : undefined,
              })
              presented = value.refresh
              await Effect.runPromise(credentials.update(credentialID, { value }))
            },
            clientInformation: async () => {
              const oauth = await readOAuthCredential()
-              return oauth ? McpOAuth.clientFromCredential(oauth) : undefined
+              return oauth ? MCPOAuth.clientFromCredential(oauth) : undefined
            },
            saveClientInformation: async () => {},
            codeVerifier: async () => undefined,
@@ -328,7 +330,7 @@ export const layer = (options?: Options) =>
      const elicitation = {
        create: (input: {
          readonly server: string
-          readonly params: McpClient.ElicitationParams
+          readonly params: MCPClient.ElicitationParams
          readonly signal: AbortSignal
        }) =>
          Effect.gen(function* () {
@@ -353,7 +355,7 @@ export const layer = (options?: Options) =>
                  Effect.raceFirst(waitForAbort(input.signal)),
                  Effect.ensuring(Effect.sync(() => urlElicitations.delete(key))),
                  Effect.map(
-                    (state): McpClient.ElicitationResult => ({
+                    (state): MCPClient.ElicitationResult => ({
                      action: state.status === "answered" ? "accept" : "cancel",
                    }),
                  ),
@@ -373,13 +375,13 @@ export const layer = (options?: Options) =>
              })
              .pipe(
                Effect.raceFirst(waitForAbort(input.signal)),
-                Effect.map((state): McpClient.ElicitationResult => {
+                Effect.map((state): MCPClient.ElicitationResult => {
                  if (state.status !== "answered") return { action: "cancel" }
                  return {
                    action: "accept",
                    content: Object.fromEntries(
                      Object.entries(state.answer).map(
-                        ([key, value]): [string, NonNullable<McpClient.ElicitationResult["content"]>[string]] =>
+                        ([key, value]): [string, NonNullable<MCPClient.ElicitationResult["content"]>[string]] =>
                          typeof value === "object" ? [key, Array.from(value)] : [key, value],
                      ),
                    ),
@@ -393,9 +395,9 @@ export const layer = (options?: Options) =>
            if (!formID) return
            yield* forms.reply({ id: formID, answer: { [URL_ELICITATION_FIELD_KEY]: true } }).pipe(Effect.ignore)
          }),
-      } satisfies McpClient.ElicitationHandler
+      } satisfies MCPClient.ElicitationHandler

-      const toTool = (server: ServerName, entry: ServerEntry, def: McpClient.ToolDefinition) =>
+      const toTool = (server: ServerName, entry: ServerEntry, def: MCPClient.ToolDefinition) =>
        new Tool({
          server,
          name: def.name,
@@ -405,7 +407,7 @@ export const layer = (options?: Options) =>
          outputSchema: def.outputSchema,
        })

-      const toPrompt = (server: ServerName, def: McpClient.PromptDefinition) =>
+      const toPrompt = (server: ServerName, def: MCPClient.PromptDefinition) =>
        new Prompt({
          server,
          name: def.name,
@@ -420,7 +422,7 @@ export const layer = (options?: Options) =>
          ),
        })

-      const toResource = (server: ServerName, def: McpClient.ResourceDefinition) =>
+      const toResource = (server: ServerName, def: MCPClient.ResourceDefinition) =>
        Resource.make({
          server,
          name: def.name,
@@ -429,7 +431,7 @@ export const layer = (options?: Options) =>
          mimeType: def.mimeType,
        })

-      const toResourceTemplate = (server: ServerName, def: McpClient.ResourceTemplateDefinition) =>
+      const toResourceTemplate = (server: ServerName, def: MCPClient.ResourceTemplateDefinition) =>
        ResourceTemplate.make({
          server,
          name: def.name,
@@ -438,14 +440,14 @@ export const layer = (options?: Options) =>
          mimeType: def.mimeType,
        })

-      const refreshTools = (name: ServerName, entry: ServerEntry, connection: McpClient.Connection) =>
+      const refreshTools = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
        connection.tools().pipe(
          Effect.map((defs) => {
            entry.tools = defs.map((def) => toTool(name, entry, def))
          }),
        )

-      const refreshPrompts = (name: ServerName, entry: ServerEntry, connection: McpClient.Connection) =>
+      const refreshPrompts = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
        connection.prompts().pipe(
          Effect.orElseSucceed(() => []),
          Effect.map((defs) => {
@@ -457,7 +459,7 @@ export const layer = (options?: Options) =>
      // Runs a connection callback under the server lock, dropping it if the connection is no longer
      // the entry's live client, so late SDK callbacks cannot commit obsolete state.
      const whenLive =
-        (name: ServerName, entry: ServerEntry, connection: McpClient.Connection) =>
+        (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
        <E>(effect: Effect.Effect<void, E>) =>
          fork(
            Effect.suspend(() => (entry.client === connection ? effect : Effect.void)).pipe(
@@ -466,7 +468,7 @@ export const layer = (options?: Options) =>
            ),
          )

-      const watch = (name: ServerName, entry: ServerEntry, connection: McpClient.Connection) => {
+      const watch = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) => {
        const live = whenLive(name, entry, connection)
        connection.onClose(() =>
          live(
@@ -489,7 +491,7 @@ export const layer = (options?: Options) =>
        connection.onResourcesChanged(() => live(bus.publish(McpEvent.ResourcesChanged, { server: name })))
      }

-      const serverLog = (server: ServerName, message: McpClient.LogMessage) => {
+      const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
        const fields = { server, logger: message.logger, level: message.level, data: message.data }
        switch (message.level) {
          case "debug":
@@ -516,10 +518,10 @@ export const layer = (options?: Options) =>
          const scope = yield* Scope.fork(root)
          entry.scope = scope
          const authProvider = yield* connectProvider(entry)
-          const { McpClient } = yield* Effect.promise(() => import("./client.js"))
+          const { MCPClient } = yield* Effect.promise(() => import("./client.js"))
          // List tools as part of connect so a failure here marks the server failed rather than
          // leaving it connected with a silently empty tool list and no path to recover.
-          const result = yield* McpClient.connect(
+          const result = yield* MCPClient.connect(
            name,
            entry.config,
            location.directory,
@@ -553,7 +555,7 @@ export const layer = (options?: Options) =>
          entry.scope = undefined
          const error = Cause.squash(result.cause)
          entry.status =
-            error instanceof McpClient.NeedsAuthError
+            error instanceof MCPClient.NeedsAuthError
              ? { status: "needs_auth" }
              : { status: "failed", error: error instanceof Error ? error.message : String(error) }
          yield* Effect.logWarning("mcp connect failed", { server: name, status: entry.status })
@@ -936,4 +938,4 @@ function toElicitationField(key: string, property: ElicitationProperty, required
  }
 }

-type ElicitationProperty = McpClient.ElicitationFormParams["requestedSchema"]["properties"][string]
+type ElicitationProperty = MCPClient.ElicitationFormParams["requestedSchema"]["properties"][string]
@@ -5,7 +5,7 @@ import { Context, Effect, Layer, Schema } from "effect"
 import { Agent } from "../agent.js"
 import { Permission } from "../permission.js"
 import { McpTool } from "../tool/mcp.js"
-import { Mcp } from "./index.js"
+import { MCP } from "./index.js"
 import { Instructions } from "../instructions/index.js"

 const Summary = Schema.Struct({
@@ -63,7 +63,7 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/Mc
 export const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
-    const mcp = yield* Mcp.Service
+    const mcp = yield* MCP.Service

    return Service.of({
      load: Effect.fn("McpInstructions.load")(function* (selection) {
@@ -110,4 +110,4 @@ export const layer = Layer.effect(
  }),
 )

-export const node = makeLocationNode({ service: Service, layer, deps: [Mcp.node] })
+export const node = makeLocationNode({ service: Service, layer, deps: [MCP.node] })
@@ -1,4 +1,4 @@
-export * as McpOAuth from "./oauth.js"
+export * as MCPOAuth from "./oauth.js"

 import { auth, type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js"
 import type { OAuthClientInformationMixed, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js"
@@ -1,4 +1,4 @@
-export * as McpStdio from "./stdio.js"
+export * as MCPStdio from "./stdio.js"

 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js"
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js"
@@ -19,7 +19,7 @@ async function install(
  const directory = path.join(root, `${input.version}-${input.sha256.slice(0, 16)}`)
  await privateDirectory(directory)
  const destination = path.join(directory, "opencode-pty")
-  if (await validateIfPresent(destination, input.sha256)) return destination
+  if (await exists(destination, input.sha256)) return destination

  const bytes = new Uint8Array(await Bun.file(input.path).arrayBuffer())
  if (sha256(bytes) !== input.sha256) throw new Error("Embedded opencode-pty checksum mismatch")
@@ -34,7 +34,7 @@ async function install(
    }
    await chmod(temporary, 0o755)
    await rename(temporary, destination).catch(async (error) => {
-      if (!(await validateIfPresent(destination, input.sha256))) throw error
+      if (!(await exists(destination, input.sha256))) throw error
    })
  } finally {
    await rm(temporary, { force: true })
@@ -52,7 +52,7 @@ async function privateDirectory(directory: string) {
  await chmod(directory, 0o700)
 }

-async function validateIfPresent(file: string, expected: string) {
+async function exists(file: string, expected: string) {
  try {
    await validate(file, expected)
    return true
@@ -62,13 +62,14 @@ async function validateIfPresent(file: string, expected: string) {
  }
 }

-async function validate(file: string, expected: string) {
+async function validate(file: string, expected?: string) {
  const info = await lstat(file)
  if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Unsafe opencode-pty executable: ${file}`)
  const uid = typeof process.getuid === "function" ? process.getuid() : undefined
  if (uid !== undefined && info.uid !== uid)
    throw new Error(`opencode-pty executable is owned by another user: ${file}`)
-  if (sha256(await readFile(file)) !== expected) throw new Error(`Cached opencode-pty checksum mismatch: ${file}`)
+  if (expected && sha256(await readFile(file)) !== expected)
+    throw new Error(`Cached opencode-pty checksum mismatch: ${file}`)
  await chmod(file, 0o755)
  return file
 }
@@ -13,7 +13,7 @@ import { Command } from "./command.js"
 import { Bus } from "./bus.js"
 import { Integration } from "./integration.js"
 import { KV } from "./kv.js"
-import { Mcp } from "./mcp/index.js"
+import { MCP } from "./mcp/index.js"
 import { Location } from "./location.js"
 import { PluginHost } from "./plugin/host.js"
 import { PluginRuntime } from "./plugin/runtime.js"
@@ -91,11 +91,16 @@ const layer = Layer.effect(

      yield* lock.withPermit(
        Effect.gen(function* () {
+          const next = definitions.map((definition) => ({ id: definition.id, version: definition.version }))
+          const current = Array.from(active.values(), (entry) => ({
+            id: entry.plugin.id,
+            version: entry.plugin.version,
+          }))
          if (
-            active.size === definitions.length &&
-            Array.from(active.values()).every((entry, index) => {
-              const definition = definitions[index]
-              return entry.plugin.id === definition?.id && entry.plugin.version === definition.version
+            current.length === next.length &&
+            current.every((definition, index) => {
+              const candidate = next[index]
+              return definition.id === candidate?.id && definition.version === candidate.version
            })
          ) {
            const nextInventory = [...Array.from(active.values(), (entry) => activeInfo(entry.plugin)), ...failures]
@@ -192,7 +197,7 @@ export const node = makeLocationNode({
    Command.node,
    Integration.node,
    KV.node,
-    Mcp.node,
+    MCP.node,
    Location.node,
    Reference.node,
    Skill.node,
--- a/Show More
+++ b/Show More