feat(tui): streamline diff review workflow (#45817 )

fix(ai): normalize response item boundaries (#45789 )
chore: update nix node_modules hashes
2026-08-28 04:26:11 +00:00 · 2026-08-28 00:11:29 -04:00 · 2026-08-27 23:08:50 -05:00 · 2026-08-28 04:03:16 +00:00 · 2026-08-27 23:58:41 -04:00 · 2026-08-27 23:58:34 -04:00
294 changed files with 14454 additions and 9553 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Preserve prompt cache prefixes when sessions move between locations with unchanged instructions.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Fix OpenCode Console device authorization URLs when the server returns an origin-rooted verification path.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Propagate fatal Git ignore-check errors during index refresh so best-effort snapshot capture returns unavailable instead of treating the check as having no matches.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Prompt and synthetic inbox ID reuse is now idempotent: reusing an ID within the same Session succeeds and returns the first admission, ignoring the retried payload, metadata, and delivery mode. Previously reuse with a differing payload failed with a conflict. Cross-Session and cross-type reuse still fail, and control items keep their operation-specific conflict behavior.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": major
---
-
-Treat MCP as a word in current Core namespace exports: rename `MCP` to `Mcp`, `MCPClient` to `McpClient`, `MCPStdio` to `McpStdio`, `MCPOAuth` to `McpOAuth`, `ConfigMCPPlugin` to `ConfigMcpPlugin`, and `MCPCodeModeExclusionPlugin` to `McpCodeModeExclusionPlugin`. Direct consumers must update their imports. Module paths, Schema contracts, runtime service keys, error tags, and behavior are unchanged.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Rename the write, patch, and question tool formatting helpers from `toModelOutput` to `toModelContent` to match the result field they populate. Direct imports of these helpers must use the new name; generated content and declared machine output are unchanged.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": minor
---
-
-Rename ModelResolver.supported to ModelResolver.hasPackage. Consumers of the old export must update the name; the predicate remains Boolean(model.package), checking only whether a catalog model declares a provider package, not whether it can be loaded. Default-model selection behavior is unchanged.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Nested AGENTS.md instructions are re-injected after compaction. Previously the in-memory dedup claim outlived the synthetic message that compaction dropped from model-visible history, so nested instructions were silently lost for the rest of the process lifetime. The claim now only guards in-flight loads; the synthetic message metadata in durable history is the sole lasting ledger, so any history truncation (compaction, revert) self-heals on the next read in that subtree.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/plugin": patch
---
-
-Derive Promise plugin API request and response conversion from the canonical protocol schemas.
@@ -1,8 +0,0 @@
---
-"@opencode-ai/core": minor
-"@opencode-ai/schema": minor
-"@opencode-ai/protocol": minor
-"@opencode-ai/client": minor
---
-
-Remove the unused question request API and use session forms for question tool interactions.
@@ -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,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Apply shared Session model-request preparation to transient generation.
@@ -1,9 +0,0 @@
---
-"@opencode-ai/core": minor
-"@opencode-ai/schema": minor
-"@opencode-ai/protocol": minor
-"@opencode-ai/client": minor
---
-
-Add an opt-in portable shell permission scanner. Opaque commands use normal shell authorization without inferring
-external directories, while the default tree-sitter path remains unchanged.
@@ -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.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Use parent directory names for SKILL.md IDs so individually downloaded skills do not overwrite each other.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Simplify interrupt continuation: the steer-scoped resume decision now lives in SessionExecution as a post-cleanup inbox check, and the run coordinator drops its continuation state machine. Wakes arriving during cancellation cleanup now restart a normal full drain, and interrupting an idle session with continue now resumes pending steering input. Recovery-applied moves now end with the same full wake as inbox-admitted moves, retrying any stranded inbox work at the new location. Interrupting with continue now also resumes a next-in-line control item: between-turn manual compaction and moves run under any drain scope, while queued prompts remain parked.
@@ -1,6 +0,0 @@
---
-"@opencode-ai/client": patch
-"@opencode-ai/plugin": patch
---
-
-Add form reply and cancellation operations that reconcile terminal forms in the local TUI projection.
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.
@@ -1,6 +0,0 @@
---
-"@opencode-ai/plugin": patch
-"@opencode-ai/core": patch
---
-
-Add transport-neutral Session model request hooks and provider-scoped hook registration so eligible OpenAI Responses requests can prefer WebSocket without bypassing HTTP-only middleware.
@@ -41,11 +41,5 @@
    // Warn when spreading non-plain objects (Headers, class instances, etc.)
    "typescript/no-misused-spread": "warn"
  },
-  "options": {
-    "typeAware": true
-  },
-  "options": {
-    "typeAware": true
-  },
  "ignorePatterns": ["**/node_modules", "**/dist", "**/.build", "**/.sst", "**/*.d.ts", "**/sdk.gen.ts"]
 }
@@ -2,7 +2,7 @@
 exact = true
 # Only install newly resolved package versions published at least 3 days ago.
 minimumReleaseAge = 259200
-minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron-builder", "electron-publish", "blume"]
+minimumReleaseAgeExcludes = ["@ai-sdk/amazon-bedrock", "@ai-sdk/anthropic", "@brendonovich/vite-plugin-opencode", "@opencode-ai/sdk", "@opencode-ai/pty", "@opencode-ai/pty-darwin-arm64", "@opencode-ai/pty-darwin-x64", "@opencode-ai/pty-linux-arm64-gnu", "@opencode-ai/pty-linux-arm64-musl", "@opencode-ai/pty-linux-x64-gnu", "@opencode-ai/pty-linux-x64-musl", "@opentui/core", "@opentui/core-darwin-arm64", "@opentui/core-darwin-x64", "@opentui/core-linux-arm64", "@opentui/core-linux-arm64-musl", "@opentui/core-linux-x64", "@opentui/core-linux-x64-musl", "@opentui/core-win32-arm64", "@opentui/core-win32-x64", "@opentui/keymap", "@opentui/solid", "opentui-spinner", "gitlab-ai-provider", "opencode-gitlab-auth", "@ff-labs/fff-node", "@ff-labs/fff-bun", "@ff-labs/fff-bin-darwin-arm64", "@ff-labs/fff-bin-darwin-x64", "@ff-labs/fff-bin-linux-arm64-gnu", "@ff-labs/fff-bin-linux-arm64-musl", "@ff-labs/fff-bin-linux-x64-gnu", "@ff-labs/fff-bin-linux-x64-musl", "@ff-labs/fff-bin-win32-arm64", "@ff-labs/fff-bin-win32-x64", "@pierre/diffs", "@pierre/theming", "app-builder-lib", "dmg-builder", "electron", "electron-builder", "electron-publish", "blume", "mermaid"]

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

  preBuild = ''
@@ -0,0 +1,13 @@
+{ callPackage, path }:
+let
+  version = (builtins.fromJSON (builtins.readFile ../packages/desktop/package.json)).devDependencies.electron;
+in
+(callPackage (path + "/pkgs/development/tools/electron/binary/generic.nix") { }) version {
+  # Electron 42.10.1 SHASUMS256.txt; update with the desktop package version.
+  aarch64-linux = "20e68d6c4e47f3ebf59de7c6b1f8b8bec6a6ebda6a451132f9b465f3f13ce467";
+  x86_64-linux = "2452b27112d92387471fa2488aafac85d79ea3f2ee1216c0abd5150d6c12362b";
+  aarch64-darwin = "ac7194a3dfd81930ba35355c01620262c1254752859b42dcb8f4b9e4d174a871";
+  x86_64-darwin = "4489aba55477a0082266cb690db1c829503ba3338048599d8fd243953df37dab";
+  # fetchzip hashes the unpacked headers, not the release tarball.
+  headers = "sha256-4eUy3BZVvxTl7KUOsxio7769lL6ag/ecbeK+qLURWMI=";
+}
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-agxF1Ab8P84tijHvw7jaG+9UZm/dJZhHw8CGNlQQqYc=",
-    "aarch64-linux": "sha256-Kg6CkhoEEsb+ZOGPN/rnNoirLdGSyQl6HU/Fy8t9Mqs=",
-    "aarch64-darwin": "sha256-SnxBpmcfPL2p3OYmSuG5Y/aFW8PeEOLhfQrxAs/53fs=",
-    "x86_64-darwin": "sha256-Dnxl1EcfiE7/rlHmPkko0BKc6hHVk6rQ/2h/PWuLfNo="
+    "x86_64-linux": "sha256-EtUp4pHl9TyPtRrLGvk/X7kd2LuIxNxCpUwF5aLtzN4=",
+    "aarch64-linux": "sha256-m0j/pMZCguclR3/T9JmzCfi11YzmIvBFyR2bVhIO37Y=",
+    "aarch64-darwin": "sha256-nqefk68ZTUfNU15q1WkXaGsFzPNwOjCtMHpp6WrpNqM=",
+    "x86_64-darwin": "sha256-syD7hX62E4yCDV/wux1QKw4q/zZr24f99Y2mmzMJo6o="
  }
 }
@@ -39,24 +39,24 @@
      "packages/stats/*"
    ],
    "catalog": {
-      "@effect/opentelemetry": "4.0.0-rc.111",
-      "@effect/platform-node": "4.0.0-rc.111",
-      "@effect/platform-node-shared": "4.0.0-rc.111",
-      "@effect/sql-sqlite-bun": "4.0.0-rc.111",
+      "@effect/opentelemetry": "4.0.0-rc.112",
+      "@effect/platform-node": "4.0.0-rc.112",
+      "@effect/platform-node-shared": "4.0.0-rc.112",
+      "@effect/sql-sqlite-bun": "4.0.0-rc.112",
      "@npmcli/arborist": "9.4.0",
      "@types/bun": "1.3.13",
      "@types/cross-spawn": "6.0.6",
      "@octokit/rest": "22.0.0",
      "@hono/standard-validator": "0.2.0",
      "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.5.8",
-      "@opentui/keymap": "0.5.8",
-      "@opentui/solid": "0.5.8",
+      "@opentui/core": "0.5.9",
+      "@opentui/keymap": "0.5.9",
+      "@opentui/solid": "0.5.9",
      "@tanstack/solid-virtual": "3.13.37",
-      "@shikijs/stream": "4.2.0",
+      "@shikijs/stream": "4.4.3",
      "@standard-schema/spec": "1.1.0",
      "ulid": "3.0.1",
-      "@kobalte/core": "0.13.11",
+      "@kobalte/core": "0.13.13",
      "@corvu/drawer": "0.2.4",
      "@types/luxon": "3.7.1",
      "@types/node": "24.12.2",
@@ -67,13 +67,16 @@
      "@openauthjs/openauth": "0.0.0-20250322224806",
      "@pierre/diffs": "1.2.10",
      "opentui-spinner": "0.0.7",
-      "@solid-primitives/storage": "4.3.3",
+      "@solid-primitives/event-listener": "2.4.6",
+      "@solid-primitives/media": "2.3.6",
+      "@solid-primitives/resize-observer": "2.2.0",
+      "@solid-primitives/storage": "4.4.0",
      "@tailwindcss/vite": "4.1.11",
-      "diff": "8.0.2",
-      "dompurify": "3.3.1",
+      "diff": "8.0.4",
+      "dompurify": "3.4.14",
      "drizzle-kit": "1.0.0-rc.5-ab785fc",
      "drizzle-orm": "1.0.0-rc.5-169397b",
-      "effect": "4.0.0-rc.111",
+      "effect": "4.0.0-rc.112",
      "ai": "6.0.168",
      "cross-spawn": "7.0.6",
      "hono": "4.10.7",
@@ -81,9 +84,9 @@
      "fuzzysort": "3.1.0",
      "get-east-asian-width": "1.6.0",
      "luxon": "3.6.1",
-      "marked": "18.0.7",
+      "marked": "18.0.11",
      "marked-shiki": "1.2.1",
-      "remend": "1.3.0",
+      "remend": "1.3.1",
      "@playwright/test": "1.59.1",
      "semver": "7.7.4",
      "typescript": "5.8.2",
@@ -92,17 +95,17 @@
      "remeda": "2.26.0",
      "resolve.exports": "2.0.3",
      "sst": "4.13.1",
-      "shiki": "4.2.0",
+      "shiki": "4.4.3",
      "solid-list": "0.3.0",
      "string-width": "7.2.0",
      "tailwindcss": "4.1.11",
-      "vite": "7.1.4",
+      "vite": "7.3.6",
      "@solidjs/meta": "0.29.4",
-      "@solidjs/router": "0.15.4",
+      "@solidjs/router": "1.0.0",
      "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
-      "@sentry/solid": "10.36.0",
-      "@sentry/vite-plugin": "4.6.0",
-      "solid-js": "1.9.10",
+      "@sentry/solid": "10.71.0",
+      "@sentry/vite-plugin": "5.4.0",
+      "solid-js": "1.9.15",
      "solid-sonner": "0.3.1",
      "vite-plugin-solid": "2.11.10",
      "@lydell/node-pty": "1.2.0-beta.12"
@@ -158,7 +161,8 @@
    "@effect/platform-node-shared": "catalog:",
    "@types/bun": "catalog:",
    "@types/node": "catalog:",
-    "effect": "catalog:"
+    "effect": "catalog:",
+    "solid-js": "catalog:"
  },
  "patchedDependencies": {
    "@ai-sdk/openai-compatible@2.0.41": "patches/@ai-sdk%2Fopenai-compatible@2.0.41.patch",
@@ -166,7 +170,7 @@
    "@npmcli/agent@4.0.2": "patches/@npmcli%2Fagent@4.0.2.patch",
    "@silvia-odwyer/photon-node@0.3.4": "patches/@silvia-odwyer%2Fphoton-node@0.3.4.patch",
    "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
-    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
+    "solid-js@1.9.15": "patches/solid-js@1.9.15.patch",
    "@ai-sdk/mistral@3.0.51": "patches/@ai-sdk%2Fmistral@3.0.51.patch",
    "gcp-metadata@8.1.2": "patches/gcp-metadata@8.1.2.patch",
    "pacote@21.5.0": "patches/pacote@21.5.0.patch",
@@ -374,6 +374,12 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
            content.push({ reasoningContent: { redactedContent: redactedData } })
            continue
          }
+          if (signature === undefined || signature.trim().length === 0) {
+            // Interrupted streams and model switches can leave unsigned reasoning.
+            // Preserve readable history as text rather than replay invalid reasoningContent.
+            if (part.text.trim().length > 0) content.push(...textWithCache(breakpoints, part.text, part.cache))
+            continue
+          }
          content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } })
          continue
        }
@@ -382,7 +388,7 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (
          continue
        }
      }
-      messages.push({ role: "assistant", content })
+      if (content.length > 0) messages.push({ role: "assistant", content })
      continue
    }

@@ -391,6 +391,10 @@ export interface ParserState {
  readonly name: string
  readonly providerMetadataKey: string
  readonly tools: ToolStream.State<string>
+  // Call ids that already emitted their terminal tool-call event, so duplicate
+  // or late item events for the same call stay no-ops. Keyed by `call_id`
+  // because duplicate events may disagree on whether `item.id` is present.
+  readonly completedTools: ReadonlySet<string>
  readonly hasFunctionCall: boolean
  readonly lifecycle: Lifecycle.State
  readonly outputItems: Readonly<Record<number, string>>
@@ -846,18 +850,70 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
 export const outputItemID = (state: ParserState, event: Event) =>
  event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)

+const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
+  const item = state.reasoningItems[itemID]
+  if (!item || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
+  if (Object.values(item.summaryParts).every((status) => status === "concluded")) return [state, NO_EVENTS]
+
+  const events: LLMEvent[] = []
+  const lifecycle = Object.entries(item.summaryParts)
+    .filter((entry) => entry[1] !== "concluded")
+    .reduce(
+      (lifecycle, entry) =>
+        Lifecycle.reasoningEnd(lifecycle, events, `${itemID}:${entry[0]}`, providerMetadata(state, { itemId: itemID })),
+      state.lifecycle,
+    )
+  return [
+    {
+      ...state,
+      lifecycle: Lifecycle.reasoningStart(
+        lifecycle,
+        events,
+        `${itemID}:${index}`,
+        providerMetadata(state, { itemId: itemID, reasoningEncryptedContent: item.encryptedContent ?? null }),
+      ),
+      reasoningItems: {
+        ...state.reasoningItems,
+        [itemID]: {
+          ...item,
+          summaryParts: {
+            ...Object.fromEntries(
+              Object.entries(item.summaryParts).map((entry) =>
+                entry[1] === "concluded" ? entry : [entry[0], "concluded" as const],
+              ),
+            ),
+            [index]: "active",
+          },
+        },
+      },
+    },
+    events,
+  ]
+}
+
 export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
  const item = state.reasoningItems[itemID]
  if (!event.delta || !item) return [state, NO_EVENTS]
  const index = event.summary_index ?? 0
-  const events: LLMEvent[] = []
+  if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
+  // An unseen index cannot reopen an item whose parts have all concluded.
+  if (
+    item.summaryParts[index] === undefined &&
+    Object.values(item.summaryParts).every((status) => status === "concluded")
+  )
+    return [state, NO_EVENTS]
+  const started: StepResult =
+    item.summaryParts[index] === undefined ? startReasoningSummaryPart(state, itemID, index) : [state, NO_EVENTS]
+  const current = started[0].reasoningItems[itemID]
+  if (!current) return started
+  const events: LLMEvent[] = [...started[1]]
  return [
    {
-      ...state,
-      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `${itemID}:${index}`, event.delta),
+      ...started[0],
+      lifecycle: Lifecycle.reasoningDelta(started[0].lifecycle, events, `${itemID}:${index}`, event.delta),
      reasoningItems: {
-        ...state.reasoningItems,
-        [itemID]: { ...item, deltaIndexes: new Set([...item.deltaIndexes, index]) },
+        ...started[0].reasoningItems,
+        [itemID]: { ...current, deltaIndexes: new Set([...current.deltaIndexes, index]) },
      },
    },
    events,
@@ -878,32 +934,49 @@ export const onReasoningDone = (state: ParserState, event: Event, itemID: string
 const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
  providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })

-// Responses APIs stream reasoning items in a stable order:
+// Responses APIs normally stream reasoning items in this order:
 //   `output_item.added` (reasoning) →
 //     `reasoning_summary_part.added` (index=0) →
 //     `reasoning_summary_text.delta` →
 //     `reasoning_summary_part.done` (index=0) →
 //     (repeat for index>0) →
 //   `output_item.done` (reasoning).
-// The handlers below rely on this ordering: `onOutputItemAdded` seeds the
-// per-item entry, `onReasoningSummaryPartAdded` for `summary_index === 0`
-// short-circuits when the entry already exists, and higher-index handlers
-// fold against the same entry. Behaviour for out-of-order events is
-// best-effort, not guaranteed.
+// `onOutputItemAdded` seeds the per-item entry, while each later part start is
+// also an implicit boundary for the previous part. This keeps the common event
+// lifecycle ordered when a compatible provider omits or delays a part-done event.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
  const item = event.item
  if (item?.type === "message" && item.id !== undefined) {
+    const itemID = item.id
    const phase = messagePhase(item.phase)
+    // A new message item is an implicit boundary for every earlier message
+    // item: text still streaming is ended, and all older items leave the
+    // tracked set so their late deltas stay no-ops instead of overlapping.
+    const events: LLMEvent[] = []
+    const lifecycle = [...state.lifecycle.text]
+      .filter((id) => id !== itemID)
+      .reduce((lifecycle, id) => {
+        const openPhase = state.messagePhases[id]
+        return Lifecycle.textEnd(
+          lifecycle,
+          events,
+          id,
+          providerMetadata(state, { itemId: id, ...(openPhase === undefined ? {} : { phase: openPhase }) }),
+        )
+      }, state.lifecycle)
+    const nextPhase = phase === undefined ? state.messagePhases[itemID] : phase
    return [
      {
        ...state,
-        messageItems: new Set([...state.messageItems, item.id]),
-        messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
+        lifecycle,
+        messageItems: new Set([itemID]),
+        messagePhases: nextPhase === undefined ? {} : { [itemID]: nextPhase },
      },
-      NO_EVENTS,
+      events,
    ]
  }
  if (item && isReasoningItem(item)) {
+    if (state.reasoningItems[item.id] !== undefined) return [state, NO_EVENTS]
    const events: LLMEvent[] = []
    return [
      {
@@ -923,6 +996,10 @@ 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
+  // Pending tools always store the call id, so this also catches duplicates
+  // that disagree on whether `item.id` is present.
+  if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
+    return [state, NO_EVENTS]
  const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
  const events: LLMEvent[] = []
  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
@@ -943,55 +1020,14 @@ 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]
-  const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
-  if (event.summary_index === 0) return [state, NO_EVENTS]
-
-  const events: LLMEvent[] = []
-  const closed = Object.entries(item.summaryParts)
-    .filter((entry) => entry[1] === "can-conclude")
-    .reduce(
-      (lifecycle, entry) =>
-        Lifecycle.reasoningEnd(
-          lifecycle,
-          events,
-          `${event.item_id}:${entry[0]}`,
-          providerMetadata(state, { itemId: event.item_id }),
-        ),
-      state.lifecycle,
-    )
-  return [
-    {
-      ...state,
-      lifecycle: Lifecycle.reasoningStart(
-        closed,
-        events,
-        `${event.item_id}:${event.summary_index}`,
-        providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null }),
-      ),
-      reasoningItems: {
-        ...state.reasoningItems,
-        [event.item_id]: {
-          ...item,
-          summaryParts: {
-            ...Object.fromEntries(
-              Object.entries(item.summaryParts).map((entry) =>
-                entry[1] === "can-conclude" ? [entry[0], "concluded" as const] : entry,
-              ),
-            ),
-            [event.summary_index]: "active",
-          },
-        },
-      },
-    },
-    events,
-  ]
+  return startReasoningSummaryPart(state, event.item_id, event.summary_index)
 }

 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
  if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
  const item = state.reasoningItems[event.item_id]
  if (!item) return [state, NO_EVENTS]
+  if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
  return [
    {
      ...state,
@@ -1070,20 +1106,36 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (

  if (item.type === "function_call") {
    if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const id = item.id ?? item.call_id
-    const tools = state.tools[id]
-      ? state.tools
-      : ToolStream.start(state.tools, id, {
-          id: item.call_id,
-          name: item.name,
-          providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
-        })
+    const callID = item.call_id
+    if (state.completedTools.has(callID)) return [state, NO_EVENTS] satisfies StepResult
+    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
+    const fallback = item.id ?? callID
+    // Match the pending tool by call id so item events that disagree on
+    // whether `item.id` is present still resolve the same call.
+    const registered =
+      state.tools[fallback] !== undefined
+        ? fallback
+        : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID)
+    const id = registered ?? fallback
+    const tools =
+      registered !== undefined
+        ? state.tools
+        : ToolStream.start(state.tools, id, {
+            id: callID,
+            name: item.name,
+            providerMetadata: metadata,
+          })
    const result =
      item.arguments === undefined
        ? yield* ToolStream.finish(state.id, tools, id)
        : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments)
    const events: LLMEvent[] = []
-    const resultEvents = result.events ?? []
+    const finished = result.events ?? []
+    // A done-only call never streamed a start event, so open its lifecycle here.
+    const resultEvents =
+      registered !== undefined || finished.length === 0
+        ? finished
+        : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished]
    const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
    events.push(...resultEvents)
    return [
@@ -1094,6 +1146,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
          resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
          state.hasFunctionCall,
        tools: result.tools,
+        completedTools: new Set([...state.completedTools, callID]),
      },
      events,
    ] satisfies StepResult
@@ -1110,14 +1163,45 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
          (lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, metadata),
          state.lifecycle,
        )
-      const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
+      // Keep the fully-concluded entry so duplicate or late events for this
+      // item remain no-ops instead of reopening lifecycle state.
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              ...reasoningItem,
+              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+              summaryParts: Object.fromEntries(
+                Object.keys(reasoningItem.summaryParts).map((index) => [index, "concluded" as const]),
+              ),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
    }
    if (!state.lifecycle.reasoning.has(item.id)) {
      const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
      events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
      events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata }))
-      return [{ ...state, lifecycle }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              encryptedContent: item.encrypted_content,
+              summaryParts: { 0: "concluded" },
+              deltaIndexes: new Set(),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
    }
    return [
      { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
@@ -1256,6 +1340,13 @@ export const step = (state: ParserState, input: Event) => {
  if (event.type === "response.output_item.added") {
    if (event.item?.type === "message" && event.item.id === undefined)
      return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
+    if (
+      event.item &&
+      isReasoningItem(event.item) &&
+      state.reasoningItems[event.item.id] === undefined &&
+      state.lifecycle.reasoning.size > 0
+    )
+      return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`)
    const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
    return Effect.succeed(
      onOutputItemAdded(
@@ -1305,6 +1396,7 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
  providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
  hasFunctionCall: false,
  tools: ToolStream.empty<string>(),
+  completedTools: new Set<string>(),
  lifecycle: Lifecycle.initial(),
  outputItems: {},
  messageItems: new Set<string>(),
@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Effect, Schema, Stream } from "effect"
 import { LLM, LLMRequest, LLMResponse } from "../src/index.js"
 import { Route, Endpoint, LLMClient, Protocol, type FramingDef } from "../src/route.js"
@@ -148,15 +148,13 @@ describe("llm route", () => {
    }),
  )

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

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

  it.effect("does not register duplicate route ids globally", () =>
    Effect.gen(function* () {
@@ -44,21 +44,23 @@ describe("Tool.make (dynamic JSON Schema)", () => {
    expect(definition?.inputSchema).toEqual(jsonSchema)
  })

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

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

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

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

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

-  it.effect("rejects tuned Gemini models in express mode", () =>
-    Effect.sync(() => {
-      expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
-        "Google Vertex tuned models do not support Express Mode API keys",
-      )
-    }),
-  )
+  test("rejects tuned Gemini models in express mode", () => {
+    expect(() => GoogleVertex.configure({ apiKey: "fixture" }).model("endpoints/1234567890")).toThrow(
+      "Google Vertex tuned models do not support Express Mode API keys",
+    )
+  })
 })
@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { ConfigProvider, Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolDefinition } from "../../src/index.js"
@@ -31,82 +31,71 @@ 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
+  test("assigns provider-owned metadata namespaces across native routes", () => {
+    const vertex = { project: "project", accessToken: "token" }
+    const providers = [
+      [OpenAI.configure({ apiKey: "test" }).chat("model"), "openai"],
+      [OpenAI.configure({ apiKey: "test" }).responses("model"), "openai"],
+      [Azure.configure({ resourceName: "resource", apiKey: "test" }).chat("model"), "azure"],
+      [Azure.configure({ resourceName: "resource", apiKey: "test" }).responses("model"), "azure"],
+      [AmazonBedrock.configure({ apiKey: "test" }).model("model"), "bedrock"],
+      [AmazonBedrockMantle.configure({ apiKey: "test" }).chat("model"), "mantle"],
+      [AmazonBedrockMantle.configure({ apiKey: "test" }).responses("model"), "mantle"],
+      [Google.configure({ apiKey: "test" }).model("model"), "google"],
+      [GoogleVertex.configure(vertex).model("model"), "vertex"],
+      [GoogleVertexChat.configure(vertex).model("model"), "vertex"],
+      [GoogleVertexResponses.configure(vertex).model("model"), "vertex"],
+      [GoogleVertexMessages.configure(vertex).model("model"), "anthropic"],
+      [Anthropic.configure({ apiKey: "test" }).model("model"), "anthropic"],
+      [
+        AnthropicCompatible.configure({ baseURL: "https://example.test/v1", provider: "minimax" }).model("model"),
+        "minimax",
+      ],
+      [OpenAICompatible.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"), "custom"],
+      [
+        OpenAICompatibleResponses.configure({ baseURL: "https://example.test/v1", provider: "custom" }).model("model"),
+        "custom",
+      ],
+      [Cerebras.configure({ apiKey: "test" }).model("model"), "cerebras"],
+      [DeepInfra.configure({ apiKey: "test" }).model("model"), "deepinfra"],
+      [TogetherAI.configure({ apiKey: "test" }).model("model"), "togetherai"],
+      [CloudflareAIGateway.configure({ accountId: "account" }).model("model"), "cloudflare-ai-gateway"],
+      [CloudflareWorkersAI.configure({ accountId: "account" }).model("model"), "cloudflare-workers-ai"],
+      [OpenRouter.configure({ apiKey: "test" }).model("model"), "openrouter"],
+      [XAI.configure({ apiKey: "test" }).chat("model"), "xai"],
+      [XAI.configure({ apiKey: "test" }).responses("model"), "xai"],
+    ] as const

-      for (const [model, key] of providers) expect(model.route.providerMetadataKey).toBe(key)
-    }),
-  )
+    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")
-      const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")
+  test("preserves native Together AI and Cerebras provider and route identities", () => {
+    const together = TogetherAI.configure({ apiKey: "fixture" }).model("meta-llama/Llama-3.3-70B")
+    const cerebras = Cerebras.configure({ apiKey: "fixture" }).model("qwen-3-235b-a22b")

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

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

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

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

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

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

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

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

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

  it.effect("matches AI SDK compatible basic request body fixture", () =>
    Effect.gen(function* () {
@@ -2750,6 +2750,227 @@ describe("OpenAI Responses route", () => {
    }),
  )

+  it.effect("concludes reasoning at implicit summary boundaries", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(
+        LLMRequest.update(request, { providerOptions: { store: false } }),
+      ).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              {
+                type: "response.output_item.added",
+                item: { type: "reasoning", id: "rs_1", encrypted_content: null },
+              },
+              { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 0 },
+              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
+              // The next part is enough to conclude the previous one even when
+              // its done event is delayed.
+              { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
+              { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
+              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 1, delta: "Second" },
+              { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 1 },
+              // Some compatible providers begin the next part with its first delta.
+              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 2, delta: "Third" },
+              {
+                type: "response.output_item.done",
+                item: { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.reasoning).toBe("FirstSecondThird")
+      expect(response.events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
+        {
+          type: "reasoning-start",
+          id: "rs_1:0",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:0", text: "First", providerMetadata: undefined },
+        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { openai: { itemId: "rs_1" } } },
+        {
+          type: "reasoning-start",
+          id: "rs_1:1",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:1", text: "Second", providerMetadata: undefined },
+        {
+          type: "reasoning-end",
+          id: "rs_1:1",
+          providerMetadata: { openai: { itemId: "rs_1" } },
+        },
+        {
+          type: "reasoning-start",
+          id: "rs_1:2",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:2", text: "Third", providerMetadata: undefined },
+        {
+          type: "reasoning-end",
+          id: "rs_1:2",
+          providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
+      ])
+    }),
+  )
+
+  it.effect("rejects a reasoning item that starts before the previous item ends", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
+              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
+              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_2" } },
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error.reason._tag).toBe("InvalidProviderOutput")
+      expect(error.message).toContain("started reasoning before the previous item ended")
+    }),
+  )
+
+  it.effect("concludes text at implicit message boundaries", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              // An item that never streams text is untracked at the boundary too.
+              { type: "response.output_item.added", item: { type: "message", id: "msg_0" } },
+              { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
+              { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
+              // The previous message's done event is missing; the next message
+              // item is the boundary for its open text.
+              { type: "response.output_item.added", item: { type: "message", id: "msg_2" } },
+              // Late deltas for concluded or untracked messages must stay no-ops.
+              { type: "response.output_text.delta", item_id: "msg_1", delta: " late" },
+              { type: "response.output_text.delta", item_id: "msg_0", delta: " stale" },
+              { type: "response.output_text.delta", item_id: "msg_2", delta: "Second" },
+              { type: "response.output_item.done", item: { type: "message", id: "msg_2" } },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.text).toBe("FirstSecond")
+      expect(response.events.filter((event) => event.type.startsWith("text-"))).toMatchObject([
+        { type: "text-start", id: "msg_1" },
+        { type: "text-delta", id: "msg_1", text: "First" },
+        { type: "text-end", id: "msg_1" },
+        { type: "text-start", id: "msg_2" },
+        { type: "text-delta", id: "msg_2", text: "Second" },
+        { type: "text-end", id: "msg_2" },
+      ])
+    }),
+  )
+
+  it.effect("opens the tool lifecycle for a done-only function call", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              // No output_item.added: the call arrives only as a completed item.
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "function_call",
+                  id: "fc_1",
+                  call_id: "call_1",
+                  name: "lookup",
+                  arguments: '{"query":"weather"}',
+                },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.events.filter((event) => event.type.startsWith("tool-"))).toMatchObject([
+        { type: "tool-input-start", id: "call_1", name: "lookup" },
+        { type: "tool-input-end", id: "call_1", name: "lookup" },
+        { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" } },
+      ])
+      expect(response.finishReason.normalized).toBe("tool-calls")
+    }),
+  )
+
+  it.effect("ignores duplicate item boundary events", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
+              // Duplicate added for a known item is not overlap and must no-op.
+              { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1" } },
+              { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "Think" },
+              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
+              { type: "response.output_item.done", item: { type: "reasoning", id: "rs_1" } },
+              {
+                type: "response.output_item.added",
+                item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
+              },
+              {
+                type: "response.output_item.added",
+                item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "" },
+              },
+              { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":"weather"}' },
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "function_call",
+                  id: "fc_1",
+                  call_id: "call_1",
+                  name: "lookup",
+                  arguments: '{"query":"weather"}',
+                },
+              },
+              {
+                type: "response.output_item.done",
+                item: {
+                  type: "function_call",
+                  id: "fc_1",
+                  call_id: "call_1",
+                  name: "lookup",
+                  arguments: '{"query":"weather"}',
+                },
+              },
+              // Duplicates that drop the item id still resolve the same call.
+              {
+                type: "response.output_item.done",
+                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: '{"query":"weather"}' },
+              },
+              {
+                type: "response.output_item.added",
+                item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "" },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.reasoning).toBe("Think")
+      expect(response.events.filter((event) => event.type === "reasoning-start")).toHaveLength(1)
+      expect(response.events.filter((event) => event.type === "reasoning-end")).toHaveLength(1)
+      expect(response.events.filter((event) => event.type === "tool-input-start")).toHaveLength(1)
+      expect(response.events.filter(LLMEvent.is.toolCall)).toEqual([
+        expect.objectContaining({ id: "call_1", input: { query: "weather" } }),
+      ])
+    }),
+  )
+
  it.effect("reconciles reasoning summaries that arrive only as finals", () =>
    Effect.gen(function* () {
      const response = yield* LLMClient.generate(
@@ -26,6 +26,7 @@ import {
  Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
+import { it } from "./lib/effect.js"

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

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

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

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

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

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

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

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

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

 test("transport errors serialize execution facts", () => {
  const reason = new TransportError({
@@ -1,4 +1,4 @@
-import { describe, expect } from "bun:test"
+import { describe, expect, test } from "bun:test"
 import { Content } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import {
@@ -277,65 +277,61 @@ describe("LLMClient tools", () => {
    }),
  )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  it.effect("uses final input override without losing accumulated deltas", () =>
    Effect.gen(function* () {
@@ -25,6 +25,7 @@ for (const viewport of [
    const mock = await openDraft(page)
    const pending = await submitPending(page, mock)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 export type SessionCreateOutput = { data: SessionInfo }["data"]
@@ -2752,6 +2769,7 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
+      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3028,6 +3046,7 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
+      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -3304,6 +3323,7 @@ export type SessionImportInput = {
      readonly title?: string
      readonly location: { readonly directory: string; readonly workspaceID?: string }
      readonly subpath?: string
+      readonly metadata?: { readonly [x: string]: JsonValue }
      readonly revert?: {
        readonly messageID: string
        readonly partID?: string
@@ -19,7 +19,7 @@

 - If a captured user-visible output channel returns (an earlier `output.text`/`output.file`/`output.image` API was removed from v1), keep `output` as its name, distinct from the program return value: `return` stays the structured result for the model, while `output.*` describes artifacts the host may render into a conversation or UI after execution. Keep this host-neutral and let applications decide how captured output is delivered. In v1, hosts collect media host-side (outside CodeMode) instead.
 - Improve the failure taxonomy. Distinguish parse/compile mistakes, unsupported syntax, user-thrown errors, invalid returned data, tool refusal, tool internal failure, timeout, and genuine runtime defects so agents can recover accurately instead of treating everything as a generic execution failure.
- Preserve the public/private error split. Tool authors should be able to return a safe model-visible message while retaining a private cause for host diagnostics. Unknown host failures must remain sanitized by default.
+- Report host failure messages and underlying causes rather than replacing them with generic diagnostics. Preserve interruption behavior.
 - Think deliberately about richer binary boundaries before allowing `Blob`, `File`, `ArrayBuffer`, streams, or typed arrays beyond today's JSON-like values. If CodeMode supports binary tool args/results, use explicit tagged data shapes and clear size limits rather than relying on ambient runtime serialization.
 - Keep host capabilities explicit. Globals such as `fetch`, `crypto`, filesystem handles, extra modules, or network clients should be opt-in runtime capabilities with obvious policy defaults, not ambient authority. Default to unavailable unless a host deliberately provides the capability.
 - If `fetch` is added, model it as a host-provided outbound capability with policy controls: allowed origins, methods, headers, response size, timeout, and whether response bodies may be returned, emitted, or only summarized through a tool.
@@ -139,8 +139,8 @@ Diagnostic kinds:
 | `ExecutionFailure`      | The program threw or another execution error occurred.                                         |
 | `Truncated`             | Warning only: additional warnings were omitted by `maxOutputBytes`.                            |

-Unknown host failures, defects, and invalid outputs are sanitized. `toolError("safe message")` explicitly exposes a
-safe refusal to the model; its optional cause remains private.
+Host failures and defects report their messages and underlying causes. Invalid outputs include the validation or
+copying error. Interruption propagates without becoming an error diagnostic.

 ## Discovery

@@ -365,7 +365,7 @@ ultimate source of truth.
      `catch`.
 - [x] Source locations on unsupported-syntax diagnostics for JavaScript-shaped input; TypeScript transpilation may
      shift them.
- [x] Sanitized model-visible diagnostics and explicit safe `ToolError` messages.
- [ ] Distinguish user-thrown failures from interpreter defects and explicit tool refusals from sanitized internal tool
+- [x] Model-visible host failure messages and underlying causes, including output-validation errors.
+- [ ] Distinguish user-thrown failures from interpreter defects and explicit tool refusals from internal tool
      failures; preserve those categories in caught errors, promise rejection handlers, and `Promise.allSettled`
      reasons.
@@ -1,11 +1,11 @@
 import { Schema } from "effect"

-/** Safe operational refusal from a standard tool pack, reported as `ToolFailure`. */
+/** Tool failure reported as `ToolFailure`. */
 export class ToolError extends Schema.TaggedError<ToolError>()("ToolError", {
  message: Schema.String,
  cause: Schema.optionalKey(Schema.Defect()),
 }) {}

-/** Creates a tool refusal whose message is safe to include in an execution diagnostic. */
+/** Creates a tool failure with an optional underlying cause. */
 export const toolError = (message: string, cause?: unknown): ToolError =>
  new ToolError({ message, ...(cause === undefined ? {} : { cause }) })
@@ -1,5 +1,5 @@
-import { Cause, Effect, Exit, Schema } from "effect"
-import { ToolError, toolError } from "./tool-error.js"
+import { Cause, Effect, Exit, Formatter, Schema } from "effect"
+import { toolError } from "./tool-error.js"
 import {
  decodeInput as decodeToolInput,
  decodeOutput as decodeToolOutput,
@@ -117,15 +117,6 @@ export class ToolRuntimeError extends Error {
  }
 }

-const runHost = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, ToolError, R> =>
-  effect.pipe(
-    Effect.catchCause((cause) => {
-      if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt
-      const error = Cause.squash(cause)
-      return Effect.fail(error instanceof ToolError ? error : toolError("Tool execution failed", error))
-    }),
-  )
-
 const blockedMemberNames = new Set(["__proto__", "constructor", "prototype"])

 export const isBlockedMember = (name: string): boolean => blockedMemberNames.has(name)
@@ -507,19 +498,12 @@ export const make = <R>(
        if (Exit.isSuccess(exit)) return onEnd({ ...call, durationMs, outcome: "success" })
        if (Cause.hasInterruptsOnly(exit.cause)) return onEnd({ ...call, durationMs, outcome: "interrupted" })
        const error = Cause.squash(exit.cause)
-        const message =
-          error instanceof ToolError || error instanceof ToolRuntimeError ? error.message : "Tool execution failed"
+        const message = error instanceof Error ? error.message : Cause.pretty(exit.cause)
        return onEnd({ ...call, durationMs, outcome: "failure", message })
      }),
    )
  }

-  const decodeOutput = (value: unknown, name: string) =>
-    Effect.try({
-      try: () => copyIn(value, `Result from tool '${name}'`),
-      catch: () => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}'.`),
-    })
-
  const recordCall = (call: ToolCall): void => {
    if (maxToolCalls !== undefined && calls.length >= maxToolCalls) {
      throw new ToolRuntimeError("ToolCallLimitExceeded", `Execution exceeded its tool-call limit of ${maxToolCalls}.`)
@@ -548,12 +532,22 @@ export const make = <R>(
      return yield* observeEnd(
        Effect.gen(function* () {
          if (hooks?.onToolCallStart !== undefined) yield* hooks.onToolCallStart(call)
-          const raw = yield* runHost(Effect.suspend(() => tool.execute(input)))
-          const result = yield* Effect.try({
-            try: () => decodeToolOutput(tool, raw),
-            catch: () => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}'.`),
+          const raw = yield* Effect.suspend(() => tool.execute(input)).pipe(
+            Effect.catchCause((cause) => {
+              if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt
+              return Effect.fail(
+                toolError(
+                  Cause.prettyErrors(cause)
+                    .map((error) => (error.cause ? Formatter.format(error) : error.message || error.name))
+                    .join("\n"),
+                ),
+              )
+            }),
+          )
+          return yield* Effect.try({
+            try: () => copyIn(decodeToolOutput(tool, raw), `Result from tool '${name}'`),
+            catch: (cause) => new ToolRuntimeError("InvalidToolOutput", `Invalid output from tool '${name}': ${cause}`),
          })
-          return yield* decodeOutput(result, name)
        }),
        call,
      )
@@ -5,15 +5,15 @@ import { CodeMode, Tool, toolError } from "../src/index.js"
 const run = (tool: Tool.Tool<never>) =>
  Effect.runPromise(CodeMode.make({ tools: { host: { call: tool } } }).execute("return await tools.host.call({})"))

-class UnsafeHostError extends Schema.TaggedError<UnsafeHostError>()("UnsafeHostError", {
-  reason: Schema.String,
+class HostError extends Schema.TaggedError<HostError>()("HostError", {
+  message: Schema.String,
 }) {}

 describe("CodeMode host failure boundary", () => {
-  test("preserves explicit safe tool failures", async () => {
+  test("preserves explicit tool failures", async () => {
    const result = await run(
      Tool.make({
-        description: "Fail safely",
+        description: "Fail",
        input: Schema.Struct({}),
        output: Schema.String,
        execute: () => Effect.fail(toolError("Authorized request was refused")),
@@ -26,10 +26,10 @@ describe("CodeMode host failure boundary", () => {
    })
  })

-  test("does not rewrite explicit safe tool failures", async () => {
+  test("does not rewrite explicit tool failures", async () => {
    const result = await run(
      Tool.make({
-        description: "Fail safely",
+        description: "Fail",
        input: Schema.Struct({}),
        output: Schema.String,
        execute: () => Effect.fail(toolError("File not found: /tmp/report.json")),
@@ -42,10 +42,15 @@ describe("CodeMode host failure boundary", () => {
    })
  })

-  test("sanitizes unknown host failures and defects", async () => {
+  test("reports failures, defects, rejected Promises, and nested causes", async () => {
    for (const failure of [
-      Effect.fail(new UnsafeHostError({ reason: "Authorization: Bearer typed-secret" })),
-      Effect.die(new Error("postgres://user:defect-secret@example.invalid")),
+      Effect.fail(new HostError({ message: "Connection refused" })),
+      Effect.die(new Error("Connection refused")),
+      Effect.promise(async () => {
+        throw new Error("Connection refused")
+      }),
+      Effect.fail(toolError("Request failed", new Error("Connection refused"))),
+      Effect.failCause(Cause.combine(Cause.fail("Request failed"), Cause.die("Connection refused"))),
    ]) {
      const result = await run(
        Tool.make({
@@ -58,31 +63,28 @@ describe("CodeMode host failure boundary", () => {

      expect(result.ok ? undefined : result.error).toStrictEqual({
        kind: "ToolFailure",
-        message: "Tool execution failed",
+        message: expect.stringContaining("Connection refused"),
      })
-      expect(JSON.stringify(result)).not.toMatch(/typed-secret|defect-secret|Authorization: Bearer/)
    }
  })

-  test("sanitizes invalid host output", async () => {
-    const secret = "invalid-output-secret"
+  test("reports invalid host output", async () => {
    const result = await run(
      Tool.make({
        description: "Return invalid output",
        input: Schema.Struct({}),
-        output: Schema.Struct({ safe: Schema.String }),
-        execute: () => Effect.succeed({ safe: 1, secret } as unknown as { readonly safe: string }),
+        output: Schema.Struct({ value: Schema.String }),
+        execute: () => Effect.succeed({ value: 1 } as unknown as { readonly value: string }),
      }),
    )

    expect(result.ok ? undefined : result.error).toStrictEqual({
      kind: "InvalidToolOutput",
-      message: "Invalid output from tool 'host.call'.",
+      message: "Invalid output from tool 'host.call': SchemaError(Expected string\n  at [\"value\"])",
    })
-    expect(JSON.stringify(result)).not.toMatch(/invalid-output-secret/)
  })

-  test("sanitizes host output that throws while being copied", async () => {
+  test("reports host output copying errors", async () => {
    const result = await run(
      Tool.make({
        description: "Return hostile output",
@@ -94,7 +96,7 @@ describe("CodeMode host failure boundary", () => {
              {},
              {
                ownKeys: () => {
-                  throw new Error("host-output-secret")
+                  throw new Error("Cannot enumerate output")
                },
              },
            ),
@@ -104,9 +106,8 @@ describe("CodeMode host failure boundary", () => {

    expect(result.ok ? undefined : result.error).toStrictEqual({
      kind: "InvalidToolOutput",
-      message: "Invalid output from tool 'host.call'.",
+      message: "Invalid output from tool 'host.call': Error: Cannot enumerate output",
    })
-    expect(JSON.stringify(result)).not.toMatch(/host-output-secret/)
  })

  test("caught tool failures are Error values in-program", async () => {
@@ -229,7 +230,7 @@ describe("CodeMode tool-call observation", () => {
      { phase: "start", index: 0, name: "context.lookup" },
      { phase: "end", index: 0, name: "context.lookup", outcome: "failure", message: "Lookup refused" },
      { phase: "start", index: 0, name: "context.lookup" },
-      { phase: "end", index: 0, name: "context.lookup", outcome: "failure", message: "Tool execution failed" },
+      { phase: "end", index: 0, name: "context.lookup", outcome: "failure", message: "broken" },
    ])
  })

@@ -12,7 +12,9 @@ import { AbsolutePath } from "../src/schema"
 const args = process.argv.slice(2)
 const iterationsIndex = args.indexOf("--iterations")
 const iterations = iterationsIndex === -1 ? 10 : Number(args[iterationsIndex + 1])
-const directory = args.find((arg, index) => !arg.startsWith("--") && index !== iterationsIndex + 1) ?? process.cwd()
+const directory =
+  args.find((arg, index) => !arg.startsWith("--") && (iterationsIndex === -1 || index !== iterationsIndex + 1)) ??
+  process.cwd()

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

 const ExecuteFile = Schema.Struct({
  data: Schema.String,
@@ -65,9 +65,7 @@ export const create = (
          (name, tool, input) =>
            Effect.gen(function* () {
              const index = yield* Ref.getAndUpdate(callIndex, (index) => index + 1)
-              const executed = yield* executeTool(name, tool, input, context).pipe(
-                Effect.mapError((failure) => toolError(failure.message, failure)),
-              )
+              const executed = yield* executeTool(name, tool, input, context)
              const content =
                typeof executed.content === "string"
                  ? [{ type: "text" as const, text: executed.content }]
@@ -165,7 +163,7 @@ function runtime(
 }

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

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

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

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

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

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

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

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

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

      const projectSource = Effect.fn("ConfigInstructionPlugin.projectSource")(function* () {
        if (!project) return []
-        const discovered = new Set(
-          yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve),
-        )
+        const walked = yield* Effect.forEach(yield* fs.up({ targets: ["AGENTS.md"], start, stop }), fs.resolve)
+        const discovered = new Set(walked.filter((file) => discovery.global || file !== globalFile))
        const files = yield* Effect.forEach(discovered, read, { concurrency: "unbounded" })
        if (files.some((file) => file === undefined)) return Instructions.unavailable
        return files.filter((file): file is InstructionDiscovery.File => file !== undefined)
@@ -5,7 +5,7 @@ import path from "path"
 import { Clock, Context, Deferred, Duration, Effect, Layer, Schema, Scope } from "effect"
 import { Fff } from "#fff"
 import fuzzysort from "fuzzysort"
-import { FileSystem } from "../filesystem.js"
+import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { Location } from "../location.js"
 import { Ripgrep } from "../ripgrep.js"
 import { RelativePath } from "../schema.js"
@@ -7,16 +7,16 @@ import { FileSystem } from "@opencode-ai/schema/filesystem"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Cause, Context, Effect, Layer, PubSub, RcMap, Schema, Stream } from "effect"
 import { lazy } from "../util/lazy.js"
-import { watch as watchFileSystem } from "node:fs"
+import { watch } from "node:fs"
 import path from "path"
 import loadBinding from "./watcher-binding.js"

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

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

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

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

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

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

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

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

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

 export type OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>

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

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

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

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

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

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

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

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

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

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

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

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

 export class Service extends Context.Service<
  Service,
-  LayerMap.LayerMap<Location.Ref, LocationServices, LocationError>
+  LayerMap.LayerMap<Location.Ref, Instance.Services, Instance.Error>
 >()("@opencode/example/LocationServiceMap") {
  static get(ref: Location.Ref) {
    return Layer.unwrap(Effect.map(Service, (locations) => locations.get(ref)))
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kit Langton	92b9eebab2	feat(tui): streamline diff review workflow (#45817 )	2026-08-28 00:11:29 -04:00
Aiden Cline	074413a96d	fix(ai): normalize response item boundaries (#45789 )	2026-08-27 23:08:50 -05:00
opencode-agent[bot]	4685ba8d3e	chore: update nix node_modules hashes	2026-08-28 04:03:16 +00:00
Kit Langton	d2c307ab30	test(core): remove unused test imports (#45674 )	2026-08-27 23:58:41 -04:00
Kit Langton	a5193634d0	test(core): use direct test imports (#45683 )	2026-08-27 23:58:34 -04:00
Kit Langton	95725d121a	chore: remove unused changesets (#45827 )	2026-08-27 23:55:57 -04:00
Aiden Cline	56f2559798	fix(codemode): report original tool errors (#45820 )	2026-08-27 22:54:36 -05:00
Kit Langton	38bffc9db1	chore(deps): upgrade Effect to rc.112 (#45819 )	2026-08-27 23:43:37 -04:00
Kit Langton	1d3308d904	test(core): refresh test vocabulary (#45714 )	2026-08-27 23:26:45 -04:00
opencode-agent[bot]	3c9e5adefa	chore: update nix node_modules hashes	2026-08-28 03:23:31 +00:00
Kit Langton	a065ad4ba7	feat(core): vanilla instance discovery option (#45752 )	2026-08-28 03:16:29 +00:00
Kit Langton	048aec32e7	refactor(core): share local provider settings fold (#45645 )	2026-08-27 23:13:13 -04:00
Kit Langton	a258b17fac	test(core): use partial service mocks (#45703 )	2026-08-27 23:13:04 -04:00
Kit Langton	07facd2086	refactor(util): share process stop policy (#45725 )	2026-08-27 23:12:57 -04:00
Kit Langton	6bf342a861	refactor(core): consolidate HTML inline handling (#45649 )	2026-08-27 23:12:50 -04:00
Kit Langton	2cca1ae860	refactor(core): use nonthrowing URL parsing (#45726 )	2026-08-27 23:12:43 -04:00
Kit Langton	becf5bf482	refactor(core): retain changed worktrees directly (#45709 )	2026-08-27 23:12:36 -04:00
Kit Langton	afe9e579d6	refactor(core): simplify instruction preview blobs (#45702 )	2026-08-27 23:12:28 -04:00
Kit Langton	0b82fe60ea	refactor(core): consolidate model error mapping (#45722 )	2026-08-27 23:12:19 -04:00
Luke Parker	6fad330efc	chore(deps): upgrade Solid and Router (#45808 )	2026-08-28 03:03:08 +00:00
Kit Langton	87f21a301d	fix(core): forward plugin interrupt options (#45632 )	2026-08-27 23:01:57 -04:00
Kit Langton	0123fed65d	fix(core): preserve Responses tool strictness (#45663 )	2026-08-27 23:01:43 -04:00
Kit Langton	64ef85159d	fix(core): preserve assistant text metadata (#45650 )	2026-08-27 23:01:33 -04:00
Kit Langton	e63779d9e1	fix(core): keep vertex settings serializable (#45704 )	2026-08-27 23:01:20 -04:00
Kit Langton	ac55c05c30	fix(core): correct compaction history direction (#45698 )	2026-08-27 23:01:07 -04:00
Dax Raad	8fa672ed71	docs: document diagnostic profile signals	2026-08-27 22:53:28 -04:00
Kit Langton	d84d1421ae	test(core): bind acquired test services (#45711 )	2026-08-27 22:43:09 -04:00
Kit Langton	dd2674e9c4	refactor(core): reuse Mercurial diff preparation (#45652 )	2026-08-27 22:42:47 -04:00
Kit Langton	ade8175ad8	refactor(core): use environment driver namespace (#45707 )	2026-08-27 22:42:36 -04:00
Kit Langton	b0db52da6f	refactor(tui): remove inert diff viewer setup (#45687 )	2026-08-27 22:42:29 -04:00
Kit Langton	9d673d7fb3	docs(core): align built-in prompt guidance (#45642 )	2026-08-27 22:42:19 -04:00
Kit Langton	9cab8b45b2	refactor(core): remove unreachable transport state (#45628 )	2026-08-27 22:42:11 -04:00
Kit Langton	17aa942541	refactor(core): reuse tool name normalization (#45644 )	2026-08-27 22:42:00 -04:00
Kit Langton	cbc3e63869	refactor(core): simplify skill discovery validation (#45729 )	2026-08-27 22:41:51 -04:00
Kit Langton	2ce126e2df	test(core): simplify runner scenario fixtures (#45440 )	2026-08-27 22:37:07 -04:00
Aiden Cline	1faba03cfe	fix(core): normalize Windows tool paths (#45806 )	2026-08-27 21:36:22 -05:00
Kit Langton	09b0edd662	refactor(core): compare plugin generations directly (#45728 )	2026-08-27 22:31:42 -04:00
Kit Langton	0c75b7b3c7	feat(core): per-instance plugin input (#45732 )	2026-08-28 02:31:36 +00:00
Kit Langton	fd77a721ac	test(core): align session test vocabulary (#45670 )	2026-08-27 22:31:33 -04:00
Kit Langton	11aab207f0	test(core): remove dead test setup (#45669 )	2026-08-27 22:31:26 -04:00
Kit Langton	04c9e01dad	refactor: normalize filesystem boundary imports (#45730 )	2026-08-27 22:31:15 -04:00
Kit Langton	762291b2a8	feat(core): durable session metadata at creation (#45805 )	2026-08-28 02:30:55 +00:00
Kit Langton	e0bad10065	test(core): exercise fsutil passthroughs (#45667 )	2026-08-27 22:30:43 -04:00
Kit Langton	e6d656dec1	refactor(core): clarify PTY binary validation (#45715 )	2026-08-27 22:30:35 -04:00
Kit Langton	d34dd6c14a	refactor(core): type native PTY import explicitly (#45710 )	2026-08-27 22:30:15 -04:00
Kit Langton	43c8690c14	docs(core): correct newtype decoding guidance (#45736 )	2026-08-27 22:30:07 -04:00
Kit Langton	35d681afab	test(core): make test sentinels effective (#45706 )	2026-08-27 22:29:59 -04:00
Kit Langton	8ab08f7fc9	refactor(core): remove infallible layer conversion (#45672 )	2026-08-27 22:29:44 -04:00
Luke Parker	c5113ee74a	chore(desktop): trim external dependency archives (#45804 )	2026-08-28 02:24:46 +00:00
Kit Langton	88988b8c12	fix(core): preserve typed config test-layer errors (#45778 )	2026-08-27 22:13:34 -04:00
opencode-agent[bot]	2389111bf6	chore: update nix node_modules hashes	2026-08-28 02:08:36 +00:00
Luke Parker	b92b84f33d	chore(deps): refresh markdown dependencies (#45793 )	2026-08-28 01:45:46 +00:00
opencode-agent[bot]	078522e534	chore: update nix node_modules hashes	2026-08-28 01:28:15 +00:00
Aiden Cline	7111e71528	fix(core): treat project paths as internal (#45799 )	2026-08-27 20:26:25 -05:00
Luke Parker	0ce3214844	chore(deps): upgrade Sentry and verify reporting (#45796 )	2026-08-28 01:13:17 +00:00
Luke Parker	132ec56fda	chore(ui): refresh Kobalte and Solid primitives (#45794 )	2026-08-28 01:08:44 +00:00
opencode-agent[bot]	216af25ecc	chore: update nix node_modules hashes	2026-08-28 01:00:46 +00:00
Luke Parker	6881cffc41	chore(deps): refresh Vite and Electron Builder tooling (#45790 )	2026-08-28 00:46:32 +00:00
opencode-agent[bot]	aecea54e95	chore: update nix node_modules hashes	2026-08-28 00:37:45 +00:00
Luke Parker	c0fa9aff72	fix(app): render local Markdown images through the server (#45780 )	2026-08-28 00:30:00 +00:00
opencode-agent[bot]andrekram1-node	d5be4cf888	fix(core): share native model defaults with v1 config migration (#45760 ) Co-authored-by: rekram1-node <rekram1-node@users.noreply.github.com>	2026-08-27 19:25:56 -05:00
Aiden Cline	7b6b0f2717	fix(core): cap provider retry-after delays at fifteen minutes (#45787 )	2026-08-27 19:23:06 -05:00
James Long	a03a1dd854	chore: upgrade opentui to 0.5.9 (#45785 )	2026-08-27 20:20:59 -04:00
Luke Parker	8f350df392	chore(deps): remove unused frontend dependencies (#45779 )	2026-08-28 00:19:57 +00:00
Luke Parker	4cecfe8e79	chore(desktop): remove stale native packaging (#45786 )	2026-08-28 10:18:53 +10:00
Kit Langton	89ca9fc641	fix(core): complete supervisor flush when plugin activation fails (#45783 )	2026-08-28 00:16:25 +00:00
Kit Langton	a2dcf2dff0	fix(core): wake sessions for recovered shell outcomes (#45781 )	2026-08-27 20:11:56 -04:00
Luke Parker	7477e21b02	fix(session-ui): upgrade DOMPurify and restore Mermaid rendering (#45773 )	2026-08-28 00:00:21 +00:00
Kit Langton	59e7b32c92	refactor(core): extract instance module from location services (#45705 )	2026-08-27 23:57:52 +00:00
Luke Parker	4681c734b2	fix(desktop): bundle selected main-process dependencies (#45774 )	2026-08-27 23:53:51 +00:00
Luke Parker	84fa689686	fix(desktop): preserve lazy Sentry loading (#45776 )	2026-08-27 23:41:09 +00:00
Kit Langton	62d9aa9838	refactor(core): delegate credential activation (#45692 )	2026-08-27 19:39:25 -04:00
Kit Langton	02550b36c7	refactor(util): narrow layer visitor options (#45734 )	2026-08-27 19:39:18 -04:00
Kit Langton	35231b408e	refactor(core): use keyed MCP credential reads (#45708 )	2026-08-27 19:39:12 -04:00
Kit Langton	74f5317489	docs(tui): complete session tabs story guidance (#45712 )	2026-08-27 19:39:05 -04:00
Kit Langton	81e099a441	fix(core): preserve benchmark directory argument (#45634 )	2026-08-27 19:38:58 -04:00
Luke Parker	498436f225	chore(desktop): upgrade Electron to 42.10.1 (#45775 )	2026-08-27 23:36:39 +00:00
opencode-agent[bot]andneriousy	b20748f821	fix(cli): prevent repeated updates and npm cache growth (#45091 ) Co-authored-by: neriousy <34747899+neriousy@users.noreply.github.com>	2026-08-28 01:30:34 +02:00
Kit Langton	f0d5b5e073	refactor(core): remove unused response stream state (#45742 )	2026-08-27 19:27:21 -04:00
Kit Langton	4f6c4ddf1c	test(core): guarantee execution scope cleanup (#45740 )	2026-08-27 19:27:05 -04:00
Kit Langton	792f84b59d	refactor(core): reuse execute visibility predicate (#45699 )	2026-08-27 19:26:55 -04:00
Kit Langton	b4bd14864a	refactor(core): remove unused responses state (#45659 )	2026-08-27 19:26:48 -04:00
Kit Langton	6bbf2e34e7	refactor(core): parse MCP prompt arguments once (#45646 )	2026-08-27 19:26:40 -04:00
Luke Parker	d432823515	fix(deps): upgrade diff to 8.0.4 (#45772 )	2026-08-27 23:24:33 +00:00
opencode-agent[bot]andneriousy	bdf2e84812	feat(core): support Azure CLI authentication (#45086 ) Co-authored-by: neriousy <34747899+neriousy@users.noreply.github.com>	2026-08-27 23:22:22 +00:00
Kit Langton	a438d34fcd	chore: lint identity pipe callbacks (#45771 )	2026-08-27 19:11:03 -04:00
Kit Langton	fa7a1ca39e	chore: remove duplicate oxlint options (#45719 )	2026-08-27 19:10:55 -04:00
Kit Langton	38e4c97aa9	refactor(core): import filesystem search schemas directly (#45684 )	2026-08-27 19:10:50 -04:00
Kit Langton	569a39c4ba	refactor(core): preserve Copilot handler inference (#45668 )	2026-08-27 19:10:44 -04:00
Kit Langton	bfb00cbb75	refactor(core): remove unused chat state (#45664 )	2026-08-27 19:10:36 -04:00
Kit Langton	a067c45cb6	test(schema): target config color contract (#45626 )	2026-08-27 19:10:29 -04:00
Kit Langton	0a7baaaed5	refactor(core): reuse shared record guard (#45643 )	2026-08-27 19:06:52 -04:00
Luke Parker	454ed81556	fix(desktop): minify production bundles (#45770 )	2026-08-27 23:06:28 +00:00
Kit Langton	7fe8bf5b24	refactor(core): remove duplicate config failure (#45625 )	2026-08-27 18:52:36 -04:00
Kit Langton	991a0d05b5	refactor(core): remove identity schema pipes (#45624 )	2026-08-27 18:52:20 -04:00
opencode-agent[bot]andneriousy	3288a12528	fix(ai): safely replay unsigned Bedrock reasoning (#45765 ) Co-authored-by: neriousy <34747899+neriousy@users.noreply.github.com>	2026-08-28 00:51:07 +02:00
Kit Langton	091396742e	refactor(core): isolate tool test fixture state (#45452 )	2026-08-27 18:48:44 -04:00
Kit Langton	ba85531931	refactor(core): remove redundant coordinator test scopes (#45451 )	2026-08-27 18:48:20 -04:00
Kit Langton	0440bd96be	refactor(core): simplify Effect test setup (#45446 )	2026-08-27 18:47:56 -04:00
Kit Langton	ace4249711	refactor(core): name session runner test services (#45445 )	2026-08-27 18:47:44 -04:00
Kit Langton	7d007670a0	refactor(core): simplify duplicate test layers (#45444 )	2026-08-27 18:47:20 -04:00
Kit Langton	98e3fa9d0d	test(core): budget real startup in session revert test (#45762 )	2026-08-27 18:43:54 -04:00
opencode-agent[bot]andjlongster	5d4ce14dc4	fix(core): skip tracing streamed LLM deltas (#45761 ) Co-authored-by: jlongster <17031+jlongster@users.noreply.github.com>	2026-08-27 17:59:43 -04:00
Simon Klee	8381153418	fix(tui): respect selection copy modes (#45758 )	2026-08-27 23:53:07 +02:00
Kit Langton	96d84626f8	fix(core): keep project labels stable across clones (#45735 ) Keep shared project labels stable across clones while explicitly using each selected checkout for worktree creation and setup. Preserve real directory rename handling and cover the TUI Home and app workspace creation paths.	2026-08-27 17:35:18 -04:00
Kit Langton	f607ca4c72	fix(tui): unify attention indicators with unread accent (#45741 ) Use the unread accent color for question and permission status indicators by default, preserving semantic tokens and explicit theme overrides.	2026-08-27 17:15:44 -04:00
Kit Langton	39416a0d95	test(ai): align test runners with API boundaries (#45469 )	2026-08-27 17:07:02 -04:00
opencode-agent[bot]andiamdavidhill	84a012a0e9	fix(app): show grouped tool counts inline (#45603 ) Co-authored-by: iamdavidhill <1879069+iamdavidhill@users.noreply.github.com>	2026-08-27 21:01:38 +00:00
opencode-agent[bot]andiamdavidhill	16a0996bd4	fix(ui): replace error icon with updated svg (#45604 ) Co-authored-by: iamdavidhill <1879069+iamdavidhill@users.noreply.github.com>	2026-08-28 06:50:56 +10:00