chore: update nix node_modules hashes

2026-08-27 03:56:18 +00:00 · 2026-08-26 16:44:38 +00:00
246 changed files with 3293 additions and 15459 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Include both paths of renamed files in new snapshot change lists so undo restores the original file instead of only deleting the renamed file.
@@ -1,10 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Make the experimental portable shell scanner authoritative, with no Tree-sitter
-fallback. Scan common Bash and PowerShell control flow, heredocs, functions,
-expressions, quoting, and substitutions natively. Preserve existing redirect and
-declaration permission matching, and make PowerShell saved approvals cover the
-original command spelling. Parser failures remain visible without changing the
-permission engine. The default Tree-sitter path is unchanged.
@@ -81,33 +81,6 @@ jobs:
      - name: Setup Bun
        uses: ./.github/actions/setup-bun

-      - name: Find affected verification checks
-        id: checks
-        env:
-          TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
-          TURBO_SCM_HEAD: ${{ github.sha }}
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            for package in cli codemode sdk; do
-              echo "$package=true" >> "$GITHUB_OUTPUT"
-            done
-            exit 0
-          fi
-          bun turbo ls --affected --output=json > affected.json
-          bun -e '
-            const result = await Bun.file("affected.json").json()
-            const packages = new Set(result.packages.items.map((item) => item.name))
-            const affected = (name) => packages.has(`@opencode-ai/${name}`)
-            const checks = {
-              // CLI builds embed the web app outside the workspace dependency graph.
-              cli: affected("cli") || affected("app"),
-              // Codemode publishing imports the shared script package directly.
-              codemode: affected("codemode") || affected("script"),
-              sdk: affected("sdk"),
-            }
-            for (const [name, enabled] of Object.entries(checks)) console.log(`${name}=${enabled}`)
-          ' >> "$GITHUB_OUTPUT"
-
      - name: Test Effect simplification rules
        if: runner.os == 'Linux'
        run: bun run test:effect-simplification-rules
@@ -150,17 +123,25 @@ jobs:
          TURBO_SCM_HEAD: ${{ github.sha }}

      - name: Verify published codemode package
-        if: runner.os == 'Linux' && steps.checks.outputs.codemode == 'true'
+        if: runner.os == 'Linux'
        working-directory: packages/codemode
        run: bun run script/publish.ts --dry-run

      - name: Verify packed workerd SDK
-        if: runner.os == 'Linux' && steps.checks.outputs.sdk == 'true'
+        if: runner.os == 'Linux'
        timeout-minutes: 15
-        run: bun turbo verify:package --filter=@opencode-ai/sdk
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            bun turbo verify:package --filter=@opencode-ai/sdk
+            exit 0
+          fi
+          bun turbo verify:package --affected --filter=@opencode-ai/sdk
+        env:
+          TURBO_SCM_BASE: ${{ github.event_name == 'pull_request' && format('{0}^1', github.sha) || github.event.before }}
+          TURBO_SCM_HEAD: ${{ github.sha }}

      - name: Verify compiled service lifecycle
-        if: steps.checks.outputs.cli == 'true'
+        if: always()
        timeout-minutes: 10
        working-directory: packages/cli
        env:
@@ -170,13 +151,13 @@ jobs:
          bun run script/service-smoke.ts

      - name: Setup Node build runtime
-        if: steps.checks.outputs.cli == 'true'
+        if: always()
        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
        with:
          node-version: "26.4.0"

      - name: Verify Node build
-        if: steps.checks.outputs.cli == 'true'
+        if: always()
        timeout-minutes: 15
        working-directory: packages/cli
        env:
@@ -256,9 +237,9 @@ jobs:
        working-directory: packages/app
        run: bunx playwright install chromium

-      - name: Run app e2e tests against production build
+      - name: Run app e2e tests
        if: env.E2E_ENABLED == 'true'
-        run: bun --cwd packages/app test:e2e:built
+        run: bun --cwd packages/app test:e2e:local
        env:
          CI: true
        timeout-minutes: 30
@@ -125,7 +125,7 @@
        "@effect/platform-node": "catalog:",
        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.12",
+        "@opencode-ai/pty": "0.1.9",
        "@opencode-ai/schema": "workspace:*",
        "@opencode-ai/server": "workspace:*",
        "@opencode-ai/tui": "workspace:*",
@@ -364,7 +364,7 @@
        "@opencode-ai/ai": "workspace:*",
        "@opencode-ai/codemode": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.12",
+        "@opencode-ai/pty": "0.1.9",
        "@opencode-ai/schema": "workspace:*",
        "@opencode-ai/util": "workspace:*",
        "@parcel/watcher": "2.5.1",
@@ -553,20 +553,6 @@
        "@typescript/native-preview": "catalog:",
      },
    },
-    "packages/latex": {
-      "name": "@opencode-ai/latex",
-      "version": "0.0.0",
-      "dependencies": {
-        "@opencode-ai/plugin": "workspace:*",
-        "@opentui/core": "catalog:",
-        "string-width": "catalog:",
-      },
-      "devDependencies": {
-        "@tsconfig/bun": "catalog:",
-        "@types/bun": "catalog:",
-        "@typescript/native-preview": "catalog:",
-      },
-    },
    "packages/merman": {
      "name": "@opencode-ai/merman",
      "version": "0.0.0",
@@ -745,7 +731,6 @@
      },
      "devDependencies": {
        "@happy-dom/global-registrator": "20.0.11",
-        "@playwright/test": "catalog:",
        "@tsconfig/node22": "catalog:",
        "@types/bun": "catalog:",
        "@types/luxon": "catalog:",
@@ -851,7 +836,6 @@
        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/session-ui": "workspace:*",
        "@opencode-ai/ui": "workspace:*",
-        "@playwright/test": "catalog:",
        "@solidjs/meta": "catalog:",
        "@storybook/addon-a11y": "10.4.4",
        "@storybook/addon-docs": "10.4.4",
@@ -893,7 +877,6 @@
      "dependencies": {
        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/core": "workspace:*",
-        "@opencode-ai/latex": "workspace:*",
        "@opencode-ai/merman": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
        "@opencode-ai/schema": "workspace:*",
@@ -2165,8 +2148,6 @@

    "@opencode-ai/httpapi-codegen": ["@opencode-ai/httpapi-codegen@workspace:packages/httpapi-codegen"],

-    "@opencode-ai/latex": ["@opencode-ai/latex@workspace:packages/latex"],
-
    "@opencode-ai/merman": ["@opencode-ai/merman@workspace:packages/merman"],

    "@opencode-ai/plugin": ["@opencode-ai/plugin@workspace:packages/plugin"],
@@ -2175,19 +2156,19 @@

    "@opencode-ai/protocol": ["@opencode-ai/protocol@workspace:packages/protocol"],

-    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.12", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.12", "@opencode-ai/pty-darwin-x64": "0.1.12", "@opencode-ai/pty-linux-arm64-gnu": "0.1.12", "@opencode-ai/pty-linux-arm64-musl": "0.1.12", "@opencode-ai/pty-linux-x64-gnu": "0.1.12", "@opencode-ai/pty-linux-x64-musl": "0.1.12" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-dl4FyJUhTXThsWYY8txG/8/nwN7dE0M5Sic9r4L9f2pvtJnbR5zrCrPoiPIBIxZle1wVks1dhz4z/CfqLf5sCg=="],
+    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.9", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.9", "@opencode-ai/pty-darwin-x64": "0.1.9", "@opencode-ai/pty-linux-arm64-gnu": "0.1.9", "@opencode-ai/pty-linux-arm64-musl": "0.1.9", "@opencode-ai/pty-linux-x64-gnu": "0.1.9", "@opencode-ai/pty-linux-x64-musl": "0.1.9" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-9WysQgX9J3RXfZy/t/8MGqf1IGLeckyHQsT/eVnKiBnp+GnzOXtZePryj08CN/3GT2BuP5tWqMRMH0JzCMsrgg=="],

-    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-tMvoriq3VegVlj1uEglc6qE0M7VXy61nyf9Si7tTO7xa8JiyxuFJSXOZ1pGeErDu+pe24hvTyVOR+gkdew8w9g=="],
+    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.9", "", { "os": "darwin", "cpu": "arm64" }, "sha512-a2OZGutBdVGDO+X4t37L2K8wD1phTcLJBcNLj8j3LqCmaHbJmQyNYYFo6i8loZCTjjhb+8Wq0wMxSLny4tqdwA=="],

-    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-Sn5vMLL5giHOhx7J5H6zwDp4YjjXorY+QV0IEYY+SCT4wQfRBliokIyj23pRl6P2RK3u9bDLXJHDNMfDVZ2Rxg=="],
+    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.9", "", { "os": "darwin", "cpu": "x64" }, "sha512-+vyRLwzNMzP/JFtYEIkMHxRC9Lkd7sUeuAqI5medtdgZmvTwS3NdkHbq6zQQG3rTQ9asObPKilvcpQDf+LYHRQ=="],

-    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-HbnlKZy052l7G527wK0+05EXaUpZ4ykVAmNBEzqWCoi4TeQj2+Nr9kJ9trx9o1KrVcT4Ki58CCvN5QOls6Z0yQ=="],
+    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-vjNKhCsw6mI6w+9bITCyCmb5nS+XiWA8xMGn02GOKE9AahcVX9JIbjUF1zAmPXZ1QD7nxWoanh4FvnqukbYPHw=="],

-    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-2nTN7ggu1h9XgjNcoQMYjP5sirfYnAskpdFCOqjokLqhytX/IMMmkRTQs+foaEaPz0dAIQD3DQplR2jZIgxp1w=="],
+    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.9", "", { "os": "linux", "cpu": "arm64" }, "sha512-xpS0N6/uEiJPabv6Ib9BpOlfyZdcUES7sMVa4bCrgcxy6y4bnQMeGF/Ju4u7LBABD/rjBKZM0XhPMnvZ6qoX1w=="],

-    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.12", "", { "os": "linux", "cpu": "x64" }, "sha512-FnD5ndnObTQKAoaVvxLKi5W+r3/+dsaMsobz6uK0B9hlmffXxY5CQ6HQyUU/h3aIKLWXxho5XYkA2b9yrp8/gA=="],
+    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.9", "", { "os": "linux", "cpu": "x64" }, "sha512-N1Dx8rOLkpJd2DSetZZW9dPnpL3mxbRQagk/7K7TbS7M1rDnLazhq8/T9vulLET8KTwu6lmWcZYuSDfPLNWXnA=="],

-    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.12", "", { "os": "linux", "cpu": "x64" }, "sha512-prkrNu6uvjqoffxdGiDHSU5C0Y+kCSfv+lslu7dfRPgPKenVELNpRTAbOduyrWPac2vGt8j5NM61icJyodbJmA=="],
+    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.9", "", { "os": "linux", "cpu": "x64" }, "sha512-osb203LrlwXpQKQABrCfD5QRVK9Ajiq5atulC/VuMye6KkErcetDnjQvobjhaEjgnSEGPCH4U9sM84okGqip5Q=="],

    "@opencode-ai/schema": ["@opencode-ai/schema@workspace:packages/schema"],

@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-NV1PD2fCgWEKsr9kR0pV9jgkC400dzoF7/DnI/fY5yI=",
-    "aarch64-linux": "sha256-TDTdwE0mcHLrrKPDwPPBk3qIDl/PXJrLX6Zbwp7EH3I=",
-    "aarch64-darwin": "sha256-6MEoiV1UKAWgC7C6PR4USCP/LLZXROfBfPg6sb2VVWg=",
-    "x86_64-darwin": "sha256-8JV6YVZFq1BC++zpARxBWhQ+wuNJrWgTZJ6jfQhDybs="
+    "x86_64-linux": "sha256-Q7BQ46mKePJtaKzhHxahIXy/pZczPmm5cQuBDrgd2Bc=",
+    "aarch64-linux": "sha256-pqk4iUhXzEc4ei9zpeGpPjX7Q6pxH1K5rgotD5Wf91s=",
+    "aarch64-darwin": "sha256-1q3mK5zLqQA0vz7KErDOkjeAnmsTReI0lhBJfIobC/E=",
+    "x86_64-darwin": "sha256-dBMQ6tZxt5VjgWTZELHgPk6fVhBfNYfmY+AnQ3iJ88Q="
  }
 }
@@ -406,7 +406,6 @@ const AnthropicEvent = Schema.Struct({
 type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>

 interface ParserState {
-  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  readonly reasoningSignatures: Readonly<Record<number, string>>
  readonly usage?: Usage
@@ -441,18 +440,18 @@ const cacheControl = (breakpoints: Cache.Breakpoints, cache: CacheHint | undefin
  return Cache.ttlBucket(cache.ttlSeconds) === "1h" ? EPHEMERAL_1H : EPHEMERAL_5M
 }

-const providerMetadata = (key: string, metadata: Record<string, unknown>): ProviderMetadata => ({ [key]: metadata })
+const anthropicMetadata = (metadata: Record<string, unknown>): ProviderMetadata => ({ anthropic: metadata })

-const signatureFromMetadata = (metadata: ProviderMetadata | undefined, key: string): string | undefined => {
-  const provider = metadata?.[key]
-  if (!ProviderShared.isRecord(provider)) return undefined
-  return typeof provider.signature === "string" ? provider.signature : undefined
+const signatureFromMetadata = (metadata: ProviderMetadata | undefined): string | undefined => {
+  const anthropic = metadata?.anthropic
+  if (!ProviderShared.isRecord(anthropic)) return undefined
+  return typeof anthropic.signature === "string" ? anthropic.signature : undefined
 }

-const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined, key: string): string | undefined => {
-  const provider = metadata?.[key]
-  if (!ProviderShared.isRecord(provider)) return undefined
-  return typeof provider.redactedData === "string" ? provider.redactedData : undefined
+const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined): string | undefined => {
+  const anthropic = metadata?.anthropic
+  if (!ProviderShared.isRecord(anthropic)) return undefined
+  return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined
 }

 const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSchema: JsonSchema): AnthropicTool => ({
@@ -512,16 +511,13 @@ const serverToolResultType = (name: string): AnthropicServerToolResultType | und
  return undefined
 }

-const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (
-  part: ToolResultPart,
-  providerMetadataKey: string,
-) {
+const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult")(function* (part: ToolResultPart) {
  const wireType = serverToolResultType(part.name)
  if (!wireType)
    return yield* invalid(`Anthropic Messages does not know how to round-trip server tool result for ${part.name}`)
  // Prefer the provider-owned replay payload; fall back to the result value for
  // histories constructed directly from provider events.
-  const payload = part.providerMetadata?.[providerMetadataKey]?.["result"] ?? part.result.value
+  const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value
  return {
    type: wireType,
    tool_use_id: scrubToolCallID(part.id),
@@ -808,7 +804,6 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
  breakpoints: Cache.Breakpoints,
 ) {
  const messages: AnthropicMessage[] = []
-  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)

  for (const [index, message] of request.messages.entries()) {
    if (message.role === "system") {
@@ -854,8 +849,8 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
        if (part.type === "reasoning") {
          // A signature marks visible thinking; only signature-less parts carrying
          // redactedData round-trip as opaque redacted_thinking blocks.
-          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata, providerMetadataKey)
-          const redactedData = redactedDataFromMetadata(part.providerMetadata, providerMetadataKey)
+          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata)
+          const redactedData = redactedDataFromMetadata(part.providerMetadata)
          if (signature === undefined && redactedData !== undefined) {
            content.push({ type: "redacted_thinking", data: redactedData })
            continue
@@ -884,7 +879,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
          continue
        }
        if (part.type === "tool-result" && part.providerExecuted) {
-          content.push(yield* lowerServerToolResult(part, providerMetadataKey))
+          content.push(yield* lowerServerToolResult(part))
          continue
        }
        return yield* invalid(
@@ -1074,7 +1069,7 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
 // inclusive `inputTokens` the rest of the contract expects. Extended
 // thinking tokens are included in `output_tokens`; newer responses also
 // expose that subset through `output_tokens_details.thinking_tokens`.
-const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: AnthropicUsage | undefined): Usage | undefined => {
  if (!usage) return undefined
  const nonCached = usage.input_tokens ?? undefined
  const cacheRead = usage.cache_read_input_tokens ?? undefined
@@ -1088,7 +1083,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: usage.output_tokens_details?.thinking_tokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, usage.output_tokens, undefined),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { anthropic: usage },
  })
 }

@@ -1097,7 +1092,7 @@ const mapUsage = (usage: AnthropicUsage | undefined, providerMetadataKey: string
 // field prefers `right` when defined, falls back to `left`. `inputTokens` is
 // recomputed from the merged breakdown so the inclusive total stays
 // consistent with `nonCached + cacheRead + cacheWrite`.
-const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerMetadataKey: string) => {
+const mergeUsage = (left: Usage | undefined, right: Usage | undefined) => {
  if (!left) return right
  if (!right) return left
  const nonCachedInputTokens = right.nonCachedInputTokens ?? left.nonCachedInputTokens
@@ -1115,9 +1110,7 @@ const mergeUsage = (left: Usage | undefined, right: Usage | undefined, providerM
    reasoningTokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, outputTokens, undefined),
    providerMetadata: {
-      [providerMetadataKey]:
-        mergeJsonRecords(left.providerMetadata?.[providerMetadataKey], right.providerMetadata?.[providerMetadataKey]) ??
-        {},
+      anthropic: mergeJsonRecords(left.providerMetadata?.["anthropic"], right.providerMetadata?.["anthropic"]) ?? {},
    },
  })
 }
@@ -1135,7 +1128,7 @@ const SERVER_TOOL_RESULT_NAMES: Record<AnthropicServerToolResultType, string> =

 const isServerToolResultType = (type: string): type is AnthropicServerToolResultType => type in SERVER_TOOL_RESULT_NAMES

-const serverToolResultEvent = (block: AnthropicStreamBlock, providerMetadataKey: string): LLMEvent | undefined => {
+const serverToolResultEvent = (block: AnthropicStreamBlock): LLMEvent | undefined => {
  if (!block.type || !isServerToolResultType(block.type)) return undefined
  const errorPayload =
    typeof block.content === "object" && block.content !== null && "type" in block.content
@@ -1149,7 +1142,7 @@ const serverToolResultEvent = (block: AnthropicStreamBlock, providerMetadataKey:
    providerExecuted: true,
    // The complete payload is irreducible provider replay state: subsequent
    // stateless requests must round-trip the typed result block verbatim.
-    providerMetadata: providerMetadata(providerMetadataKey, { blockType: block.type, result: block.content }),
+    providerMetadata: anthropicMetadata({ blockType: block.type, result: block.content }),
  })
 }

@@ -1158,8 +1151,8 @@ type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 const NO_EVENTS: StepResult["1"] = []

 const onMessageStart = (state: ParserState, event: AnthropicEvent): StepResult => {
-  const usage = mapUsage(event.message?.usage, state.providerMetadataKey)
-  return [usage ? { ...state, usage: mergeUsage(state.usage, usage, state.providerMetadataKey) } : state, NO_EVENTS]
+  const usage = mapUsage(event.message?.usage)
+  return [usage ? { ...state, usage: mergeUsage(state.usage, usage) } : state, NO_EVENTS]
 }

 const onContentBlockStart = (
@@ -1211,16 +1204,14 @@ const onContentBlockStart = (
  if (block.type === "thinking" && block.thinking !== undefined) {
    const events: LLMEvent[] = []
    const id = `reasoning-${event.index ?? 0}`
-    const metadata =
-      block.signature === undefined
-        ? undefined
-        : providerMetadata(state.providerMetadataKey, { signature: block.signature })
-    const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, metadata)
+    const providerMetadata =
+      block.signature === undefined ? undefined : anthropicMetadata({ signature: block.signature })
+    const lifecycle = Lifecycle.reasoningStart(state.lifecycle, events, id, providerMetadata)
    return [
      {
        ...state,
        lifecycle: block.thinking
-          ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, metadata)
+          ? Lifecycle.reasoningDelta(lifecycle, events, id, block.thinking, providerMetadata)
          : lifecycle,
        reasoningSignatures:
          event.index === undefined || block.signature === undefined
@@ -1243,14 +1234,14 @@ const onContentBlockStart = (
          state.lifecycle,
          events,
          `reasoning-${event.index ?? 0}`,
-          providerMetadata(state.providerMetadataKey, { redactedData: block.data }),
+          anthropicMetadata({ redactedData: block.data }),
        ),
      },
      events,
    ]
  }

-  const result = serverToolResultEvent(block, state.providerMetadataKey)
+  const result = serverToolResultEvent(block)
  if (!result) return [state, NO_EVENTS]
  const events: LLMEvent[] = []
  return [{ ...state, lifecycle: Lifecycle.stepStart(state.lifecycle, events) }, [...events, result]]
@@ -1330,7 +1321,7 @@ const onContentBlockStop = Effect.fn("AnthropicMessages.onContentBlockStop")(fun
        Lifecycle.textEnd(state.lifecycle, events, `text-${event.index}`),
        events,
        `reasoning-${event.index}`,
-        signature === undefined ? undefined : providerMetadata(state.providerMetadataKey, { signature }),
+        signature === undefined ? undefined : anthropicMetadata({ signature }),
      )
  events.push(...resultEvents)
  const reasoningSignatures = { ...state.reasoningSignatures }
@@ -1342,7 +1333,7 @@ const onMessageDelta = (
  state: ParserState,
  event: AnthropicEvent & { readonly delta?: AnthropicStreamDelta },
 ): StepResult => {
-  const usage = mergeUsage(state.usage, mapUsage(event.usage, state.providerMetadataKey), state.providerMetadataKey)
+  const usage = mergeUsage(state.usage, mapUsage(event.usage))
  return [
    {
      ...state,
@@ -1355,7 +1346,7 @@ const onMessageDelta = (
        providerMetadata:
          event.delta?.stop_sequence === null || event.delta?.stop_sequence === undefined
            ? undefined
-            : providerMetadata(state.providerMetadataKey, { stopSequence: event.delta.stop_sequence }),
+            : anthropicMetadata({ stopSequence: event.delta.stop_sequence }),
      },
    },
    NO_EVENTS,
@@ -1481,8 +1472,7 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: Protocol.jsonEvent(AnthropicEvent),
-    initial: (request) => ({
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+    initial: () => ({
      tools: ToolStream.empty<number>(),
      reasoningSignatures: {},
      lifecycle: Lifecycle.initial(),
@@ -258,21 +258,19 @@ const lowerToolChoice = (toolChoice: NonNullable<LLMRequest["toolChoice"]>) =>
    tool: (name) => ({ tool: { name } }) as const,
  })

-const providerMetadata = (key: string, metadata: Record<string, unknown>): ProviderMetadata => ({ [key]: metadata })
+const bedrockMetadata = (metadata: Record<string, unknown>): ProviderMetadata => ({ bedrock: metadata })

-const reasoningSignature = (part: ReasoningPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
+const reasoningSignature = (part: ReasoningPart) => {
+  const bedrock = part.providerMetadata?.bedrock
  return (
    part.encrypted ??
-    (ProviderShared.isRecord(metadata) && typeof metadata.signature === "string" ? metadata.signature : undefined)
+    (ProviderShared.isRecord(bedrock) && typeof bedrock.signature === "string" ? bedrock.signature : undefined)
  )
 }

-const reasoningRedactedData = (part: ReasoningPart, providerMetadataKey: string) => {
-  const metadata = part.providerMetadata?.[providerMetadataKey]
-  return ProviderShared.isRecord(metadata) && typeof metadata.redactedData === "string"
-    ? metadata.redactedData
-    : undefined
+const reasoningRedactedData = (part: ReasoningPart) => {
+  const bedrock = part.providerMetadata?.bedrock
+  return ProviderShared.isRecord(bedrock) && typeof bedrock.redactedData === "string" ? bedrock.redactedData : undefined
 }

 const lowerToolCall = (part: ToolCallPart): BedrockToolUseBlock => ({
@@ -320,7 +318,6 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
  breakpoints: BedrockCache.Breakpoints,
 ) {
  const messages: BedrockMessage[] = []
-  const providerMetadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)

  for (const message of request.messages) {
    if (message.role === "system") {
@@ -368,8 +365,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
        if (part.type === "reasoning") {
-          const signature = reasoningSignature(part, providerMetadataKey)
-          const redactedData = reasoningRedactedData(part, providerMetadataKey)
+          const signature = reasoningSignature(part)
+          const redactedData = reasoningRedactedData(part)
          if (signature === undefined && redactedData !== undefined) {
            content.push({ reasoningContent: { redactedContent: redactedData } })
            continue
@@ -469,7 +466,7 @@ const mapFinishReason = (reason: string): FinishReason => {

 // AWS reports inputTokens separately from cache reads and writes.
 // Bedrock does not break reasoning out of outputTokens for current models.
-const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: BedrockUsageSchema | undefined): Usage | undefined => {
  if (!usage) return undefined
  const inputTokens = ProviderShared.sumTokens(
    usage.inputTokens,
@@ -483,12 +480,11 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
    cacheReadInputTokens: usage.cacheReadInputTokens,
    cacheWriteInputTokens: usage.cacheWriteInputTokens,
    totalTokens: ProviderShared.totalTokens(inputTokens, usage.outputTokens, usage.totalTokens),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { bedrock: usage },
  })
 }

 interface ParserState {
-  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
  // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
@@ -545,14 +541,20 @@ const step = (state: ParserState, event: BedrockEvent) =>
      const reasoning = event.contentBlockDelta.delta.reasoningContent
      const events: LLMEvent[] = []
      const redactedData = reasoning.redactedContent ?? reasoning.data
-      const metadata = reasoning.signature
-        ? providerMetadata(state.providerMetadataKey, { signature: reasoning.signature })
+      const providerMetadata = reasoning.signature
+        ? bedrockMetadata({ signature: reasoning.signature })
        : redactedData !== undefined
-          ? providerMetadata(state.providerMetadataKey, { redactedData })
+          ? bedrockMetadata({ redactedData })
          : undefined
      const lifecycle =
-        reasoning.text !== undefined || metadata !== undefined
-          ? Lifecycle.reasoningDelta(state.lifecycle, events, `reasoning-${index}`, reasoning.text ?? "", metadata)
+        reasoning.text !== undefined || providerMetadata !== undefined
+          ? Lifecycle.reasoningDelta(
+              state.lifecycle,
+              events,
+              `reasoning-${index}`,
+              reasoning.text ?? "",
+              providerMetadata,
+            )
          : state.lifecycle
      return [
        {
@@ -594,7 +596,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
            events,
            `reasoning-${index}`,
            state.reasoningSignatures[index]
-              ? providerMetadata(state.providerMetadataKey, { signature: state.reasoningSignatures[index] })
+              ? bedrockMetadata({ signature: state.reasoningSignatures[index] })
              : undefined,
          )
      events.push(...resultEvents)
@@ -631,7 +633,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
    }

    if (event.metadata) {
-      const usage = mapUsage(event.metadata.usage, state.providerMetadataKey) ?? state.pendingFinish?.usage
+      const usage = mapUsage(event.metadata.usage) ?? state.pendingFinish?.usage
      return [
        {
          ...state,
@@ -696,8 +698,7 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: BedrockEvent,
-    initial: (request) => ({
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
+    initial: () => ({
      tools: ToolStream.empty<number>(),
      pendingFinish: undefined,
      hasToolCalls: false,
@@ -229,7 +229,6 @@ type GeminiEvent = Schema.Schema.Type<typeof GeminiEvent>

 interface ParserState {
  readonly route: string
-  readonly providerMetadataKey: string
  readonly finishReason?: string
  readonly hasToolCalls: boolean
  readonly promptFeedback?: GeminiPromptFeedback
@@ -286,23 +285,22 @@ const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part: TextPar
  return { inlineData: { mimeType: media.mime, data: media.base64 } }
 })

-const providerMetadata = (key: string, metadata: Record<string, unknown>): ProviderMetadata => ({ [key]: metadata })
+const googleMetadata = (metadata: Record<string, unknown>): ProviderMetadata => ({ google: metadata })

-const thoughtSignature = (metadata: ProviderMetadata | undefined, key: string) => {
-  const value = metadata?.[key]
-  return ProviderShared.isRecord(value) && typeof value.thoughtSignature === "string"
-    ? value.thoughtSignature
+const thoughtSignature = (providerMetadata: ProviderMetadata | undefined) => {
+  const google = providerMetadata?.google
+  return ProviderShared.isRecord(google) && typeof google.thoughtSignature === "string"
+    ? google.thoughtSignature
    : undefined
 }

-const lowerToolCall = (part: ToolCallPart, omitIds: boolean, metadataKey: string) => ({
+const lowerToolCall = (part: ToolCallPart, omitIds: boolean) => ({
  functionCall: { ...(omitIds ? {} : { id: part.id }), name: part.name, args: part.input },
-  thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
+  thoughtSignature: thoughtSignature(part.providerMetadata),
 })

 const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMRequest) {
  const contents: GeminiContent[] = []
-  const metadataKey = request.model.route.providerMetadataKey ?? String(request.model.provider)
  const omitCallIds = omitsFunctionCallIds(request.model.id)
  const legacyToolMedia = routesLegacyToolMedia(request.model.id)
  let pendingMedia: GeminiInlineDataPart[] | undefined
@@ -344,19 +342,15 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request: LLMR
        if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
          return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"])
        if (part.type === "text") {
-          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) })
+          parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata) })
          continue
        }
        if (part.type === "reasoning") {
-          parts.push({
-            text: part.text,
-            thought: true,
-            thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey),
-          })
+          parts.push({ text: part.text, thought: true, thoughtSignature: thoughtSignature(part.providerMetadata) })
          continue
        }
        if (part.type === "tool-call") {
-          const lowered = lowerToolCall(part, omitCallIds, metadataKey)
+          const lowered = lowerToolCall(part, omitCallIds)
          const signature = lowered.thoughtSignature
          parts.push({
            ...lowered,
@@ -504,7 +498,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request: LLMReque
 // `cachedContentTokenCount` subset. `candidatesTokenCount` is *exclusive*
 // of `thoughtsTokenCount` — visible-only, not a total — so we sum the two
 // to produce the inclusive `outputTokens` the rest of the contract expects.
-const mapUsage = (usage: GeminiUsage | undefined, metadataKey: string) => {
+const mapUsage = (usage: GeminiUsage | undefined) => {
  if (!usage) return undefined
  // Explicit provider nulls decode as `null`; normalize to `undefined` so the
  // token arithmetic below treats them like absent counts.
@@ -525,7 +519,7 @@ const mapUsage = (usage: GeminiUsage | undefined, metadataKey: string) => {
    cacheReadInputTokens: cached,
    reasoningTokens: thoughts,
    totalTokens: ProviderShared.totalTokens(promptTokens, outputTokens, usage.totalTokenCount ?? undefined),
-    providerMetadata: providerMetadata(metadataKey, usage),
+    providerMetadata: { google: usage },
  })
 }

@@ -573,14 +567,14 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
      lifecycle,
      events,
      "reasoning-0",
-      providerMetadata(state.providerMetadataKey, { thoughtSignature: state.reasoningSignature }),
+      googleMetadata({ thoughtSignature: state.reasoningSignature }),
    )
  if (state.textSignature !== undefined)
    lifecycle = Lifecycle.textEnd(
      lifecycle,
      events,
      "text-0",
-      providerMetadata(state.providerMetadataKey, { thoughtSignature: state.textSignature }),
+      googleMetadata({ thoughtSignature: state.textSignature }),
    )
  Lifecycle.finish(lifecycle, events, {
    reason: {
@@ -590,9 +584,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
    },
    usage: state.usage,
    providerMetadata:
-      state.promptFeedback === undefined
-        ? undefined
-        : providerMetadata(state.providerMetadataKey, { promptFeedback: state.promptFeedback }),
+      state.promptFeedback === undefined ? undefined : googleMetadata({ promptFeedback: state.promptFeedback }),
  })
  return events
 }
@@ -601,9 +593,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
  const nextState = {
    ...state,
    promptFeedback: event.promptFeedback ?? state.promptFeedback,
-    usage: event.usageMetadata
-      ? (mapUsage(event.usageMetadata, state.providerMetadataKey) ?? state.usage)
-      : state.usage,
+    usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? state.usage) : state.usage,
  }
  const candidate = event.candidates?.[0]
  if (!candidate?.content)
@@ -647,7 +637,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
          events,
          "reasoning-0",
          part.text,
-          signature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature }) : undefined,
+          signature ? googleMetadata({ thoughtSignature: signature }) : undefined,
        )
        continue
      }
@@ -655,16 +645,14 @@ const step = (state: ParserState, event: GeminiEvent) => {
        lifecycle,
        events,
        "reasoning-0",
-        reasoningSignature
-          ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
-          : undefined,
+        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
      )
      lifecycle = Lifecycle.textDelta(
        lifecycle,
        events,
        "text-0",
        part.text,
-        textSignature ? providerMetadata(state.providerMetadataKey, { thoughtSignature: textSignature }) : undefined,
+        textSignature ? googleMetadata({ thoughtSignature: textSignature }) : undefined,
      )
      textSignature = undefined
      continue
@@ -684,9 +672,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
        lifecycle,
        events,
        "reasoning-0",
-        reasoningSignature
-          ? providerMetadata(state.providerMetadataKey, { thoughtSignature: reasoningSignature })
-          : undefined,
+        reasoningSignature ? googleMetadata({ thoughtSignature: reasoningSignature }) : undefined,
      )
      lifecycle = Lifecycle.stepStart(lifecycle, events)
      events.push(
@@ -695,7 +681,7 @@ const step = (state: ParserState, event: GeminiEvent) => {
          name: part.functionCall.name,
          input,
          providerMetadata: part.thoughtSignature
-            ? providerMetadata(state.providerMetadataKey, { thoughtSignature: part.thoughtSignature })
+            ? googleMetadata({ thoughtSignature: part.thoughtSignature })
            : undefined,
        }),
      )
@@ -734,7 +720,6 @@ export const protocol = Protocol.make({
    event: Protocol.jsonEvent(GeminiEvent),
    initial: (request) => ({
      route: `${request.model.provider}/${request.model.route.id}`,
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      hasToolCalls: false,
      lifecycle: Lifecycle.initial(),
    }),
@@ -346,8 +346,7 @@ export const Event = Schema.StructWithRest(
    item_id: Schema.optional(Schema.String),
    output_index: Schema.optional(Schema.Number),
    summary_index: Schema.optional(Schema.Number),
-    // OutputItemAdded/Done permit a null item in the Open Responses OpenAPI schema.
-    item: optionalNull(StreamItem),
+    item: Schema.optional(StreamItem),
    response: Schema.optional(
      Schema.StructWithRest(
        Schema.Struct({
@@ -813,7 +812,7 @@ export const providerMetadata = (state: ParserState, metadata: Record<string, un
 })

 const isReasoningItem = (item: StreamItem): item is StreamItem & { type: "reasoning"; id: string } =>
-  item.type === "reasoning" && typeof item.id === "string"
+  item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0

 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]

@@ -892,7 +891,7 @@ const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
  const item = event.item
-  if (item?.type === "message" && item.id !== undefined) {
+  if (item?.type === "message" && item.id) {
    const phase = messagePhase(item.phase)
    return [
      {
@@ -923,7 +922,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
  }
  if (item?.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
  const id = item.id ?? item.call_id
-  const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
+  const metadata = item.id ? providerMetadata(state, { itemId: item.id }) : undefined
  const events: LLMEvent[] = []
  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
  return [
@@ -942,7 +941,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 }

 const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
-  if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
+  if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
  const item = state.reasoningItems[event.item_id]
  if (!item) return [state, NO_EVENTS]
  if (event.summary_index === 0) return [state, NO_EVENTS]
@@ -989,7 +988,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
 }

 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
-  if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
+  if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
  const item = state.reasoningItems[event.item_id]
  if (!item) return [state, NO_EVENTS]
  return [
@@ -1014,7 +1013,7 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
  state: ParserState,
  event: Event,
 ) {
-  if (event.item_id === undefined) return [state, NO_EVENTS] satisfies StepResult
+  if (!event.item_id) return [state, NO_EVENTS] satisfies StepResult
  const tool = state.tools[event.item_id]
  if (!tool) return [state, NO_EVENTS] satisfies StepResult
  const final = event.type === "response.function_call_arguments.done" ? event.arguments : undefined
@@ -1045,7 +1044,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
  const item = event.item
  if (!item) return [state, NO_EVENTS] satisfies StepResult

-  if (item.type === "message" && item.id !== undefined) {
+  if (item.type === "message" && item.id) {
    const itemPhase = messagePhase(item.phase)
    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
    const events: LLMEvent[] = []
@@ -1076,7 +1075,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
      : ToolStream.start(state.tools, id, {
          id: item.call_id,
          name: item.name,
-          providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
+          providerMetadata: item.id ? providerMetadata(state, { itemId: item.id }) : undefined,
        })
    const result =
      item.arguments === undefined
@@ -1137,7 +1136,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
          ([current, events], item) => {
            const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined)
            if (
-              id === undefined ||
+              !id ||
              ((item.type !== "function_call" || !current.tools[id]) &&
                (item.type !== "reasoning" || !current.reasoningItems[id]))
            )
@@ -1220,13 +1219,12 @@ export const providerFailure = (id: string, event: Event, fallback: string) => {
 const providerError = (state: ParserState, event: Event, fallback: string) => providerFailure(state.id, event, fallback)

 export const step = (state: ParserState, input: Event) => {
-  // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
  const event =
-    input.item_id !== undefined && outputItemID(state, input) !== input.item_id
+    input.item_id && outputItemID(state, input) !== input.item_id
      ? { ...input, item_id: outputItemID(state, input) }
      : input
  if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
-    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(
      event.type === "response.output_text.delta"
        ? onOutputTextDelta(state, event, event.item_id)
@@ -1235,7 +1233,7 @@ export const step = (state: ParserState, input: Event) => {
  }
  if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
    const value = event.type === "response.refusal.delta" ? event.delta : event.refusal
-    if (event.item_id === undefined || typeof value !== "string")
+    if (!event.item_id || typeof value !== "string")
      return ProviderShared.eventError(state.id, `${event.type} is malformed`)
    return Effect.succeed(
      event.type === "response.refusal.delta"
@@ -1244,7 +1242,7 @@ export const step = (state: ParserState, input: Event) => {
    )
  }
  if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
-    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(onReasoningDelta(state, event, event.item_id))
  }
  if (
@@ -1252,24 +1250,24 @@ export const step = (state: ParserState, input: Event) => {
    event.type === "response.reasoning_summary_text.done" ||
    event.type === "response.reasoning_text.done"
  ) {
-    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
    return Effect.succeed(onReasoningDone(state, event, event.item_id))
  }
  if (event.type === "response.reasoning_summary_part.added")
-    return event.item_id !== undefined
+    return event.item_id
      ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
  if (event.type === "response.reasoning_summary_part.done")
-    return event.item_id !== undefined
+    return event.item_id
      ? Effect.succeed(onReasoningSummaryPartDone(state, event))
      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
  if (event.type === "response.output_item.added") {
-    if (event.item?.type === "message" && event.item.id === undefined)
+    if (event.item?.type === "message" && !event.item.id)
      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
    const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
    return Effect.succeed(
      onOutputItemAdded(
-        event.output_index !== undefined && id !== undefined
+        event.output_index !== undefined && id
          ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
          : state,
        event,
@@ -1277,11 +1275,11 @@ export const step = (state: ParserState, input: Event) => {
    )
  }
  if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
-    return event.item_id !== undefined
+    return event.item_id
      ? onFunctionCallArgumentsDelta(state, event)
      : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
  if (event.type === "response.output_item.done") {
-    if (event.item?.type === "message" && event.item.id === undefined)
+    if (event.item?.type === "message" && !event.item.id)
      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
    return onOutputItemDone(state, event)
  }
@@ -253,7 +253,6 @@ interface PendingToolDelta {
 }

 export interface ParserState {
-  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<number>
  readonly pendingTools: Partial<Record<number, PendingToolDelta>>
  readonly toolCallEvents: ReadonlyArray<LLMEvent>
@@ -325,18 +324,17 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart
 const openAICompatibleReasoningContent = (native: unknown) =>
  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined

-const reasoningField = (part: ReasoningPart, providerMetadataKey: string) => {
-  const field = part.providerMetadata?.[providerMetadataKey]?.reasoningField
+const reasoningField = (part: ReasoningPart) => {
+  const field = part.providerMetadata?.openai?.reasoningField
  return typeof field === "string" ? field : undefined
 }

-const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown, providerMetadataKey: string) => {
+const reasoningDetails = (parts: ReadonlyArray<ReasoningPart>, native: unknown) => {
  const observed = parts.flatMap((part) => {
-    const details = part.providerMetadata?.[providerMetadataKey]?.reasoningDetails
+    const details = part.providerMetadata?.openai?.reasoningDetails
    return Array.isArray(details) ? details : []
  })
-  if (parts.some((part) => Array.isArray(part.providerMetadata?.[providerMetadataKey]?.reasoningDetails)))
-    return observed
+  if (parts.some((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))) return observed
  if (isRecord(native) && Array.isArray(native.reasoning_details)) return native.reasoning_details
 }

@@ -368,7 +366,7 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
  message: OpenAIChatRequestMessage,
  configuredField: string | undefined,
  requireReasoning: boolean,
-  options: LoweringOptions & { readonly providerMetadataKey: string },
+  options: LoweringOptions,
 ) {
  const content: TextPart[] = []
  const reasoning: ReasoningPart[] = []
@@ -390,14 +388,10 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
    }
  }
  const text = reasoning.map((part) => part.text).join("")
-  const details = reasoningDetails(reasoning, message.native?.openaiCompatible, options.providerMetadataKey)
-  const observedField = reasoning
-    .map((part) => reasoningField(part, options.providerMetadataKey))
-    .find((value) => value !== undefined)
+  const details = reasoningDetails(reasoning, message.native?.openaiCompatible)
+  const observedField = reasoning.map(reasoningField).find((value) => value !== undefined)
  const nativeReasoning = openAICompatibleReasoningContent(message.native?.openaiCompatible)
-  const fullyStructured = reasoning.every((part) =>
-    Array.isArray(part.providerMetadata?.[options.providerMetadataKey]?.reasoningDetails),
-  )
+  const fullyStructured = reasoning.every((part) => Array.isArray(part.providerMetadata?.openai?.reasoningDetails))
  const field = (() => {
    if (configuredField !== undefined && (requireReasoning || reasoning.length > 0 || nativeReasoning !== undefined))
      return configuredField
@@ -465,7 +459,7 @@ const lowerMessage = Effect.fn("OpenAIChat.lowerMessage")(function* (
  message: OpenAIChatRequestMessage,
  reasoningField: string | undefined,
  requireReasoning: boolean,
-  options: LoweringOptions & { readonly providerMetadataKey: string },
+  options: LoweringOptions,
 ) {
  if (message.role === "user") return [yield* lowerUserMessage(message, options)]
  if (message.role === "assistant")
@@ -501,7 +495,6 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
  const mistral = ["mistral", "devstral", "codestral", "pixtral", "mixtral"].some((family) => modelID.includes(family))
  const lowering = {
    ...options,
-    providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
    toolCallID: (id: string) => {
      if (mistral)
        return id
@@ -827,7 +820,7 @@ const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event
 // Providers differ on cache-hit location: OpenAI uses
 // `prompt_tokens_details.cached_tokens`, DeepSeek uses
 // `prompt_cache_hit_tokens`, and Zai uses top-level `cached_tokens`.
-const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string): Usage | undefined => {
+const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
  if (!usage) return undefined
  const input = usage.prompt_tokens ?? undefined
  const output = usage.completion_tokens ?? undefined
@@ -846,7 +839,7 @@ const mapUsage = (usage: OpenAIChatEvent["usage"], providerMetadataKey: string):
    cacheWriteInputTokens: cacheWrite,
    reasoningTokens: reasoning,
    totalTokens: ProviderShared.totalTokens(input, output, usage.total_tokens ?? undefined),
-    providerMetadata: { [providerMetadataKey]: usage },
+    providerMetadata: { openai: usage },
  })
 }

@@ -920,12 +913,8 @@ const conflictingReasoningTextDetails = (previous: Record<string, unknown>, curr
 const conflictingDetailValue = (previous: unknown, current: unknown) =>
  previous !== undefined && previous !== null && current !== undefined && current !== null && previous !== current

-const reasoningMetadata = (
-  providerMetadataKey: string,
-  field: ParserState["reasoningField"],
-  details?: ReadonlyArray<unknown>,
-) => ({
-  [providerMetadataKey]: {
+const reasoningMetadata = (field: ParserState["reasoningField"], details?: ReadonlyArray<unknown>) => ({
+  openai: {
    ...(field ? { reasoningField: field } : {}),
    ...(details ? { reasoningDetails: details } : {}),
  },
@@ -952,10 +941,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    // Moonshot (and a few other OpenAI-compatible providers) attach usage to
    // `choice.usage` instead of the top-level `usage` field.
    const choiceUsage = (choice as unknown as { usage?: OpenAIChatEvent["usage"] })?.usage
-    const usage =
-      mapUsage(event.usage, state.providerMetadataKey) ??
-      (choiceUsage ? mapUsage(choiceUsage, state.providerMetadataKey) : undefined) ??
-      state.usage
+    const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage
    const rawFinishReason = choice?.finish_reason
    const finishReason = rawFinishReason
      ? {
@@ -993,7 +979,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    const detailDelta = Array.isArray(delta?.reasoning_details) ? delta.reasoning_details : undefined
    if (detailDelta !== undefined) appendReasoningDetails(state.reasoningDetails, detailDelta)
    const reasoningDetailsObserved = state.reasoningDetailsObserved || detailDelta !== undefined
-    const deltaMetadata = reasoningMetadata(state.providerMetadataKey, reasoningField)
+    const deltaMetadata = reasoningMetadata(reasoningField)
    const text = detailDelta?.length ? (detailText(detailDelta) ?? reasoning?.text) : reasoning?.text
    if (text !== undefined) lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", text, deltaMetadata)
    else if (
@@ -1009,11 +995,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        lifecycle,
        events,
        "reasoning-0",
-        reasoningMetadata(
-          state.providerMetadataKey,
-          reasoningField,
-          reasoningDetailsObserved ? state.reasoningDetails : undefined,
-        ),
+        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
      )
      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.content)
    }
@@ -1023,11 +1005,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        lifecycle,
        events,
        "reasoning-0",
-        reasoningMetadata(
-          state.providerMetadataKey,
-          reasoningField,
-          reasoningDetailsObserved ? state.reasoningDetails : undefined,
-        ),
+        reasoningMetadata(reasoningField, reasoningDetailsObserved ? state.reasoningDetails : undefined),
      )
      lifecycle = Lifecycle.textDelta(lifecycle, events, "text-0", delta.refusal)
    }
@@ -1088,7 +1066,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>

    return [
      {
-        providerMetadataKey: state.providerMetadataKey,
        tools: finished?.tools ?? tools,
        pendingTools,
        toolCallEvents: finished?.events ?? state.toolCallEvents,
@@ -1132,18 +1109,12 @@ const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: Pars
      }
    : { normalized: hasToolCalls ? ("tool-calls" as const) : ("stop" as const) }
  const metadata = reasoningMetadata(
-    state.providerMetadataKey,
    state.reasoningField,
    state.reasoningDetailsObserved ? state.reasoningDetails : undefined,
  )
  const started =
    state.reasoningDetailsObserved && !state.reasoningEmitted
-      ? Lifecycle.reasoningStart(
-          state.lifecycle,
-          events,
-          "reasoning-0",
-          reasoningMetadata(state.providerMetadataKey, state.reasoningField),
-        )
+      ? Lifecycle.reasoningStart(state.lifecycle, events, "reasoning-0", reasoningMetadata(state.reasoningField))
      : state.lifecycle
  const ended = Lifecycle.reasoningEnd(started, events, "reasoning-0", metadata)
  const lifecycle = toolCallEvents.length ? Lifecycle.stepStart(ended, events) : ended
@@ -1170,7 +1141,6 @@ export const protocol = Protocol.make({
  stream: {
    event: Protocol.jsonEvent(OpenAIChatEvent),
    initial: (request) => ({
-      providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
      tools: ToolStream.empty<number>(),
      pendingTools: {},
      toolCallEvents: [],
@@ -184,7 +184,7 @@ const HOSTED_TOOLS = {

 const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
  if (event.type === "response.reasoning_text.delta")
-    return event.item_id !== undefined
+    return event.item_id
      ? Effect.succeed(
          OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id),
        )
@@ -23,14 +23,13 @@ export interface Settings extends ProviderPackage.Settings {
  readonly baseURL?: string
  readonly credentials?: Credentials
  readonly region?: string
-  readonly topP?: number
  readonly providerOptions?: OpenAIProviderOptionsInput
 }

 const responsesRoute = Route.make({
  id: "bedrock-mantle-responses",
  provider: id,
-  providerMetadataKey: "mantle",
+  providerMetadataKey: OpenAIResponses.route.providerMetadataKey,
  protocol: OpenAIResponses.protocol,
  endpoint: OpenAIResponses.route.endpoint,
  auth: OpenAIResponses.route.auth,
@@ -41,7 +40,6 @@ const responsesRoute = Route.make({
 const chatRoute = OpenAIChat.route.with({
  id: "bedrock-mantle-chat",
  provider: id,
-  providerMetadataKey: "mantle",
 })

 export const routes = [responsesRoute, chatRoute]
@@ -78,7 +76,7 @@ export const configure = (input: Config = {}) => {

  return {
    id,
-    model: responses,
+    model: chat,
    chat,
    responses,
    configure,
@@ -96,7 +94,6 @@ const config = (settings: Settings): Config => {
    apiKey: settings.auth === "sigv4" ? undefined : settings.apiKey,
    baseURL: settings.baseURL,
    credentials: settings.credentials,
-    generation: settings.topP === undefined ? undefined : { topP: settings.topP },
    headers: settings.headers === undefined ? undefined : { ...settings.headers },
    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
    providerOptions: settings.providerOptions,
@@ -112,4 +109,4 @@ export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProvider
  modelID,
  settings,
 ) => configure(config(settings)).responses(modelID)
-export const model = responsesModel
+export const model = chatModel
@@ -35,7 +35,6 @@ const configuredRoute = (input: Config) => {
  return BedrockConverse.route.with({
    ...rest,
    provider: id,
-    providerMetadataKey: "bedrock",
    endpoint: { baseURL: baseURL ?? bedrockBaseURL(resolvedRegion) },
    auth: apiKey === undefined ? BedrockConverse.sigV4Auth(credentials) : Auth.bearer(apiKey),
  })
@@ -1,2 +1,2 @@
-export { responsesModel as model } from "../amazon-bedrock-mantle.js"
+export { chatModel as model } from "../amazon-bedrock-mantle.js"
 export type { Settings } from "../amazon-bedrock-mantle.js"
@@ -27,7 +27,6 @@ export interface Settings extends ProviderPackage.Settings {
 const route = OpenAICompatibleChat.route.with({
  id: "google-vertex-chat",
  provider: id,
-  providerMetadataKey: "vertex",
 })

 export const routes = [route]
@@ -27,7 +27,6 @@ export interface Settings extends ProviderPackage.Settings {
 const route = OpenAICompatibleResponses.route.with({
  id: "google-vertex-responses",
  provider: id,
-  providerMetadataKey: "vertex",
  providerOptions: { store: false },
 })

@@ -68,7 +68,7 @@ const protocol = {
 const route = Route.make({
  id: "google-vertex-gemini",
  provider: id,
-  providerMetadataKey: "vertex",
+  providerMetadataKey: "google",
  protocol,
  endpoint: Endpoint.path(({ request }) => {
    const model = String(request.model.id)
@@ -164,7 +164,6 @@ const bodyOptions = (input: unknown) => {
 export const route = Route.make({
  id: ADAPTER,
  provider: profile.provider,
-  providerMetadataKey: "openrouter",
  protocol,
  endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
  framing: Framing.sse,
@@ -89,7 +89,6 @@ export interface RouteDefaultsInput {
 export interface RoutePatch<Body, Prepared> extends RouteDefaultsInput {
  readonly id?: string
  readonly provider?: string | ProviderID
-  readonly providerMetadataKey?: string
  readonly auth?: Auth.Definition
  readonly transport?: Transport<Body, Prepared, unknown>
  readonly endpoint?: EndpointPatch<Body>
@@ -290,16 +289,11 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
      defaults: routeInput.defaults ?? {},
      body: protocol.body,
      with: (patch: RoutePatch<Body, Prepared>) => {
-        const { id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch
+        const { id, provider, auth, transport, endpoint, ...defaults } = patch
        return build({
          ...routeInput,
          id: id ?? routeInput.id,
          provider: provider ?? routeInput.provider,
-          providerMetadataKey:
-            providerMetadataKey ??
-            (provider !== undefined && String(provider) !== String(routeInput.provider)
-              ? String(provider)
-              : routeInput.providerMetadataKey),
          auth: auth ?? routeInput.auth,
          endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
          transport: (transport as Transport<Body, Prepared, Frame> | undefined) ?? routeInput.transport,
@@ -40,6 +40,17 @@ const headerDetails = (headers: Headers.Headers) =>
 const normalizedHeaders = (headers: Headers.Headers) =>
  Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]))

+const requestId = (headers: Record<string, string>) => {
+  return (
+    headers["x-request-id"] ??
+    headers["request-id"] ??
+    headers["x-amzn-requestid"] ??
+    headers["x-amz-request-id"] ??
+    headers["x-goog-request-id"] ??
+    headers["cf-ray"]
+  )
+}
+
 const retryAfterMs = (headers: Record<string, string>) => {
  const millis = Number(headers["retry-after-ms"])
  if (Number.isFinite(millis)) return Math.max(0, millis)
@@ -136,12 +147,14 @@ const responseHttp = (input: {
  readonly request: HttpClientRequest.HttpClientRequest
  readonly response: HttpClientResponse.HttpClientResponse
  readonly body: ReturnType<typeof responseBody>
+  readonly requestId?: string | undefined
  readonly rateLimit?: HttpRateLimitDetails | undefined
 }) =>
  new HttpContext({
    request: requestDetails(input.request),
    response: responseDetails(input.response),
    ...input.body,
+    requestId: input.requestId,
    rateLimit: input.rateLimit,
  })

@@ -166,6 +179,7 @@ const statusError =
            request,
            response,
            body: details,
+            requestId: requestId(headers),
            rateLimit,
          }),
        }),
@@ -202,6 +216,7 @@ export const classifyHttpFailure = (input: {
          ? undefined
          : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
      ...details,
+      requestId: requestId(headers),
      rateLimit,
    }),
  })
@@ -29,6 +29,7 @@ export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
  response: Schema.optional(HttpResponseDetails),
  body: Schema.optional(Schema.String),
  bodyTruncated: Schema.optional(Schema.Boolean),
+  requestId: Schema.optional(Schema.String),
  rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {}

@@ -327,6 +327,7 @@ describe("RequestExecutor", () => {
          retryAfterMs: 0,
          rateLimit: { retryAfterMs: 0 },
          http: {
+            requestId: "req_123",
            request: {
              method: "POST",
              url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
@@ -2,7 +2,7 @@ import { describe, expect } from "bun:test"
 import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { CacheHint, LLM, AIError, LLMRequest, Message, ToolCallPart, ToolDefinition, Usage } from "../../src/index.js"
-import { Auth, Endpoint, LLMClient, Route } from "../../src/route.js"
+import { Auth, LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import * as AnthropicMessages from "../../src/protocols/anthropic-messages.js"
 import { GoogleVertexMessages } from "../../src/providers.js"
@@ -810,99 +810,6 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("round-trips compatible provider metadata in its own namespace", () =>
-    Effect.gen(function* () {
-      const compatible = Route.make({
-        id: "custom-anthropic-messages",
-        provider: "custom-anthropic",
-        protocol: AnthropicMessages.protocol,
-        endpoint: Endpoint.path("/messages", { baseURL: "https://compatible.test/v1" }),
-        auth: Auth.header("x-api-key", "test"),
-        framing: AnthropicMessages.framing,
-      }).model({ id: "custom-model" })
-      const result = [
-        {
-          type: "web_search_result",
-          url: "https://example.com",
-          citations: [{ type: "web_search_result_location", cited_text: "Example" }],
-        },
-      ]
-      const response = yield* LLMClient.generate(LLM.request({ model: compatible, prompt: "Search." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5, custom_start: true } } },
-              { type: "content_block_start", index: 0, content_block: { type: "thinking", thinking: "Thinking." } },
-              { type: "content_block_delta", index: 0, delta: { type: "signature_delta", signature: "custom_sig" } },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "content_block_start",
-                index: 1,
-                content_block: { type: "redacted_thinking", data: "custom_redacted" },
-              },
-              { type: "content_block_stop", index: 1 },
-              {
-                type: "content_block_start",
-                index: 2,
-                content_block: {
-                  type: "server_tool_use",
-                  id: "custom_tool",
-                  name: "web_search",
-                  input: { query: "example" },
-                },
-              },
-              { type: "content_block_stop", index: 2 },
-              {
-                type: "content_block_start",
-                index: 3,
-                content_block: { type: "web_search_tool_result", tool_use_id: "custom_tool", content: result },
-              },
-              { type: "content_block_stop", index: 3 },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "end_turn", stop_sequence: "custom_stop" },
-                usage: { output_tokens: 2, custom_terminal: true },
-              },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toMatchObject([
-        { type: "reasoning", text: "Thinking.", providerMetadata: { "custom-anthropic": { signature: "custom_sig" } } },
-        { type: "reasoning", text: "", providerMetadata: { "custom-anthropic": { redactedData: "custom_redacted" } } },
-        { type: "tool-call", id: "custom_tool", providerExecuted: true },
-        {
-          type: "tool-result",
-          providerExecuted: true,
-          providerMetadata: { "custom-anthropic": { blockType: "web_search_tool_result", result } },
-        },
-      ])
-      expect(response.usage?.providerMetadata).toEqual({
-        "custom-anthropic": { input_tokens: 5, custom_start: true, output_tokens: 2, custom_terminal: true },
-      })
-      expect(response.events.at(-1)).toMatchObject({
-        providerMetadata: { "custom-anthropic": { stopSequence: "custom_stop" } },
-      })
-
-      const prepared = yield* compileRequest(
-        LLM.request({ model: compatible, messages: [response.message], cache: "none" }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [
-            { type: "thinking", thinking: "Thinking.", signature: "custom_sig" },
-            { type: "redacted_thinking", data: "custom_redacted" },
-            { type: "server_tool_use", id: "custom_tool", name: "web_search", input: { query: "example" } },
-            { type: "web_search_tool_result", tool_use_id: "custom_tool", content: result },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("parses text, reasoning, and usage stream fixtures", () =>
    Effect.gen(function* () {
      const body = sseEvents(
@@ -569,57 +569,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("round-trips reassigned provider reasoning and usage metadata in its own namespace", () =>
-    Effect.gen(function* () {
-      const compatible = model.route.with({ provider: "custom-bedrock" }).model({ id: model.id })
-      const redactedData = "cmVkYWN0ZWQtdGhpbmtpbmc="
-      const response = yield* LLMClient.generate(LLMRequest.update(baseRequest, { model: compatible })).pipe(
-        Effect.provide(
-          fixedBytes(
-            eventStreamBody(
-              ["messageStart", { role: "assistant" }],
-              ["contentBlockDelta", { contentBlockIndex: 0, delta: { reasoningContent: { text: "Let me think." } } }],
-              ["contentBlockDelta", { contentBlockIndex: 0, delta: { reasoningContent: { signature: "custom_sig" } } }],
-              ["contentBlockStop", { contentBlockIndex: 0 }],
-              [
-                "contentBlockDelta",
-                { contentBlockIndex: 1, delta: { reasoningContent: { redactedContent: redactedData } } },
-              ],
-              ["contentBlockStop", { contentBlockIndex: 1 }],
-              ["messageStop", { stopReason: "end_turn" }],
-              ["metadata", { usage: { inputTokens: 5, outputTokens: 2, totalTokens: 7 } }],
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "reasoning",
-          text: "Let me think.",
-          providerMetadata: { "custom-bedrock": { signature: "custom_sig" } },
-        },
-        { type: "reasoning", text: "", providerMetadata: { "custom-bedrock": { redactedData } } },
-      ])
-      expect(response.usage?.providerMetadata).toEqual({
-        "custom-bedrock": { inputTokens: 5, outputTokens: 2, totalTokens: 7 },
-      })
-
-      const prepared = yield* compileRequest(
-        LLM.request({ model: compatible, messages: [response.message], cache: "none" }),
-      )
-      expect(prepared.body.messages).toEqual([
-        {
-          role: "assistant",
-          content: [
-            { reasoningContent: { reasoningText: { text: "Let me think.", signature: "custom_sig" } } },
-            { reasoningContent: { redactedContent: redactedData } },
-          ],
-        },
-      ])
-    }),
-  )
-
  it.effect("preserves reasoning signatures when contentBlockStop is missing", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(baseRequest).pipe(
@@ -3,7 +3,6 @@ import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message } from "../../src/index.js"
 import { AmazonBedrockMantle } from "../../src/providers.js"
-import { model } from "../../src/providers/amazon-bedrock/mantle.js"
 import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
 import { compileRequest, LLMClient } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
@@ -18,16 +17,13 @@ const credentials = {
 }

 describe("Amazon Bedrock Mantle provider", () => {
-  it.effect("uses Responses by default and exposes Chat explicitly", () =>
+  it.effect("uses Chat by default and exposes Responses", () =>
    Effect.gen(function* () {
      const provider = AmazonBedrockMantle.configure({ credentials })
-      expect(provider.model).toBe(provider.responses)
-      expect(AmazonBedrockMantle.model).toBe(AmazonBedrockMantle.responsesModel)
-      expect(model).toBe(AmazonBedrockMantle.responsesModel)
-      expect(provider.model("openai.gpt-oss-120b").route.transport).toBe(OpenAIResponses.httpTransport)
-      const chat = yield* compileRequest(LLM.request({ model: provider.chat("openai.gpt-oss-120b"), prompt: "Hi" }))
+      expect(provider.responses("openai.gpt-oss-120b").route.transport).toBe(OpenAIResponses.httpTransport)
+      const chat = yield* compileRequest(LLM.request({ model: provider.model("openai.gpt-oss-120b"), prompt: "Hi" }))
      const responses = yield* compileRequest(
-        LLM.request({ model: provider.model("openai.gpt-oss-120b"), prompt: "Hi" }),
+        LLM.request({ model: provider.responses("openai.gpt-oss-120b"), prompt: "Hi" }),
      )

      expect(chat).toMatchObject({
@@ -40,23 +36,6 @@ describe("Amazon Bedrock Mantle provider", () => {
        protocol: "openai-responses",
        body: { model: "openai.gpt-oss-120b", store: false },
      })
-      expect(provider.model("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
-      expect(provider.chat("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
-    }),
-  )
-
-  it.effect("preserves configured top-p generation defaults for Chat and Responses", () =>
-    Effect.gen(function* () {
-      const settings = { apiKey: "test-key", topP: 0.8 }
-      const chat = yield* compileRequest(
-        LLM.request({ model: AmazonBedrockMantle.chatModel("openai.gpt-oss-safeguard-20b", settings), prompt: "Hi" }),
-      )
-      const responses = yield* compileRequest(
-        LLM.request({ model: AmazonBedrockMantle.responsesModel("openai.gpt-oss-120b", settings), prompt: "Hi" }),
-      )
-
-      expect(chat.body.top_p).toBe(0.8)
-      expect(responses.body.top_p).toBe(0.8)
    }),
  )

@@ -128,9 +107,6 @@ describe("Amazon Bedrock Mantle provider", () => {
        LLM.request({ model, messages: [response.message, Message.user("Continue.")] }),
      )

-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        mantle: { itemId: "msg_95d4d0af4350432a", reasoningEncryptedContent: "mantle-state" },
-      })
      expect(prepared.body.input).toEqual([
        {
          type: "reasoning",
@@ -126,7 +126,7 @@ describe("Cloudflare", () => {
      expect(response.reasoning).toBe("Thinking")
      expect(response.events.filter(LLMEvent.is.reasoningDelta)).toHaveLength(2)
      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        "cloudflare-ai-gateway": { reasoningField: "reasoning", reasoningDetails: merged },
+        openai: { reasoningField: "reasoning", reasoningDetails: merged },
      })

      const replay = yield* compileRequest(LLM.request({ model, messages: [response.message] }))
@@ -6,7 +6,7 @@ import { GoogleVertex, GoogleVertexChat, GoogleVertexMessages, GoogleVertexRespo
 import { LLMClient } from "../../src/route.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
-import { dynamicResponse, fixedResponse } from "../lib/http.js"
+import { dynamicResponse } from "../lib/http.js"
 import { deltaChunk, finishChunk } from "../lib/openai-chunks.js"
 import { sseEvents } from "../lib/sse.js"

@@ -89,7 +89,7 @@ describe("Google Vertex providers", () => {
                id: "call_1",
                name: "lookup",
                input: { query: "weather" },
-                providerMetadata: { vertex: { functionCallId: "provider_call_1" } },
+                providerMetadata: { google: { functionCallId: "provider_call_1" } },
              }),
            ]),
            Message.tool({
@@ -97,7 +97,7 @@ describe("Google Vertex providers", () => {
              name: "lookup",
              result: "sunny",
              resultType: "text",
-              providerMetadata: { vertex: { functionCallId: "provider_call_1" } },
+              providerMetadata: { google: { functionCallId: "provider_call_1" } },
            }),
          ],
        }),
@@ -122,91 +122,6 @@ describe("Google Vertex providers", () => {
    }),
  )

-  it.effect("round-trips Vertex Gemini metadata through signed content, tool calls, and usage", () =>
-    Effect.gen(function* () {
-      const model = GoogleVertex.configure({
-        accessToken: "vertex-token",
-        project: "vertex-project",
-      }).model("gemini-3.5-flash")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Check the weather." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              candidates: [
-                {
-                  content: {
-                    role: "model",
-                    parts: [
-                      { text: "Thinking.", thought: true, thoughtSignature: "reasoning_sig" },
-                      { text: "Checking.", thoughtSignature: "text_sig" },
-                      {
-                        functionCall: { id: "provider_call_1", name: "lookup", args: { query: "weather" } },
-                        thoughtSignature: "tool_sig",
-                      },
-                    ],
-                  },
-                  finishReason: "STOP",
-                },
-              ],
-              promptFeedback: { blockReasonMessage: "Reviewed" },
-              usageMetadata: { promptTokenCount: 5, candidatesTokenCount: 2, thoughtsTokenCount: 1 },
-            }),
-          ),
-        ),
-      )
-      const reasoning = response.events.find((event) => event.type === "reasoning-end")
-      const text = response.events.find((event) => event.type === "text-delta")
-      const toolCall = response.toolCalls[0]
-
-      expect(reasoning?.providerMetadata).toEqual({ vertex: { thoughtSignature: "reasoning_sig" } })
-      expect(text?.providerMetadata).toEqual({ vertex: { thoughtSignature: "text_sig" } })
-      expect(toolCall).toMatchObject({
-        id: "provider_call_1",
-        providerMetadata: { vertex: { thoughtSignature: "tool_sig" } },
-      })
-      expect(response.usage?.providerMetadata).toEqual({
-        vertex: { promptTokenCount: 5, candidatesTokenCount: 2, thoughtsTokenCount: 1 },
-      })
-      expect(response.events.at(-1)?.providerMetadata).toEqual({
-        vertex: { promptFeedback: { blockReasonMessage: "Reviewed" } },
-      })
-
-      const prepared = yield* compileRequest(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              { type: "reasoning", text: "Thinking.", providerMetadata: reasoning?.providerMetadata },
-              { type: "text", text: "Checking.", providerMetadata: text?.providerMetadata },
-              ToolCallPart.make({
-                id: toolCall.id,
-                name: toolCall.name,
-                input: toolCall.input,
-                providerMetadata: toolCall.providerMetadata,
-              }),
-            ]),
-            Message.tool({ id: toolCall.id, name: toolCall.name, result: "sunny", resultType: "text" }),
-          ],
-        }),
-      )
-
-      expect(prepared.body.contents).toEqual([
-        {
-          role: "model",
-          parts: [
-            { text: "Thinking.", thought: true, thoughtSignature: "reasoning_sig" },
-            { text: "Checking.", thoughtSignature: "text_sig" },
-            { functionCall: { name: "lookup", args: { query: "weather" } }, thoughtSignature: "tool_sig" },
-          ],
-        },
-        {
-          role: "user",
-          parts: [{ functionResponse: { name: "lookup", response: { name: "lookup", content: "sunny" } } }],
-        },
-      ])
-    }),
-  )
-
  it.effect("projects Anthropic Messages onto the Vertex raw-predict API", () =>
    Effect.gen(function* () {
      const model = GoogleVertexMessages.configure({
@@ -2,80 +2,13 @@ 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"
-import {
-  AmazonBedrock,
-  AmazonBedrockMantle,
-  Anthropic,
-  AnthropicCompatible,
-  Azure,
-  Cerebras,
-  CloudflareAIGateway,
-  CloudflareWorkersAI,
-  DeepInfra,
-  Google,
-  GoogleVertex,
-  GoogleVertexChat,
-  GoogleVertexMessages,
-  GoogleVertexResponses,
-  Groq,
-  OpenAI,
-  OpenAICompatible,
-  OpenAICompatibleResponses,
-  OpenRouter,
-  TogetherAI,
-  XAI,
-} from "../../src/providers/index.js"
+import { Cerebras, DeepInfra, Groq, TogetherAI } from "../../src/providers/index.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse } from "../lib/http.js"
 import { sseEvents } from "../lib/sse.js"

 describe("native OpenAI-compatible providers", () => {
-  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)
-    }),
-  )
-
  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")
@@ -68,13 +68,11 @@ for (const item of cases) {
          expect(response.text.replaceAll(",", "").trim()).toBe("37887")
          expect(response.reasoning.length).toBeGreaterThan(0)
          expect(response.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
-          const metadata = response.message.content.find((part) => part.type === "reasoning")?.providerMetadata?.[
-            item.model.route.providerMetadataKey ?? String(item.model.provider)
-          ]
-          expect(metadata?.reasoningField).toBe(item.structured ? "reasoning" : "reasoning_content")
-          expect(Array.isArray(metadata?.reasoningDetails)).toBe(item.structured)
+          const metadata = response.message.content.find((part) => part.type === "reasoning")?.providerMetadata
+          expect(metadata?.openai?.reasoningField).toBe(item.structured ? "reasoning" : "reasoning_content")
+          expect(Array.isArray(metadata?.openai?.reasoningDetails)).toBe(item.structured)
          if (!item.structured) return
-          const details = metadata?.reasoningDetails
+          const details = metadata?.openai?.reasoningDetails
          if (!Array.isArray(details)) return
          expect(
            details.some(
@@ -128,11 +126,7 @@ for (const item of cases) {
          ).toMatch(/^Paris is sunny\.?$/)
          const details = events
            .filter(LLMEvent.is.reasoningEnd)
-            .map(
-              (event) =>
-                event.providerMetadata?.[item.model.route.providerMetadataKey ?? String(item.model.provider)]
-                  ?.reasoningDetails,
-            )
+            .map((event) => event.providerMetadata?.openai?.reasoningDetails)
            .find(Array.isArray)
          expect(Array.isArray(details)).toBe(item.structured)
          if (!item.structured || !Array.isArray(details)) return
@@ -903,70 +903,6 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("uses the configured provider metadata namespace for reasoning and usage", () =>
-    Effect.gen(function* () {
-      const selected = LanguageModel.update(model, {
-        route: { ...model.route, providerMetadataKey: "vendor" },
-      })
-      const details = [{ type: "reasoning.text", text: "thinking", signature: "signed" }]
-      const response = yield* LLMClient.generate(LLMRequest.update(request, { model: selected })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { choices: [{ delta: { reasoning: "thinking", reasoning_details: details } }] },
-              deltaChunk({ content: "Hello" }),
-              deltaChunk({}, "stop"),
-              usageChunk({ prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 }),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        vendor: { reasoningField: "reasoning", reasoningDetails: details },
-      })
-      expect(response.usage?.providerMetadata).toEqual({
-        vendor: { prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 },
-      })
-
-      const replay = yield* compileRequest(LLM.request({ model: selected, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([
-        { role: "assistant", content: "Hello", reasoning: "thinking", reasoning_details: details },
-      ])
-    }),
-  )
-
-  it.effect("falls back to the selected provider for the metadata namespace", () =>
-    Effect.gen(function* () {
-      const compatible = model.route.with({ provider: "deepseek" }).model({ id: "deepseek-chat" })
-      const selected = LanguageModel.update(compatible, {
-        route: { ...compatible.route, providerMetadataKey: undefined },
-      })
-      const response = yield* LLMClient.generate(LLMRequest.update(request, { model: selected })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              deltaChunk({ reasoning_content: "thinking" }),
-              deltaChunk({ content: "Hello" }),
-              deltaChunk({}, "stop"),
-              usageChunk({ prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 }),
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-        deepseek: { reasoningField: "reasoning_content" },
-      })
-      expect(response.usage?.providerMetadata).toEqual({
-        deepseek: { prompt_tokens: 5, completion_tokens: 2, total_tokens: 7 },
-      })
-
-      const replay = yield* compileRequest(LLM.request({ model: selected, messages: [response.message] }))
-      expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", reasoning_content: "thinking" }])
-    }),
-  )
-
  it.effect("parses and replays a configured custom reasoning field", () =>
    Effect.gen(function* () {
      const custom = LanguageModel.update(model, { compatibility: { reasoningField: "vendor_reasoning" } })
@@ -437,7 +437,7 @@ describe("OpenAI-compatible Chat route", () => {
        outputTokens: undefined,
        totalTokens: undefined,
        providerMetadata: {
-          deepseek: {
+          openai: {
            prompt_tokens: null,
            completion_tokens: null,
            total_tokens: null,
@@ -195,19 +195,19 @@ describe("Open Responses-compatible route", () => {
          model,
          messages: [
            Message.assistant([
-              { type: "text", text: "Kept.", providerMetadata: { "openai-compatible": { itemId: "history_1" } } },
+              { type: "text", text: "Kept.", providerMetadata: { openresponses: { itemId: "history_1" } } },
              {
                type: "text",
                text: "Long.",
-                providerMetadata: { "openai-compatible": { itemId: `history_${"a".repeat(64)}` } },
+                providerMetadata: { openresponses: { itemId: `history_${"a".repeat(64)}` } },
              },
              {
                type: "text",
                text: "Opaque.",
-                providerMetadata: { "openai-compatible": { itemId: "provider_value/with+symbols" } },
+                providerMetadata: { openresponses: { itemId: "provider_value/with+symbols" } },
              },
-              { type: "text", text: "No suffix.", providerMetadata: { "openai-compatible": { itemId: "msg_" } } },
-              { type: "text", text: "No prefix.", providerMetadata: { "openai-compatible": { itemId: "_item" } } },
+              { type: "text", text: "No suffix.", providerMetadata: { openresponses: { itemId: "msg_" } } },
+              { type: "text", text: "No prefix.", providerMetadata: { openresponses: { itemId: "_item" } } },
            ]),
          ],
        }),
@@ -267,7 +267,7 @@ describe("Open Responses-compatible route", () => {
              name: item.type,
              result: { type: "json", value: item },
              providerExecuted: true,
-              providerMetadata: { example: { itemId: item.id } },
+              providerMetadata: { openresponses: { itemId: item.id } },
            }),
          ),
        }),
@@ -302,296 +302,11 @@ describe("Open Responses-compatible route", () => {
      )

      expect(response.message.content).toEqual([
-        { type: "text", text: "Indexed", providerMetadata: { "openai-compatible": { itemId: "msg_1" } } },
+        { type: "text", text: "Indexed", providerMetadata: { openresponses: { itemId: "msg_1" } } },
      ])
    }),
  )

-  describe("stream validation", () => {
-    const request = LLM.request({
-      model: configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model("example-model"),
-      prompt: "Respond.",
-    })
-
-    const fixtures = [
-      {
-        item: { type: "message" },
-        events: [
-          { type: "response.output_text.delta", delta: "Preserved" },
-          { type: "response.output_text.done", text: "Preserved" },
-          { type: "response.refusal.delta", delta: "Preserved" },
-          { type: "response.refusal.done", refusal: "Preserved" },
-        ],
-      },
-      {
-        item: { type: "reasoning", encrypted_content: "encrypted-state" },
-        events: [
-          { type: "response.reasoning.delta", delta: "Preserved" },
-          { type: "response.reasoning.done", text: "Preserved" },
-          { type: "response.reasoning_summary_text.delta", delta: "Preserved" },
-          { type: "response.reasoning_summary_text.done", text: "Preserved" },
-          { type: "response.reasoning_text.done", text: "Preserved" },
-        ],
-      },
-      {
-        item: { type: "function_call", call_id: "call_1", name: "lookup" },
-        events: [
-          { type: "response.function_call_arguments.delta", delta: '{"query":"Preserved"}' },
-          { type: "response.function_call_arguments.done", arguments: '{"query":"Preserved"}' },
-        ],
-      },
-    ]
-
-    const routings = [
-      { name: "empty item and event IDs", id: "", item_id: "" },
-      { name: "empty event ID with registered index", id: "item_1", item_id: "", output_index: 2 },
-      { name: "empty stored ID with registered index", id: "", item_id: "wrong_item", output_index: 2 },
-      { name: "empty item and event IDs with registered index", id: "", item_id: "", output_index: 2 },
-    ]
-
-    fixtures.forEach((fixture) => {
-      fixture.events.forEach((event) => {
-        routings.forEach((routing) => {
-          it.effect(`${event.type} preserves content with ${routing.name}`, () =>
-            Effect.gen(function* () {
-              const item = { ...fixture.item, id: routing.id }
-              const response = yield* LLMClient.generate(request).pipe(
-                Effect.provide(
-                  fixedResponse(
-                    sseEvents(
-                      { type: "response.output_item.added", output_index: routing.output_index, item },
-                      { ...event, item_id: routing.item_id, output_index: routing.output_index },
-                      { type: "response.output_item.done", output_index: routing.output_index, item },
-                      { type: "response.completed", response: { id: "resp_1" } },
-                    ),
-                  ),
-                ),
-              )
-
-              const metadata = { "openai-compatible": { itemId: routing.id } }
-              if (fixture.item.type === "function_call") {
-                expect(response.toolCalls).toEqual([
-                  expect.objectContaining({
-                    id: "call_1",
-                    name: "lookup",
-                    input: { query: "Preserved" },
-                    providerMetadata: metadata,
-                  }),
-                ])
-                return
-              }
-              if (fixture.item.type === "reasoning") {
-                expect(response.message.content).toEqual([
-                  {
-                    type: "reasoning",
-                    text: "Preserved",
-                    providerMetadata: {
-                      "openai-compatible": { itemId: routing.id, reasoningEncryptedContent: "encrypted-state" },
-                    },
-                  },
-                ])
-                expect(response.events.filter(LLMEvent.is.reasoningEnd)).toHaveLength(1)
-                return
-              }
-              expect(response.message.content).toEqual([
-                { type: "text", text: "Preserved", providerMetadata: metadata },
-              ])
-              expect(response.events.filter(LLMEvent.is.textEnd)).toEqual([
-                expect.objectContaining({ id: routing.id, providerMetadata: metadata }),
-              ])
-            }),
-          )
-        })
-      })
-    })
-
-    routings.forEach((routing) => {
-      it.effect(`preserves reasoning summary boundaries and terminal metadata with ${routing.name}`, () =>
-        Effect.gen(function* () {
-          const address = { item_id: routing.item_id, output_index: routing.output_index }
-          const response = yield* LLMClient.generate(request).pipe(
-            Effect.provide(
-              fixedResponse(
-                sseEvents(
-                  {
-                    type: "response.output_item.added",
-                    output_index: routing.output_index,
-                    item: { type: "reasoning", id: routing.id },
-                  },
-                  { type: "response.reasoning_summary_part.added", ...address, summary_index: 0 },
-                  { type: "response.reasoning_summary_text.delta", ...address, summary_index: 0, delta: "First." },
-                  { type: "response.reasoning_summary_text.done", ...address, summary_index: 0, text: "First." },
-                  { type: "response.reasoning_summary_part.done", ...address, summary_index: 0 },
-                  { type: "response.reasoning_summary_part.added", ...address, summary_index: 1 },
-                  { type: "response.reasoning_summary_text.done", ...address, summary_index: 1, text: "Second." },
-                  { type: "response.reasoning_summary_part.done", ...address, summary_index: 1 },
-                  {
-                    type: "response.completed",
-                    response: { output: [{ type: "reasoning", id: routing.id, encrypted_content: "final-state" }] },
-                  },
-                ),
-              ),
-            ),
-          )
-
-          expect(response.message.content).toEqual([
-            {
-              type: "reasoning",
-              text: "First.",
-              providerMetadata: { "openai-compatible": { itemId: routing.id } },
-            },
-            {
-              type: "reasoning",
-              text: "Second.",
-              providerMetadata: {
-                "openai-compatible": { itemId: routing.id, reasoningEncryptedContent: "final-state" },
-              },
-            },
-          ])
-          expect(response.events.filter(LLMEvent.is.reasoningEnd)).toEqual([
-            expect.objectContaining({
-              id: `${routing.id}:0`,
-              providerMetadata: { "openai-compatible": { itemId: routing.id } },
-            }),
-            expect.objectContaining({
-              id: `${routing.id}:1`,
-              providerMetadata: {
-                "openai-compatible": { itemId: routing.id, reasoningEncryptedContent: "final-state" },
-              },
-            }),
-          ])
-        }),
-      )
-    })
-
-    it.effect("reconciles pending empty-ID function arguments from completed output", () =>
-      Effect.gen(function* () {
-        const item = { type: "function_call", id: "", call_id: "call_1", name: "lookup" }
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents(
-                { type: "response.output_item.added", item },
-                { type: "response.function_call_arguments.delta", item_id: "", delta: '{"query":"partial' },
-                {
-                  type: "response.completed",
-                  response: { output: [{ ...item, arguments: '{"query":"complete"}' }] },
-                },
-              ),
-            ),
-          ),
-        )
-
-        expect(response.toolCalls).toEqual([
-          expect.objectContaining({
-            id: "call_1",
-            name: "lookup",
-            input: { query: "complete" },
-            providerMetadata: { "openai-compatible": { itemId: "" } },
-          }),
-        ])
-      }),
-    )
-
-    it.effect("treats null output items as no-ops without disturbing registered items", () =>
-      Effect.gen(function* () {
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents(
-                { type: "response.output_item.added", output_index: 0, item: null },
-                { type: "response.output_item.done", output_index: 0, item: null },
-                { type: "response.output_item.added", output_index: 0, item: { type: "message", id: "msg_1" } },
-                { type: "response.output_text.delta", output_index: 0, item_id: "wrong_item", delta: "Before " },
-                { type: "response.output_item.added", output_index: 0, item: null },
-                { type: "response.output_item.done", output_index: 0, item: null },
-                { type: "response.output_text.delta", output_index: 0, item_id: "wrong_item", delta: "after" },
-                { type: "response.output_item.done", output_index: 0, item: { type: "message", id: "msg_1" } },
-                { type: "response.completed", response: { id: "resp_1" } },
-              ),
-            ),
-          ),
-        )
-
-        expect(response.message.content).toEqual([
-          { type: "text", text: "Before after", providerMetadata: { "openai-compatible": { itemId: "msg_1" } } },
-        ])
-        expect(response.events.map((event) => event.type)).toEqual([
-          "step-start",
-          "text-start",
-          "text-delta",
-          "text-delta",
-          "text-end",
-          "step-finish",
-          "finish",
-        ])
-      }),
-    )
-
-    it.effect("rejects missing, null, and non-string event IDs even with a registered output index", () =>
-      Effect.gen(function* () {
-        yield* Effect.forEach(
-          [
-            ...fixtures.flatMap((fixture) => fixture.events.map((event) => ({ item: fixture.item, event }))),
-            ...["response.reasoning_summary_part.added", "response.reasoning_summary_part.done"].map((type) => ({
-              item: { type: "reasoning" },
-              event: { type, summary_index: 0 },
-            })),
-          ],
-          (fixture) =>
-            Effect.forEach([undefined, null, 0, false, {}, []], (item_id) =>
-              Effect.gen(function* () {
-                const error = yield* LLMClient.generate(request).pipe(
-                  Effect.provide(
-                    fixedResponse(
-                      sseEvents(
-                        {
-                          type: "response.output_item.added",
-                          output_index: 0,
-                          item: { ...fixture.item, id: "item_1" },
-                        },
-                        { ...fixture.event, output_index: 0, item_id },
-                        { type: "response.completed", response: { id: "resp_1" } },
-                      ),
-                    ),
-                  ),
-                  Effect.flip,
-                )
-                expect(error.reason._tag).toBe("InvalidProviderOutput")
-              }),
-            ),
-        )
-      }),
-    )
-
-    it.effect("keeps malformed output item IDs invalid", () =>
-      Effect.gen(function* () {
-        yield* Effect.forEach(["response.output_item.added", "response.output_item.done"], (type) =>
-          Effect.forEach(fixtures, (fixture) =>
-            Effect.forEach(
-              fixture.item.type === "message" ? [undefined, null, 0, false, {}, []] : [null, 0, false, {}, []],
-              (id) =>
-                Effect.gen(function* () {
-                  const error = yield* LLMClient.generate(request).pipe(
-                    Effect.provide(
-                      fixedResponse(
-                        sseEvents(
-                          { type, item: { ...fixture.item, id } },
-                          { type: "response.completed", response: { id: "resp_1" } },
-                        ),
-                      ),
-                    ),
-                    Effect.flip,
-                  )
-                  expect(error.reason._tag).toBe("InvalidProviderOutput")
-                }),
-            ),
-          ),
-        )
-      }),
-    )
-  })
-
  it.effect("streams function calls without optional item ids through the shared baseline", () =>
    Effect.gen(function* () {
      const model = configure({
@@ -666,7 +381,7 @@ describe("Open Responses-compatible route", () => {

      expect(response.events.find(LLMEvent.is.toolCall)).toMatchObject({
        input: { query: "complete" },
-        providerMetadata: { example: { itemId: "item_1" } },
+        providerMetadata: { openresponses: { itemId: "item_1" } },
      })
    }),
  )
@@ -698,7 +413,7 @@ describe("Open Responses-compatible route", () => {
      )

      expect(response.events.find((event) => event.type === "reasoning-end")).toMatchObject({
-        providerMetadata: { "openai-compatible": { itemId: "rs_raw", reasoningEncryptedContent: "raw-state" } },
+        providerMetadata: { openresponses: { itemId: "rs_raw", reasoningEncryptedContent: "raw-state" } },
      })
    }),
  )
@@ -747,7 +462,7 @@ describe("Open Responses-compatible route", () => {
            Message.assistant({
              type: "text",
              text: "Unclassified.",
-              providerMetadata: { "openai-compatible": { phase: null } },
+              providerMetadata: { openresponses: { phase: null } },
            }),
          ],
        }),
@@ -806,7 +521,7 @@ describe("Open Responses-compatible route", () => {
        {
          type: "text",
          text: "I can't help with that.",
-          providerMetadata: { example: { itemId: "msg_refusal" } },
+          providerMetadata: { openresponses: { itemId: "msg_refusal" } },
        },
      ])

@@ -895,7 +610,7 @@ describe("Open Responses-compatible route", () => {

      expect(response.toolCalls).toEqual([])
      expect(response.events.find(LLMEvent.is.finish)).toMatchObject({
-        providerMetadata: { example: { responseId: "resp_1" } },
+        providerMetadata: { openresponses: { responseId: "resp_1" } },
      })
    }),
  )
@@ -2229,35 +2229,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("accepts empty IDs for native reasoning text deltas", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "response.output_item.added", output_index: 1, item: { type: "reasoning", id: "" } },
-              { type: "response.reasoning_text.delta", output_index: 1, item_id: "", delta: "Raw" },
-              {
-                type: "response.output_item.done",
-                output_index: 1,
-                item: { type: "reasoning", id: "", encrypted_content: "state" },
-              },
-              { type: "response.completed", response: { id: "resp_1" } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.message.content).toEqual([
-        {
-          type: "reasoning",
-          text: "Raw",
-          providerMetadata: { openai: { itemId: "", reasoningEncryptedContent: "state" } },
-        },
-      ])
-    }),
-  )
-
  it.effect("falls back to item ids when an output index was not registered", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(request).pipe(
@@ -295,7 +295,7 @@ describe("OpenRouter", () => {
              {
                type: "reasoning",
                text: "Thinking",
-                providerMetadata: { openrouter: { reasoningField: "reasoning", reasoningDetails: details } },
+                providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
              },
            ]),
          ],
@@ -328,7 +328,7 @@ describe("OpenRouter", () => {
            Message.assistant({
              type: "reasoning",
              text: "Thinking",
-              providerMetadata: { openrouter: { reasoningField: "reasoning", reasoningDetails: details } },
+              providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
            }),
          ],
        }),
@@ -354,7 +354,7 @@ describe("OpenRouter", () => {
            Message.assistant({
              type: "reasoning",
              text: "AB",
-              providerMetadata: { openrouter: { reasoningField: "reasoning", reasoningDetails: details } },
+              providerMetadata: { openai: { reasoningField: "reasoning", reasoningDetails: details } },
            }),
          ],
        }),
@@ -40,13 +40,4 @@ describe("Route.with", () => {
      "x-patch": "patch",
    })
  })
-
-  test("assigns metadata ownership to a replacement provider and preserves explicit overrides", () => {
-    const route = OpenAIChat.route.with({ provider: "azure" })
-    const overridden = route.with({ providerMetadataKey: "custom-azure" }).with({ headers: { "x-test": "value" } })
-
-    expect(route.providerMetadataKey).toBe("azure")
-    expect(overridden.providerMetadataKey).toBe("custom-azure")
-    expect(overridden.defaults).not.toHaveProperty("providerMetadataKey")
-  })
 })
@@ -1,5 +1,3 @@
 src/assets/theme.css
 e2e/test-results
 e2e/playwright-report
-component-tests/test-results
-component-tests/playwright-report
@@ -31,7 +31,7 @@ Your app is ready to be deployed!

 ## E2E Testing

-Locally, Playwright starts the Vite dev server automatically via `webServer`, or reuses one already running at the configured address. The browser suite uses isolated API fixtures rather than a live opencode backend.
+Playwright starts the Vite dev server automatically via `webServer`, and UI tests expect an opencode backend at `localhost:4096` by default.

 ```bash
 bunx playwright install chromium
@@ -39,35 +39,11 @@ bun run test:e2e:local
 bun run test:e2e:local -- --grep "settings"
 ```

-CI builds the app once and runs the same suite against Vite preview, serving production assets from `dist`. Managed built runs never reuse an existing server, so a running dev server cannot silently replace the production build. To run this mode locally:
-
-```bash
-bun run test:e2e:built
-bun run test:e2e:built -- --grep "settings"
-```
-
-To test an already-running dev server without starting or building a server:
-
-```bash
-PLAYWRIGHT_BASE_URL=http://127.0.0.1:4444 bun run test:e2e
-```
-
-For an already-running production build, also set `PLAYWRIGHT_BUILD=1` so the fixture API uses the app's origin:
-
-```bash
-PLAYWRIGHT_BUILD=1 PLAYWRIGHT_BASE_URL=http://127.0.0.1:4444 bun run test:e2e
-```
-
-External targets must use HTTP because fixture URLs use HTTP. `PLAYWRIGHT_BASE_URL` skips server startup and building in either mode.
-
-Compiled CLI startup and service lifecycle coverage runs separately in CI via `packages/cli/script/service-smoke.ts`.
-
 Environment options:

- `PLAYWRIGHT_BUILD=1` (build and preview locally; always enabled when `CI` is set)
- `PLAYWRIGHT_SERVER_HOST` / `PLAYWRIGHT_SERVER_PORT` (dev fixture API address, default: `127.0.0.1:4096`; built runs use the app's origin, matching production)
- `PLAYWRIGHT_PORT` (managed dev or preview server port, default: `3000`)
- `PLAYWRIGHT_BASE_URL` (use an externally managed app instead of starting a server; otherwise defaults to `http://127.0.0.1:<PLAYWRIGHT_PORT>`)
+- `PLAYWRIGHT_SERVER_HOST` / `PLAYWRIGHT_SERVER_PORT` (backend address, default: `localhost:4096`)
+- `PLAYWRIGHT_PORT` (Vite dev server port, default: `3000`)
+- `PLAYWRIGHT_BASE_URL` (override base URL, default: `http://localhost:<PLAYWRIGHT_PORT>`)

 ## Deployment

@@ -1,26 +0,0 @@
-import { expect, story } from "../../storybook/playwright/story"
-
-// Moved from packages/app/e2e/regression/prompt-thinking-level.spec.ts
-story("shows the thinking level control while relevant", async ({ mount, page }) => {
-  const component = await mount("opencode-composer-flow--model-and-variant")
-  const composer = component.locator('[data-component="composer"]')
-  const input = composer.locator('[data-component="composer-editor"]')
-  const control = composer.getByRole("button", { name: "Choose model variant" })
-
-  await page.mouse.move(0, 0)
-  await page.evaluate(() => (document.activeElement as HTMLElement | null)?.blur())
-  await expect(control).toBeVisible()
-
-  await control.click()
-  const high = page.getByRole("menuitemradio", { name: "high" })
-  await expect(high).toBeVisible()
-  await page.mouse.move(0, 0)
-  await expect(control).toBeVisible()
-  await expect(high).toBeVisible()
-  await high.click()
-
-  await input.focus()
-  await expect(control).toBeVisible()
-  await input.blur()
-  await expect(control).toBeVisible()
-})
@@ -44,7 +44,6 @@ The suite contains:
 - single-session tab close timing through stable home restoration
 - cached session repaint and mutation tracing
 - streaming timeline throughput, RAF-gap, long-task, geometry, and remount diagnostics
- retained renderer heap with a large model catalog across repeated session navigation

 All benchmarks import the shared `benchmark` fixture. Pages created through Playwright's `page` fixture automatically capture main-frame navigation history and emit a Chrome trace when `OPENCODE_PERFORMANCE_TRACE_DIR` is set. Benchmarks that need isolated browser contexts use `withBenchmarkPage`, which owns the context and the same diagnostics lifecycle.

@@ -79,17 +78,6 @@ Benchmarks do not assert machine-dependent performance budgets. Streaming proces

 Committed smoke and regression tests continue to own correctness coverage for pagination, tab paint, context resize, collapse state, and composer spacing.

-## Retained renderer memory
-
-Run the catalog workload against the production app bundle:
-
-```sh
-bunx playwright test --config e2e/performance/playwright.config.ts \
-  timeline/provider-memory-benchmark.spec.ts --repeat-each=3
-```
-
-`PROVIDER_MEMORY_MODELS` defaults to 1,200 and `PROVIDER_MEMORY_SWITCHES` defaults to 10. Each sample records Chromium's `Runtime.getHeapUsage` and `Memory.getDOMCounters` after an explicit garbage collection. This measures retained state, not allocation peaks or normal GC timing. It does not include worker heaps, the Electron main/GPU processes, or the OpenCode server, and must not be reported as total desktop RAM. Use identical model counts and navigation sequences for before/after comparisons.
-
 ## Chrome traces

 Set `OPENCODE_PERFORMANCE_TRACE_DIR` to emit a standard Chrome DevTools trace for every benchmark page automatically:
@@ -1,7 +1,7 @@
 import config from "../../playwright.config"

 const port = Number(process.env.PLAYWRIGHT_PORT ?? 3000)
-process.env.PLAYWRIGHT_SERVER_PORT = new URL(process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${port}`).port || "80"
+process.env.PLAYWRIGHT_SERVER_PORT = String(port)
 process.env.OPENCODE_PERFORMANCE_RUN_ID ??= `${new Date().toISOString().replace(/[:.]/g, "-")}-${process.pid}`

 export default {
@@ -12,11 +12,9 @@ export default {
  fullyParallel: false,
  workers: 1,
  reporter: [["html", { outputFolder: "../playwright-report/performance", open: "never" }], ["line"]],
-  webServer: config.webServer
-    ? {
-        ...config.webServer,
-        command: `bun run build && bun run serve -- --host 0.0.0.0 --port ${port} --strictPort`,
-        reuseExistingServer: false,
-      }
-    : undefined,
+  webServer: {
+    ...config.webServer,
+    command: `bun run build && bun run serve -- --host 0.0.0.0 --port ${port} --strictPort`,
+    reuseExistingServer: false,
+  },
 }
@@ -1,98 +0,0 @@
-import { benchmark, expect } from "../benchmark"
-import { mockOpenCodeServer } from "../../utils/mock-server"
-import { expectSessionTitle } from "../../utils/waits"
-import { fixture, pageMessages } from "./session-timeline-stress.fixture"
-import { installStressSessionTabs, installTimelineSettings, stressSessionHref } from "./timeline-test-helpers"
-import { waitForStableTimeline } from "./session-tab-switch-probe"
-import type { CatalogUpdated } from "@opencode-ai/client/promise"
-
-benchmark("measures retained renderer memory with a large model catalog", async ({ page, report }) => {
-  benchmark.setTimeout(120_000)
-  const count = Number(process.env.PROVIDER_MEMORY_MODELS ?? 1200)
-  const switches = Number(process.env.PROVIDER_MEMORY_SWITCHES ?? 10)
-  const provider = fixture.provider.all[0]
-  const selected = { ...provider.models["claude-opus-4-6"] }
-  await mockOpenCodeServer(page, {
-    directory: fixture.directory,
-    project: fixture.project,
-    sessions: fixture.sessions,
-    pageMessages,
-    provider: {
-      ...fixture.provider,
-      all: [
-        {
-          ...provider,
-          models: {
-            [selected.id]: selected,
-            ...Object.fromEntries(
-              Array.from({ length: count - 1 }, (_, index) => {
-                const id = `catalog-model-${index}`
-                return [
-                  id,
-                  {
-                    id,
-                    name: `Catalog model ${index}`,
-                    cost: { input: 1, output: 2 },
-                    limit: { context: 200_000, output: 8192 },
-                    variants: { high: { reasoningEffort: "high" } },
-                  },
-                ]
-              }),
-            ),
-          },
-        },
-      ],
-    },
-  })
-  await installTimelineSettings(page)
-  await installStressSessionTabs(page)
-  await page.goto(stressSessionHref(fixture.sourceID))
-  await expectSessionTitle(page, fixture.expected.sourceTitle)
-  await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
-  await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6")
-  const cdp = await page.context().newCDPSession(page)
-  const samples = []
-  for (let index = 0; index <= switches; index++) {
-    if (index > 0) {
-      const target = index % 2 === 1
-      const id = target ? fixture.targetID : fixture.sourceID
-      await page.locator(`[data-slot="titlebar-tabs"] a[href="${stressSessionHref(id)}"]`).click()
-      await expectSessionTitle(page, target ? fixture.expected.targetTitle : fixture.expected.sourceTitle)
-      await waitForStableTimeline(
-        page,
-        (target ? fixture.expected.targetMessageIDs : fixture.expected.sourceMessageIDs).at(-1)!,
-      )
-      await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6")
-    }
-    // GC is an explicit retained-heap measurement, not an application optimization or readiness wait.
-    await cdp.send("HeapProfiler.collectGarbage")
-    samples.push({
-      switches: index,
-      heap: await cdp.send("Runtime.getHeapUsage"),
-      dom: await cdp.send("Memory.getDOMCounters"),
-    })
-  }
-  expect(samples).toHaveLength(switches + 1)
-  expect(samples.every((sample) => sample.heap.usedSize > 0)).toBe(true)
-  selected.name = "Updated catalog model"
-  await page.evaluate(
-    (event) => {
-      const host = window as Window & { __mockServerStream?: { push: (events: CatalogUpdated[]) => void } }
-      if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-      host.__mockServerStream.push([event])
-    },
-    {
-      id: "evt_catalog_refresh",
-      created: Date.now(),
-      type: "catalog.updated",
-      location: { directory: fixture.directory },
-      data: {},
-    } satisfies CatalogUpdated,
-  )
-  await expect(page.locator('[data-action="composer-model"]')).toContainText(selected.name)
-  report(
-    { samples },
-    { models: count, switches, gc: "explicit", scope: "renderer main isolate; not total desktop RAM" },
-  )
-  await cdp.detach()
-})
@@ -3,7 +3,7 @@ import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
 import { installSseTransport } from "../utils/sse-transport"

-const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const serverA = "http://127.0.0.1:4096"
 const serverB = "http://127.0.0.1:4097"
 const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
 const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
@@ -12,17 +12,17 @@ test("closing the active server's last tab opens the remaining server tab", asyn
  const requests: string[] = []
  await mockServers(page, requests)
  await page.addInitScript(
-    ({ serverA, serverB, sessionA, sessionB }) => {
+    ({ serverB, sessionA, sessionB }) => {
      localStorage.setItem("opencode.global.dat:server", JSON.stringify({ list: [serverB] }))
      localStorage.setItem(
        "opencode.window.browser.dat:tabs",
        JSON.stringify([
-          { type: "session", server: serverA, sessionId: sessionA },
+          { type: "session", server: "http://127.0.0.1:4096", sessionId: sessionA },
          { type: "session", server: serverB, sessionId: sessionB },
        ]),
      )
    },
-    { serverA, serverB, sessionA: sessionA.id, sessionB: sessionB.id },
+    { serverB, sessionA: sessionA.id, sessionB: sessionB.id },
  )

  const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
@@ -55,7 +55,7 @@ function session(id: string, directory: string, title: string) {
 async function mockServers(page: Page, requests: string[]) {
  await installSseTransport(page, { server: serverA })
  await installSseTransport(page, { server: serverB })
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    requests.push(url.toString())
@@ -3,7 +3,7 @@ import { expect, test, type Page, type Route } from "@playwright/test"
 import { installSseTransport } from "../utils/sse-transport"
 import { currentSession } from "../utils/mock-server"

-const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const serverA = `http://127.0.0.1:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
 const serverB = "http://127.0.0.1:4097"
 const directoryA = "C:/server-a"
 const directoryB = "/home/server-b"
@@ -308,7 +308,7 @@ async function mockServers(
  permissionResponses: PermissionResponse[] = [],
  options: MockServerOptions = {},
 ) {
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    const remote = url.origin === serverB
@@ -2,7 +2,7 @@ import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"

-const serverA = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const serverA = "http://127.0.0.1:4096"
 const serverB = "http://127.0.0.1:4097"
 const sessionA = session("ses_server_a", "C:/server-a", "Server A session")
 const sessionB = session("ses_server_b", "/home/server-b", "Server B session")
@@ -51,7 +51,7 @@ function session(id: string, directory: string, title: string) {
 }

 async function mockServers(page: Page) {
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    const current = url.origin === serverA ? sessionA : sessionB
@@ -12,6 +12,54 @@ test.beforeEach(async ({ page }) => {
  await openReview(page)
 })

+test("opens the comment editor when code is clicked", async ({ page }) => {
+  const review = page.locator('[data-component="session-review"]')
+  const line = review.getByText("export const value = 'after'", { exact: true })
+  await expectAppVisible(line)
+  await line.click()
+
+  await expect(review.getByRole("textbox")).toBeVisible()
+  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on line 2")
+})
+
+test("opens the comment editor when a line number is clicked", async ({ page }) => {
+  const review = page.locator('[data-component="session-review"]')
+  const lineNumber = review.locator('[data-column-number="1"]').last()
+  await expectAppVisible(lineNumber)
+  await lineNumber.click()
+
+  await expect(review.getByRole("textbox")).toBeVisible()
+  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on line 1")
+})
+
+test("opens the comment editor for a line number range", async ({ page }) => {
+  const review = page.locator('[data-component="session-review"]')
+  const start = review.locator('[data-column-number="1"]').last()
+  const end = review.locator('[data-column-number="3"]').last()
+  await expectAppVisible(start)
+  await expectAppVisible(end)
+
+  await start.dragTo(end)
+
+  await expect(review.getByRole("textbox")).toBeVisible()
+  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on lines 1-3")
+})
+
+test("shows a comment button when a diff line is hovered", async ({ page }) => {
+  const review = page.locator('[data-component="session-review"]')
+  const line = review.getByText("export const first = 1", { exact: true })
+  await expectAppVisible(line)
+
+  const comment = review.getByRole("button", { name: "Comment", exact: true, includeHidden: true })
+  await expect(comment).toHaveCount(1)
+  await line.dispatchEvent("pointermove", { pointerType: "mouse", bubbles: true, composed: true })
+  await expect(comment).toBeVisible()
+  await expect(comment).toHaveCSS("pointer-events", "auto")
+  await comment.dispatchEvent("click")
+  await expect(review.getByRole("textbox")).toBeVisible()
+  await expect(review.locator('[data-slot="line-comment-editor-label"]')).toHaveText("Commenting on line 1")
+})
+
 test("stages a submitted line comment in the prompt context", async ({ page }) => {
  page.on("request", (request) => {
    expect.soft(request.method(), `unexpected ${request.method()} ${new URL(request.url()).pathname}`).toBe("GET")
@@ -201,15 +201,12 @@ test("editing restores the existing draft and replaces only the original queue p
  await view.input.fill("my in-progress draft")
  await original.click()
  await expect(view.input).toHaveText("tighten the error copy")
-  await expect(view.input).toBeFocused()
  await view.input.press("Escape")
  await expect(view.input).toHaveText("my in-progress draft")

  await original.click()
  await expect(view.input).toHaveText("tighten the error copy")
-  await expect(view.input).toBeFocused()
  await view.input.fill("tighten the error copy and add a retry hint")
-  await expect(view.input).toHaveText("tighten the error copy and add a retry hint")
  await view.input.press("Enter")

  await expect(view.rows.locator('[data-action="session-queue-edit"]')).toHaveText([
@@ -1,43 +1,16 @@
 import { expect, test } from "@playwright/test"
-import {
-  assistantMessage,
-  setupTimeline,
-  shell,
-  textPart,
-  userMessage,
-} from "../performance/timeline-stability/fixture"
+import { assistantMessage, setupTimeline, shell, userMessage } from "../performance/timeline-stability/fixture"

 test("space activates a focused timeline button instead of scrolling", async ({ page }) => {
  const shellID = "prt_space_button_shell"
  await setupTimeline(page, {
-    messages: [
-      userMessage(),
-      assistantMessage([
-        shell(shellID, "completed", lines(5)),
-        textPart(
-          "prt_space_following",
-          "Following content leaves room to focus the command away from the bottom. ".repeat(40),
-        ),
-      ]),
-    ],
+    messages: [userMessage(), assistantMessage([shell(shellID, "completed", lines(5))])],
    settings: { shellToolPartsExpanded: false },
    reducedMotion: true,
-    seedHistory: true,
  })
  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
  const trigger = page.getByRole("button", { name: "Used Shell" })
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight))
-    .toBeGreaterThan(300)
-  await trigger.scrollIntoViewIfNeeded()
-  await scroller.hover()
-  await page.mouse.wheel(0, -100)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeGreaterThan(50)
-  await expect(trigger).toBeInViewport()
  await trigger.focus()
-  await expect(trigger).toBeFocused()
  const before = await scroller.evaluate((element) => element.scrollTop)
  await trigger.press("Space")
  await expect(trigger).toHaveAttribute("aria-expanded", "true")
@@ -8,6 +8,21 @@ import {
  userText,
 } from "../performance/timeline-stability/fixture"

+test("renders completed write content", async ({ page }) => {
+  const id = "prt_file_projection_write"
+  await setupTimeline(page, {
+    messages: [
+      userMessage(),
+      assistantMessage([
+        toolPart(id, "write", "completed", { path: "src/write.ts", content: "export const written = true\n" }),
+      ]),
+    ],
+    settings: { editToolPartsExpanded: true },
+  })
+
+  await expect(page.locator(`[data-timeline-part-id="${id}"] [data-component="write-content"]`)).toBeVisible()
+})
+
 test("renders a completed single-file patch", async ({ page }) => {
  const id = "prt_file_projection_single_patch"
  await setupTimeline(page, {
@@ -0,0 +1,53 @@
+import { expect, test } from "@playwright/test"
+import { assistantMessage, setupTimeline, toolPart, userMessage } from "../performance/timeline-stability/fixture"
+import { createTwoFilesPatch } from "diff"
+
+test("keeps patch file disclosures independent", async ({ page }) => {
+  const patchID = "prt_nested_patch"
+  const files = [patchFile("src/a.ts", "modified"), patchFile("src/b.ts", "added"), patchFile("src/old.ts", "deleted")]
+  await setupTimeline(page, {
+    messages: [
+      userMessage(),
+      assistantMessage([
+        toolPart(
+          patchID,
+          "patch",
+          "completed",
+          { patchText: "Update three files" },
+          { metadata: { files } },
+        ),
+      ]),
+    ],
+    settings: { editToolPartsExpanded: true },
+  })
+  const wrapper = page.locator(`[data-timeline-part-id="${patchID}"]`)
+  const modified = wrapper.locator('[data-scope="apply-patch"] [data-type="update"]')
+  const deleted = wrapper.locator('[data-scope="apply-patch"] [data-type="delete"]')
+  await expect(wrapper.locator('[data-scope="apply-patch"] [aria-expanded="false"]')).toHaveCount(3)
+  await deleted.getByRole("button").click()
+  await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "true")
+  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "false")
+  await modified.getByRole("button").click()
+  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "true")
+  await deleted.getByRole("button").click()
+  await expect(deleted.getByRole("button")).toHaveAttribute("aria-expanded", "false")
+  await expect(modified.getByRole("button")).toHaveAttribute("aria-expanded", "true")
+})
+
+function patchFile(file: string, status: "added" | "modified" | "deleted") {
+  const before = status === "added" ? "" : source(false)
+  const after = status === "deleted" ? "" : source(true)
+  return {
+    file,
+    status,
+    patch: createTwoFilesPatch(`a/${file}`, `b/${file}`, before, after),
+    additions: status === "deleted" ? 0 : 4,
+    deletions: status === "added" ? 0 : 3,
+  }
+}
+
+function source(changed: boolean) {
+  return Array.from({ length: 12 }, (_, index) => `export const value${index} = ${changed ? index + 1 : index}\n`).join(
+    "",
+  )
+}
@@ -122,7 +122,6 @@ test("transitions thinking and hidden reasoning through busy to idle", async ({
  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
  await expect(page.getByText("Inspecting stability", { exact: true })).toBeVisible()
  await expect(page.locator(`[data-timeline-part-id="${reasoningID}"]`)).toHaveCount(0)
-  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)).toHaveCount(0)
  await timeline.send(partUpdated(shell("prt_reasoning_shell", "running")), 160)
  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
  await timeline.send(partUpdated(shell("prt_reasoning_shell", "completed", "done")), 180)
@@ -130,7 +129,6 @@ test("transitions thinking and hidden reasoning through busy to idle", async ({
  await timeline.send(status("idle"), 300)
  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
  await expect(page.locator(`[data-timeline-part-id="${reasoningID}"]`)).toHaveCount(0)
-  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)).toHaveCount(0)
 })

 test("moves busy through retry and recovery to final idle content", async ({ page }) => {
@@ -122,7 +122,6 @@ test("updates running compactions to failed and cancelled boundaries", async ({

  await timeline.send(compactionStarted({ sessionID, reason: "auto", recent: "" }))
  await timeline.send(compactionDelta({ sessionID, text: "Partial summary that should be discarded." }))
-  await expect(page.getByText("Partial summary that should be discarded.", { exact: true })).toBeVisible()
  await timeline.send(
    compactionFailed({
      sessionID,
@@ -141,9 +140,6 @@ test("updates running compactions to failed and cancelled boundaries", async ({
  await expect(failed).not.toContainText("Partial summary that should be discarded.")

  await timeline.send(compactionStarted({ sessionID, reason: "manual", recent: "" }))
-  await expect(compactions).toHaveCount(2)
-  await timeline.send(compactionDelta({ sessionID, text: "Summary before cancellation." }))
-  await expect(page.getByText("Summary before cancellation.", { exact: true })).toBeVisible()
  await timeline.send(
    compactionFailed({
      sessionID,
@@ -156,7 +152,88 @@ test("updates running compactions to failed and cancelled boundaries", async ({
  const cancelled = compactions.filter({ hasNotText: "The provider rejected the summary." })
  await expect(cancelled.getByText("Session compacted", { exact: true })).toBeVisible()
  await expect(cancelled).not.toContainText("Cancellation detail should stay hidden.")
-  await expect(cancelled).not.toContainText("Summary before cancellation.")
+})
+
+test("shows a delegating row while subagent input streams", async ({ page }) => {
+  await setupTimeline(page, {
+    sessionMessages: [
+      user,
+      {
+        ...assistant(false),
+        content: [
+          {
+            type: "tool",
+            id: "call_subagent",
+            name: "subagent",
+            state: { status: "streaming", input: "" },
+            time: { created: 2 },
+          },
+        ],
+      },
+    ],
+  })
+
+  const delegating = page.locator('[data-component="task-tool-delegating"]')
+  await expect(delegating).toBeVisible()
+  const shimmer = delegating.locator('[data-component="text-shimmer"]')
+  await expect(shimmer).toHaveAttribute("aria-label", "Delegating agent...")
+  await expect(shimmer).toHaveCSS("line-height", "16px")
+  const icon = delegating.locator('[data-slot="icon-svg"]')
+  await expect(icon.locator('use[href="#opencode-v2-icon-subagent"]')).toBeVisible()
+  await expect(icon).toHaveCSS("color", "rgb(174, 174, 174)")
+  await expect(page.locator('[data-component="task-tool-card"]')).toHaveCount(0)
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
+})
+
+test("renders the moved location notice in its compact timeline style", async ({ page }) => {
+  const directory = `/Users/usrnk1/Developer/opencode/${"nested-directory/".repeat(24)}session`
+  await page.setViewportSize({ width: 480, height: 720 })
+  await setupTimeline(page, {
+    sessionMessages: [
+      user,
+      {
+        id: "msg_location",
+        type: "location-switched",
+        location: { directory },
+        time: { created: 2 },
+      },
+    ],
+  })
+
+  const notice = page.locator('[data-slot="session-timeline-notice"][data-type="location-switched"]')
+  const label = notice.locator('[data-slot="session-timeline-notice-label"]')
+  const value = notice.locator('[data-slot="session-timeline-notice-value"]')
+  const tooltipTrigger = notice.locator('[data-component="tooltip-v2-trigger"]')
+
+  await expect(label).toHaveText("Moved to")
+  await expect(value).toHaveText(directory)
+  await expect(notice).not.toContainText("·")
+  await expect(notice.locator("svg")).toHaveCount(0)
+  await expect(notice).toHaveCSS("height", "28px")
+  await expect(notice).toHaveCSS("gap", "8px")
+  await expect(notice).toHaveCSS("padding-top", "4px")
+  await expect(notice).toHaveCSS("padding-bottom", "4px")
+  await expect(label).toHaveCSS("font-size", "13px")
+  await expect(label).toHaveCSS("font-weight", "530")
+  await expect(label).toHaveCSS("line-height", "16px")
+  await expect(label).toHaveCSS("color", "rgb(128, 128, 128)")
+  await expect(value).toHaveCSS("font-size", "13px")
+  await expect(value).toHaveCSS("font-weight", "440")
+  await expect(value).toHaveCSS("line-height", "16px")
+  await expect(value).toHaveCSS("color", "rgb(128, 128, 128)")
+  await expect(value).toHaveCSS("text-overflow", "ellipsis")
+  await expect(value).toHaveCSS("white-space", "nowrap")
+  await expect(value).toHaveAttribute("dir", "ltr")
+  await expect.poll(() => value.evaluate((element) => element.scrollWidth > element.clientWidth)).toBe(true)
+
+  const tooltip = page.getByText("Session working directory changed", { exact: true })
+  await label.hover()
+  await expect(tooltip).toBeVisible()
+  await page.mouse.move(0, 0)
+  await expect(tooltip).toBeHidden()
+  await tooltipTrigger.focus()
+  await expect(tooltipTrigger).toBeFocused()
+  await expect(tooltip).toBeVisible()
 })

 test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
@@ -194,6 +271,11 @@ test("moves blocking work to the background with Ctrl+B", async ({ page }) => {
  await request
 })

+test("waits for completion before labeling requested background work", async ({ page }) => {
+  await setupTimeline(page, { sessionMessages: [user, assistant(false, true, undefined, true)] })
+  await expect(page.locator('[data-component="task-tool-card"]')).not.toContainText("(background)")
+})
+
 test("navigates from a running subagent card and hides background controls in the child", async ({ page }) => {
  const childID = "ses_running_child"
  await setupTimeline(page, {
@@ -7,9 +7,86 @@ import {
  toolPart,
  userMessage,
  userText,
+  type PartSeed,
 } from "../performance/timeline-stability/fixture"

 test.describe("session timeline projection", () => {
+  test("renders every admitted tool family and hides timeline-only exclusions", async ({ page }) => {
+    const parts = [
+      toolPart("prt_01_read", "read", "completed", { path: "src/a.ts" }),
+      toolPart("prt_02_glob", "glob", "completed", { path: ".", pattern: "**/*.ts" }),
+      toolPart("prt_03_grep", "grep", "completed", { path: ".", pattern: "value" }),
+      toolPart("prt_04_list", "list", "completed", { path: "src" }),
+      toolPart("prt_webfetch", "webfetch", "completed", { url: "https://example.com" }),
+      toolPart(
+        "prt_websearch",
+        "websearch",
+        "completed",
+        { query: "timeline stability" },
+        { output: "https://example.com/result" },
+      ),
+      toolPart("prt_task", "subagent", "completed", {
+        description: "Inspect timeline",
+        agent: "explore",
+        prompt: "Inspect the timeline implementation.",
+      }),
+      toolPart(
+        "prt_bash",
+        "shell",
+        "completed",
+        { command: "printf stable" },
+        { output: "stable", title: "printf stable" },
+      ),
+      editPart("prt_edit"),
+      toolPart("prt_write", "write", "completed", { path: "src/new.ts", content: "export const stable = true\n" }),
+      patchPart("prt_patch"),
+      toolPart("prt_todo", "todowrite", "completed", { todos: [{ content: "Hidden", status: "pending" }] }),
+      toolPart(
+        "prt_question",
+        "question",
+        "completed",
+        { questions: [{ question: "Keep stable?", header: "Stability", options: [] }] },
+        { metadata: { answers: [["Yes"]] } },
+      ),
+      toolPart("prt_skill", "skill", "completed", { name: "stability" }),
+      toolPart("prt_custom", "custom_mcp_tool", "completed", { target: "timeline", count: 2 }),
+    ]
+    await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })
+
+    const first = page.locator(
+      '[data-timeline-part-ids="prt_01_read,prt_02_glob,prt_03_grep,prt_04_list,prt_webfetch,prt_websearch,prt_task,prt_bash,prt_edit,prt_write,prt_patch"]',
+    )
+    const second = page.locator('[data-timeline-part-ids="prt_skill,prt_custom"]')
+    await expect(first).toBeVisible()
+    await expect(second).toBeVisible()
+    await first.getByRole("button").click()
+    await second.getByRole("button").click()
+    for (const id of [
+      "prt_webfetch",
+      "prt_websearch",
+      "prt_task",
+      "prt_bash",
+      "prt_edit",
+      "prt_write",
+      "prt_patch",
+      "prt_question",
+      "prt_skill",
+      "prt_custom",
+    ]) {
+      await expect(page.locator(`[data-timeline-part-id="${id}"]`).first(), id).toBeVisible()
+    }
+    const patch = page.locator('[data-timeline-part-id="prt_patch"]')
+    await expect(patch.getByText("1 file", { exact: true })).toBeVisible()
+    await expect(patch.getByRole("button", { name: "Patch 1 file", exact: true })).toHaveCount(0)
+    await expect(patch.getByRole("button")).toHaveCount(1)
+    await expect(patch.locator('[data-scope="apply-patch"] button[aria-expanded="false"]')).toHaveCount(1)
+    await expect(patch.locator('[data-slot="message-part-title-filename"]')).toHaveCount(0)
+    await expect(patch.locator('[data-slot="message-part-actions"]')).toHaveCount(0)
+    const edit = page.locator('[data-timeline-part-id="prt_edit"]')
+    await expect(edit).toContainText("Edit")
+    await expect(page.locator('[data-timeline-part-id="prt_todo"]')).toHaveCount(0)
+  })
+
  test("combines adjacent patch calls and repeated files into one group", async ({ page }) => {
    const first = "prt_patch_first"
    const second = "prt_patch_second"
@@ -81,6 +158,43 @@ test.describe("session timeline projection", () => {
    await expect(page.locator(`[data-timeline-part-id="${first}"], [data-timeline-part-id="${second}"]`)).toHaveCount(0)
  })

+  test("combines adjacent edit calls and repeated files into one group", async ({ page }) => {
+    const first = "prt_edit_first"
+    const second = "prt_edit_second"
+    await setupTimeline(page, {
+      messages: [
+        userMessage(),
+        assistantMessage([
+          toolPart(
+            first,
+            "edit",
+            "completed",
+            { path: "src/first.ts", oldString: "one", newString: "two" },
+            {
+              metadata: { files: [patchFile("src/first.ts", "modified")] },
+            },
+          ),
+          toolPart(
+            second,
+            "edit",
+            "completed",
+            { path: "src/first.ts", oldString: "two", newString: "three" },
+            {
+              metadata: { files: [patchFile("src/first.ts", "modified")] },
+            },
+          ),
+        ]),
+      ],
+      settings: { editToolPartsExpanded: true },
+    })
+
+    const group = page.locator(`[data-timeline-part-ids="${first},${second}"]`)
+    await expect(group.locator('[data-slot="basic-tool-tool-title"]')).toContainText("Edit")
+    await expect(group.getByText("1 file", { exact: true })).toBeVisible()
+    await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["first.ts"])
+    await expect(group.locator('[data-scope="apply-patch"] button')).toHaveAttribute("aria-expanded", "true")
+  })
+
  test("projects gaps, dividers, assistant parts, and errors together", async ({ page }) => {
    const firstUser = userMessage(
      [
@@ -122,6 +236,25 @@ test.describe("session timeline projection", () => {
    await expect(page.locator('[data-timeline-row="TurnGap"]')).toBeVisible()
  })

+  test("renders interruption independently when the turn is not compacted", async ({ page }) => {
+    const user = userMessage()
+    const before = assistantMessage([{ id: "prt_before", type: "text", text: "Before" }], {
+      id: "msg_1001_before",
+      error: { type: "MessageAbortedError", message: "Stopped" },
+    })
+    const after = assistantMessage([{ id: "prt_after", type: "text", text: "After" }], {
+      id: "msg_1002_after",
+      created: 1700000003000,
+    })
+    await setupTimeline(page, { messages: [user, before, after] })
+
+    await expect(page.getByText("Interrupted", { exact: true })).toBeVisible()
+    const rows = await page
+      .locator('[data-timeline-row="AssistantPart"], [data-timeline-row="TurnDivider"]')
+      .evaluateAll((elements) => elements.map((element) => element.getAttribute("data-timeline-row")))
+    expect(rows).toEqual(["AssistantPart", "TurnDivider", "AssistantPart"])
+  })
+
  test("renders aliased and long custom model notices", async ({ page }) => {
    const shortName = "GPT-5.4 nano"
    const longName = "Company Gateway Extra Long Context Model for Narrow Timeline Layouts"
@@ -158,8 +291,77 @@ test.describe("session timeline projection", () => {
    await expect(longNotice.locator("[title]")).toHaveAttribute("title", `Switched to ${longName}`)
    await expect.poll(() => longNotice.evaluate((element) => element.scrollWidth <= element.clientWidth)).toBe(true)
  })
+
+  test("renders user image, file attachment, file reference, and agent reference", async ({ page }) => {
+    const text = "Use @explore with @src/a.ts and inspect the attachments"
+    const parts: PartSeed<"user">[] = [
+      userText(text, { id: "prt_user_rich" }),
+      {
+        id: "prt_user_image",
+        type: "file",
+        mime: "image/png",
+        filename: "pixel.png",
+        url: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
+      },
+      {
+        id: "prt_user_attachment",
+        type: "file",
+        mime: "application/json",
+        filename: "tsconfig.json",
+        url: "data:application/json;base64,e30=",
+      },
+      {
+        id: "prt_user_reference",
+        type: "file",
+        mime: "text/plain",
+        filename: "a.ts",
+        url: "src/a.ts",
+        source: { type: "file", path: "src/a.ts", text: { value: "@src/a.ts", start: 18, end: 27 } },
+      },
+      {
+        id: "prt_user_agent",
+        type: "agent",
+        name: "explore",
+        source: { value: "@explore", start: 4, end: 12 },
+      },
+    ]
+    await setupTimeline(page, { messages: [userMessage(parts), assistantMessage()] })
+
+    await expect(page.getByAltText("pixel.png")).toBeVisible()
+    await expect(page.getByText("tsconfig.json")).toBeVisible()
+    await expect(page.getByText("@src/a.ts", { exact: true })).toBeVisible()
+    await expect(page.getByText("@explore", { exact: true })).toBeVisible()
+  })
 })

+function editPart(id: string) {
+  return toolPart(
+    id,
+    "edit",
+    "completed",
+    { path: "src/a.ts", oldString: "export const value = 1", newString: "export const value = 2" },
+    {
+      metadata: {
+        files: [patchFile("src/a.ts", "modified")],
+      },
+    },
+  )
+}
+
+function patchPart(id: string) {
+  return toolPart(
+    id,
+    "patch",
+    "completed",
+    { patchText: "Update the projected files" },
+    {
+      metadata: {
+        files: [patchFile("src/a.ts", "modified")],
+      },
+    },
+  )
+}
+
 function patchFile(file: string, status: "added" | "modified" | "deleted") {
  return {
    file,
@@ -7,25 +7,33 @@ import {
  renderedPartID,
  setupTimeline,
  shell,
-  toolPart,
  status,
  textPart,
+  toolPart,
  userMessage,
 } from "../performance/timeline-stability/fixture"

-test("reducer-hardening: converges when idle arrives before final part and message completion", async ({ page }) => {
-  const textID = "prt_event_order_text"
-  const assistant = assistantMessage([textPart(textID, "Partial")], { completed: false })
-  const timeline = await setupTimeline(page, { messages: [userMessage(), assistant] })
-  await timeline.send(status("busy"), 100)
-  await timeline.send(status("idle"), 100)
-  await timeline.send(partUpdated(textPart(textID, "Final after early idle")), 120)
-  await timeline.send(messageUpdated(completedAssistantInfo(assistant)), 250)
+test("groups every collapsed tool until visible text separates the stack", async ({ page }) => {
+  const parts = [
+    toolPart("prt_boundary_01_read", "read", "completed", { path: "src/a.ts" }),
+    textPart("prt_boundary_02_text", "Boundary text"),
+    toolPart("prt_boundary_03_glob", "glob", "completed", { path: ".", pattern: "**/*.ts" }),
+    toolPart("prt_boundary_04_grep", "grep", "completed", { path: ".", pattern: "stable" }),
+    shell("prt_boundary_05_shell", "completed", "done"),
+    toolPart("prt_boundary_06_list", "list", "completed", { path: "src" }),
+  ]
+  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })

-  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(textID)}"]`)).toContainText(
-    "Final after early idle",
+  await expect(page.locator('[data-timeline-part-ids="prt_boundary_01_read"]')).toBeVisible()
+  const group = page.locator(
+    '[data-timeline-part-ids="prt_boundary_03_glob,prt_boundary_04_grep,prt_boundary_05_shell,prt_boundary_06_list"]',
  )
+  await expect(group).toBeVisible()
+  await expect(group.getByRole("button")).toHaveAccessibleName("Used Glob, Grep, Shell, List")
+  await expect(group.locator('[data-component="tag"]')).toHaveText("4")
+  await expect(page.locator('[data-timeline-row="AssistantPart"]')).toHaveCount(3)
+  await expect(page.locator('[data-timeline-spacing="content"]')).toHaveCount(2)
+  await expect(page.locator('[data-timeline-spacing="content"]').nth(0)).toHaveCSS("padding-top", "16px")
 })

 test("expands a mixed collapsed tool stack without expanding its individual calls", async ({ page }) => {
@@ -124,3 +132,18 @@ test("keeps failed search calls and their error cards inside the collapsed stack
    "Search timed out after 30 seconds",
  )
 })
+
+test("reducer-hardening: converges when idle arrives before final part and message completion", async ({ page }) => {
+  const textID = "prt_event_order_text"
+  const assistant = assistantMessage([textPart(textID, "Partial")], { completed: false })
+  const timeline = await setupTimeline(page, { messages: [userMessage(), assistant] })
+  await timeline.send(status("busy"), 100)
+  await timeline.send(status("idle"), 100)
+  await timeline.send(partUpdated(textPart(textID, "Final after early idle")), 120)
+  await timeline.send(messageUpdated(completedAssistantInfo(assistant)), 250)
+
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
+  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(textID)}"]`)).toContainText(
+    "Final after early idle",
+  )
+})
@@ -7,6 +7,31 @@ import {
  userMessage,
 } from "../performance/timeline-stability/fixture"

+test("renders every tool error outcome without leaking hidden tools", async ({ page }) => {
+  const ordinary = ["shell", "edit", "write", "patch", "webfetch", "websearch", "subagent", "skill", "mcp_probe"]
+  const parts = ordinary.map((tool, index) =>
+    toolPart(`prt_error_${index}`, tool, "error", errorInput(tool), { error: `${tool} failed visibly` }),
+  )
+  parts.push(
+    toolPart("prt_question_dismissed", "question", "error", questionInput(), {
+      error: "The user dismissed this question",
+    }),
+    toolPart("prt_question_error", "question", "error", questionInput(), { error: "Question transport failed" }),
+    toolPart("prt_todo_error", "todowrite", "error", { todos: [] }, { error: "Hidden todo failure" }),
+  )
+  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })
+
+  const group = page.locator(`[data-timeline-part-ids="${ordinary.map((_, index) => `prt_error_${index}`).join(",")}"]`)
+  await expect(group.locator('[data-component="tag"]')).toHaveText(String(ordinary.length))
+  await group.getByRole("button").click()
+  await expect(page.locator('[data-kind="tool-error-card"]')).toHaveCount(ordinary.length + 1)
+  await expect(page.getByText(/dismissed/i)).toBeVisible()
+  await expect(page.locator('[data-timeline-part-id="prt_todo_error"]')).toHaveCount(0)
+  for (let index = 0; index < ordinary.length; index++) {
+    await expect(page.locator(`[data-timeline-part-id="prt_error_${index}"]`)).toBeVisible()
+  }
+})
+
 test("transitions shell and question through running error outcomes", async ({ page }) => {
  const shellID = "prt_transition_error_shell"
  const questionID = "prt_transition_error_question"
@@ -113,6 +138,62 @@ test("preserves surviving grouped patch state when its first patch fails", async
    .toBeGreaterThanOrEqual(-0.5)
 })

+test("labels all web search provider variants", async ({ page }) => {
+  const parts = [
+    toolPart(
+      "prt_search_parallel",
+      "websearch",
+      "completed",
+      { query: "parallel" },
+      { metadata: { provider: "parallel" } },
+    ),
+    toolPart("prt_search_exa", "websearch", "completed", { query: "exa" }, { metadata: { provider: "exa" } }),
+    toolPart("prt_search_generic", "websearch", "completed", { query: "generic" }),
+  ]
+  await setupTimeline(page, { messages: [userMessage(), assistantMessage(parts)] })
+  await page.getByRole("button", { name: "Used Parallel Web Search, Exa Web Search, Web Search" }).click()
+
+  const tools = page.locator('[data-component="context-tool-group-list"]')
+  await expect(tools.getByRole("button", { name: /Parallel Web Search/ })).toBeVisible()
+  await expect(tools.getByRole("button", { name: /Exa Web Search/ })).toBeVisible()
+  await expect(tools.getByRole("button", { name: /^Web Search/ })).toBeVisible()
+})
+
+test("labels completed searches with result counts", async ({ page }) => {
+  const glob = "prt_glob_count"
+  const grep = "prt_grep_count"
+  await setupTimeline(page, {
+    messages: [
+      userMessage(),
+      assistantMessage([
+        toolPart(glob, "glob", "completed", { path: ".", pattern: "**/*.ts" }, { metadata: { count: 1 } }),
+        toolPart(grep, "grep", "completed", { path: ".", pattern: "value" }, { metadata: { matches: 12 } }),
+      ]),
+    ],
+  })
+
+  const group = page.locator(`[data-timeline-part-ids="${glob},${grep}"]`)
+  await group.locator('[data-slot="collapsible-trigger"]').click()
+  const rows = group.locator('[data-component="context-tool-group-list"] [data-component="tool-trigger"]')
+  await expect(rows.filter({ hasText: "Glob" })).toContainText("(1 match)")
+  await expect(rows.filter({ hasText: "Grep" })).toContainText("(12 matches)")
+})
+
+test("labels read tools from their path input", async ({ page }) => {
+  const id = "prt_read_path"
+  await setupTimeline(page, {
+    messages: [userMessage(), assistantMessage([toolPart(id, "read", "completed", { path: "src/a.ts" })])],
+  })
+
+  const group = page.locator(`[data-timeline-part-ids="${id}"]`)
+  await group.locator('[data-slot="collapsible-trigger"]').click()
+  await expect(
+    group
+      .locator('[data-component="context-tool-group-list"] [data-component="tool-trigger"]')
+      .filter({ hasText: "Read" }),
+  ).toContainText("a.ts")
+})
+
 test("groups instruction files loaded by the same read", async ({ page }) => {
  const id = "prt_read_instructions"
  await setupTimeline(page, {
@@ -140,6 +221,36 @@ test("groups instruction files loaded by the same read", async ({ page }) => {
  await expect(loaded.locator('[data-slot="tool-loaded-kind"]')).toHaveCount(0)
 })

+test("labels skill tools from IDs and result metadata", async ({ page }) => {
+  const pending = "prt_skill_id"
+  const completed = "prt_skill_name"
+  await setupTimeline(page, {
+    messages: [
+      userMessage(),
+      assistantMessage([
+        toolPart(pending, "skill", "running", { id: "frontend-design" }),
+        toolPart(completed, "skill", "completed", { id: "opencode" }, { metadata: { name: "OpenCode" } }),
+      ]),
+    ],
+  })
+
+  const group = page.locator(`[data-timeline-part-ids="${pending},${completed}"]`)
+  await expect(group.getByRole("button")).toHaveAccessibleName("Used Skill")
+  await expect(group.locator('[data-component="tag"]')).toHaveText("2")
+  await group.getByRole("button").click()
+
+  const loaded = group.locator('[data-component="tool-loaded-item"]')
+  await expect(loaded).toHaveCount(1)
+  await expect(loaded).toHaveAttribute("aria-label", "Loaded frontend-design, OpenCode skills")
+  await expect(loaded).toHaveCSS("line-height", "16px")
+  await expect(loaded.locator('[data-slot="tool-loaded-label"]')).toHaveText("Loaded")
+  await expect(loaded.locator('[data-slot="tool-loaded-kind"]')).toHaveText("skills")
+  const names = loaded.locator('[data-component="text-shimmer"]')
+  await expect(names).toHaveCount(2)
+  await expect(names.nth(0)).toHaveAttribute("aria-label", "frontend-design")
+  await expect(names.nth(1)).toHaveAttribute("aria-label", "OpenCode")
+})
+
 test("groups only consecutive successful skill tools", async ({ page }) => {
  const parts = [
    toolPart("prt_skill_first", "skill", "completed", { id: "ocpr" }),
@@ -162,3 +273,14 @@ test("groups only consecutive successful skill tools", async ({ page }) => {
 function questionInput() {
  return { questions: [{ header: "Stability", question: "Keep it stable?", options: [] }] }
 }
+
+function errorInput(tool: string) {
+  if (tool === "shell") return { command: "exit 1" }
+  if (["edit", "write"].includes(tool)) return { path: "src/error.ts", content: "" }
+  if (tool === "patch") return { patchText: "Update src/error.ts" }
+  if (tool === "webfetch") return { url: "https://example.com" }
+  if (tool === "websearch") return { query: "failure" }
+  if (tool === "subagent") return { description: "Fail subagent", agent: "explore", prompt: "Inspect the failure." }
+  if (tool === "skill") return { name: "failure" }
+  return { target: "failure" }
+}
@@ -2,7 +2,7 @@ import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"

-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const server = "http://127.0.0.1:4096"
 const sessionA = session("ses_tab_a", "Tab A session")
 const sessionB = session("ses_tab_b", "Tab B session")
 const sessionC = session("ses_tab_c", "Tab C session")
@@ -238,7 +238,7 @@ function session(id: string, title: string) {

 async function mockServer(page: Page) {
  const sessions = [sessionA, sessionB, sessionC]
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== server) return route.fallback()
    if (url.pathname === `/api/session/${unresolvedSessionID}`) return new Promise(() => {})
@@ -87,7 +87,6 @@ test("clears the terminal line with Command+Delete", async ({ page }) => {
  const terminal = page.locator('[data-component="terminal"]')
  await page.keyboard.press("Control+Backquote")
  await expect(terminal.locator("textarea")).toHaveCount(1)
-  await expect.poll(() => sendPtyOutput).toBeDefined()

  await page.keyboard.press("Meta+Backspace")

@@ -127,6 +127,7 @@ test("animates review and terminal panels while caching hidden terminal content"
  await expectStackedGeometry(page)
  await expectPanelGapHeld(page)

+  await resetTerminalTopMotion(page)
  await resetTerminalBottomMotion(page)
  await resetTerminalAnchorGaps(page)
  await resetPanelGaps(page)
@@ -138,6 +139,7 @@ test("animates review and terminal panels while caching hidden terminal content"
  await expect(panel).toBeVisible()
  await expectHeightMotions(page, "session-side-region", 2)
  await expectHeightMotions(page, "session-side-terminal-region", 2)
+  await expectTerminalTopMotion(page)
  await expectTerminalBottomFixed(page)
  await expectTerminalTopAnchored(page)
  await expectPanelGapHeld(page)
@@ -223,6 +225,7 @@ type MotionProbe = {
  terminalAnchorGaps: number[]
  resetAnchorOnMotion: boolean
  panelGaps: number[]
+  terminalTops: number[]
  terminalBottoms: number[]
  heights: string[]
  animations: string[]
@@ -240,6 +243,7 @@ async function installMotionProbe(page: Page) {
      terminalAnchorGaps: [],
      resetAnchorOnMotion: false,
      panelGaps: [],
+      terminalTops: [],
      terminalBottoms: [],
      heights: [],
      animations: [],
@@ -266,6 +270,7 @@ async function installMotionProbe(page: Page) {
        const terminalContent = document.querySelector<HTMLElement>('[data-slot="terminal-panel-content"]')
        const panelGap = document.querySelector<HTMLElement>('[data-slot="session-side-panel-gap"]')
        if (!terminal || !terminalContent) return
+        probe.terminalTops.push(terminal.getBoundingClientRect().top)
        probe.terminalBottoms.push(terminal.getBoundingClientRect().bottom)
        probe.terminalContentSizes.push({
          width: terminalContent.getBoundingClientRect().width,
@@ -441,6 +446,13 @@ async function expectStackPainted(page: Page) {
  expect(Math.max(...gaps.map((gap) => gap.terminalSurface)), JSON.stringify(gaps)).toBeLessThanOrEqual(1)
 }

+async function resetTerminalTopMotion(page: Page) {
+  await page.evaluate(() => {
+    const probe = (window as Window & { __panelMotion?: MotionProbe }).__panelMotion
+    if (probe) probe.terminalTops = []
+  })
+}
+
 async function resetTerminalBottomMotion(page: Page) {
  await page.evaluate(() => {
    const probe = (window as Window & { __panelMotion?: MotionProbe }).__panelMotion
@@ -504,6 +516,17 @@ async function expectTerminalContentCachedSize(page: Page) {
  expect(Math.min(...sizes.map((size) => size.height))).toBeGreaterThan(100)
 }

+async function expectTerminalTopMotion(page: Page) {
+  const tops = await page.evaluate(
+    () => (window as Window & { __panelMotion?: MotionProbe }).__panelMotion?.terminalTops.map(Math.round) ?? [],
+  )
+  const unique = [...new Set(tops)]
+  const range = Math.max(...unique) - Math.min(...unique)
+  const maxDelta = Math.max(...unique.slice(1).map((value, index) => Math.abs(value - unique[index])))
+  expect(unique.length, JSON.stringify(unique)).toBeGreaterThan(6)
+  expect(maxDelta, JSON.stringify({ unique, range, maxDelta })).toBeLessThan(range * 0.3)
+}
+
 async function expectHeightMotions(page: Page, slot: string, count: number) {
  await expect
    .poll(() =>
@@ -1,137 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { readFile } from "node:fs/promises"
-import { createServer } from "node:http"
-import { once } from "node:events"
-
-const legacy = `
-self.addEventListener("install", event => event.waitUntil(
-  caches.open("workbox-precache-v2-" + self.registration.scope).then(cache =>
-    cache.addAll(["/index.html", "/assets/app-old.js", "/assets/lazy-old.js"])
-  )
-))
-self.addEventListener("fetch", event => {
-  if (event.request.mode === "navigate") {
-    event.respondWith(caches.match("/index.html"))
-    return
-  }
-  event.respondWith(caches.match(event.request).then(response => response || fetch(event.request)))
-})
-`
-
-const fixture = test.extend<{ site: { url: string; upgrade: () => void; repair: () => void } }>({
-  site: async ({}, use) => {
-    const worker = await readFile(new URL("../../dist/sw.js", import.meta.url), "utf8")
-    const state = { version: "old", repaired: false }
-    const server = createServer((request, response) => {
-      const pathname = new URL(request.url ?? "/", "http://localhost").pathname
-      const prefix = state.version === "old" ? "/assets" : "/_assets"
-      response.setHeader("cache-control", "no-store")
-      if (pathname === "/sw.js") {
-        response.setHeader("content-type", "text/javascript")
-        response.end(state.version === "old" ? legacy : worker)
-        return
-      }
-      if (pathname === `${prefix}/app-${state.version}.js`) {
-        response.setHeader("content-type", "text/javascript")
-        response.end(`import "${prefix}/startup-${state.version}.js"`)
-        return
-      }
-      if (pathname === `${prefix}/startup-${state.version}.js`) {
-        response.setHeader("content-type", "text/javascript")
-        response.end(`
-          document.getElementById("root").innerHTML = '<h1>${state.version}</h1><label>Draft<input></label><button>Load older chunk</button><output></output>'
-          document.querySelector("button").onclick = () => import("/assets/lazy-old.js")
-        `)
-        return
-      }
-      if (
-        (pathname === "/assets/lazy-old.js" && state.version === "old") ||
-        (pathname === "/_assets/retry.js" && state.repaired)
-      ) {
-        response.setHeader("content-type", "text/javascript")
-        response.end('document.querySelector("output").textContent = "Older chunk loaded"')
-        return
-      }
-      // Deliberately retain the old server's fallback so the worker must reject HTML asset responses itself.
-      response.setHeader("content-type", "text/html")
-      response.end(`<div id="root"></div><script type="module" src="${prefix}/app-${state.version}.js"></script>`)
-    })
-    server.listen(0, "127.0.0.1")
-    await once(server, "listening")
-    const address = server.address()
-    if (!address || typeof address === "string") throw new Error("Expected a TCP address")
-    try {
-      await use({
-        url: `http://127.0.0.1:${address.port}`,
-        upgrade: () => (state.version = "new"),
-        repair: () => (state.repaired = true),
-      })
-    } finally {
-      server.closeAllConnections()
-      await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
-    }
-  },
-})
-
-fixture("updates a legacy worker without reloading drafts or deleting old chunks", async ({ page, site }) => {
-  await page.goto(site.url)
-  await expect(page.getByRole("heading")).toHaveText("old")
-  await page.evaluate(async () => {
-    await navigator.serviceWorker.register("/sw.js")
-    await navigator.serviceWorker.ready
-  })
-  await page.goto(site.url)
-  await expect(page.getByRole("heading")).toHaveText("old")
-  await page.getByLabel("Draft").fill("Keep this unsent prompt")
-
-  site.upgrade()
-  await page.evaluate(async () => {
-    const cache = await caches.open("opencode-assets")
-    await cache.put(
-      "/_assets/startup-new.js",
-      new Response("<html>stale fallback</html>", {
-        headers: { "content-type": "text/html" },
-      }),
-    )
-    const changed = new Promise<void>((resolve) =>
-      navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true }),
-    )
-    const registration = await navigator.serviceWorker.getRegistration()
-    if (!registration) throw new Error("Missing legacy worker")
-    await registration.update()
-    await changed
-  })
-
-  await expect(page.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
-  await page.getByRole("button", { name: "Load older chunk" }).click()
-  await expect(page.getByRole("status")).toHaveText("Older chunk loaded")
-
-  await page.goto(`${site.url}/workspace/example`)
-  await expect(page.getByRole("heading")).toHaveText("new")
-  await expect
-    .poll(() =>
-      page.evaluate(async () =>
-        (await (await caches.open("opencode-assets")).match("/_assets/startup-new.js"))?.headers.get("content-type"),
-      ),
-    )
-    .toBe("text/javascript")
-})
-
-fixture("does not cache HTML responses under asset URLs", async ({ page, site }) => {
-  site.upgrade()
-  await page.goto(site.url)
-  await expect(page.getByRole("heading")).toHaveText("new")
-  await page.evaluate(async () => {
-    await navigator.serviceWorker.register("/sw.js")
-    await navigator.serviceWorker.ready
-  })
-  await page.goto(site.url)
-  await expect(page.getByRole("heading")).toHaveText("new")
-  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
-    "text/html",
-  )
-  site.repair()
-  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
-    "text/javascript",
-  )
-})
@@ -1,9 +0,0 @@
-import { defineConfig } from "@playwright/test"
-
-export default defineConfig({
-  testDir: ".",
-  testMatch: "*.spec.ts",
-  outputDir: "../test-results/service-worker",
-  timeout: 30_000,
-  use: { browserName: "chromium" },
-})
@@ -7,5 +7,5 @@
    "rootDir": "..",
    "types": ["node", "bun"]
  },
-  "include": ["./**/*.ts", "./**/*.tsx", "../component-tests/**/*.ts", "../src/types.ts"]
+  "include": ["./**/*.ts", "./**/*.tsx", "../src/types.ts"]
 }
@@ -144,14 +144,12 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
  )
  page.on("close", () => void transport.dispose())

-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    const appPort = new URL(
      process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${process.env.PLAYWRIGHT_PORT ?? "3000"}`,
    ).port
    if (url.origin !== server && url.port !== appPort) return route.fallback()
-    // Production serves the UI and API from one origin; leave app assets to Vite.
-    if (!url.pathname.startsWith("/api/")) return route.fallback()
    if (route.request().method() === "OPTIONS") {
      return route.fulfill({ status: 204, headers: corsHeaders })
    }
@@ -25,13 +25,9 @@
    "test:browser": "bun test --conditions=browser --preload ./happydom.ts ./test-browser",
    "test:unit:watch": "bun test --conditions=solid --watch --preload ./happydom.ts ./src",
    "test:e2e": "playwright test",
-    "test:e2e:built": "PLAYWRIGHT_BUILD=1 playwright test",
    "test:e2e:local": "playwright test",
-    "test:components": "playwright test --config playwright.components.config.ts",
-    "test:components:ui": "playwright test --config playwright.components.config.ts --ui",
    "test:e2e:ui": "playwright test --ui",
    "test:e2e:report": "playwright show-report e2e/playwright-report",
-    "test:service-worker": "bun run build && playwright test --config e2e/service-worker/playwright.config.ts",
    "test:stability": "bun test ./e2e/performance/unit/visual-stability.test.ts && playwright test --config e2e/performance/timeline-stability/playwright.config.ts",
    "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts",
    "test:bench:devex": "bun test ./e2e/performance/unit/desktop-startup.test.ts && playwright test --config e2e/performance/devex/playwright.config.ts"
@@ -1,4 +0,0 @@
-import { fileURLToPath } from "node:url"
-import { componentConfig } from "../storybook/playwright/config"
-
-export default componentConfig(fileURLToPath(new URL(".", import.meta.url)))
@@ -2,26 +2,14 @@ import { defineConfig, devices } from "@playwright/test"

 const port = Number(process.env.PLAYWRIGHT_PORT ?? 3000)
 const baseURL = process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${port}`
-const url = new URL(baseURL)
-if (url.protocol !== "http:") throw new Error("E2E fixtures require an http:// app URL")
-const built = !!process.env.CI || process.env.PLAYWRIGHT_BUILD === "1"
-// Production connects to its own origin, so fixture URLs must match the preview server.
-if (built) {
-  process.env.PLAYWRIGHT_SERVER_HOST = url.hostname
-  process.env.PLAYWRIGHT_SERVER_PORT = url.port || "80"
-}
 const serverHost = process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"
 const serverPort = process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"
-const command = built
-  ? `bun run build && bun run serve -- --host 127.0.0.1 --port ${port} --strictPort`
-  : `bun run dev -- --host 127.0.0.1 --port ${port} --strictPort`
+const command = `bun run dev -- --host 0.0.0.0 --port ${port}`
+const reuse = !process.env.CI
 const workers = Number(process.env.PLAYWRIGHT_WORKERS ?? (process.env.CI ? 5 : 0)) || undefined
 export default defineConfig({
  testDir: "./e2e",
-  testIgnore: [
-    "service-worker/**",
-    process.env.OPENCODE_PERFORMANCE === "1" ? "performance/**/*.test.ts" : "performance/**",
-  ],
+  testIgnore: process.env.OPENCODE_PERFORMANCE === "1" ? "performance/**/*.test.ts" : "performance/**",
  outputDir: "./e2e/test-results",
  timeout: 60_000,
  expect: {
@@ -32,18 +20,16 @@ export default defineConfig({
  retries: process.env.CI ? 2 : 0,
  workers,
  reporter: [["html", { outputFolder: "e2e/playwright-report", open: "never" }], ["line"]],
-  webServer: process.env.PLAYWRIGHT_BASE_URL
-    ? undefined
-    : {
-        command,
-        url: baseURL,
-        reuseExistingServer: !built,
-        timeout: 120_000,
-        env: {
-          VITE_OPENCODE_SERVER_HOST: serverHost,
-          VITE_OPENCODE_SERVER_PORT: serverPort,
-        },
-      },
+  webServer: {
+    command,
+    url: baseURL,
+    reuseExistingServer: reuse,
+    timeout: 120_000,
+    env: {
+      VITE_OPENCODE_SERVER_HOST: serverHost,
+      VITE_OPENCODE_SERVER_PORT: serverPort,
+    },
+  },
  use: {
    baseURL,
    trace: "on-first-retry",
@@ -1,10 +1,10 @@
-/_assets/*.js
+/assets/*.js
  Content-Type: application/javascript

-/_assets/*.mjs
+/assets/*.mjs
  Content-Type: application/javascript

-/_assets/*.css
+/assets/*.css
  Content-Type: text/css

 /*.js
@@ -17,7 +17,7 @@ export function Home() {
  return (
    <div
      class={`
-        mx-2 mb-2 mt-[var(--shell-top-inset,8px)] min-h-0 flex-1 self-stretch overflow-hidden rounded-[10px]
+        m-2 min-h-0 flex-1 self-stretch overflow-hidden rounded-[10px]
        bg-v2-background-bg-base shadow-[var(--v2-elevation-raised)]
      `}
    >
@@ -73,7 +73,7 @@ export default function NewSessionPage(props: { draftId: string }) {
    <div class="relative size-full overflow-hidden flex flex-col">
      {suspendUntilPromptReady()}
      <NewSessionStatus visible={settings.visibility.status()} />
-      <div class="flex-1 min-h-0 flex flex-col gap-2 px-2 pb-2 pt-[var(--shell-top-inset,8px)]">
+      <div class="flex-1 min-h-0 flex flex-col gap-2 p-2">
        <NewSessionView composer={model} project={project} workspace={workspace} />
      </div>
    </div>
@@ -1,16 +1,10 @@
 import type { AgentListOutput, ModelListOutput, ProviderListOutput } from "@opencode-ai/client/promise"
 import type { Agent, Project, Provider, ProviderListResponse } from "@/runtime/server/types"
 import type { Project as CurrentProject } from "@opencode-ai/client/promise"
-import { unwrap } from "solid-js/store"
 export { pathKey as directoryKey, type PathKey as DirectoryKey } from "@/workspaces/path-key"

 export const cmp = (a: string, b: string) => (a < b ? -1 : a > b ? 1 : 0)

-const providerCatalogs = new WeakMap<
-  ProviderListOutput["data"],
-  WeakMap<ModelListOutput["data"], ProviderListResponse>
->()
-
 export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Agent[] {
  if (input.every((agent) => !("request" in agent))) return input as Agent[]
  return (input as AgentListOutput["data"]).map((agent) => ({
@@ -36,16 +30,12 @@ export function normalizeAgentList(input: AgentListOutput["data"] | Agent[]): Ag
 }

 export function normalizeProviderList(
-  input: ProviderListOutput["data"] | ProviderListResponse,
-  catalog?: ModelListOutput["data"],
+  providers: ProviderListOutput["data"] | ProviderListResponse,
+  models?: ModelListOutput["data"],
 ): ProviderListResponse {
-  if (!Array.isArray(input)) return input
-  // Client sync replaces whole catalog lists. Track those reads at the caller,
-  // not every model field, and share conversions without retaining old lists.
-  const providers = unwrap(input)
-  const models = unwrap(catalog)
-  const cached = models && providerCatalogs.get(providers)?.get(models)
-  if (cached) return cached
+  if (!Array.isArray(providers)) {
+    return providers
+  }
  const all = new Map<string, Provider>()

  for (const provider of providers) {
@@ -111,7 +101,7 @@ export function normalizeProviderList(
    }
  }

-  const result = {
+  return {
    all,
    connected: providers.map((provider) => provider.id),
    default: Object.fromEntries(
@@ -121,12 +111,6 @@ export function normalizeProviderList(
      }),
    ),
  }
-  if (models) {
-    const cache = providerCatalogs.get(providers) ?? new WeakMap<ModelListOutput["data"], ProviderListResponse>()
-    cache.set(models, result)
-    providerCatalogs.set(providers, cache)
-  }
-  return result
 }

 export function normalizeProjectInfo(project: Project | CurrentProject): Project {
@@ -44,7 +44,9 @@ function TargetSessionSettingsCommand() {
  return null
 }

-function SessionRouteErrorBoundary(props: ParentProps<{ sessionID?: string; serverKey?: ServerConnection.Key }>) {
+function SessionRouteErrorBoundary(
+  props: ParentProps<{ sessionID?: string; serverKey?: ServerConnection.Key }>,
+) {
  return (
    <ErrorBoundary
      fallback={(error) => (
@@ -104,7 +106,7 @@ function PendingSessionState(props: { sessionID: string }) {

 function SessionStatePanel(props: ParentProps) {
  return (
-    <div class="flex min-h-0 flex-1 px-2 pb-2 pt-[var(--shell-top-inset,8px)]">
+    <div class="flex min-h-0 flex-1 p-2">
      <SessionPanelFrame raised>{props.children}</SessionPanelFrame>
    </div>
  )
@@ -164,7 +164,7 @@ export function SessionScreen(props: { session: SessionModel }) {
  return (
    <>
      <SessionHeader />
-      <div class="flex-1 min-h-0 flex flex-col gap-2 px-2 pb-2 pt-[var(--shell-top-inset,8px)]">
+      <div class="flex-1 min-h-0 flex flex-col gap-2 p-2">
        <div ref={screen.panel.ref} class="relative flex-1 min-h-0 flex flex-col md:flex-row gap-2">
          <div
            classList={{
@@ -2,10 +2,7 @@ import type { ParentProps } from "solid-js"

 export function SessionRouteFrame(props: ParentProps<{ padded?: boolean }>) {
  return (
-    <div
-      class="relative flex size-full flex-col overflow-hidden"
-      classList={{ "px-2 pb-2 pt-[var(--shell-top-inset,8px)]": props.padded }}
-    >
+    <div class="relative flex size-full flex-col overflow-hidden" classList={{ "p-2": props.padded }}>
      {props.children}
    </div>
  )
@@ -481,6 +481,7 @@ function MessageTimelineView(
  const backgroundHintPresence = createAnimatedPresence(backgroundHintPartID, () => backgroundHintRef() ?? null)
  return (
    <VirtualizedTimeline
+      workspaceSession={workspaceSession}
      bottomSpacer={
        <Show when={backgroundHintPresence.present()}>
          <div
@@ -55,6 +55,7 @@ type Input = {
 type ViewProps = {
  header: JSX.Element
  bottomSpacer?: JSX.Element
+  workspaceSession: Accessor<boolean>
  deferred: (row: TimelineRow.TimelineRow) => boolean
  renderRow: (row: Accessor<TimelineRow.TimelineRow>, onSizeChange?: () => void) => JSX.Element
 }
@@ -370,7 +371,7 @@ export function createTimelineVirtualizer(input: Input) {
    }

    return (
-      <div class="relative w-full h-full min-w-0">
+      <div class="relative w-full h-full min-w-0" data-workspace-session={props.workspaceSession() ? "" : undefined}>
        <div
          class="absolute left-1/2 -translate-x-1/2 z-[60] pointer-events-none transition-all duration-200 ease-out"
          classList={{
@@ -36,7 +36,7 @@ export function AppRoutes() {
          <SessionRouteFrame>
            <Suspense
              fallback={
-                <div class="flex min-h-0 flex-1 px-2 pb-2 pt-[var(--shell-top-inset,8px)]">
+                <div class="flex min-h-0 flex-1 p-2">
                  <SessionPanelFrame raised />
                </div>
              }
@@ -43,13 +43,6 @@ export default function Layout(props: ParentProps) {
        style={{
          "padding-top": "env(safe-area-inset-top, 0px)",
          "padding-bottom": "env(safe-area-inset-bottom, 0px)",
-          // The native Windows titlebar already includes the gap above the content panels.
-          "--shell-top-inset":
-            platform.platform === "desktop" &&
-            platform.os === "windows" &&
-            !(mobile() && preferences.general.mobileTitlebarPosition() === "bottom")
-              ? "0px"
-              : "8px",
        }}
      >
        <Titlebar
@@ -66,7 +59,7 @@ export default function Layout(props: ParentProps) {
            <aside
              ref={(element) => setState("tabsMount", element)}
              data-slot="vertical-tabs-sidebar"
-              class="relative flex min-h-0 shrink-0 flex-col bg-v2-background-bg-deep px-2.5 pb-2 pt-[var(--shell-top-inset,8px)]"
+              class="relative flex min-h-0 shrink-0 flex-col bg-v2-background-bg-deep px-2.5 py-2"
              style={{ width: `${state.tabsWidth}px` }}
            >
              <ResizeHandle
@@ -27,7 +27,6 @@ import { newTabTooltipKeybind } from "@/shell/commands/tooltip-keybind"
 import { TitlebarRightMount } from "@/shell/titlebar/right-slot"

 const titlebarHeight = 36
-const windowsTitlebarHeight = 44 // Includes the content inset; matches the native Windows overlay.
 const minTitlebarZoom = 0.25
 const windowsControlsBaseWidth = 138 // 3 native Windows caption buttons at 46px each.
 const macTrafficLightsBaseWidth = 84
@@ -60,7 +59,7 @@ export function Titlebar(props: {
  const titlebarZoom = () => (windows() ? Math.max(zoom(), minTitlebarZoom) : zoom())
  const minHeight = () => {
    if (mac()) return `${titlebarHeight / zoom()}px`
-    if (windows()) return `env(titlebar-area-height, ${windowsTitlebarHeight / Math.min(titlebarZoom(), 1)}px)`
+    if (windows()) return `env(titlebar-area-height, ${titlebarHeight / Math.min(titlebarZoom(), 1)}px)`
    return undefined
  }
  const windowsControlsWidth = () => `${windowsControlsBaseWidth / Math.max(titlebarZoom(), 1)}px`
@@ -1,70 +0,0 @@
-import { expect, test } from "bun:test"
-import path from "node:path"
-
-test.each([
-  { name: "local development", ci: "", build: "", built: false },
-  { name: "local production build", ci: "", build: "1", built: true },
-  { name: "CI production build", ci: "true", build: "", built: true },
-  { name: "CI cannot opt into development", ci: "true", build: "0", built: true },
-])("Playwright uses $name", ({ ci, build, built }) => {
-  const result = Bun.spawnSync({
-    cmd: [process.execPath, "-e", 'import config from "./playwright.config.ts"; console.log(JSON.stringify(config))'],
-    cwd: path.resolve(import.meta.dirname, ".."),
-    env: {
-      ...process.env,
-      CI: ci,
-      PLAYWRIGHT_BUILD: build,
-      PLAYWRIGHT_BASE_URL: undefined,
-      PLAYWRIGHT_PORT: "4321",
-      PLAYWRIGHT_SERVER_HOST: "127.0.0.2",
-      PLAYWRIGHT_SERVER_PORT: "4322",
-    },
-  })
-  expect(result.exitCode).toBe(0)
-  const config = JSON.parse(result.stdout.toString())
-  expect(config.use.baseURL).toBe("http://127.0.0.1:4321")
-  expect(config.webServer.url).toBe(config.use.baseURL)
-  expect(config.webServer.command).toBe(
-    built
-      ? "bun run build && bun run serve -- --host 127.0.0.1 --port 4321 --strictPort"
-      : "bun run dev -- --host 127.0.0.1 --port 4321 --strictPort",
-  )
-  expect(config.webServer.reuseExistingServer).toBe(!built)
-  expect(config.webServer.env).toEqual({
-    VITE_OPENCODE_SERVER_HOST: built ? "127.0.0.1" : "127.0.0.2",
-    VITE_OPENCODE_SERVER_PORT: built ? "4321" : "4322",
-  })
-})
-
-test.each([
-  "./playwright.config.ts",
-  "./e2e/performance/playwright.config.ts",
-  "./e2e/performance/playwright.uncapped.config.ts",
-  "./e2e/performance/timeline-stability/playwright.config.ts",
-])("%s leaves an explicit external app unmanaged", (file) => {
-  const result = Bun.spawnSync({
-    cmd: [
-      process.execPath,
-      "-e",
-      `import config from ${JSON.stringify(file)}; console.log(JSON.stringify({ ...config, fixtureHost: process.env.PLAYWRIGHT_SERVER_HOST, fixturePort: process.env.PLAYWRIGHT_SERVER_PORT }))`,
-    ],
-    cwd: path.resolve(import.meta.dirname, ".."),
-    env: { ...process.env, CI: "true", PLAYWRIGHT_BASE_URL: "http://127.0.0.1:4444" },
-  })
-  expect(result.exitCode).toBe(0)
-  const config = JSON.parse(result.stdout.toString())
-  expect(config.webServer).toBeUndefined()
-  expect(config.use.baseURL).toBe("http://127.0.0.1:4444")
-  expect(config.fixtureHost).toBe("127.0.0.1")
-  expect(config.fixturePort).toBe("4444")
-})
-
-test("Playwright rejects HTTPS targets unsupported by the API fixtures", () => {
-  const result = Bun.spawnSync({
-    cmd: [process.execPath, "-e", 'import "./playwright.config.ts"'],
-    cwd: path.resolve(import.meta.dirname, ".."),
-    env: { ...process.env, CI: "true", PLAYWRIGHT_BASE_URL: "https://e2e.example.com" },
-  })
-  expect(result.exitCode).not.toBe(0)
-  expect(result.stderr.toString()).toContain("E2E fixtures require an http:// app URL")
-})
@@ -1,52 +0,0 @@
-import { expect, test } from "bun:test"
-import { createMemo, createRoot } from "solid-js"
-import { createStore } from "solid-js/store"
-import { normalizeProviderList } from "@/runtime/server/global-sync/utils"
-
-test("preserves an already normalized reactive catalog", () => {
-  const [store] = createStore({ catalog: { all: new Map<string, never>(), connected: [], default: {} } })
-  expect(normalizeProviderList(store.catalog)).toBe(store.catalog)
-})
-
-test("shares catalog snapshots and reacts to replacement lists", () => {
-  createRoot((dispose) => {
-    const provider = { id: "openai", name: "OpenAI", package: "@ai-sdk/openai", activation: "enabled" as const }
-    const model = {
-      id: "gpt-5",
-      modelID: "gpt-5",
-      providerID: "openai",
-      name: "GPT-5",
-      settings: {},
-      headers: {},
-      capabilities: { tools: true, input: ["text" as const], output: ["text" as const] },
-      variants: [],
-      time: { released: 1 },
-      cost: [],
-      status: "active" as const,
-      enabled: true,
-      limit: { context: 128_000, output: 8192 },
-    }
-    const [store, setStore] = createStore({ providers: [provider], models: [model] })
-    const first = createMemo(() => normalizeProviderList(store.providers, store.models))
-    const second = createMemo(() => normalizeProviderList(store.providers, store.models))
-    expect(first()).toBe(second())
-    const initial = first()
-    setStore("models", [{ ...model, name: "Renamed", limit: { context: 256_000, output: 16384 } }])
-    expect(first()).not.toBe(initial)
-    expect(first()).toBe(second())
-    expect(first().all.get("openai")?.models[model.id]).toMatchObject({
-      name: "Renamed",
-      limit: { context: 256_000, output: 16384 },
-    })
-    const renamed = first()
-    setStore("providers", [{ ...provider, name: "Custom OpenAI" }])
-    expect(first()).not.toBe(renamed)
-    expect(first()).toBe(second())
-    expect(first().all.get("openai")?.name).toBe("Custom OpenAI")
-    expect(normalizeProviderList(store.providers).all.get("openai")?.models).toEqual({})
-    setStore("models", [])
-    expect(first().all.get("openai")?.models).toEqual({})
-    expect(first().default).toEqual({})
-    dispose()
-  })
-})
@@ -21,12 +21,6 @@
      "@/*": ["./src/*"]
    }
  },
-  "include": [
-    "src",
-    "component-tests",
-    "playwright.components.config.ts",
-    "../storybook/playwright/*.ts",
-    "package.json"
-  ],
+  "include": ["src", "package.json"],
  "exclude": ["dist", "ts-dist"]
 }
@@ -29,44 +29,33 @@ export default defineConfig({
      injectRegister: false,
      manifest: false,
      workbox: {
+        cleanupOutdatedCaches: true,
        clientsClaim: false,
-        skipWaiting: true,
+        skipWaiting: false,
        inlineWorkboxRuntime: true,
-        // Always fetch the current HTML. Precaching a partial build can strand it without its chunks after an upgrade.
-        navigateFallback: null,
-        globPatterns: [],
+        navigateFallback: "/index.html",
+        navigateFallbackDenylist: [/^\/api(?:\/|$)/],
+        globPatterns: [
+          "index.html",
+          "site.webmanifest",
+          "favicon*",
+          "apple-touch-icon*",
+          "web-app-manifest*",
+          "assets/index-*.{js,css}",
+          "assets/session-*.js",
+          "assets/IBMPlexMono-Text-*.woff2",
+          "assets/Inter.ttf",
+          "assets/JetBrainsMonoNerdFontMono-Regular.woff2",
+        ],
        runtimeCaching: [
          {
-            urlPattern: ({ url }) =>
-              url.origin === self.location.origin &&
-              (url.pathname.startsWith("/_assets/") || url.pathname.startsWith("/assets/")),
+            urlPattern: ({ url }) => url.origin === self.location.origin && url.pathname.startsWith("/assets/"),
            handler: "CacheFirst",
            options: {
              cacheName: "opencode-assets",
-              plugins: [
-                {
-                  cachedResponseWillBeUsed: async ({ request, cachedResponse }) => {
-                    if (
-                      cachedResponse?.status === 200 &&
-                      !/^(text\/html|application\/xhtml\+xml)\b/i.test(cachedResponse.headers.get("content-type") ?? "")
-                    )
-                      return cachedResponse
-                    // Keep old tabs' precached chunks usable without retaining their stale HTML navigation handler.
-                    const response = await caches.match(request, {
-                      cacheName: `workbox-precache-v2-${self.location.origin}/`,
-                    })
-                    return response?.status === 200 &&
-                      !/^(text\/html|application\/xhtml\+xml)\b/i.test(response.headers.get("content-type") ?? "")
-                      ? response
-                      : null
-                  },
-                  cacheWillUpdate: async ({ response }) =>
-                    response.status === 200 &&
-                    !/^(text\/html|application\/xhtml\+xml)\b/i.test(response.headers.get("content-type") ?? "")
-                      ? response
-                      : null,
-                },
-              ],
+              cacheableResponse: {
+                statuses: [200],
+              },
              expiration: {
                maxEntries: 1000,
              },
@@ -83,7 +72,6 @@ export default defineConfig({
    port: 3000,
  },
  build: {
-    assetsDir: "_assets",
    target: "esnext",
    sourcemap: true,
  },
@@ -27,7 +27,7 @@
    "@effect/platform-node": "catalog:",
    "@opencode-ai/client": "workspace:*",
    "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/pty": "0.1.12",
+    "@opencode-ai/pty": "0.1.9",
    "@opencode-ai/schema": "workspace:*",
    "@opencode-ai/server": "workspace:*",
    "@opencode-ai/tui": "workspace:*",
@@ -4,14 +4,11 @@ import { Service } from "@opencode-ai/client/effect/service"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
-import { ServerConnection } from "../../../services/server-connection"

 export default Runtime.handler(
  Commands.commands.service.commands.restart,
  Effect.fn("cli.service.restart")(function* () {
    const options = yield* ServiceConfig.options()
-    // Keep this explicit: automatic service replacement must preserve terminals.
-    yield* ServerConnection.shutdownPersistentPty(options).pipe(Effect.ignore)
    yield* Service.stop(options)
    const transport = yield* Service.ensure(options)
    process.stdout.write(transport.url + EOL)
@@ -26,8 +26,6 @@ export const handler = Effect.fn("cli.web-ui.handler")(function* (options?: { re

 function serveUI(request: HttpServerRequest.HttpServerRequest, url: URL, assets: AssetMap) {
  const key = url.pathname.replace(/^\//, "")
-  if (key.startsWith("_assets/") && assets[key] === undefined)
-    return Effect.succeed(HttpServerResponse.empty({ status: 404, headers: { "cache-control": "no-store" } }))
  const name = assets[key] !== undefined ? key : "index.html"
  const file = assets[name]
  if (!file) return Effect.succeed(HttpServerResponse.empty({ status: 404 }))
@@ -19,7 +19,7 @@ describe("web UI", () => {
    await writeFile(asset, "console.log('embedded')")
    const assets = {
      "index.html": await Bun.file(index).text(),
-      "_assets/app.js": await Bun.file(asset).text(),
+      "app.js": await Bun.file(asset).text(),
      "sw.js": "service worker",
      "registerSW.js": "registration",
      "font.woff2": new Uint8Array([0, 1, 2, 255]),
@@ -53,16 +53,7 @@ describe("web UI", () => {
          expect(missing.status).toBe(404)
          expect(yield* Effect.promise(() => missing.text())).toBe("")

-          yield* Effect.forEach(["/_assets/old.js", "/_assets/old.css", "/_assets/missing"], (pathname) =>
-            Effect.gen(function* () {
-              const missing = yield* Effect.promise(() => fetch(`${origin}${pathname}`))
-              expect(missing.status).toBe(404)
-              expect(missing.headers.get("cache-control")).toBe("no-store")
-              expect(yield* Effect.promise(() => missing.text())).toBe("")
-            }),
-          )
-
-          const script = yield* Effect.promise(() => fetch(`${origin}/_assets/app.js`))
+          const script = yield* Effect.promise(() => fetch(`${origin}/app.js`))
          expect(yield* Effect.promise(() => script.text())).toBe("console.log('embedded')")
          expect(script.headers.get("content-type")).toContain("javascript")
          expect(script.headers.get("cache-control")).toBe("public, max-age=31536000, immutable")
@@ -83,14 +74,6 @@ describe("web UI", () => {
          expect(yield* Effect.promise(() => fallback.text())).toContain("embedded")
          expect(fallback.headers.get("content-security-policy")).toContain("default-src 'self'")
          expect(fallback.headers.get("content-security-policy")).toContain("connect-src * data: blob:")
-
-          const dotted = yield* Effect.promise(() => fetch(`${origin}/workspace/example.js`))
-          expect(dotted.status).toBe(200)
-          expect(yield* Effect.promise(() => dotted.text())).toContain("embedded")
-
-          const legacy = yield* Effect.promise(() => fetch(`${origin}/assets/missing.js`))
-          expect(legacy.status).toBe(200)
-          expect(yield* Effect.promise(() => legacy.text())).toContain("embedded")
        }),
      ).pipe(Effect.provide(NodeFileSystem.layer)),
    )
@@ -514,115 +514,6 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
  expect(events[1]?.type === "session.model.selected" && events[1].created).toBe(1_717_171_717_000)
 })

-// Moved from packages/app/e2e/regression/session-timeline-transport.spec.ts
-test("event.subscribe keeps one request open while delivering multiple events", async () => {
-  const requests: Request[] = []
-  const events = [
-    { id: "evt_first", created: 1, type: "server.connected", data: {} },
-    { id: "evt_second", created: 2, type: "server.connected", data: {} },
-  ]
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      requests.push(input instanceof Request ? input : new Request(input, init))
-      return new Response(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join(""), {
-        headers: { "content-type": "text/event-stream" },
-      })
-    },
-  })
-  const received = []
-  for await (const event of client.event.subscribe()) received.push(event)
-  expect(received).toEqual(events)
-  expect(requests).toHaveLength(1)
-})
-
-// Moved from packages/app/e2e/regression/session-timeline-transport.spec.ts
-test("event.subscribe delivers every event from one stream chunk", async () => {
-  const events = Array.from({ length: 4 }, (_, index) => ({
-    id: `evt_burst_${index}`,
-    created: index,
-    type: "server.connected",
-    data: {},
-  }))
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      new Response(new TextEncoder().encode(events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("")), {
-        headers: { "content-type": "text/event-stream" },
-      }),
-  })
-  const received = []
-  for await (const event of client.event.subscribe()) received.push(event)
-  expect(received).toEqual(events)
-  expect(new Set(received.map((event) => event.id)).size).toBe(4)
-})
-
-// Moved from packages/app/e2e/regression/session-timeline-transport.spec.ts
-test("event.subscribe parses split JSON and a split multibyte code point", async () => {
-  const event = {
-    id: "evt_split",
-    created: 1,
-    type: "server.connected",
-    data: { text: "split snowman \u2603\u2603\u2603" },
-  }
-  const encoded = new TextEncoder().encode(`data: ${JSON.stringify(event)}\n\n`)
-  const multibyte = encoded.indexOf(new TextEncoder().encode("\u2603")[0]!)
-  const boundaries = [9, multibyte + 1, multibyte + 2, encoded.length]
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      new Response(
-        new ReadableStream({
-          start(controller) {
-            boundaries.forEach((end, index) =>
-              controller.enqueue(encoded.slice(index ? boundaries[index - 1] : 0, end)),
-            )
-            controller.close()
-          },
-        }),
-        { headers: { "content-type": "text/event-stream" } },
-      ),
-  })
-  await expect(client.event.subscribe()[Symbol.asyncIterator]().next()).resolves.toEqual({ done: false, value: event })
-})
-
-// Moved from packages/app/e2e/regression/session-timeline-transport.spec.ts
-test("event.subscribe ignores server heartbeat comments", async () => {
-  const event = { id: "evt_sentinel", created: 1, type: "server.connected", data: {} }
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async () =>
-      new Response(`: heartbeat\n\ndata: ${JSON.stringify(event)}\n\n: heartbeat\n\n`, {
-        headers: { "content-type": "text/event-stream" },
-      }),
-  })
-  const received = []
-  for await (const item of client.event.subscribe()) received.push(item)
-  expect(received).toEqual([event])
-})
-
-// Moved from packages/app/e2e/regression/session-timeline-transport.spec.ts
-test("event transport passes through ordinary health requests", async () => {
-  const requests: string[] = []
-  const event = { id: "evt_connected", created: 1, type: "server.connected", data: {} }
-  const client = OpenCode.make({
-    baseUrl: "http://localhost:3000",
-    fetch: async (input, init) => {
-      const request = input instanceof Request ? input : new Request(input, init)
-      requests.push(new URL(request.url).pathname)
-      if (new URL(request.url).pathname === "/api/event") {
-        return new Response(`data: ${JSON.stringify(event)}\n\n`, {
-          headers: { "content-type": "text/event-stream" },
-        })
-      }
-      return Response.json({ healthy: true, version: "2.0.0", pid: 1 })
-    },
-  })
-  await expect(client.event.subscribe()[Symbol.asyncIterator]().next()).resolves.toEqual({ done: false, value: event })
-  await expect(client.health.get()).resolves.toEqual({ healthy: true, version: "2.0.0", pid: 1 })
-  expect(requests).toEqual(["/api/event", "/api/health"])
-})
-
 test("event.subscribe terminates on malformed Promise SSE data", async () => {
  const client = OpenCode.make({
    baseUrl: "http://localhost:3000",
@@ -118,7 +118,7 @@
    "@ff-labs/fff-node": "0.10.5",
    "@opencode-ai/codemode": "workspace:*",
    "@opencode-ai/ai": "workspace:*",
-    "@opencode-ai/pty": "0.1.12",
+    "@opencode-ai/pty": "0.1.9",
    "@opencode-ai/schema": "workspace:*",
    "@opencode-ai/plugin": "workspace:*",
    "@opencode-ai/util": "workspace:*",
@@ -80,11 +80,10 @@ export function importLegacyCredentials(tx: Parameters<DatabaseMigration.Migrati
                      }
                    : undefined,
              })
-      const label = credential.type === "oauth" ? "OAuth" : "API key"
      const now = Date.now()
      yield* tx.run(sql`
        INSERT INTO credential (id, integration_id, label, value, time_created, time_updated)
-        VALUES (${Credential.ID.create()}, ${integrationID}, ${label}, ${JSON.stringify(credential)}, ${now}, ${now})
+        VALUES (${Credential.ID.create()}, ${integrationID}, 'default', ${JSON.stringify(credential)}, ${now}, ${now})
      `)
    }

@@ -507,11 +507,9 @@ const layer = Layer.effect(
      from: TreeID
      to: TreeID
    }) {
-      // Undo needs both paths of a rename, not only its destination.
      return (yield* repositoryOperation("list_files", input.repository, [
        "diff",
        "--name-only",
-        "--no-renames",
        "-z",
        input.from,
        input.to,
@@ -1,41 +1,11 @@
 export * as Job from "./job.js"

-import { Array, Cause, Clock, Context, Deferred, Effect, Exit, Layer, Schema, Scope, SynchronizedRef } from "effect"
+import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Identifier } from "./id/id.js"
-import { KV } from "./kv.js"
-import { SessionMessage } from "./session/message.js"
 import { SessionSchema } from "./session/schema.js"

-const Background = Schema.Struct({
-  id: Schema.String,
-  notificationID: SessionMessage.ID,
-  recovery: Schema.Union([
-    Schema.Struct({
-      kind: Schema.Literal("shell"),
-      sessionID: SessionSchema.ID,
-      shellID: Schema.String,
-      command: Schema.String,
-    }),
-    Schema.Struct({
-      kind: Schema.Literal("subagent"),
-      parentSessionID: SessionSchema.ID,
-      childSessionID: SessionSchema.ID,
-      agent: Schema.String,
-      description: Schema.String,
-    }),
-  ]),
-  status: Schema.Literals(["running", "completed", "error", "cancelled"]),
-  output: Schema.optionalKey(Schema.String),
-  error: Schema.optionalKey(Schema.String),
-})
-
-export type Background = typeof Background.Type
-export type Recovery = Background["recovery"]
-export type Status = Background["status"]
-
-const decodeBackground = Schema.decodeUnknownResult(Background)
-const backgroundPrefix = "job.background/"
+export type Status = "running" | "completed" | "error" | "cancelled"

 export type Info = {
  id: string
@@ -47,7 +17,6 @@ export type Info = {
  output?: string
  error?: string
  metadata?: Record<string, unknown>
-  notificationID?: SessionMessage.ID
 }

 type Active = {
@@ -58,7 +27,6 @@ type Active = {
  token: object
  blockingSessions: Map<SessionSchema.ID, number>
  isBackgrounded: boolean
-  recovery?: Recovery
 }

 type State = {
@@ -95,8 +63,6 @@ export type StartInput = {
  type: string
  title?: string
  metadata?: Record<string, unknown>
-  recovery?: Recovery
-  notificationID?: SessionMessage.ID
  run: Effect.Effect<string, unknown>
 }

@@ -130,8 +96,6 @@ export interface Interface {
  readonly background: (id: string) => Effect.Effect<Info | undefined>
  readonly backgroundAll: (input: BackgroundAllInput) => Effect.Effect<Info[]>
  readonly cancel: (id: string) => Effect.Effect<Info | undefined>
-  readonly pendingBackground: Effect.Effect<readonly Background[]>
-  readonly completeBackground: (notificationID: SessionMessage.ID) => Effect.Effect<void>
 }

 export class Service extends Context.Service<Service, Interface>()("@opencode/Job") {}
@@ -162,57 +126,43 @@ function decrementSession(input: Map<SessionSchema.ID, number>, sessionID: Sessi
 }

 /**
- * Makes one scoped, process-local registry. Explicitly recoverable background
- * work also owns a durable notification marker until its notification is admitted.
+ * Makes one scoped, process-local registry. Entries are intentionally not
+ * durable: process restart or owner-scope closure loses status and interrupts
+ * live work. Persisted observation, restart recovery, and remote workers need a
+ * separate durable ownership slice rather than pretending this registry has
+ * those semantics.
 */
 export const make = Effect.gen(function* () {
-  const kv = yield* KV.Service
  const state: State = {
    jobs: yield* SynchronizedRef.make(new Map()),
    scope: yield* Scope.Scope,
  }

-  const persistBackground = Effect.fnUntraced(function* (job: Active) {
-    if (!job.recovery || !job.info.notificationID) return
-    yield* kv.set(`${backgroundPrefix}${job.info.notificationID}`, {
-      id: job.info.id,
-      notificationID: job.info.notificationID,
-      recovery: job.recovery,
-      status: job.info.status,
-      ...(job.info.output !== undefined ? { output: job.info.output } : {}),
-      ...(job.info.error !== undefined ? { error: job.info.error } : {}),
-    })
-  })
-
  const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
    const completed_at = yield* Clock.currentTimeMillis
-    const result = yield* SynchronizedRef.modifyEffect(
-      state.jobs,
-      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [FinishResult, Map<string, Active>]> {
-        const job = jobs.get(id)
-        if (!job) return [{}, jobs]
-        if (job.token !== token) return [{}, jobs]
-        if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
-        const status: Exclude<Status, "running"> = Exit.isSuccess(exit)
-          ? "completed"
-          : Cause.hasInterruptsOnly(exit.cause)
-            ? "cancelled"
-            : "error"
-        const next = {
-          ...job,
-          blockingSessions: new Map<SessionSchema.ID, number>(),
-          info: {
-            ...job.info,
-            status,
-            completed_at,
-            ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
-            ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
-          },
-        }
-        if (status !== "cancelled") yield* persistBackground(next)
-        return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
-      }),
-    )
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
+      const job = jobs.get(id)
+      if (!job) return [{}, jobs]
+      if (job.token !== token) return [{}, jobs]
+      if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
+      const status: Exclude<Status, "running"> = Exit.isSuccess(exit)
+        ? "completed"
+        : Cause.hasInterruptsOnly(exit.cause)
+          ? "cancelled"
+          : "error"
+      const next = {
+        ...job,
+        blockingSessions: new Map<SessionSchema.ID, number>(),
+        info: {
+          ...job.info,
+          status,
+          completed_at,
+          ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
+          ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
+        },
+      }
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+    })
    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
    if (result.scope) {
      yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }))
@@ -220,6 +170,22 @@ export const make = Effect.gen(function* () {
    return result.info
  })

+  const fork = Effect.fnUntraced(function* (
+    scope: Scope.Scope,
+    id: string,
+    token: object,
+    run: Effect.Effect<string, unknown>,
+  ) {
+    return yield* run.pipe(
+      Effect.matchCauseEffect({
+        onSuccess: (output) => settle(id, token, Exit.succeed(output)),
+        onFailure: (cause) => settle(id, token, Exit.failCause(cause)),
+      }),
+      Effect.asVoid,
+      Effect.forkIn(scope, { startImmediately: true }),
+    )
+  })
+
  const get: Interface["get"] = Effect.fn("Job.get")(function* (id) {
    const job = (yield* SynchronizedRef.get(state.jobs)).get(id)
    if (!job) return undefined
@@ -235,10 +201,10 @@ export const make = Effect.gen(function* () {
        const backgrounded = yield* Deferred.make<Info>()
        const result = yield* SynchronizedRef.modifyEffect(
          state.jobs,
-          Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [StartResult, Map<string, Active>]> {
+          Effect.fnUntraced(function* (jobs) {
            const existing = jobs.get(id)
            if (existing?.info.status === "running") {
-              return [{ info: snapshot(existing) }, jobs]
+              return [{ info: snapshot(existing) }, jobs] as readonly [StartResult, Map<string, Active>]
            }
            const scope = yield* Scope.fork(state.scope, "parallel")
            const token = {}
@@ -250,7 +216,6 @@ export const make = Effect.gen(function* () {
                status: "running" as const,
                started_at,
                metadata: input.metadata,
-                ...(input.notificationID ? { notificationID: input.notificationID } : {}),
              },
              done,
              backgrounded,
@@ -258,18 +223,14 @@ export const make = Effect.gen(function* () {
              token,
              blockingSessions: new Map<SessionSchema.ID, number>(),
              isBackgrounded: false,
-              recovery: input.recovery,
            }
-            return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)]
+            return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)] as readonly [
+              StartResult,
+              Map<string, Active>,
+            ]
          }),
        )
-        if ("scope" in result)
-          yield* restore(input.run).pipe(
-            Effect.exit,
-            Effect.flatMap((exit) => settle(id, result.token, exit)),
-            Effect.asVoid,
-            Effect.forkIn(result.scope, { startImmediately: true }),
-          )
+        if ("scope" in result) yield* fork(result.scope, id, result.token, restore(input.run))
        return result.info
      }),
    )
@@ -320,31 +281,20 @@ export const make = Effect.gen(function* () {
    ).pipe(Effect.ensuring(removeBlock(input)))
  })

-  const markBackground = Effect.fnUntraced(function* (job: Active) {
-    const next = {
-      ...job,
-      isBackgrounded: true,
-      blockingSessions: new Map<SessionSchema.ID, number>(),
-      info: {
-        ...job.info,
-        ...(job.recovery ? { notificationID: job.info.notificationID ?? SessionMessage.ID.create() } : {}),
-      },
-    }
-    yield* persistBackground(next)
-    return next
-  })
-
  const background: Interface["background"] = Effect.fn("Job.background")(function* (id) {
-    const result = yield* SynchronizedRef.modifyEffect(
+    const result = yield* SynchronizedRef.modify(
      state.jobs,
-      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [BackgroundResult, Map<string, Active>]> {
+      (jobs): readonly [BackgroundResult, Map<string, Active>] => {
        const job = jobs.get(id)
-        // Recoverable work may finish before the caller backgrounds it.
-        if (!job || (job.info.status !== "running" && !job.recovery)) return [{}, jobs]
+        if (!job || job.info.status !== "running") return [{}, jobs]
        if (job.isBackgrounded) return [{ info: snapshot(job) }, jobs]
-        const next = yield* markBackground(job)
+        const next = {
+          ...job,
+          isBackgrounded: true,
+          blockingSessions: new Map<SessionSchema.ID, number>(),
+        }
        return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)]
-      }),
+      },
    )
    if (result.info && result.backgrounded)
      yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore)
@@ -352,83 +302,60 @@ export const make = Effect.gen(function* () {
  })

  const backgroundAll: Interface["backgroundAll"] = Effect.fn("Job.backgroundAll")(function* (input) {
-    const result = yield* SynchronizedRef.modifyEffect(
+    const result = yield* SynchronizedRef.modify(
      state.jobs,
-      Effect.fnUntraced(function* (jobs): Effect.fn.Return<
-        readonly [Required<BackgroundResult>[], Map<string, Active>]
-      > {
-        const results: Required<BackgroundResult>[] = []
+      (jobs): readonly [BackgroundResult[], Map<string, Active>] => {
+        const results: BackgroundResult[] = []
        const next = new Map(jobs)
        for (const [id, job] of jobs) {
          if (job.info.status !== "running") continue
          if (job.isBackgrounded) continue
          if (input.type !== undefined && job.info.type !== input.type) continue
          if (!job.blockingSessions.has(input.sessionID)) continue
-          const updated = yield* markBackground(job)
+          const updated = {
+            ...job,
+            isBackgrounded: true,
+            blockingSessions: new Map<SessionSchema.ID, number>(),
+          }
          results.push({ info: snapshot(updated), backgrounded: job.backgrounded })
          next.set(id, updated)
        }
        return [results, next]
-      }),
+      },
    )
-    yield* Effect.forEach(result, (item) => Deferred.succeed(item.backgrounded, item.info), { discard: true })
-    return result.map((item) => item.info)
+    yield* Effect.forEach(
+      result,
+      (item) => (item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void),
+      { discard: true },
+    )
+    return result.flatMap((item) => (item.info ? [item.info] : []))
  })

  const cancel: Interface["cancel"] = Effect.fn("Job.cancel")(function* (id) {
    const completed_at = yield* Clock.currentTimeMillis
-    const result = yield* SynchronizedRef.modifyEffect(
-      state.jobs,
-      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [FinishResult, Map<string, Active>]> {
-        const job = jobs.get(id)
-        if (!job) return [{}, jobs]
-        if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
-        const next = {
-          ...job,
-          blockingSessions: new Map<SessionSchema.ID, number>(),
-          info: {
-            ...job.info,
-            status: "cancelled" as const,
-            completed_at,
-          },
-        }
-        yield* persistBackground(next)
-        return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
-      }),
-    )
+    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
+      const job = jobs.get(id)
+      if (!job) return [{}, jobs]
+      if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
+      const next = {
+        ...job,
+        blockingSessions: new Map<SessionSchema.ID, number>(),
+        info: {
+          ...job.info,
+          status: "cancelled" as const,
+          completed_at,
+        },
+      }
+      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+    })
    if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
    if (result.scope) yield* Scope.close(result.scope, Exit.void)
    return result.info
  })

-  const pendingBackground: Interface["pendingBackground"] = Effect.gen(function* () {
-    const recovered: Background[] = []
-    let after: string | undefined
-    do {
-      const page = yield* kv.scan({ prefix: backgroundPrefix, after })
-      recovered.push(...Array.filterMap(page.entries, (entry) => decodeBackground(entry.value)))
-      after = page.next
-    } while (after)
-    return recovered
-  }).pipe(Effect.withSpan("Job.pendingBackground"))
-
-  const completeBackground: Interface["completeBackground"] = Effect.fn("Job.completeBackground")((notificationID) =>
-    kv.remove(`${backgroundPrefix}${notificationID}`),
-  )
-
-  return Service.of({
-    get,
-    start,
-    wait,
-    block,
-    background,
-    backgroundAll,
-    cancel,
-    pendingBackground,
-    completeBackground,
-  })
+  return Service.of({ get, start, wait, block, background, backgroundAll, cancel })
 })

 const layer = Layer.effect(Service, make)

-export const node = makeGlobalNode({ service: Service, layer, deps: [KV.node] })
+export const node = makeGlobalNode({ service: Service, layer, deps: [] })
@@ -207,10 +207,7 @@ export const connect = Effect.fnUntraced(function* (
    }
    if (!URL.canParse(config.url))
      return yield* new ConnectError({ server, message: `Invalid MCP URL for "${server}"` })
-    // Prefer raw tools for our Code Mode without changing the configured URL used for OAuth identity.
-    const url = new URL(config.url)
-    if (config.codemode !== false && !url.searchParams.has("codemode")) url.searchParams.set("codemode", "false")
-    return new StreamableHTTPClientTransport(url, {
+    return new StreamableHTTPClientTransport(new URL(config.url), {
      requestInit: config.headers ? { headers: config.headers } : undefined,
      authProvider,
    })
@@ -73,7 +73,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p

  return {
    app,
-    location: locationInfo(),
    options: {},
    agent: {
      get: (input) => {
@@ -289,6 +288,26 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
        if (ref && !isCurrentLocation(ref)) return runtime.location.mcp.list(ref)
        return response(mcp.servers())
      },
+      add: (input) => {
+        const ref = locationRef(input)
+        if (ref && !isCurrentLocation(ref)) return runtime.location.mcp.add(ref, input.server, input.config)
+        return mcp.add(input.server, input.config)
+      },
+      remove: (input) => {
+        const ref = locationRef(input)
+        if (ref && !isCurrentLocation(ref)) return runtime.location.mcp.remove(ref, input.server)
+        return mcp.remove(input.server)
+      },
+      connect: (input) => {
+        const ref = locationRef(input)
+        if (ref && !isCurrentLocation(ref)) return runtime.location.mcp.connect(ref, input.server)
+        return mcp.connect(input.server)
+      },
+      disconnect: (input) => {
+        const ref = locationRef(input)
+        if (ref && !isCurrentLocation(ref)) return runtime.location.mcp.disconnect(ref, input.server)
+        return mcp.disconnect(input.server)
+      },
      reload: mcp.reload,
      transform: (callback) =>
        mcp.transform((draft) => {
@@ -365,7 +384,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
              add: (tool) => draft.add(tool),
            }),
          )
-          .pipe(Effect.as({ dispose: Effect.void })),
+          .pipe(Effect.orDie, Effect.as({ dispose: Effect.void })),
      hook: (name, callback) => hooks.register("tool", name, callback),
    },
    vcs: {
@@ -4,7 +4,7 @@ import { define } from "@opencode-ai/plugin/effect/plugin"
 import { Effect } from "effect"

 // These servers provide Code Mode, so expose them directly instead of nesting them inside OpenCode Code Mode.
-const urls = [/^https:\/\/executor\.sh\/[^/]+\/mcp$/]
+const urls = [/^https:\/\/mcp\.cloudflare\.com\/mcp$/, /^https:\/\/executor\.sh\/[^/]+\/mcp$/]

 export const Plugin = define({
  id: "opencode.mcp.codemode.exclusion",
@@ -2,6 +2,7 @@ export * as PluginRuntime from "./runtime.js"

 import { Context, Effect, Layer } from "effect"
 import { Agent } from "../agent.js"
+import { Mcp } from "@opencode-ai/schema/mcp"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Job } from "../job.js"
 import { Location } from "../location.js"
@@ -28,7 +29,7 @@ export interface Interface {
    | "wait"
    | "context"
  >
-  readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel" | "completeBackground">
+  readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel">
  readonly location: {
    readonly agent: {
      readonly list: (
@@ -39,6 +40,10 @@ export interface Interface {
      readonly list: (
        ref: Location.Ref,
      ) => Effect.Effect<{ readonly location: Location.Info; readonly data: MCP.ServerInfo[] }, unknown>
+      readonly add: (ref: Location.Ref, server: string, config: Mcp.ServerConfig) => Effect.Effect<void, unknown>
+      readonly remove: (ref: Location.Ref, server: string) => Effect.Effect<void, unknown>
+      readonly connect: (ref: Location.Ref, server: string) => Effect.Effect<void, unknown>
+      readonly disconnect: (ref: Location.Ref, server: string) => Effect.Effect<void, unknown>
    }
  }
 }
@@ -87,8 +92,6 @@ export const layerWithCell = (cell: Cell) =>
        block: (input) => require(cell, (runtime) => runtime.job.block(input)),
        background: (id) => require(cell, (runtime) => runtime.job.background(id)),
        cancel: (id) => require(cell, (runtime) => runtime.job.cancel(id)),
-        completeBackground: (notificationID) =>
-          require(cell, (runtime) => runtime.job.completeBackground(notificationID)),
      },
      location: {
        agent: {
@@ -96,6 +99,10 @@ export const layerWithCell = (cell: Cell) =>
        },
        mcp: {
          list: (ref) => require(cell, (runtime) => runtime.location.mcp.list(ref)),
+          add: (ref, server, config) => require(cell, (runtime) => runtime.location.mcp.add(ref, server, config)),
+          remove: (ref, server) => require(cell, (runtime) => runtime.location.mcp.remove(ref, server)),
+          connect: (ref, server) => require(cell, (runtime) => runtime.location.mcp.connect(ref, server)),
+          disconnect: (ref, server) => require(cell, (runtime) => runtime.location.mcp.disconnect(ref, server)),
        },
      },
    }),
@@ -140,6 +147,14 @@ export const providerLayerWithCell = (cell: Cell) =>
                  data: yield* mcp.servers(),
                }
              }).pipe(Effect.provide(locations.get(ref))),
+            add: (ref, server, config) =>
+              MCP.Service.use((mcp) => mcp.add(server, config)).pipe(Effect.provide(locations.get(ref))),
+            remove: (ref, server) =>
+              MCP.Service.use((mcp) => mcp.remove(server)).pipe(Effect.provide(locations.get(ref))),
+            connect: (ref, server) =>
+              MCP.Service.use((mcp) => mcp.connect(server)).pipe(Effect.provide(locations.get(ref))),
+            disconnect: (ref, server) =>
+              MCP.Service.use((mcp) => mcp.disconnect(server)).pipe(Effect.provide(locations.get(ref))),
          },
        },
      }
@@ -3,7 +3,6 @@ export * as SessionExecution from "./execution.js"
 import { Cause, Context, Effect, Exit, Layer } from "effect"
 import { Bus } from "../bus.js"
 import { Database } from "../database/database.js"
-import { Job } from "../job.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { SessionEvent } from "./event.js"
@@ -53,7 +52,6 @@ export const layer = Layer.effect(
    const store = yield* SessionStore.Service
    const locations = yield* LocationServiceMap.Service
    const bus = yield* Bus.Service
-    const jobs = yield* Job.Service
    const db = (yield* Database.Service).db
    const reportLifecycle = <A>(sessionID: SessionSchema.ID, effect: Effect.Effect<A>) =>
      effect.pipe(
@@ -96,7 +94,7 @@ export const layer = Layer.effect(
              : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID })),
          ),
        )
-        if (result._tag === "Complete") return
+        if (result.type === "complete") return
        return yield* drain(sessionID, false, result.continuation, promotable)
      })
    }
@@ -120,7 +118,6 @@ export const layer = Layer.effect(
            if (outcome.type === "interrupted") {
              // A user cancel releases the claim: the turn must not resurrect at the next
              // boot. Shutdown interruption keeps it for restart continuity.
-              if (outcome.reason === "user") yield* jobs.cancel(sessionID)
              yield* bus.publish(
                SessionEvent.Execution.Interrupted,
                { sessionID, reason: outcome.reason },
@@ -170,7 +167,7 @@ export const layer = Layer.effect(
 export const node = makeGlobalNode({
  service: Service,
  layer,
-  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node, Job.node],
+  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node],
 })

 /** Low-level compatibility layer for callers that only need durable Session recording. */
@@ -3,8 +3,6 @@ export * as SessionRestart from "./restart.js"
 import { Context, Effect, Layer } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "../../bus.js"
-import { Job } from "../../job.js"
-import { Session } from "../../session.js"
 import { SessionEvent } from "../event.js"
 import { SessionExecution } from "../execution.js"
 import { SessionSchema } from "../schema.js"
@@ -47,9 +45,6 @@ export interface Interface {
 * process: crash, SIGKILL, isolate eviction, and graceful restart all leave
 * the same durable signature.
 *
- * Recovery is at-least-once: local coordination prevents concurrent drains,
- * not repeated external side effects after a crash.
- *
 * The sweep assumes every orphaned claim's owner is dead. The managed-server
 * protocol guarantees this: a successor is only spawned after the previous
 * process is confirmed dead (client service `kill`/`evict` poll the PID), the
@@ -67,16 +62,14 @@ export const layer = (options?: Options) =>
      const store = yield* SessionStore.Service
      const execution = yield* SessionExecution.Service
      const bus = yield* Bus.Service
-      const jobs = yield* Job.Service
-      const sessions = yield* Session.Service
      const scope = yield* Effect.scope
      const maxAttempts = options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS

-      const prepareResume = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
+      const resumeOne = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
        // Durable before the resume runs, so a crash inside the resumed turn is
        // counted by the next sweep and the budget cannot be dodged.
        const attempts = yield* store.countResume(sessionID)
-        if (attempts === undefined) return false
+        if (attempts === undefined) return // the Session was deleted since listing
        if (attempts > maxAttempts) {
          // Terminalize instead: the release hook clears the claim and resets the
          // counter atomically with the terminal event.
@@ -85,166 +78,31 @@ export const layer = (options?: Options) =>
            { sessionID, error: RESUME_EXHAUSTED },
            { commit: () => store.release(sessionID) },
          )
-          return false
+          return
        }
        yield* bus.publish(SessionEvent.Synthetic, {
          sessionID,
          text: CONTINUE_AFTER_SERVER_RESTART,
          description: "Continuing after restart",
        })
-        return true
-      })
-
-      const recoverShell = Effect.fnUntraced(function* (
-        background: Job.Background,
-        recovery: Extract<Job.Recovery, { kind: "shell" }>,
-      ) {
-        const state = background.status === "running" ? "cancelled" : background.status
-        const text =
-          background.status === "running"
-            ? "Command cancelled because the server restarted"
-            : state === "completed"
-              ? (background.output ?? "Command completed")
-              : state === "error"
-                ? (background.error ?? "Command failed")
-                : "Command cancelled"
-
-        yield* sessions
-          .synthetic({
-            id: background.notificationID,
-            sessionID: recovery.sessionID,
-            description: recovery.command,
-            text: `<shell id="${background.id}" state="${state}" command="${recovery.command}">\n${text}\n</shell>`,
-            metadata: {
-              source: "shell",
-              jobID: background.id,
-              shellID: recovery.shellID,
-              state,
-            },
-            resume: false,
-          })
-          .pipe(
-            Effect.catchTag("Session.NotFoundError", () => Effect.void),
-            Effect.orDie,
-          )
-        yield* jobs.completeBackground(background.notificationID)
-      })
-
-      const recoverSubagent = Effect.fnUntraced(function* (
-        background: Job.Background,
-        recovery: Extract<Job.Recovery, { kind: "subagent" }>,
-        suspended: ReadonlySet<SessionSchema.ID>,
-      ) {
-        const child = yield* store.get(recovery.childSessionID)
-        if (!child || child.parentID !== recovery.parentSessionID || !(yield* store.get(recovery.parentSessionID))) {
-          yield* jobs.completeBackground(background.notificationID)
-          return
-        }
-
-        const notify = Effect.fnUntraced(function* (result: Pick<Job.Background, "status" | "output" | "error">) {
-          if (result.status === "running") return
-          const text =
-            result.status === "completed"
-              ? (result.output ?? "Subagent completed without a text response.")
-              : result.status === "error"
-                ? (result.error ?? "Subagent failed")
-                : "Subagent cancelled"
-          yield* sessions
-            .synthetic({
-              id: background.notificationID,
-              sessionID: recovery.parentSessionID,
-              ...(suspended.has(recovery.parentSessionID) ? { resume: false } : {}),
-              description: recovery.description,
-              text: `<subagent sessionID="${recovery.childSessionID}" state="${result.status}" description="${recovery.description}">\n${text}\n</subagent>`,
-              metadata: {
-                source: "subagent",
-                childID: recovery.childSessionID,
-                agent: recovery.agent,
-                state: result.status,
-              },
-            })
-            .pipe(Effect.orDie)
-          yield* jobs.completeBackground(background.notificationID)
-        })
-
-        if (background.status !== "running") {
-          yield* notify(background)
-          return
-        }
-        if ((yield* execution.active).has(recovery.childSessionID)) return
-        if (!(yield* prepareResume(recovery.childSessionID))) {
-          yield* notify({ status: "error", error: RESUME_EXHAUSTED.message })
-          return
-        }
-
-        yield* jobs.start({
-          id: background.id,
-          type: "subagent",
-          title: recovery.description,
-          notificationID: background.notificationID,
-          recovery,
-          run: execution.resume(recovery.childSessionID).pipe(
-            Effect.andThen(store.context(recovery.childSessionID)),
-            Effect.map((messages) => {
-              const assistant = messages.findLast(
-                (message) =>
-                  message.type === "assistant" && message.time.completed !== undefined && message.error === undefined,
-              )
-              if (assistant?.type !== "assistant") return "Subagent completed without a text response."
-              return (
-                assistant.content
-                  .filter((part) => part.type === "text")
-                  .map((part) => part.text)
-                  .join("") || "Subagent completed without a text response."
-              )
-            }),
-          ),
-        })
-        yield* jobs.background(background.id)
-        yield* jobs.wait({ id: background.id }).pipe(
-          Effect.flatMap((result) => (result.info ? notify(result.info) : Effect.void)),
-          Effect.ignore,
-          Effect.forkIn(scope),
-        )
+        // Forked into the service scope so boot never waits on resumed turns;
+        // resuming an already-live Session joins its execution. Drain failures
+        // are logged and durably recorded by the execution layer.
+        yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope))
      })

      return Service.of({
        resumeSuspendedSessions: Effect.gen(function* () {
+          // Child claims never drive recovery (children are not resumed), so a
+          // dead child's claim is noise no terminal will ever release. Clearing
+          // is safe even against a live child: claims are recovery markers, not
+          // locks, and children are excluded from that recovery.
+          yield* store.releaseChildClaims
          const active = yield* execution.active
-          // Early notices wait for root recovery's accounting, including roots that exhaust their budget.
-          const suspended = new Set((yield* store.listSuspended()).filter((sessionID) => !active.has(sessionID)))
-          const pending = yield* jobs.pendingBackground
-          yield* store.releaseChildClaims(
-            pending.flatMap((background) =>
-              background.status === "running" && background.recovery.kind === "subagent"
-                ? [background.recovery.childSessionID]
-                : [],
-            ),
-          )
-          yield* Effect.forEach(
-            pending,
-            Effect.fnUntraced(function* (background) {
-              if ((yield* jobs.get(background.id))?.status === "running") return
-              const recovery = background.recovery
-              yield* recovery.kind === "shell"
-                ? recoverShell(background, recovery)
-                : recoverSubagent(background, recovery, suspended)
-            }),
-            { discard: true },
-          )
-
-          // Background completion can wake a parent, so inspect local ownership only after recovery.
-          const resumed = yield* execution.active
-          yield* Effect.forEach(
-            (yield* store.listSuspended()).filter((sessionID) => !resumed.has(sessionID)),
-            (sessionID) =>
-              execution
-                .resume(sessionID)
-                .pipe(Effect.ignore, Effect.forkIn(scope), Effect.when(prepareResume(sessionID))),
-            { concurrency: "unbounded", discard: true },
-          )
-          // Async observers consult this set at delivery; later completions wake parents normally.
-          suspended.clear()
+          // Sessions already draining in this process keep their claim; resuming
+          // them would only inject a stray continuation into a live turn.
+          const orphaned = (yield* store.listSuspended()).filter((sessionID) => !active.has(sessionID))
+          yield* Effect.forEach(orphaned, resumeOne, { concurrency: "unbounded", discard: true })
        }),
      })
    }),
@@ -253,5 +111,5 @@ export const layer = (options?: Options) =>
 export const node = makeGlobalNode({
  service: Service,
  layer: layer(),
-  deps: [SessionStore.node, SessionExecution.node, Bus.node, Job.node, Session.node],
+  deps: [SessionStore.node, SessionExecution.node, Bus.node],
 })
@@ -45,7 +45,7 @@ const declineDefect = (cause: Cause.Cause<Tool.Error>) => {
  return decline ? Result.succeed(decline) : Result.fail(cause)
 }

-export interface Prepared {
+interface Prepared {
  readonly request: LLMRequest
  readonly options: StreamOptions
  /**
@@ -1,7 +1,7 @@
 export * as SessionRunner from "./index.js"

 import type { AIError } from "@opencode-ai/ai"
-import { Context, Data, Effect } from "effect"
+import { Context, Effect } from "effect"
 import { SessionSchema } from "../schema.js"
 import type { Promotable } from "../inbox.js"
 import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js"
@@ -19,11 +19,9 @@ export type RunError =

 export type Continuation = { readonly step: number }

-export type DrainResult = Data.TaggedEnum<{
-  Complete: {}
-  Moved: { readonly continuation?: Continuation }
-}>
-export const DrainResult = Data.taggedEnum<DrainResult>()
+export type DrainResult =
+  | { readonly type: "complete" }
+  | { readonly type: "moved"; readonly continuation?: Continuation }

 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {
@@ -1,9 +1,20 @@
 export * as SessionRunnerLLM from "./llm.js"

-import { Message } from "@opencode-ai/ai"
-import { Cause, Config, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect"
+import {
+  LLMClient,
+  AIError,
+  InvalidProviderOutputReason,
+  LLMEvent,
+  Message,
+  isContextOverflowFailure,
+  type ProviderErrorEvent,
+  type ToolCall,
+} from "@opencode-ai/ai"
+import { Cause, Config, Data, Effect, Exit, Fiber, FiberMap, Layer, Option, Pull, Schedule, Stream } from "effect"
 import { Database } from "../../database/database.js"
 import { Bus } from "../../bus.js"
+import { Permission } from "../../permission.js"
+import { QuestionTool } from "../../tool/plugin/question.js"
 import { InstructionState } from "../instruction-state.js"
 import { SessionCompaction } from "../compaction.js"
 import { SessionContext } from "../context.js"
@@ -15,18 +26,100 @@ import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 import { SessionStore } from "../store.js"
 import { SessionTitle } from "../title.js"
-import { DrainResult, Service, type Continuation } from "./index.js"
+import { Service, type Continuation } from "./index.js"
+import { createLLMEventPublisher, type StepRecord } from "./publish-llm-event.js"
 import { Snapshot } from "../../snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../../effect/app-node-platform.js"
 import { StepFailedError } from "../error.js"
+import { toSessionError } from "../to-session-error.js"
 import { SessionRunnerRetry } from "./retry.js"
-import { SessionStep } from "./step.js"
+import { SessionUsage } from "../usage.js"
 import { ToolOutput } from "../../tool-output.js"
 import { PluginSupervisor } from "../../plugin/supervisor.js"
+import { Tool } from "../../tool.js"
 import { PromptCacheDiagnostics } from "../prompt-cache-diagnostics.js"
 import { MAX_STEPS_PROMPT } from "./max-steps.js"

+/** How one model call ended: settled, awaiting retry/recovery, or restarted by compaction. */
+type CallOutcome = Data.TaggedEnum<{
+  Completed: { readonly needsContinuation: boolean; readonly step: number }
+  Retry: { readonly step: number }
+  Continue: {
+    readonly cause: AIError
+    readonly error: SessionRunnerRetry.RetryableFailure["error"]
+    readonly step: number
+  }
+  RecoverFull: { readonly step: number }
+  Restart: { readonly step: number; readonly recoveredOverflow: boolean }
+}>
+const CallOutcome = Data.taggedEnum<CallOutcome>()
+
+// Declining an interactive prompt halts the drain instead of becoming model-facing tool output.
+const isDecline = (
+  error: SessionModelRequest.ExecuteError,
+): error is Permission.DeclinedError | QuestionTool.CancelledError =>
+  error._tag === "Permission.DeclinedError" || error._tag === "QuestionTool.CancelledError"
+
+const isInterruptedStream = (failure: AIError) => {
+  if (failure.reason._tag === "InvalidProviderOutput")
+    return failure.reason.classification === "incomplete-stream"
+  if (failure.reason._tag === "Transport") return failure.reason.operation === "read"
+  return false
+}
+
+/**
+ * Classifies how the owned tool fibers ended. Interrupts abort the step; a user decline
+ * settles its own call and then aborts the step; a defect from a tool implementation
+ * becomes a failed tool call the model can read; a typed infrastructure failure must
+ * fail the assistant and then the drain.
+ */
+const classifyToolExits = (
+  settled: Exit.Exit<Array<Exit.Exit<void, SessionModelRequest.ExecuteError>>, never>,
+  calls: ReadonlyArray<ToolCall>,
+) => {
+  // Exits align with calls by construction: one owned fiber per accepted local call.
+  const exits = settled._tag === "Success" ? settled.value : []
+  const declines = exits.flatMap((exit, index) =>
+    exit._tag === "Failure"
+      ? exit.cause.reasons.flatMap((reason) =>
+          Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : [],
+        )
+      : [],
+  )
+  const causes =
+    settled._tag === "Failure"
+      ? [settled.cause]
+      : exits.flatMap((exit) => (exit._tag === "Failure" ? [exit.cause] : []))
+  // The first non-interrupt, non-decline failure, rebuilt without decline reasons so the
+  // drain's error channel never carries a decline.
+  const failure = causes
+    .flatMap((cause) => {
+      if (Cause.hasInterrupts(cause)) return []
+      const reasons = cause.reasons.flatMap(
+        (reason): Array<Cause.Reason<never>> =>
+          Cause.isFailReason(reason)
+            ? isDecline(reason.error)
+              ? []
+              : // A typed failure here broke the ExecuteError contract (the per-fiber
+                // `catchTag("Tool.Error")` consumes honest ones). Surfacing it as a defect
+                // keeps it from being dropped, which would leave its call unsettled forever.
+                [Cause.makeDieReason(reason.error)]
+            : [reason],
+      )
+      return reasons.length > 0 ? [Cause.fromReasons(reasons)] : []
+    })
+    .at(0)
+  return {
+    interrupted: causes.some(Cause.hasInterrupts),
+    declines,
+    failure,
+  }
+}
+
+const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
+const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
+const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
 const CONTINUE_AFTER_INCOMPLETE_STREAM =
  "The previous response was interrupted. Continue from where you left off without repeating completed content."

@@ -34,15 +127,17 @@ const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
    const bus = yield* Bus.Service
+    const llm = yield* LLMClient.Service
    const store = yield* SessionStore.Service
    const context = yield* SessionContext.Service
    const modelRequests = yield* SessionModelRequest.Service
    const modelTransport = yield* SessionModelTransport.Service
+    const snapshots = yield* Snapshot.Service
    const db = (yield* Database.Service).db
    const compaction = yield* SessionCompaction.Service
    const plugins = yield* PluginSupervisor.Service
    const title = yield* SessionTitle.Service
-    const steps = yield* SessionStep.make
+    const toolOutput = yield* ToolOutput.Service
    const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(
      Config.withDefault(false),
      Effect.orDie,
@@ -71,218 +166,540 @@ const layer = Layer.effect(
    })
    // Title generation starts once input is visible and must not delay model execution.
    const titles = yield* FiberMap.make<SessionSchema.ID, void, never>()
-
+    /**
+     * Drains eligible manual compaction and user input until the Session becomes idle.
+     * Execution lifecycle is published per busy period by SessionExecution, not here.
+     */
    const drain = Effect.fn("SessionRunner.drain")(function* (input: {
      readonly sessionID: SessionSchema.ID
      readonly force: boolean
      readonly continuation?: Continuation
      readonly promotable?: SessionInbox.Promotable
    }) {
-      const sessionID = input.sessionID
      let force = input.force
-      let continuing = input.continuation !== undefined
-      let step = input.continuation?.step ?? 1
-      let entering = true
+      let continuation = input.continuation
      const promotable = input.promotable ?? "input"
-      if (!force && !continuing) {
-        const pending = yield* SessionInbox.nextPromotable(db, sessionID, "input")
-        if (
-          !pending ||
-          (pending.delivery === "queue" &&
-            promotable === "steer" &&
-            pending.type !== "compaction" &&
-            pending.type !== "move")
-        )
-          return DrainResult.Complete()
-      }
+      if (!force && !continuation && !(yield* eligible(input.sessionID, promotable)))
+        return { type: "complete" as const }
      yield* plugins.flush
-      yield* settleStaleToolCalls(sessionID)
-
-      const advanceToStep = Effect.fn("SessionRunner.advanceToStep")(() =>
-        Effect.uninterruptibleMask((restore) =>
-          Effect.gen(function* () {
-            while (true) {
-              // Location entry and idle boundaries allow queued controls, not necessarily queued prompts.
-              const pending = yield* SessionInbox.serialized(
-                sessionID,
-                Effect.gen(function* () {
-                  const next = yield* SessionInbox.nextPromotable(
-                    db,
-                    sessionID,
-                    entering || !continuing ? "input" : "steer",
-                  )
-                  if (next?.type === "compaction")
-                    yield* bus.publishAll([
-                      [SessionEvent.InboxDelivered, { sessionID, inboxID: next.id }],
-                      [SessionEvent.Compaction.Started, { sessionID, reason: "manual", recent: "", inputID: next.id }],
-                    ])
-                  if (next?.type === "move")
-                    yield* restore(
-                      Effect.gen(function* () {
-                        yield* modelTransport.close(sessionID)
-                        yield* bus.publishAll([
-                          [SessionEvent.InboxDelivered, { sessionID, inboxID: next.id }],
-                          [SessionEvent.Moved, { sessionID, ...next.payload }],
-                        ])
-                      }),
-                    )
-                  return next
-                }),
-              )
-              if (!continuing && pending?.delivery !== "steer") {
-                entering = true
-                step = 1
-              }
-              if (pending?.type === "move")
-                return DrainResult.Moved({ continuation: !entering && continuing ? { step } : undefined })
-              if (pending?.type === "compaction") {
-                const session = yield* store.get(sessionID)
-                if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
-                const compacted = yield* restore(
-                  Effect.gen(function* () {
-                    return yield* compaction.compactManual({
-                      session,
-                      messages: yield* store.context(sessionID),
-                      inputID: pending.id,
-                      started: true,
-                    })
-                  }),
-                ).pipe(Effect.exit)
-                if (Exit.isFailure(compacted)) {
-                  yield* bus.publish(SessionEvent.Compaction.Failed, {
-                    sessionID,
-                    reason: "manual",
-                    error: Cause.hasInterruptsOnly(compacted.cause)
-                      ? { type: "aborted", message: "Compaction cancelled" }
-                      : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
-                    inputID: pending.id,
-                  })
-                  return yield* Effect.failCause(compacted.cause)
-                }
-                force = false
-                continue
-              }
-              if (!force && !continuing && (!pending || (pending.delivery === "queue" && promotable === "steer")))
-                return DrainResult.Complete()
-              return yield* restore(
-                Effect.gen(function* () {
-                  const selected = yield* prepareContext(sessionID)
-                  const promoted = yield* SessionInbox.promote(
-                    db,
-                    bus,
-                    sessionID,
-                    entering && !continuing ? promotable : "steer",
-                  )
-                  if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
-                    yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
-                      onlyIfMissing: true,
-                    })
-                  if (promoted > 0) step = 1
-                  return { _tag: "Ready" as const, context: yield* context.load(selected) }
-                }),
-              )
-            }
-          }),
-        ),
-      )
-
+      yield* settleStaleToolCalls(input.sessionID)
      while (true) {
-        const next = yield* advanceToStep()
-        if (next._tag !== "Ready") return next
-        continuing = yield* runStep(next.context, step)
-        step++
+        // Between-turn control items run under any drain scope: scope gates which user
+        // input may promote, not whether admitted housekeeping runs. Steered control
+        // items go ahead of any queued input; only a queue-delivered control item
+        // parked behind a queued prompt is not the next eligible item.
+        if (yield* runPendingCompaction(input.sessionID, "input")) {
+          force = false
+          continue
+        }
+        if (yield* runPendingMove(input.sessionID, "input")) return { type: "moved" as const }
+        if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, promotable)))
+          return { type: "complete" as const }
+        const result = yield* runSteps(input.sessionID, continuation, promotable)
+        if (result.type === "moved") return result
        force = false
-        entering = false
+        continuation = undefined
      }
    })

-    const prepareContext = Effect.fn("SessionRunner.prepareContext")(function* (sessionID: SessionSchema.ID) {
-      const selected = yield* context.select(sessionID)
-      // A blocked initial instruction baseline must leave admitted input pending.
-      yield* InstructionState.prepare(db, bus, selected.instructions, sessionID)
-      return selected
+    /** Work this drain may perform: scoped input, or a between-turn control item next in line. */
+    const eligible = Effect.fnUntraced(function* (sessionID: SessionSchema.ID, promotable: SessionInbox.Promotable) {
+      if (yield* SessionInbox.has(db, sessionID, promotable)) return true
+      if (promotable === "input") return false
+      const next = yield* SessionInbox.nextPromotable(db, sessionID, "input")
+      return next?.type === "compaction" || next?.type === "move"
    })

-    /** Owns logical Step policy; each attempt owns its streaming, tools, and durable settlement. */
-    const runStep = Effect.fn("SessionRunner.runStep")(function* (first: SessionContext.Loaded, step: number) {
-      const sessionID = first.session.id
+    /**
+     * Runs logical steps until no tool result or newly admitted steer requires another
+     * model call. Queued inputs remain pending until the current model work reaches idle.
+     */
+    const runSteps = Effect.fn("SessionRunner.runSteps")(function* (
+      sessionID: SessionSchema.ID,
+      continuation: Continuation | undefined,
+      drainPromotable: SessionInbox.Promotable,
+    ) {
+      // Fresh work may promote queued input; resumed turns and later steps absorb steers only.
+      let promotable: SessionInbox.Promotable = continuation ? "steer" : drainPromotable
+      let step = continuation?.step ?? 1
+      let next = continuation
+      // The drain admitted this work, so the first step always runs — even after a
+      // control item consumed at this boundary (unlike drain's one-shot force).
+      let first = true
+      // Every boundary has the same shape: control items first, then one exit decision,
+      // then the model. The turn continues only while the first step, a continuation, or
+      // steer input is owed. Deciding after control items means consuming the last
+      // steered compaction ends the turn instead of issuing an input-free model call.
+      while (true) {
+        if (yield* runPendingCompaction(sessionID, "steer")) continue
+        if (yield* runPendingMove(sessionID, "steer")) return { type: "moved" as const, continuation: next }
+        if (!first && !next && !(yield* SessionInbox.has(db, sessionID, "steer")))
+          return { type: "complete" as const }
+        const result = yield* runStep(sessionID, promotable, step)
+        first = false
+        promotable = "steer"
+        step = result.step + 1
+        next = result.needsContinuation ? { step } : undefined
+      }
+    })
+
+    /** Completes one logical model step, transparently retrying or rebuilding after compaction. */
+    const runStep = Effect.fnUntraced(function* (
+      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable,
+      step: number,
+    ) {
+      // Minting message identity before any attempt lets retries resume the same durable
+      // message. A compaction restart re-mints: the old message is stranded behind the new
+      // compaction boundary, so the rebuilt step needs identity inside the new epoch.
      let assistantMessageID = SessionMessage.ID.create()
-      const retry = yield* Schedule.toStepWithSleep(SessionRunnerRetry.schedule(bus, sessionID))
-      let initial: SessionContext.Loaded | undefined = first
+      const retry = yield* Schedule.toStepWithSleep(
+        SessionRunnerRetry.schedule(bus, sessionID, () => assistantMessageID),
+      )
+      /**
+       * Consumes one retry allowance: sleeps the scheduled backoff, or publishes
+       * Step.Failed and fails once attempts are exhausted. The step loop performs
+       * the retry itself on the next iteration.
+       */
+      const waitForRetry = (failure: SessionRunnerRetry.RetryableFailure) =>
+        retry(failure).pipe(
+          Effect.as(CallOutcome.Retry({ step: failure.step })),
+          Pull.catchDone(() =>
+            bus
+              .publish(SessionEvent.Step.Failed, {
+                sessionID,
+                assistantMessageID,
+                error: failure.error,
+              })
+              .pipe(Effect.andThen(Effect.fail(failure.cause))),
+          ),
+        )
+      let currentPromotable: SessionInbox.Promotable | undefined = promotable
+      let currentStep = step
+      // Overflow recovery is one-shot: a call after recovery must not recover another overflow.
      let recoverOverflow = true
+      // Continuation rejection permits one immediate full-context Physical Attempt without generic backoff.
      let recoverContinuation = true
      while (true) {
-        // Reuse boundary preparation once; retries refresh context without delivering more input.
-        const loaded = initial ?? (yield* prepareContext(sessionID).pipe(Effect.flatMap(context.load)))
-        initial = undefined
-        const compactionInput = { session: loaded.session, messages: loaded.messages, resolved: loaded.model }
-        if (compaction.required(compactionInput)) {
-          const compacted = yield* compaction.compact(compactionInput)
-          if (compacted.status !== "completed") return yield* new StepFailedError({ error: compacted.error })
-          assistantMessageID = SessionMessage.ID.create()
-          continue
-        }
-        const stepLimitReached = loaded.agent.info.steps !== undefined && step >= loaded.agent.info.steps
-        const transcript = SessionModelRequest.baseTranscript({
-          agent: loaded.agent.info,
-          model: loaded.model,
-          tools: loaded.tools,
-          initial: loaded.initial,
-          messages: loaded.messages,
-        })
-        const prepared = yield* modelRequests.prepare({
-          scope: { session: loaded.session, agentID: loaded.agent.id, model: loaded.model, tools: loaded.tools },
-          transcript: {
-            system: transcript.system,
-            messages: stepLimitReached
-              ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
-              : transcript.messages,
-          },
-          // Keep tool definitions on the final Step to preserve the provider's cached prefix.
-          toolChoice: stepLimitReached ? "none" : undefined,
-          webSocket: "session",
-        })
-        yield* diagnosePromptCache(sessionID, prepared.request)
-        const outcome = yield* steps.attempt({
+        const outcome = yield* callModel(
          sessionID,
-          assistantMessageID,
-          agent: loaded.agent.id,
-          model: loaded.model,
-          prepared,
-          toolsDisabled: stepLimitReached,
+          currentPromotable,
+          currentStep,
+          recoverOverflow,
          recoverContinuation,
-          recoverOverflow: Effect.suspend(() =>
-            recoverOverflow && compaction.enabled()
-              ? compaction.compact(compactionInput).pipe(Effect.map((result) => result.status === "completed"))
-              : Effect.succeed(false),
-          ),
-        })
-        if (outcome._tag === "Completed") return outcome.needsContinuation
-        if (outcome._tag === "Retry" || outcome._tag === "Continue") {
-          yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
-            Pull.catchDone(() =>
-              Effect.gen(function* () {
-                if (outcome._tag === "Retry")
-                  yield* bus.publish(SessionEvent.Step.Failed, { sessionID, assistantMessageID, error: outcome.error })
-                return yield* outcome.cause
-              }),
-            ),
-          )
-          if (outcome._tag === "Continue") {
-            yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM })
-            assistantMessageID = SessionMessage.ID.create()
-          }
-          continue
-        }
-        if (outcome._tag === "Compacted") {
-          recoverOverflow = false
+          assistantMessageID,
+        ).pipe(Effect.catchTag("SessionRunner.RetryableFailure", waitForRetry))
+        if (outcome._tag === "Completed") return { needsContinuation: outcome.needsContinuation, step: outcome.step }
+        if (outcome._tag === "Continue") {
+          yield* retry(
+            new SessionRunnerRetry.RetryableFailure({
+              cause: outcome.cause,
+              error: outcome.error,
+              step: outcome.step,
+            }),
+          ).pipe(Pull.catchDone(() => Effect.fail(outcome.cause)))
+          yield* bus.publish(SessionEvent.Synthetic, {
+            sessionID,
+            text: CONTINUE_AFTER_INCOMPLETE_STREAM,
+          })
          assistantMessageID = SessionMessage.ID.create()
-          continue
        }
-        recoverContinuation = false
+        if (outcome._tag === "Restart") {
+          if (outcome.recoveredOverflow) recoverOverflow = false
+          assistantMessageID = SessionMessage.ID.create()
+        }
+        if (outcome._tag === "RecoverFull") recoverContinuation = false
+        // Neither a retry nor a compaction restart re-promotes input.
+        currentPromotable = undefined
+        currentStep = outcome.step
      }
    })

+    /**
+     * Prepares and runs at most one model call, executes its local tools, and durably
+     * settles the step. Compaction may instead request that the logical step restart.
+     */
+    const callModel = Effect.fn("SessionRunner.callModel")(function* (
+      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable | undefined,
+      step: number,
+      recoverOverflow: boolean,
+      recoverContinuation: boolean,
+      assistantMessageID: SessionMessage.ID,
+    ) {
+      const selected = yield* context.select(sessionID)
+      // Establish what the model knows before admitting what the user said, so
+      // a blocked first step leaves pending inputs untouched.
+      yield* InstructionState.prepare(db, bus, selected.instructions, selected.session.id)
+      const promoted = promotable ? yield* SessionInbox.promote(db, bus, selected.session.id, promotable) : 0
+      if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
+        yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
+          onlyIfMissing: true,
+        })
+      // Promoted input opens a fresh step allowance.
+      const currentStep = promoted > 0 ? 1 : step
+      const loaded = yield* context.load(selected)
+      const { session, agent } = loaded
+      const resolved = loaded.model
+      // Make room: history must fit the context window before the call. A pending manual
+      // compaction owns this instead; the runner executes it between steps.
+      const compactionInput = { session, messages: loaded.messages, resolved }
+      if (compaction.required(compactionInput)) {
+        const compacted = yield* compaction.compact(compactionInput)
+        if (compacted.status === "completed")
+          return CallOutcome.Restart({ step: currentStep, recoveredOverflow: false })
+        return yield* new StepFailedError({ error: compacted.error })
+      }
+      const stepLimitReached = agent.info.steps !== undefined && currentStep >= agent.info.steps
+      const transcript = SessionModelRequest.baseTranscript({
+        agent: agent.info,
+        model: resolved,
+        tools: loaded.tools,
+        initial: loaded.initial,
+        messages: loaded.messages,
+      })
+      const prepared = yield* modelRequests.prepare({
+        scope: { session, agentID: agent.id, model: resolved, tools: loaded.tools },
+        transcript: {
+          system: transcript.system,
+          messages: stepLimitReached
+            ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
+            : transcript.messages,
+        },
+        // The final Step keeps definitions available to protocols with native "none",
+        // preserving their prompt cache prefix. Calls are still rejected at execution.
+        toolChoice: stepLimitReached ? "none" : undefined,
+        webSocket: "session",
+      })
+      yield* diagnosePromptCache(session.id, prepared.request)
+      const executeTool = (input: Parameters<typeof prepared.executeTool>[0]) => {
+        if (stepLimitReached) return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
+        return prepared.executeTool(input)
+      }
+      // Every local tool call forked here is owned until it reaches one durable settlement.
+      const toolRuns: Array<{
+        readonly call: ToolCall
+        readonly fiber: Fiber.Fiber<void, SessionModelRequest.ExecuteError>
+      }> = []
+      const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
+      const startSnapshot = yield* snapshots.capture()
+      const publisher = createLLMEventPublisher(bus, {
+        sessionID: session.id,
+        agent: agent.id,
+        // The selected catalog identity, not model.id: route-level ids are provider API
+        // model ids (for example gpt-5.5-fast resolves to api id gpt-5.5).
+        model: resolved.ref,
+        providerMetadataKey: transcript.providerMetadataKey,
+        snapshot: startSnapshot,
+        assistantMessageID,
+      })
+      const stepUsage = (finish: NonNullable<StepRecord["finish"]>) => ({
+        cost: SessionUsage.calculateCost(resolved.cost, finish.tokens),
+        tokens: finish.tokens,
+      })
+
+      const captureStepEnd = Effect.fnUntraced(function* () {
+        const snapshot = yield* snapshots.capture()
+        const files =
+          startSnapshot && snapshot
+            ? startSnapshot === snapshot
+              ? []
+              : yield* snapshots
+                  .files({ from: startSnapshot, to: snapshot })
+                  .pipe(Effect.orElseSucceed(() => undefined))
+            : undefined
+        return { snapshot, files }
+      })
+
+      const publishStepEnd = (finish: NonNullable<StepRecord["finish"]>) =>
+        Effect.gen(function* () {
+          const end = yield* captureStepEnd()
+          yield* bus.publish(SessionEvent.Step.Ended, {
+            sessionID: session.id,
+            assistantMessageID: yield* publisher.startAssistant(),
+            finish: finish.finish,
+            rawFinish: finish.rawFinish,
+            providerState: finish.providerState,
+            ...stepUsage(finish),
+            ...end,
+          })
+        })
+
+      // Concurrent writers, no lock: the provider loop and each tool fiber publish
+      // durable events unserialized. This is safe because every publisher method commits
+      // its state marks synchronously before its first await (see publish-llm-event.ts),
+      // every required event order is per-source (each source is one sequential fiber),
+      // and a fiber's events are causally after its own Tool.Called: the fork happens
+      // below that publish. Cross-source order is unconstrained; either interleaving is
+      // a truthful history of concurrent work.
+      //
+      // The stream is defined here but runs inside the settlement mask below: publish each
+      // event durably, fork one fiber per local tool call, and hold back a virgin
+      // context-overflow provider error so settlement may recover it via compaction.
+      let overflowFailure: ProviderErrorEvent | undefined
+      const providerStream = llm.stream(prepared.request, prepared.options).pipe(
+        Stream.runForEach((event) =>
+          Effect.gen(function* () {
+            if (overflowFailure || publisher.hasProviderError()) return
+            if (
+              LLMEvent.is.providerError(event) &&
+              isContextOverflowFailure(event) &&
+              !publisher.record().outputStarted
+            ) {
+              overflowFailure = event
+              return
+            }
+            yield* publisher.publish(event)
+            if (event.type !== "tool-call" || event.providerExecuted) return
+            const assistantMessageID = yield* publisher.assistantMessageID(event.id)
+            toolRuns.push({
+              call: event,
+              fiber: yield* Effect.uninterruptibleMask((restore) =>
+                restore(
+                  executeTool({
+                    sessionID: session.id,
+                    agent: agent.id,
+                    messageID: assistantMessageID,
+                    call: event,
+                    // Progress is ephemeral, not durable history: nothing to order.
+                    progress: (update) => publisher.progress(event.id, update),
+                  }),
+                ).pipe(
+                  // The fiber owns its call: it publishes its own completion, masked so a
+                  // finished execution always reaches its durable settlement.
+                  Effect.flatMap(toolOutput.truncate),
+                  Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
+                  Effect.catchTag("Tool.Error", (error) =>
+                    publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid),
+                  ),
+                ),
+              ).pipe(Effect.forkScoped),
+            })
+          }),
+        ),
+        Effect.ensuring(publisher.flush()),
+      )
+
+      // Settle: only the stream and the fiber joins are interruptible (restore); every
+      // other line is protected so a started call always reaches one durable outcome.
+      return yield* Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
+          const stream = yield* restore(providerStream).pipe(Effect.exit)
+          const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream))
+          // Note: Exit.hasInterrupts is a type guard whose false branch unsoundly narrows
+          // away non-interrupt failures, so both interrupt checks stay Cause-based.
+          const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
+          if (!overflowFailure && publisher.hasStarted()) yield* publisher.streamed()
+
+          // Join every owned tool run first: await all exits, not just the first failure.
+          // Afterwards no fiber is alive, settlement is the only writer, and the record
+          // is final. A failed join means the waiting itself was interrupted, so the runs
+          // we abandoned are interrupted before settlement closes them out.
+          if (streamInterrupted) yield* interruptTools
+          const joined = yield* restore(
+            Effect.forEach(toolRuns, (run) => Fiber.await(run.fiber), { concurrency: "unbounded" }),
+          ).pipe(Effect.exit)
+          if (joined._tag === "Failure") yield* interruptTools
+          const tools = classifyToolExits(
+            joined,
+            toolRuns.map((run) => run.call),
+          )
+
+          // A context overflow before any assistant output is recoverable: compact and
+          // restart the step instead of surfacing the provider error.
+          if (
+            recoverOverflow &&
+            compaction.enabled() &&
+            !publisher.record().outputStarted &&
+            isContextOverflowFailure(overflowFailure ?? streamFailure) &&
+            (yield* restore(compaction.compact(compactionInput))).status === "completed"
+          )
+            return CallOutcome.Restart({ step: currentStep, recoveredOverflow: true })
+
+          // An unrecovered held-back overflow becomes the step's durable provider error.
+          if (overflowFailure) yield* publisher.publish(overflowFailure)
+          // A thrown LLM failure not already recorded as the provider error either
+          // escapes as a scheduled retry or fails the assistant durably.
+          const unknownFinish =
+            stream._tag === "Success" && publisher.record().finish?.finish === "unknown"
+              ? new AIError({
+                  module: "session",
+                  method: "stream",
+                  reason: new InvalidProviderOutputReason({
+                    classification: "incomplete-stream",
+                    message: "The provider response ended with an unknown finish reason.",
+                  }),
+                })
+              : undefined
+          const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish
+          const llmError = llmFailure && !publisher.record().providerFailed ? toSessionError(llmFailure) : undefined
+          if (
+            recoverContinuation &&
+            llmFailure?.reason._tag === "Transport" &&
+            (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") &&
+            !publisher.record().outputStarted
+          )
+            return CallOutcome.RecoverFull({ step: currentStep })
+          if (
+            llmFailure &&
+            llmError &&
+            SessionRunnerRetry.isRetryable(llmFailure) &&
+            !publisher.record().outputStarted
+          ) {
+            // RetryScheduled and Step.Failed fold onto an existing assistant message, so
+            // Step.Started must be durable before the failure escapes.
+            yield* publisher.startAssistant()
+            return yield* new SessionRunnerRetry.RetryableFailure({
+              cause: llmFailure,
+              error: llmError,
+              step: currentStep,
+            })
+          }
+          if (llmError) yield* publisher.failAssistant(llmError)
+
+          // Close every unsettled call with the reason it could not settle truthfully,
+          // and fail the assistant when the step itself cannot complete. A declined call
+          // settles with its own reason before the generic sweeps.
+          for (const decline of tools.declines)
+            yield* publisher.failTool(decline.call.id, {
+              type: "aborted",
+              message:
+                decline.reason._tag === "QuestionTool.CancelledError"
+                  ? decline.reason.message
+                  : "The user declined this tool call",
+            })
+          if (tools.declines.length > 0 || streamInterrupted || tools.interrupted) {
+            yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
+            yield* publisher.failAssistant(STEP_INTERRUPTED)
+          }
+          if (tools.failure !== undefined) {
+            const error = toSessionError(Cause.squash(tools.failure))
+            yield* publisher.failUnsettledTools(error)
+          }
+          // Local calls have joined, so the remaining sweeps only close hosted calls the
+          // provider promised but never resolved.
+          if (publisher.record().providerFailed) yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
+          if (llmError) yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
+          // A clean stream that still left hosted calls unresolved fails the step itself.
+          if (stream._tag === "Success" && !publisher.record().providerFailed) {
+            const hostedResultMissing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
+            if (hostedResultMissing && !publisher.record().finish) yield* publisher.failAssistant(RESULT_MISSING)
+          }
+
+          // One terminal event: Step.Ended on a clean finish, Step.Failed otherwise.
+          const record = publisher.record()
+          if (record.finish && !record.failure) yield* publishStepEnd(record.finish)
+          if (record.failure) {
+            const end = yield* captureStepEnd()
+            yield* publisher.publishStepFailure({
+              ...(record.finish ? stepUsage(record.finish) : {}),
+              ...end,
+            })
+          }
+
+          if (
+            llmFailure &&
+            llmError &&
+            isInterruptedStream(llmFailure) &&
+            record.outputStarted &&
+            tools.declines.length === 0 &&
+            !tools.interrupted
+          )
+            return CallOutcome.Continue({
+              cause: llmFailure,
+              error: llmError,
+              step: currentStep,
+            })
+
+          if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
+          if (tools.declines.length > 0) return yield* Effect.interrupt
+          if (tools.interrupted && tools.failure) return yield* Effect.failCause(tools.failure)
+          if (tools.interrupted && joined._tag === "Failure") return yield* Effect.failCause(joined.cause)
+          if (record.failure) return yield* new StepFailedError({ error: record.failure })
+          return CallOutcome.Completed({
+            // A local call or malformed tool input requires another model step, unless
+            // this step already exhausted the agent's allowance.
+            needsContinuation:
+              !stepLimitReached && record.calls.some((call) => !call.providerExecuted && (call.called || call.settled)),
+            step: currentStep,
+          })
+        }),
+      )
+    }, Effect.scoped)
+
+    /** Executes a previously admitted manual compaction request, if one is pending. */
+    const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (
+      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable,
+    ) {
+      return yield* Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
+          const pending = yield* SessionInbox.serialized(
+            sessionID,
+            Effect.gen(function* () {
+              const selected = yield* SessionInbox.nextPromotable(db, sessionID, promotable)
+              if (selected?.type !== "compaction") return
+              yield* bus.publishAll([
+                [SessionEvent.InboxDelivered, { sessionID, inboxID: selected.id }],
+                [SessionEvent.Compaction.Started, { sessionID, reason: "manual", recent: "", inputID: selected.id }],
+              ])
+              return selected
+            }),
+          )
+          if (pending?.type !== "compaction") return false
+          const session = yield* getSession(sessionID)
+          const compacted = yield* restore(
+            Effect.gen(function* () {
+              return yield* compaction.compactManual({
+                session,
+                messages: yield* store.context(sessionID),
+                inputID: pending.id,
+                started: true,
+              })
+            }),
+          ).pipe(Effect.exit)
+          if (Exit.isSuccess(compacted)) return true
+          yield* bus.publish(SessionEvent.Compaction.Failed, {
+            sessionID,
+            reason: "manual",
+            error: Cause.hasInterruptsOnly(compacted.cause)
+              ? { type: "aborted", message: "Compaction cancelled" }
+              : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+            inputID: pending.id,
+          })
+          return yield* Effect.failCause(compacted.cause)
+        }),
+      )
+    })
+
+    const runPendingMove = Effect.fn("SessionRunner.runPendingMove")(function* (
+      sessionID: SessionSchema.ID,
+      promotable: SessionInbox.Promotable,
+    ) {
+      return yield* SessionInbox.serialized(
+        sessionID,
+        Effect.gen(function* () {
+          const pending = yield* SessionInbox.nextPromotable(db, sessionID, promotable)
+          if (pending?.type !== "move") return false
+          yield* modelTransport.close(sessionID)
+          yield* bus.publishAll([
+            [SessionEvent.InboxDelivered, { sessionID, inboxID: pending.id }],
+            [
+              SessionEvent.Moved,
+              {
+                sessionID,
+                location: pending.payload.location,
+                projectID: pending.payload.projectID,
+                subpath: pending.payload.subpath,
+              },
+            ],
+          ])
+          return true
+        }),
+      )
+    })
+
+    /** Closes stale tool calls left active by an earlier interrupted drain. */
    const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (
      sessionID: SessionSchema.ID,
    ) {
@@ -290,24 +707,23 @@ const layer = Layer.effect(
        if (message.type !== "assistant") continue
        for (const tool of message.content) {
          if (tool.type !== "tool" || (tool.state.status !== "streaming" && tool.state.status !== "running")) continue
-          const metadata = tool.state.status === "running" ? tool.state.metadata : undefined
-          const childID =
-            tool.name === "subagent" && typeof metadata?.sessionID === "string" ? metadata.sessionID : undefined
          yield* bus.publish(SessionEvent.Tool.Failed, {
            sessionID,
            assistantMessageID: message.id,
            id: tool.id,
-            error: {
-              type: "aborted",
-              message: `Tool execution interrupted: ${tool.name}${childID ? ` (sessionID: ${childID})` : ""}`,
-            },
-            ...(metadata && Object.keys(metadata).length > 0 ? { metadata } : {}),
+            error: { type: "aborted", message: `Tool execution interrupted: ${tool.name}` },
            executed: tool.executed === true,
          })
        }
      }
    })

+    const getSession = Effect.fn("SessionRunner.getSession")(function* (sessionID: SessionSchema.ID) {
+      const session = yield* store.get(sessionID)
+      if (!session) return yield* Effect.die(new Error(`Session not found: ${sessionID}`))
+      return session
+    })
+
    return Service.of({ drain })
  }),
 )
@@ -1,5 +1,5 @@
 import { type LLMEvent, type ProviderMetadata, type ToolResultValue } from "@opencode-ai/ai"
-import { Clock, Effect, Iterable } from "effect"
+import { Clock, Effect } from "effect"
 import { Bus } from "../../bus.js"
 import { Model } from "../../model.js"
 import { SessionEvent } from "../event.js"
@@ -39,7 +39,13 @@ export interface StepRecord {
    readonly providerState?: SessionMessage.ProviderState
    readonly tokens: ReturnType<typeof SessionUsage.tokens>
  }
-  readonly needsContinuation: boolean
+  readonly calls: ReadonlyArray<{
+    readonly id: string
+    readonly name: string
+    readonly called: boolean
+    readonly settled: boolean
+    readonly providerExecuted: boolean
+  }>
 }

 /** Derives canonical model content from a provider-hosted tool result. */
@@ -79,6 +85,7 @@ const hostedContent = (result: ToolResultValue): NonEmptyContent => {
 export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, input: Input) => {
  const deltaBatchInterval = 100
  type ToolState = {
+    readonly assistantMessageID: SessionMessage.ID
    readonly name: string
    called: boolean
    settled: boolean
@@ -243,7 +250,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
      if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${id}`))
      yield* bus.publish(SessionEvent.Tool.Input.Ended, {
        sessionID: input.sessionID,
-        assistantMessageID,
+        assistantMessageID: tool.assistantMessageID,
        id,
        text: value,
      })
@@ -262,8 +269,9 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    readonly providerExecuted?: boolean
  }) {
    if (tools.has(event.id)) return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`))
-    yield* startAssistant()
+    const assistantMessageID = yield* startAssistant()
    const tool: ToolState = {
+      assistantMessageID,
      name: event.name,
      called: false,
      settled: false,
@@ -306,7 +314,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    tool.settled = true
    yield* bus.publish(SessionEvent.Tool.Failed, {
      sessionID: input.sessionID,
-      assistantMessageID,
+      assistantMessageID: tool.assistantMessageID,
      id: event.id,
      error: {
        type: "tool.input-json",
@@ -325,12 +333,9 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    tool.settled = true
    yield* bus.publish(SessionEvent.Tool.Failed, {
      sessionID: input.sessionID,
-      assistantMessageID,
+      assistantMessageID: tool.assistantMessageID,
      id,
-      error:
-        tool.name === "subagent" && error.type === "aborted" && typeof tool.progress?.sessionID === "string"
-          ? { ...error, message: `${error.message} (sessionID: ${tool.progress.sessionID})` }
-          : error,
+      error,
      ...failureSnapshot(tool, metadata),
      executed: tool.providerExecuted,
    })
@@ -378,6 +383,11 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    (error: SessionError.Error, scope: "hosted" | "all" = "all") => failTools(error, scope),
  )

+  const assistantMessageIDForTool = (id: string) => {
+    const tool = tools.get(id)
+    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`))
+  }
+
  const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event: LLMEvent) {
    switch (event.type) {
      case "step-start":
@@ -445,7 +455,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
        tool.providerExecuted = event.providerExecuted === true
        yield* bus.publish(SessionEvent.Tool.Called, {
          sessionID: input.sessionID,
-          assistantMessageID,
+          assistantMessageID: tool.assistantMessageID,
          id: event.id,
          input: asRecord(event.input),
          executed: tool.providerExecuted,
@@ -471,7 +481,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
        if (event.result.type === "error") {
          yield* bus.publish(SessionEvent.Tool.Failed, {
            sessionID: input.sessionID,
-            assistantMessageID,
+            assistantMessageID: tool.assistantMessageID,
            id: event.id,
            error: { type: "tool.execution", message: stringify(event.result.value) },
            ...failureSnapshot(tool),
@@ -482,7 +492,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
        }
        yield* bus.publish(SessionEvent.Tool.Success, {
          sessionID: input.sessionID,
-          assistantMessageID,
+          assistantMessageID: tool.assistantMessageID,
          id: event.id,
          content: hostedContent(event.result),
          executed,
@@ -499,7 +509,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
        tool.settled = true
        yield* bus.publish(SessionEvent.Tool.Failed, {
          sessionID: input.sessionID,
-          assistantMessageID,
+          assistantMessageID: tool.assistantMessageID,
          id: event.id,
          error:
            event.message === `Unknown tool: ${event.name}`
@@ -541,7 +551,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    tool.progress = update
    yield* bus.publish(SessionEvent.Tool.Progress, {
      sessionID: input.sessionID,
-      assistantMessageID,
+      assistantMessageID: tool.assistantMessageID,
      id,
      metadata: update,
    })
@@ -564,7 +574,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
    if (content.length === 0) return yield* Effect.die(new Error(`Tool execution has no content: ${id}`))
    yield* bus.publish(SessionEvent.Tool.Success, {
      sessionID: input.sessionID,
-      assistantMessageID,
+      assistantMessageID: tool.assistantMessageID,
      id,
      content: [content[0], ...content.slice(1)],
      ...(result.metadata === undefined ? {} : { metadata: result.metadata }),
@@ -589,12 +599,16 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
      providerFailed,
      failure: stepFailure,
      finish: stepSettlement,
-      needsContinuation: Iterable.some(
-        tools.values(),
-        (tool) => !tool.providerExecuted && (tool.called || tool.settled),
-      ),
+      calls: Array.from(tools, ([id, tool]) => ({
+        id,
+        name: tool.name,
+        called: tool.called,
+        settled: tool.settled,
+        providerExecuted: tool.providerExecuted,
+      })),
    }),
    startAssistant,
    streamed,
+    assistantMessageID: assistantMessageIDForTool,
  }
 }
@@ -2,17 +2,17 @@ export * as SessionRunnerRetry from "./retry.js"

 import { AIError } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Duration, Effect, Schedule } from "effect"
+import { Data, Duration, Effect, Schedule } from "effect"
 import { Bus } from "../../bus.js"
 import { SessionEvent } from "../event.js"
 import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"

-export interface Input {
+export class RetryableFailure extends Data.TaggedError("SessionRunner.RetryableFailure")<{
  readonly cause: AIError
  readonly error: SessionError.Error
-  readonly assistantMessageID: SessionMessage.ID
-}
+  readonly step: number
+}> {}

 export function isRetryable(error: AIError) {
  const override = "http" in error.reason ? error.reason.http?.response?.headers["x-should-retry"] : undefined
@@ -40,25 +40,29 @@ export function isRetryable(error: AIError) {
  }
 }

-const retryAfter = (input: Input) => {
-  if (input.cause.reason._tag === "RateLimit" || input.cause.reason._tag === "ProviderInternal")
-    return input.cause.reason.retryAfterMs
+const retryAfter = (failure: RetryableFailure) => {
+  if (failure.cause.reason._tag === "RateLimit" || failure.cause.reason._tag === "ProviderInternal")
+    return failure.cause.reason.retryAfterMs
  return undefined
 }

-export const schedule = (bus: Bus.Interface, sessionID: SessionSchema.ID) =>
+export const schedule = (
+  bus: Bus.Interface,
+  sessionID: SessionSchema.ID,
+  assistantMessageID: () => SessionMessage.ID,
+) =>
  Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(
    Schedule.jittered,
-    Schedule.setInputType<Input>(),
-    Schedule.modifyDelay(({ input, duration: delay }) => {
-      const minimum = retryAfter(input)
+    Schedule.setInputType<RetryableFailure>(),
+    Schedule.modifyDelay(({ input: failure, duration: delay }) => {
+      const minimum = retryAfter(failure)
      const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum))
      return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))))
    }),
    Schedule.tap((metadata) =>
      bus.publish(SessionEvent.RetryScheduled, {
        sessionID,
-        assistantMessageID: metadata.input.assistantMessageID,
+        assistantMessageID: assistantMessageID(),
        attempt: metadata.attempt + 1,
        at: metadata.now + Duration.toMillis(metadata.duration),
        error: metadata.input.error,
--- a/Show More
+++ b/Show More