fix(ai): preserve top-level prompt cache key defaults

2026-08-27 20:16:17 +00:00 · 2026-08-26 16:14:36 -05:00
331 changed files with 4876 additions and 13640 deletions
@@ -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
---
-
-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
---
-
-Preserve reference insertion order when later config documents override an existing reference.
@@ -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
---
-
-Use parent directory names for SKILL.md IDs so individually downloaded skills do not overwrite each other.
@@ -237,19 +237,13 @@ jobs:
        working-directory: packages/app
        run: bunx playwright install chromium

-      - name: Run app e2e tests against production build
+      - name: Run app e2e tests
        if: env.E2E_ENABLED == 'true'
-        run: bun --cwd packages/app test:e2e:built
+        run: bun --cwd packages/app test:e2e:local
        env:
          CI: true
        timeout-minutes: 30

-      - name: Verify service worker precaching and upgrades
-        if: env.E2E_ENABLED == 'true'
-        working-directory: packages/app
-        run: bunx playwright test --config e2e/service-worker/playwright.config.ts
-        timeout-minutes: 5
-
      - name: Upload Playwright artifacts
        if: always() && env.E2E_ENABLED == 'true'
        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
@@ -125,7 +125,7 @@
        "@effect/platform-node": "catalog:",
        "@opencode-ai/client": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.13",
+        "@opencode-ai/pty": "0.1.11",
        "@opencode-ai/schema": "workspace:*",
        "@opencode-ai/server": "workspace:*",
        "@opencode-ai/tui": "workspace:*",
@@ -364,7 +364,7 @@
        "@opencode-ai/ai": "workspace:*",
        "@opencode-ai/codemode": "workspace:*",
        "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.13",
+        "@opencode-ai/pty": "0.1.11",
        "@opencode-ai/schema": "workspace:*",
        "@opencode-ai/util": "workspace:*",
        "@parcel/watcher": "2.5.1",
@@ -2175,19 +2175,19 @@

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

-    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.13", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.13", "@opencode-ai/pty-darwin-x64": "0.1.13", "@opencode-ai/pty-linux-arm64-gnu": "0.1.13", "@opencode-ai/pty-linux-arm64-musl": "0.1.13", "@opencode-ai/pty-linux-x64-gnu": "0.1.13", "@opencode-ai/pty-linux-x64-musl": "0.1.13" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-WPCN8h8HaZhhUcrMG0zu+4D9vco0EZiEg/gCF1K3JPRN6UsHMiXq1HVIy5IlyfcoyjfViRmQmXYE4AuU3laBjA=="],
+    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.11", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.11", "@opencode-ai/pty-darwin-x64": "0.1.11", "@opencode-ai/pty-linux-arm64-gnu": "0.1.11", "@opencode-ai/pty-linux-arm64-musl": "0.1.11", "@opencode-ai/pty-linux-x64-gnu": "0.1.11", "@opencode-ai/pty-linux-x64-musl": "0.1.11" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-Q4p0XXZWbc8FnpEJaaLqVbCdodxR9lVzaQjMH18KvjX/4m6tYfuspz03mvkN9MdmtDJ2GOZS7QgGQ7Q+RE9aWw=="],

-    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.13", "", { "os": "darwin", "cpu": "arm64" }, "sha512-fVtQZqVLBuJx/aB+5ojfmQifS1KMc9gxlxpFQ6bxEFU8tn8xHQTiFPaNroZgOtaw7I4ceGyx/eXieK1wp68yAA=="],
+    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.11", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Hz59ImecqeBdLQ40TknPDc9k4xWjQPaTgZ7cXzF3vclAvZiFYSM1rRdbBF6rOaOB0DBp0OFYsiaPP1ykszLsfw=="],

-    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.13", "", { "os": "darwin", "cpu": "x64" }, "sha512-b/tAEm0hCMXraPM9cxR8Rg7X1UBZInRTaxWAS4Ht9eH1nWj1rANOLvHWiWX/vVh5TB0Ubg8bWPu4B0nZkEHROQ=="],
+    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.11", "", { "os": "darwin", "cpu": "x64" }, "sha512-TPpA+FZ08BXtTcOeqe0FEJitqLld6Nl46UizcSmQCTRM22xOKPar6OoxHGYtqdFCaFk43a+hk/0GWpV7mcEQEg=="],

-    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-I124aSYBBjpGZnYExHfIajkvVK1FiK+//OJBGdqqFp5pas2Oruq4O8tv+pMoxomZIYh2ce/QhOOYLHRwXsthTg=="],
+    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-PTU9Ss5a5pApw6IeVvjjbFPuui2oKMoTQ/nY+K1+idLpgMeQHXk2URJbQqetqJxH4OLL5eSutDeWvpkweW0tTw=="],

-    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.13", "", { "os": "linux", "cpu": "arm64" }, "sha512-feWsfKpaDytGJzutoK43GqQwVghG2vHZt6BE/ydPZNuqIrySQ/6JfliUAMwn5BWs/Ky7ouSwKHCyAVeukusSvg=="],
+    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.11", "", { "os": "linux", "cpu": "arm64" }, "sha512-NFZ2LLfEaO6858cYtEwfQKda/HnCrPR0WflnWoDllHmdY12umeHkeE8DnZQK48tziXxvEACspItXmleiAMAg3g=="],

-    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.13", "", { "os": "linux", "cpu": "x64" }, "sha512-jliNgsevGuxfIeX7eyzjHhrJkF8uEUPnDLbF2v16uv69FhEHrraf7jyWkxazMP6rNvn2CGtwMMc4BXPS5pzjhg=="],
+    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.11", "", { "os": "linux", "cpu": "x64" }, "sha512-2Wbko2tFkgTmY6ceB+QMA3E+omaRd5IBBFjJoikMxkc7n75TXYQVz09tCC0pPW+flGvApFQ2YcIkSotdLwit+A=="],

-    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.13", "", { "os": "linux", "cpu": "x64" }, "sha512-rXDpidW66gz2b2M/NbUN8ZKmAxaJcASnuHATeXevlrFdiPUv8uJwvkRd6Pla1fp01Q65MkBmgRa7Q9c+H1PlzA=="],
+    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.11", "", { "os": "linux", "cpu": "x64" }, "sha512-PF7vbOsSOVbRSo11pOOmJq/Vp34Ww7Xoo8rUeMSAoG1tJSIp2SXFHCRKEGH9H4KxGUfpRHQlDBV1HLz8onnyJQ=="],

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

@@ -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-NV1PD2fCgWEKsr9kR0pV9jgkC400dzoF7/DnI/fY5yI=",
+    "aarch64-linux": "sha256-TDTdwE0mcHLrrKPDwPPBk3qIDl/PXJrLX6Zbwp7EH3I=",
+    "aarch64-darwin": "sha256-6MEoiV1UKAWgC7C6PR4USCP/LLZXROfBfPg6sb2VVWg=",
+    "x86_64-darwin": "sha256-8JV6YVZFq1BC++zpARxBWhQ+wuNJrWgTZJ6jfQhDybs="
  }
 }
@@ -19,14 +19,6 @@ Per-type constructors live on the type, not as top-level re-exports. Use `Messag
 - Use `testEffect(...)` from `test/lib/effect.ts` for tests requiring Effect layers.
 - Keep provider tests fixture-first. Live provider calls must stay behind `RECORD=true` and required API-key checks.

-## Errors
-
- `AIError` wraps a union of tagged reason errors. It stores only `reason`, derives `message` from the reason, and exposes the reason as its `cause`.
- Each reason owns its readable `message`, category-specific fields, and optional `body`, `http`, and underlying exception in `cause`.
- `reason.body` is the sole original-response or triggering-event payload field. Preserve original text before schema decoding removes fields; do not replace the complete event with only its nested error.
- `reason.http` describes an observed HTTP response with required `url`, `status`, and response `headers`. Do not invent status codes or derive a separate request ID from headers.
- Reclassification and transport recovery must preserve the reason's body, HTTP context, and underlying cause. Error `message` and `cause` are non-enumerable: copy them explicitly when constructing an enriched reason with its constructor or `AIErrorReason.make`.
-
 ## Architecture

 This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
@@ -376,6 +376,8 @@ Request options in order of stability:

 Route/provider defaults are overridden by request-level values for each axis.

+`promptCacheKey` belongs at the top level, not inside `providerOptions`. It can also be set in provider configuration (for example, `OpenAI.configure({ promptCacheKey: "shared-prefix" })`) or `LanguageModel.defaults`. The effective key is resolved in request > model defaults > route defaults order. For Chat and Responses, `cache: "none"` suppresses the wire cache key even when a default is configured.
+
 The selected model supplies the provider-specific option type, so per-request overrides stay flat while the canonical runtime request remains provider-neutral:

 ```ts
@@ -1,7 +1,7 @@
 import { Effect, Schema } from "effect"
 import {
  HttpOptions,
-  InvalidRequestError,
+  InvalidRequestReason,
  AIError,
  ModelID,
  ProviderID,
@@ -158,10 +158,9 @@ export function generate(input: ImageRequest | ImageRequestInput) {
    try: () => (input instanceof ImageRequest ? input : request(input)),
    catch: (error) =>
      new AIError({
-        reason: new InvalidRequestError({
-          message: error instanceof Error ? error.message : String(error),
-          cause: error,
-        }),
+        module: "Image",
+        method: "generate",
+        reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
      }),
  }).pipe(Effect.flatMap((request) => ImageClient.generate(request as unknown as ImageRequestFor<ImageOptions>)))
 }
@@ -3,7 +3,7 @@ import { LLMClient, Service } from "./route/client.js"
 import {
  GenerationOptions,
  HttpOptions,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
  AIError,
  LLMEvent,
  LLMRequest,
@@ -116,7 +116,9 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
  )
  if (!call || !LLMEvent.is.toolCall(call))
    return yield* new AIError({
-      reason: new InvalidProviderOutputError({
+      module: "LLM",
+      method: "generateObject",
+      reason: new InvalidProviderOutputReason({
        message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
      }),
    })
@@ -124,9 +126,10 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (
    Effect.mapError(
      (error) =>
        new AIError({
-          reason: new InvalidProviderOutputError({
+          module: "LLM",
+          method: "generateObject",
+          reason: new InvalidProviderOutputReason({
            message: `generateObject: tool input failed schema decode: ${error.message}`,
-            cause: error,
          }),
        }),
    ),
@@ -1387,15 +1387,14 @@ const providerErrorMessage = (event: AnthropicEvent): string => {
  return message || type || "Anthropic Messages stream error"
 }

-const onError = (event: AnthropicEvent) => {
-  const message = providerErrorMessage(event)
-  const body = ProviderShared.encodeJson(event)
-  return Effect.fail(
+const onError = (event: AnthropicEvent) =>
+  Effect.fail(
    new AIError({
-      reason: classifyProviderFailure({ message, rawBody: body }),
+      module: ADAPTER,
+      method: "stream",
+      reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
    }),
  )
-}

 const isKnownStreamBlockType = (type: string) =>
  type === "text" ||
@@ -645,13 +645,15 @@ const step = (state: ParserState, event: BedrockEvent) =>
    }

    if (event.exception) {
-      const message =
-        event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error"
-      const body = ProviderShared.encodeJson(event)
      return yield* new AIError({
+        module: ADAPTER,
+        method: "stream",
        reason: classifyProviderFailure({
-          message,
-          rawBody: body,
+          message:
+            event.exception.details.message ??
+            event.exception.details.originalMessage ??
+            "Bedrock Converse stream error",
+          code: event.exception.type,
        }),
      })
    }
@@ -1,7 +1,6 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec"
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8"
-import { Effect, Encoding, Stream } from "effect"
-import { AIError, AIErrorReason } from "../schema/index.js"
+import { Effect, Stream } from "effect"
 import { Framing } from "../route/framing.js"
 import { ProviderShared } from "./shared.js"

@@ -50,14 +49,10 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            `Failed to decode Bedrock Converse event-stream frame: ${
              error instanceof Error ? error.message : String(error)
            }`,
-            Encoding.encodeBase64(view.subarray(0, totalLength)),
-            error,
          ),
      })
      cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength }

-      const payload = utf8.decode(decoded.body)
-      const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload })
      const messageType = decoded.headers[":message-type"]?.value
      if (messageType === "error") {
        const code = decoded.headers[":error-code"]?.value
@@ -66,7 +61,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
          route,
          [code, message].filter((value): value is string => typeof value === "string").join(": ") ||
            "Bedrock Converse event-stream error",
-          body,
        )
      }
      const eventType =
@@ -76,6 +70,7 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
            ? decoded.headers[":exception-type"]?.value
            : undefined
      if (typeof eventType !== "string") continue
+      const payload = utf8.decode(decoded.body)
      if (!payload) continue
      // The AWS event stream pads short payloads with a `p` field. Drop it
      // before handing the object to the chunk schema. JSON decode goes
@@ -85,21 +80,11 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
        route,
        payload,
        "Failed to parse Bedrock Converse event-stream payload",
-      ).pipe(
-        Effect.mapError(
-          (error) =>
-            new AIError({
-              reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
-            }),
-        ),
      )) as Record<string, unknown>
      delete parsed.p
-      out.push({
-        ...(messageType === "exception"
-          ? { exception: { type: eventType, details: parsed } }
-          : { [eventType]: parsed }),
-        rawBody: body,
-      })
+      out.push(
+        messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed },
+      )
    }
    return [cursor, out] as const
  })
@@ -112,7 +97,6 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
 */
 export const framing = (route: string): Framing.Definition<object> => ({
  id: "aws-event-stream",
-  body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
  frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 })

@@ -6,7 +6,6 @@ import { Endpoint } from "../route/endpoint.js"
 import { Framing } from "../route/framing.js"
 import { Protocol } from "../route/protocol.js"
 import {
-  AIError,
  LLMEvent,
  Usage,
  type FinishReason,
@@ -18,7 +17,6 @@ import {
  type ToolCallPart,
  type ToolDefinition,
 } from "../schema/index.js"
-import { classifyProviderFailure } from "../provider-error.js"
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js"
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js"
 import { Lifecycle } from "./utils/lifecycle.js"
@@ -223,7 +221,6 @@ const GeminiPromptFeedback = Schema.StructWithRest(
 type GeminiPromptFeedback = Schema.Schema.Type<typeof GeminiPromptFeedback>

 const GeminiEvent = Schema.Struct({
-  error: Schema.optional(Schema.Unknown),
  candidates: optionalNull(Schema.Array(GeminiCandidate)),
  promptFeedback: optionalNull(GeminiPromptFeedback),
  usageMetadata: optionalNull(GeminiUsage),
@@ -601,18 +598,6 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
 }

 const step = (state: ParserState, event: GeminiEvent) => {
-  if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
-    const body = ProviderShared.encodeJson(event)
-    return Effect.fail(
-      new AIError({
-        reason: classifyProviderFailure({
-          message: event.error.message,
-          status: typeof event.error.code === "number" ? event.error.code : undefined,
-          rawBody: body,
-        }),
-      }),
-    )
-  }
  const nextState = {
    ...state,
    promptFeedback: event.promptFeedback ?? state.promptFeedback,
@@ -9,7 +9,15 @@ import {
  type ImageRoute,
 } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { AIError, Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+  type ProviderMetadata,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"

@@ -116,6 +124,13 @@ const nativeOptions = (options: GoogleImageOptions | undefined) => {
  )
 }

+const invalidOutput = (message: string, providerMetadata?: ProviderMetadata) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
  if (!query) return url
  const next = new URL(url)
@@ -154,9 +169,11 @@ export const model = (input: ModelInput) => {
          HttpClientRequest.bodyText(text, "application/json"),
        ),
      )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)),
+      const payload = yield* response.json.pipe(
+        Effect.mapError(() => invalidOutput("Failed to read the Google Images response")),
+      )
+      const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(
+        Effect.mapError(() => invalidOutput("Google Images returned an invalid response")),
      )
      const candidates = decoded.candidates ?? []
      const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
@@ -191,10 +208,9 @@ export const model = (input: ModelInput) => {
      )
      const images = yield* Effect.forEach(encoded, (item) =>
        Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(
-          Effect.mapError((cause) =>
-            output.invalid(
+          Effect.mapError(() =>
+            invalidOutput(
              `Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`,
-              cause,
            ),
          ),
          Effect.map(
@@ -221,10 +237,16 @@ export const model = (input: ModelInput) => {
        const finishReasons = candidates.flatMap((candidate) =>
          candidate.finishReason === undefined ? [] : [candidate.finishReason],
        )
-        return yield* output.invalid(
+        return yield* invalidOutput(
          `Google Images returned no final images${
            finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`
-          }; inspect body for prompt feedback and candidate details`,
+          }; inspect reason.providerMetadata.google for prompt feedback and candidate details`,
+          {
+            google: {
+              promptFeedback: decoded.promptFeedback,
+              candidates: candidateMetadata,
+            },
+          },
        )
      }
      const usage = decoded.usageMetadata
@@ -268,11 +290,12 @@ const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknow
    return Effect.succeed({ inlineData: { mimeType: image.mediaType, data: Encoding.encodeBase64(image.data) } })
  if (image.type === "file-uri") return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } })
  if (image.type === "url")
-    return ImageInputs.decodeDataUrl(image.url).pipe(
+    return ImageInputs.decodeDataUrl(image.url, ADAPTER).pipe(
      Effect.flatMap((decoded) => {
        if (decoded === undefined)
          return Effect.fail(
            ImageInputs.invalid(
+              ADAPTER,
              "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI",
            ),
          )
@@ -282,7 +305,7 @@ const googleImagePart = (image: ImageInput): Effect.Effect<Record<string, unknow
      }),
    )
  return Effect.fail(
-    ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"),
+    ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"),
  )
 }

@@ -1,7 +1,6 @@
 import { Effect, Schema, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Framing } from "../route/framing.js"
-import type { HttpContext } from "../schema/index.js"
 import {
  HttpTransport,
  WebSocketTransport,
@@ -61,8 +60,8 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
    observe: (_create, frame) =>
      Effect.gen(function* () {
        const event = yield* decodeEvent(frame).pipe(
-          Effect.mapError((cause) =>
-            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause),
+          Effect.mapError(() =>
+            ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame),
          ),
        )
        if (terminal)
@@ -74,13 +73,13 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
        if (event.type === "error") {
          terminal = true
          yield* OpenResponses.decodeKnownErrorEvent(event).pipe(
-            Effect.mapError((cause) =>
-              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause),
+            Effect.mapError(() =>
+              ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame),
            ),
          )
          return {
            type: "provider-failure",
-            error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
          }
        }
        if (event.type === "response.failed") {
@@ -93,7 +92,7 @@ const driver = (options: Options, body: string): WebSocketChannelDriver => {
            )
          return {
            type: "provider-failure",
-            error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
+            error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
          }
        }
        if (event.type === "response.created") {
@@ -176,37 +175,23 @@ export const transport = <Body>(options: Options): Transport<Body, Prepared, str
          channel,
        }
      }),
-    execute: (prepared, request, runtime, executeOptions) =>
-      Effect.gen(function* () {
-        if (!executeOptions?.webSocket || !prepared.channel) return yield* http.execute(prepared.http, request, runtime)
-        let fallbackHttp: HttpContext | undefined
-        const exchange: WebSocketChannelExchange = {
-          id: request.id ?? "request",
-          connect: {
-            url: prepared.channel.url,
-            headers: prepared.channel.headers,
-            rotateAfterMs: prepared.channel.rotateAfterMs,
-          },
-          fallback: () =>
-            Stream.unwrap(
-              http.execute(prepared.http, request, runtime).pipe(
-                Effect.map((execution) => {
-                  fallbackHttp = execution.http
-                  return execution.frames
-                }),
-              ),
-            ),
-          driver: prepared.channel.driver,
-        }
-        const execution = yield* executeOptions.webSocket.execute(exchange)
-        return {
-          frames: execution.frames,
-          complete: execution.complete,
-          get http() {
-            return fallbackHttp ?? execution.http
-          },
-        }
-      }),
+    execute: (prepared, request, runtime, executeOptions) => {
+      if (!executeOptions?.webSocket || !prepared.channel) return http.execute(prepared.http, request, runtime)
+      const exchange: WebSocketChannelExchange = {
+        id: request.id ?? "request",
+        connect: {
+          url: prepared.channel.url,
+          headers: prepared.channel.headers,
+          rotateAfterMs: prepared.channel.rotateAfterMs,
+        },
+        fallback: () =>
+          Stream.unwrap(
+            http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames)),
+          ),
+        driver: prepared.channel.driver,
+      }
+      return executeOptions.webSocket.execute(exchange)
+    },
  }
 }

@@ -1,4 +1,4 @@
-import { AIError, TransportError } from "../schema/index.js"
+import { AIError, TransportReason } from "../schema/index.js"
 import type { ChannelCheckpoint, ChannelObservation, WebSocketChannelDriver } from "../route/transport/index.js"
 import { Effect, Option, Schema } from "effect"
 import * as ProviderShared from "./shared.js"
@@ -99,17 +99,17 @@ const incremental = (
 const code = (event: OpenResponses.Event) => event.code || event.error?.code || event.response?.error?.code || undefined

 const rejected = (
+  input: DriverInput,
  observation: Extract<ChannelObservation, { readonly type: "provider-failure" }>,
  recovery: "retry-full" | "rotate-and-retry-full",
 ): ChannelObservation => ({
  type: "rejected",
  recovery,
  error: new AIError({
-    reason: new TransportError({
+    module: input.id,
+    method: "stream",
+    reason: new TransportReason({
      message: observation.error.message,
-      body: observation.error.reason.body,
-      http: observation.error.reason.http,
-      cause: observation.error.reason.cause,
      transport: "websocket",
      operation: "read",
      phase: "receive",
@@ -137,16 +137,15 @@ export const driver = (input: DriverInput): WebSocketChannelDriver => {
    observe: (create, frame) =>
      Effect.gen(function* () {
        const event = yield* decodeEvent(frame).pipe(
-          Effect.mapError((cause) =>
-            ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause),
-          ),
+          Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)),
        )
        const observation = yield* input.base.observe(create, frame)
        if (event.type === "response.output_item.done" && event.item) output.push(event.item)
        if (observation.type === "provider-failure") {
          const rejection = code(event)
-          if (rejection === "previous_response_not_found") return rejected(observation, "retry-full")
-          if (rejection === "websocket_connection_limit_reached") return rejected(observation, "rotate-and-retry-full")
+          if (rejection === "previous_response_not_found") return rejected(input, observation, "retry-full")
+          if (rejection === "websocket_connection_limit_reached")
+            return rejected(input, observation, "rotate-and-retry-full")
        }
        if (observation.type !== "completed") return observation
        const responseID = event.response?.id
@@ -5,7 +5,7 @@ import { Protocol } from "../route/protocol.js"
 import {
  AIError,
  LLMEvent,
-  ProviderInternalError,
+  ProviderInternalReason,
  Usage,
  type FinishReason,
  type JsonSchema,
@@ -1188,8 +1188,11 @@ const providerErrorMessage = (event: Event, nested: OpenResponsesErrorPayload |
  return message || code
 }

-export const providerFailure = (event: Event, fallback: string, body = ProviderShared.encodeJson(event)) => {
+export const providerFailure = (id: string, event: Event, fallback: string) => {
  const nested = event.error ?? event.response?.error ?? undefined
+  const code = event.code || nested?.code || undefined
+  // Keep the full raw payload on the error even when the message is a summary.
+  const body = JSON.stringify(nested ?? event) ?? ""
  const summary = providerErrorMessage(event, nested)
  const message = summary ?? (body === "{}" ? fallback : body)
  const status =
@@ -1204,11 +1207,18 @@ export const providerFailure = (event: Event, fallback: string, body = ProviderS
    event.response === undefined &&
    summary === undefined &&
    status === undefined
-      ? new ProviderInternalError({ message, body })
-      : classifyProviderFailure({ message, status, rawBody: body })
-  return new AIError({ reason })
+      ? new ProviderInternalReason({ message })
+      : classifyProviderFailure({ message, code, status, rawBody: body })
+  return new AIError({
+    module: id,
+    method: "stream",
+    body,
+    reason,
+  })
 }

+const providerError = (state: ParserState, event: Event, fallback: string) => providerFailure(state.id, event, fallback)
+
 export const step = (state: ParserState, input: Event) => {
  // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
  const event =
@@ -1276,18 +1286,11 @@ export const step = (state: ParserState, input: Event) => {
    return onOutputItemDone(state, event)
  }
  if (event.type === "response.completed" || event.type === "response.incomplete") return onResponseFinish(state, event)
-  if (event.type === "response.failed") return providerFailure(event, `${state.name} response failed`)
+  if (event.type === "response.failed") return providerError(state, event, `${state.name} response failed`)
  if (event.type === "error")
    return decodeKnownErrorEvent(event).pipe(
-      Effect.mapError((cause) =>
-        ProviderShared.eventError(
-          state.id,
-          `${state.name} returned a malformed error event`,
-          ProviderShared.encodeJson(event),
-          cause,
-        ),
-      ),
-      Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)),
+      Effect.mapError(() => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`)),
+      Effect.flatMap(() => providerError(state, event, `${state.name} stream error`)),
    )
  return Effect.succeed<StepResult>([state, NO_EVENTS])
 }
@@ -7,11 +7,10 @@ import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
  AIError,
-  AIErrorReason,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
  LLMEvent,
-  ProviderInternalError,
-  UnknownProviderError,
+  ProviderInternalReason,
+  UnknownProviderReason,
  Usage,
  type FinishReason,
  type FinishReasonDetails,
@@ -785,22 +784,26 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
 // Streaming parsers are small state machines: every event returns a new state
 // plus the common `LLMEvent`s produced by that event. Tool calls are accumulated
 // because OpenAI streams JSON arguments across multiple deltas.
+const finishReasonError = (event: OpenAIChatEvent, reason: AIError["reason"]) =>
+  new AIError({
+    module: ADAPTER,
+    method: "stream",
+    body: ProviderShared.encodeJson(event),
+    reason,
+  })
+
 const mapFinishReason = Effect.fn("OpenAIChat.mapFinishReason")(function* (event: OpenAIChatEvent, reason: string) {
  switch (reason) {
    case "error":
-      return yield* new AIError({
-        reason: new UnknownProviderError({
-          message: "Provider reported an error (finish_reason: error)",
-          body: ProviderShared.encodeJson(event),
-        }),
-      })
+      return yield* finishReasonError(
+        event,
+        new UnknownProviderReason({ message: "Provider reported an error (finish_reason: error)" }),
+      )
    case "network_error":
-      return yield* new AIError({
-        reason: new ProviderInternalError({
-          message: "Provider reported a network error (finish_reason: network_error)",
-          body: ProviderShared.encodeJson(event),
-        }),
-      })
+      return yield* finishReasonError(
+        event,
+        new ProviderInternalReason({ message: "Provider reported a network error (finish_reason: network_error)" }),
+      )
    case "stop":
    case "end":
      return "stop" as const
@@ -933,8 +936,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    if (event.error) {
      const body = ProviderShared.encodeJson(event)
      return yield* new AIError({
+        module: ADAPTER,
+        method: "stream",
+        body,
        reason: classifyProviderFailure({
          message: event.error.message,
+          code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
          status: typeof event.error.code === "number" ? event.error.code : undefined,
          rawBody: body,
        }),
@@ -1059,14 +1066,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        "OpenAI Chat tool call delta is missing id or name",
      )
      if (ToolStream.isError(result))
-        return yield* new AIError({
-          reason: AIErrorReason.make({
-            ...result.reason,
-            message: result.message,
-            cause: result.reason.cause,
-            body: ProviderShared.encodeJson(event),
-          }),
-        })
+        return yield* ProviderShared.eventError(ADAPTER, result.reason.message, ProviderShared.encodeJson(event))
      tools = result.tools
      if (result.events.length) lifecycle = Lifecycle.stepStart(lifecycle, events)
      events.push(...result.events)
@@ -1110,9 +1110,11 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 const finishEvents = Effect.fn("OpenAIChat.finishEvents")(function* (state: ParserState) {
  if (state.finishReason === undefined && state.requireFinishReason)
    return yield* new AIError({
-      reason: new InvalidProviderOutputError({
-        message: "OpenAI Chat stream ended without finish_reason",
+      module: ADAPTER,
+      method: "stream",
+      reason: new InvalidProviderOutputReason({
        classification: "incomplete-stream",
+        message: "OpenAI Chat stream ended without finish_reason",
        route: ADAPTER,
      }),
    })
@@ -9,7 +9,14 @@ import {
  type ImageRoute,
 } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"
 import { OpenAIImage } from "./utils/openai-image.js"
@@ -77,6 +84,13 @@ const nativeOptions = (options: OpenAIImageOptions | undefined) => {
  }
 }

+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
  if (!query) return url
  const next = new URL(url)
@@ -90,12 +104,12 @@ export const model = (input: ModelInput) => {
    generate: Effect.fn("OpenAIImages.generate")(function* (request: ImageRequestFor<OpenAIImageOptions>, execute) {
      const mask = request.options?.mask
      if (mask !== undefined && (request.images?.length ?? 0) === 0)
-        return yield* ImageInputs.invalid("An OpenAI image mask requires at least one input image")
+        return yield* ImageInputs.invalid(ADAPTER, "An OpenAI image mask requires at least one input image")
      const http = mergeHttpOptions(request.model.http, request.http)
      const sourceImages = request.images ?? []
      const multipartImages = yield* Effect.forEach(sourceImages, (image) => {
        if (image.type === "bytes") return Effect.succeed({ data: image.data, mediaType: image.mediaType })
-        if (image.type === "url") return ImageInputs.decodeDataUrl(image.url)
+        if (image.type === "url") return ImageInputs.decodeDataUrl(image.url, ADAPTER)
        return Effect.undefined
      })
      const multipartMask =
@@ -104,7 +118,7 @@ export const model = (input: ModelInput) => {
          : mask.type === "bytes"
            ? { data: mask.data, mediaType: mask.mediaType }
            : mask.type === "url"
-              ? yield* ImageInputs.decodeDataUrl(mask.url)
+              ? yield* ImageInputs.decodeDataUrl(mask.url, ADAPTER)
              : undefined
      const useMultipart =
        sourceImages.length > 0 &&
@@ -147,7 +161,7 @@ export const model = (input: ModelInput) => {
        return undefined
      })
      if (references.some((image) => image === undefined))
-        return yield* ImageInputs.invalid("OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts image URLs, data URLs, bytes, and file IDs")
      const maskReference =
        mask === undefined
          ? undefined
@@ -159,7 +173,7 @@ export const model = (input: ModelInput) => {
                ? { file_id: mask.id }
                : undefined
      if (mask !== undefined && maskReference === undefined)
-        return yield* ImageInputs.invalid("OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "OpenAI Images accepts masks as URLs, data URLs, bytes, or file IDs")
      const requestBody = mergeJsonRecords(
        {
          model: request.model.id,
@@ -195,9 +209,11 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
  options: OpenAIImageOptions | undefined,
  overlay: Record<string, unknown> | undefined,
 ) {
-  const output = yield* ProviderShared.imageResponse(ADAPTER, "OpenAI Images", response)
-  const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(OpenAIImageResponse))(output.body).pipe(
-    Effect.mapError((cause) => output.invalid("OpenAI Images returned an invalid response", cause)),
+  const payload = yield* response.json.pipe(
+    Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")),
+  )
+  const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(
+    Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")),
  )
  const requestBody = mergeJsonRecords(nativeOptions(options), overlay)
  const format =
@@ -205,7 +221,7 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
  const images = yield* Effect.forEach(decoded.data, (item, index) => {
    if (item.b64_json)
      return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-        Effect.mapError((cause) => output.invalid(`OpenAI Images result ${index} contains invalid base64 data`, cause)),
+        Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)),
        Effect.map(
          (data) =>
            new GeneratedImage({
@@ -225,9 +241,9 @@ const parseResponse = Effect.fn("OpenAIImages.parseResponse")(function* (
            item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
        }),
      )
-    return Effect.fail(output.invalid(`OpenAI Images result ${index} has neither image data nor a URL`))
+    return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`))
  })
-  if (images.length === 0) return yield* output.invalid("OpenAI Images returned no images")
+  if (images.length === 0) return yield* invalidOutput("OpenAI Images returned no images")
  return new ImageResponse({
    images,
    usage:
@@ -149,9 +149,7 @@ const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function*
  const isError = item.error !== undefined && item.error !== null
  if (item.type === "image_generation_call" && item.result) {
    yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(
-      Effect.mapError((cause) =>
-        ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64", undefined, cause),
-      ),
+      Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")),
    )
    const format = item.output_format ?? "png"
    return {
@@ -2,12 +2,11 @@ import { Buffer } from "node:buffer"
 import { Tool } from "@opencode-ai/schema/tool"
 import { Effect, Schema, Stream } from "effect"
 import * as Sse from "effect/unstable/encoding/Sse"
-import { Headers, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
-  InvalidProviderOutputError,
-  InvalidRequestError,
+  InvalidProviderOutputReason,
+  InvalidRequestReason,
  AIError,
-  HttpContext,
  type ContentPart,
  type LLMRequest,
  type MediaPart,
@@ -97,15 +96,17 @@ export const sumTokens = (...values: ReadonlyArray<number | undefined>): number
  return values.reduce((acc: number, value) => acc + (value ?? 0), 0)
 }

-export const eventError = (route: string, message: string, body?: string, cause?: unknown) =>
+export const eventError = (route: string, message: string, raw?: string) =>
  new AIError({
-    reason: new InvalidProviderOutputError({ route, message, body, cause }),
+    module: "ProviderShared",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({ route, message, raw }),
  })

 export const parseJson = (route: string, input: string, message: string) =>
  Effect.try({
    try: () => decodeJson(input),
-    catch: (cause) => eventError(route, message, input, cause),
+    catch: () => eventError(route, message, input),
  })

 /**
@@ -232,7 +233,7 @@ export const sseFraming = (
      (state, chunk) =>
        Effect.gen(function* () {
          const error = state.parser.feed(chunk)
-          if (error) return yield* eventError("sse", error.message, chunk, error)
+          if (error) return yield* eventError("sse", error.message)
          return [state, state.output.splice(0)] as const
        }),
    ),
@@ -248,39 +249,13 @@ export const sseFraming = (
 /**
 * Canonical invalid-request constructor shared by protocol lowering.
 */
-export const invalidRequest = (message: string, cause?: unknown) =>
+export const invalidRequest = (message: string) =>
  new AIError({
-    reason: new InvalidRequestError({ message, cause }),
+    module: "ProviderShared",
+    method: "request",
+    reason: new InvalidRequestReason({ message }),
  })

-export const imageResponse = Effect.fn("ProviderShared.imageResponse")(function* (
-  route: string,
-  name: string,
-  response: HttpClientResponse.HttpClientResponse,
-) {
-  const http = new HttpContext({ url: response.request.url, status: response.status, headers: response.headers })
-  const body = yield* response.text.pipe(
-    Effect.mapError(
-      (cause) =>
-        new AIError({
-          reason: new InvalidProviderOutputError({
-            route,
-            message: `Failed to read the ${name} response`,
-            http,
-            cause,
-          }),
-        }),
-    ),
-  )
-  return {
-    body,
-    invalid: (message: string, cause?: unknown) =>
-      new AIError({
-        reason: new InvalidProviderOutputError({ route, message, body, http, cause }),
-      }),
-  }
-})
-
 export const matchToolChoice = <Auto, None, Required, Tool>(
  route: string,
  toolChoice: NonNullable<LLMRequest["toolChoice"]>,
@@ -327,7 +302,7 @@ export const unsupportedContent = (
 export const validateWith =
  <A, I, E extends { readonly message: string }>(decode: (input: I) => Effect.Effect<A, E>) =>
  (payload: I) =>
-    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message, error)))
+    decode(payload).pipe(Effect.mapError((error) => invalidRequest(error.message)))

 /**
 * Build an HTTP POST with a JSON body. Sets `content-type: application/json`
@@ -1,10 +1,12 @@
 import { Effect, Encoding } from "effect"
 import type { ImageInput } from "../../image.js"
-import { InvalidRequestError, AIError } from "../../schema/index.js"
+import { InvalidRequestReason, AIError } from "../../schema/index.js"

-const invalid = (message: string, cause?: unknown) =>
+const invalid = (module: string, message: string) =>
  new AIError({
-    reason: new InvalidRequestError({ message, cause }),
+    module,
+    method: "generate",
+    reason: new InvalidRequestReason({ message }),
  })

 export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>) =>
@@ -12,12 +14,13 @@ export const dataUrl = (input: Extract<ImageInput, { readonly type: "bytes" }>)

 export const decodeDataUrl = (
  url: string,
+  module: string,
 ): Effect.Effect<{ readonly mediaType: string; readonly data: Uint8Array } | undefined, AIError> => {
  if (!url.startsWith("data:")) return Effect.undefined
  const match = /^data:([^;,]+);base64,(.*)$/s.exec(url)
-  if (!match) return Effect.fail(invalid("Image data URLs must contain a MIME type and base64 data"))
+  if (!match) return Effect.fail(invalid(module, "Image data URLs must contain a MIME type and base64 data"))
  return Effect.fromResult(Encoding.decodeBase64(match[2])).pipe(
-    Effect.mapError((cause) => invalid("Image data URL contains invalid base64 data", cause)),
+    Effect.mapError(() => invalid(module, "Image data URL contains invalid base64 data")),
    Effect.map((data) => ({ mediaType: match[1], data })),
  )
 }
@@ -2,7 +2,14 @@ import { Effect, Encoding, Schema } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { Usage, mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  Usage,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared, optionalNull } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"

@@ -87,6 +94,13 @@ const nativeOptions = (options: XAIImageOptions | undefined) => {
  }
 }

+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
  if (!query) return url
  const next = new URL(url)
@@ -106,7 +120,7 @@ export const model = (input: ModelInput) => {
        return undefined
      })
      if (imageReferences.some((image) => image === undefined))
-        return yield* ImageInputs.invalid("xAI Images accepts image URLs, data URLs, bytes, and file IDs")
+        return yield* ImageInputs.invalid(ADAPTER, "xAI Images accepts image URLs, data URLs, bytes, and file IDs")
      const requestBody = mergeJsonRecords(
        {
          model: request.model.id,
@@ -135,17 +149,17 @@ export const model = (input: ModelInput) => {
          HttpClientRequest.bodyText(text, "application/json"),
        ),
      )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "xAI Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(XAIImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("xAI Images returned an invalid response", cause)),
+      const payload = yield* response.json.pipe(
+        Effect.mapError(() => invalidOutput("Failed to read the xAI Images response")),
+      )
+      const decoded = yield* Schema.decodeUnknownEffect(XAIImageResponse)(payload).pipe(
+        Effect.mapError(() => invalidOutput("xAI Images returned an invalid response")),
      )
      const images = yield* Effect.forEach(decoded.data, (item, index) => {
        const mediaType = item.mime_type ?? "application/octet-stream"
        if (item.b64_json)
          return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(
-            Effect.mapError((cause) =>
-              output.invalid(`xAI Images result ${index} contains invalid base64 data`, cause),
-            ),
+            Effect.mapError(() => invalidOutput(`xAI Images result ${index} contains invalid base64 data`)),
            Effect.map(
              (data) =>
                new GeneratedImage({
@@ -169,9 +183,9 @@ export const model = (input: ModelInput) => {
                  : { xai: { revisedPrompt: item.revised_prompt } },
            }),
          )
-        return Effect.fail(output.invalid(`xAI Images result ${index} has neither image data nor a URL`))
+        return Effect.fail(invalidOutput(`xAI Images result ${index} has neither image data nor a URL`))
      })
-      if (images.length === 0) return yield* output.invalid("xAI Images returned no images")
+      if (images.length === 0) return yield* invalidOutput("xAI Images returned no images")
      const usage = ProviderShared.isRecord(decoded.usage) ? decoded.usage : undefined
      return new ImageResponse({
        images,
@@ -2,7 +2,13 @@ import { Effect, Schema } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
 import { GeneratedImage, ImageModel, ImageResponse, type ImageRequestFor, type ImageRoute } from "../image.js"
 import { Auth, type Definition as AuthDefinition } from "../route/auth.js"
-import { mergeHttpOptions, mergeJsonRecords, type HttpOptions } from "../schema/index.js"
+import {
+  InvalidProviderOutputReason,
+  AIError,
+  mergeHttpOptions,
+  mergeJsonRecords,
+  type HttpOptions,
+} from "../schema/index.js"
 import { ProviderShared } from "./shared.js"
 import { ImageInputs } from "./utils/image-input.js"

@@ -57,6 +63,13 @@ const nativeOptions = (options: ZAIImageOptions | undefined) => {
  }
 }

+const invalidOutput = (message: string) =>
+  new AIError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+  })
+
 const applyQuery = (url: string, query: Record<string, string> | undefined) => {
  if (!query) return url
  const next = new URL(url)
@@ -69,7 +82,7 @@ export const model = (input: ModelInput) => {
    id: ADAPTER,
    generate: Effect.fn("ZAIImages.generate")(function* (request: ImageRequestFor<ZAIImageOptions>, execute) {
      if ((request.images?.length ?? 0) > 0)
-        return yield* ImageInputs.invalid("Z.ai hosted image generation does not support image inputs")
+        return yield* ImageInputs.invalid(ADAPTER, "Z.ai hosted image generation does not support image inputs")
      const http = mergeHttpOptions(request.model.http, request.http)
      const requestBody = mergeJsonRecords(
        { model: request.model.id, prompt: request.prompt },
@@ -91,11 +104,13 @@ export const model = (input: ModelInput) => {
          HttpClientRequest.bodyText(text, "application/json"),
        ),
      )
-      const output = yield* ProviderShared.imageResponse(ADAPTER, "Z.ai Images", response)
-      const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(ZAIImageResponse))(output.body).pipe(
-        Effect.mapError((cause) => output.invalid("Z.ai Images returned an invalid response", cause)),
+      const payload = yield* response.json.pipe(
+        Effect.mapError(() => invalidOutput("Failed to read the Z.ai Images response")),
      )
-      if (decoded.data.length === 0) return yield* output.invalid("Z.ai Images returned no images")
+      const decoded = yield* Schema.decodeUnknownEffect(ZAIImageResponse)(payload).pipe(
+        Effect.mapError(() => invalidOutput("Z.ai Images returned an invalid response")),
+      )
+      if (decoded.data.length === 0) return yield* invalidOutput("Z.ai Images returned no images")
      return new ImageResponse({
        images: decoded.data.map(
          (item) =>
@@ -1,16 +1,17 @@
 import { Option, Schema } from "effect"
 import {
-  AuthenticationError,
-  ContentPolicyError,
-  InvalidRequestError,
+  AuthenticationReason,
+  ContentPolicyReason,
+  InvalidRequestReason,
  AIError,
  ProviderErrorEvent,
-  ProviderInternalError,
-  QuotaExceededError,
-  RateLimitError,
-  UnknownProviderError,
+  ProviderInternalReason,
+  QuotaExceededReason,
+  RateLimitReason,
+  UnknownProviderReason,
  type HttpContext,
  type HttpRateLimitDetails,
+  type ProviderMetadata,
 } from "./schema/index.js"

 const patterns = [
@@ -79,28 +80,27 @@ const NETWORK_ERROR_TEXT = /network[-_\s]error/i
 export interface ProviderFailure {
  readonly message: string
  readonly status?: number | undefined
+  readonly code?: string | undefined
  // Raw wire payload, scanned for failure signals (codes, overflow phrases)
  // that the summary message does not carry. Not shown to users.
  readonly rawBody?: string | undefined
-  // Some SDKs supply parsed error data separately from the original response text.
-  readonly data?: unknown
-  readonly http?: HttpContext | undefined
-  readonly cause?: unknown
  readonly retryAfterMs?: number | undefined
  readonly rateLimit?: HttpRateLimitDetails | undefined
+  readonly http?: HttpContext | undefined
+  readonly providerMetadata?: ProviderMetadata | undefined
 }

 // Keep HTTP failures and provider-reported stream failures on one typed path so
 // session retry policy never needs provider-specific string matching.
 export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
-  const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause }
-  const body = input.rawBody ?? ""
-  const codes = [...providerCodes(input.data), ...providerCodes(body), ...providerCodes(input.message)].map((code) =>
-    code.toLowerCase(),
-  )
+  const body = input.http?.body ?? input.rawBody ?? ""
+  const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
+    .filter((code): code is string => code !== undefined)
+    .map((code) => code.toLowerCase())
  // Scan the raw payload too so signals missing from the summary message
  // (e.g. overflow phrases nested in a JSON error body) still classify.
  const text = [input.message, body].filter((value) => value.length > 0).join("\n")
+  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
  const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)

  if (
@@ -110,65 +110,62 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
      codes.includes("request_too_large") ||
      isContextOverflow(text))
  )
-    return new InvalidRequestError({ ...details, classification: "context-overflow" })
+    return new InvalidRequestReason({ ...common, classification: "context-overflow" })
  if (input.status === 413 || isPayloadTooLarge(text))
-    return new InvalidRequestError({ ...details, classification: "payload-too-large" })
-  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyError(details)
+    return new InvalidRequestReason({ ...common, classification: "payload-too-large" })
+  if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyReason(common)
  if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
-    return new QuotaExceededError(details)
-  if (input.status === 401) return new AuthenticationError({ ...details, kind: "invalid" })
-  if (input.status === 403) return new AuthenticationError({ ...details, kind: "insufficient-permissions" })
-  if (codes.includes("authentication_error")) return new AuthenticationError({ ...details, kind: "invalid" })
+    return new QuotaExceededReason(common)
+  if (input.status === 401) return new AuthenticationReason({ ...common, kind: "invalid" })
+  if (input.status === 403) return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
+  if (codes.includes("authentication_error")) return new AuthenticationReason({ ...common, kind: "invalid" })
  if (codes.includes("permission_error"))
-    return new AuthenticationError({ ...details, kind: "insufficient-permissions" })
+    return new AuthenticationReason({ ...common, kind: "insufficient-permissions" })
  if (
    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
  )
-    return new RateLimitError({
-      ...details,
+    return new RateLimitReason({
+      ...common,
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
  if (RATE_LIMIT_TEXT.test(text))
-    return new RateLimitError({
-      ...details,
+    return new RateLimitReason({
+      ...common,
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
-  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalError(details)
+  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalReason({ ...common, status: input.status })
  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-    return new ProviderInternalError({
-      ...details,
+    return new ProviderInternalReason({
+      ...common,
+      status: input.status,
      retryAfterMs: input.retryAfterMs,
    })
  if (input.status === 429) {
-    return new RateLimitError({
-      ...details,
+    return new RateLimitReason({
+      ...common,
      retryAfterMs: input.retryAfterMs,
      rateLimit: input.rateLimit,
    })
  }
  if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
-    return new ProviderInternalError({
-      ...details,
+    return new ProviderInternalReason({
+      ...common,
+      status: input.status,
      retryAfterMs: input.retryAfterMs,
    })
-  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestError(details)
+  if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestReason(common)
  if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
-    return new InvalidRequestError(details)
-  return new UnknownProviderError(details)
+    return new InvalidRequestReason(common)
+  return new UnknownProviderReason({ ...common, status: input.status })
 }

-function providerCodes(value: unknown) {
-  const decoded = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value
+function providerCodes(value: string) {
+  const decoded = Option.getOrUndefined(decodeJson(value))
  if (!isRecord(decoded)) return []
  const error = isRecord(decoded.error) ? decoded.error : undefined
-  const response = isRecord(decoded.response) ? decoded.response : undefined
-  const responseError = response && isRecord(response.error) ? response.error : undefined
-  const exception = isRecord(decoded.exception) ? decoded.exception : undefined
-  return [decoded.code, error?.code, error?.type, error?.status, responseError?.code, exception?.type].filter(
-    (value): value is string => typeof value === "string",
-  )
+  return [decoded.code, error?.code, error?.type].filter((value): value is string => typeof value === "string")
 }

 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -78,7 +78,7 @@ export const configure = (input: Config = {}) => {

  return {
    id,
-    model: responses,
+    model: chat,
    chat,
    responses,
    configure,
@@ -112,4 +112,4 @@ export const responsesModel: ProviderPackage.Definition<Settings, OpenAIProvider
  modelID,
  settings,
 ) => configure(config(settings)).responses(modelID)
-export const model = responsesModel
+export const model = chatModel
@@ -1,2 +1,2 @@
-export { responsesModel as model } from "../amazon-bedrock-mantle.js"
+export { chatModel as model } from "../amazon-bedrock-mantle.js"
 export type { Settings } from "../amazon-bedrock-mantle.js"
@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect"
 import { Headers } from "effect/unstable/http"
-import { AuthenticationError, InvalidRequestError, AIError, type HttpOptions } from "../schema/index.js"
+import { AuthenticationReason, InvalidRequestReason, AIError, type HttpOptions } from "../schema/index.js"

 export class MissingCredentialError extends Error {
  readonly _tag = "MissingCredentialError"
@@ -137,10 +137,12 @@ export function bearerHeader(name: string, source?: Secret | Credential) {
 const toAIError = (error: AuthError): AIError => {
  if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
    return new AIError({
+      module: "Auth",
+      method: "apply",
      reason:
        error instanceof MissingCredentialError
-          ? new AuthenticationError({ message: error.message, cause: error, kind: "missing" })
-          : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
+          ? new AuthenticationReason({ message: error.message, kind: "missing" })
+          : new InvalidRequestReason({ message: `Failed to resolve auth config: ${error.message}` }),
    })
  }
  return error
@@ -12,14 +12,13 @@ import * as ProviderShared from "../protocols/shared.js"
 import type { ProtocolID, ProviderOptions } from "../schema/index.js"
 import {
  AIError,
-  AIErrorReason,
  GenerationOptions,
  HttpOptions,
  LLMRequest,
  LLMResponse,
  LanguageModel,
  LLMEvent,
-  InvalidProviderOutputError,
+  InvalidProviderOutputReason,
  ProviderID,
  mergeGenerationOptions,
  mergeHttpOptions,
@@ -74,6 +73,7 @@ export type RouteLanguageModelInput = Omit<LanguageModel.Input, "provider" | "ro
 export type RouteRoutedLanguageModelInput = Omit<LanguageModel.Input, "route">

 export interface RouteDefaults {
+  readonly promptCacheKey?: string
  readonly headers?: Record<string, string>
  readonly generation?: GenerationOptions
  readonly providerOptions?: ProviderOptions
@@ -81,6 +81,7 @@ export interface RouteDefaults {
 }

 export interface RouteDefaultsInput {
+  readonly promptCacheKey?: string
  readonly headers?: Record<string, string>
  readonly generation?: GenerationOptions.Input
  readonly providerOptions?: ProviderOptions
@@ -118,6 +119,7 @@ const mergeRouteDefaults = (base: RouteDefaults | undefined, patch: RouteDefault
  return {
    ...base,
    ...patch,
+    promptCacheKey: patch.promptCacheKey ?? base?.promptCacheKey,
    headers,
    generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
    providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
@@ -173,6 +175,7 @@ const resolveRequestOptions = (request: LLMRequest) => {
  const modelDefaults = request.model.defaults
  const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, request.generation)
  return LLMRequest.update(request, {
+    promptCacheKey: request.promptCacheKey ?? modelDefaults?.promptCacheKey ?? routeDefaults.promptCacheKey,
    generation: generation ?? new GenerationOptions({}),
    providerOptions: mergeProviderOptions(
      routeDefaults.providerOptions,
@@ -228,14 +231,16 @@ export interface MakeTransportInput<Body, Prepared, Frame, Event, State> {
 const streamError = (route: string, message: string, cause: Cause.Cause<unknown>) => {
  const failed = cause.reasons.find(Cause.isFailReason)?.error
  if (failed instanceof AIError) return failed
-  return ProviderShared.eventError(route, message, undefined, cause)
+  return ProviderShared.eventError(route, message, Cause.pretty(cause))
 }

 const incompleteStreamError = (route: string) =>
  new AIError({
-    reason: new InvalidProviderOutputError({
-      message: "The provider response ended unexpectedly.",
+    module: "LLMClient",
+    method: "stream",
+    reason: new InvalidProviderOutputReason({
      classification: "incomplete-stream",
+      message: "The provider response ended unexpectedly.",
      route,
    }),
  })
@@ -264,12 +269,11 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
  const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event)
  const decodeEvent = (route: string) => (frame: Frame) =>
    decodeEventEffect(frame).pipe(
-      Effect.mapError((cause) =>
+      Effect.mapError(() =>
        ProviderShared.eventError(
          input.id,
          `Invalid ${route} stream event`,
          typeof frame === "string" ? frame : ProviderShared.encodeJson(frame),
-          cause,
        ),
      ),
    )
@@ -324,48 +328,19 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
        return Stream.unwrap(
          routeInput.transport.execute(prepared, request, runtime, options).pipe(
            Effect.map((execution) => {
-              const terminal = protocol.stream.terminal
-              // Preserve assembled inputs; replace only serialized event fallbacks with their original wire data.
-              const frameError =
-                (frame: Frame, event: Frame | Event = frame) =>
-                (error: AIError) =>
-                  new AIError({
-                    reason: AIErrorReason.make({
-                      ...error.reason,
-                      message: error.reason.message,
-                      cause: error.reason.cause,
-                      body:
-                        error.reason.body !== undefined && error.reason.body !== ProviderShared.encodeJson(event)
-                          ? error.reason.body
-                          : (execution.body?.(frame) ??
-                            (typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))),
-                    }),
-                  })
              const events = execution.frames.pipe(
-                Stream.mapEffect((frame) =>
-                  decodeEvent(route)(frame).pipe(
-                    Effect.catchCause((cause) =>
-                      Effect.fail(streamError(route, `Failed to decode ${route} event`, cause)),
-                    ),
-                    Effect.map((event) => ({ event, frame })),
-                    Effect.mapError(frameError(frame)),
-                  ),
-                ),
-                terminal ? Stream.takeUntil(({ event }) => terminal(event)) : (stream) => stream,
+                Stream.mapEffect(decodeEvent(route)),
+                protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream,
              )
              const stream = Stream.suspend(() => {
                let state = protocol.stream.initial(request)
                const parsed = events.pipe(
-                  Stream.mapEffect(({ event, frame }) =>
+                  Stream.mapEffect((event) =>
                    protocol.stream.step(state, event).pipe(
-                      Effect.catchCause((cause) =>
-                        Effect.fail(streamError(route, `Failed to parse ${route} event`, cause)),
-                      ),
                      Effect.map(([next, output]) => {
                        state = next
                        return output
                      }),
-                      Effect.mapError(frameError(frame, event)),
                    ),
                  ),
                  Stream.flatMap(Stream.fromIterable),
@@ -381,17 +356,6 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
              }).pipe(
                Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))),
                requireTerminalEvent(route),
-                Stream.mapError(
-                  (error) =>
-                    new AIError({
-                      reason: AIErrorReason.make({
-                        ...error.reason,
-                        message: error.reason.message,
-                        cause: error.reason.cause,
-                        http: error.reason.http ?? execution.http,
-                      }),
-                    }),
-                ),
              )
              return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream
            }),
@@ -7,7 +7,14 @@ import {
  HttpClientRequest,
  HttpClientResponse,
 } from "effect/unstable/http"
-import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js"
+import {
+  HttpContext,
+  HttpRateLimitDetails,
+  HttpRequestDetails,
+  HttpResponseDetails,
+  AIError,
+  TransportReason,
+} from "../schema/index.js"
 import { classifyProviderFailure } from "../provider-error.js"

 export interface Interface {
@@ -90,13 +97,24 @@ const rateLimitDetails = (headers: Record<string, string>, retryAfter: number |
  })
 }

-export const responseHttp = (response: HttpClientResponse.HttpClientResponse) =>
-  new HttpContext({
-    url: response.request.url,
+const requestDetails = (request: HttpClientRequest.HttpClientRequest) =>
+  new HttpRequestDetails({
+    method: request.method,
+    url: request.url,
+    headers: headerDetails(request.headers),
+  })
+
+const responseDetails = (response: HttpClientResponse.HttpClientResponse) =>
+  new HttpResponseDetails({
    status: response.status,
    headers: headerDetails(response.headers),
  })

+const responseBody = (body: string | void) => {
+  if (body === undefined) return {}
+  return { body }
+}
+
 const decodeProviderBody = Schema.decodeUnknownOption(
  Schema.fromJsonString(
    Schema.Struct({
@@ -114,46 +132,77 @@ const providerMessage = (status: number, body: string | void) => {
  )
 }

-const statusError = (response: HttpClientResponse.HttpClientResponse) =>
-  Effect.gen(function* () {
-    if (response.status < 400) return response
-    const result = yield* response.text.pipe(Effect.result)
-    return yield* httpFailure({
-      message: providerMessage(response.status, result._tag === "Success" ? result.success : undefined),
-      url: response.request.url,
-      status: response.status,
-      responseHeaders: headerDetails(response.headers),
-      responseBody: result._tag === "Success" ? result.success : undefined,
-      cause: result._tag === "Failure" ? (result.failure.cause ?? result.failure) : undefined,
-    })
+const responseHttp = (input: {
+  readonly request: HttpClientRequest.HttpClientRequest
+  readonly response: HttpClientResponse.HttpClientResponse
+  readonly body: ReturnType<typeof responseBody>
+  readonly rateLimit?: HttpRateLimitDetails | undefined
+}) =>
+  new HttpContext({
+    request: requestDetails(input.request),
+    response: responseDetails(input.response),
+    ...input.body,
+    rateLimit: input.rateLimit,
  })

-/** Preserve HTTP diagnostics for executor and externally captured failures alike. */
-export const httpFailure = (input: {
+const statusError =
+  (request: HttpClientRequest.HttpClientRequest) => (response: HttpClientResponse.HttpClientResponse) =>
+    Effect.gen(function* () {
+      if (response.status < 400) return response
+      const body = yield* response.text.pipe(Effect.catch(() => Effect.void))
+      const headers = normalizedHeaders(response.headers)
+      const retryAfter = retryAfterMs(headers)
+      const rateLimit = rateLimitDetails(headers, retryAfter)
+      const details = responseBody(body)
+      return yield* new AIError({
+        module: "RequestExecutor",
+        method: "execute",
+        reason: classifyProviderFailure({
+          status: response.status,
+          message: providerMessage(response.status, body),
+          retryAfterMs: retryAfter,
+          rateLimit,
+          http: responseHttp({
+            request,
+            response,
+            body: details,
+            rateLimit,
+          }),
+        }),
+      })
+    })
+
+// Classifies an HTTP failure captured outside the executor (for example by the
+// AI SDK's own fetch) onto the same reason types and HttpContext that
+// executor-driven requests produce. The originating request is not available on
+// that path, so the method is assumed (language model calls are always POST),
+// request headers are empty.
+export const classifyHttpFailure = (input: {
  readonly message: string
-  readonly url?: string | undefined
+  readonly url: string
  readonly status?: number | undefined
-  readonly data?: unknown
+  readonly code?: string | undefined
  readonly responseHeaders?: Record<string, string> | undefined
  readonly responseBody?: string | undefined
-  readonly cause?: unknown
 }) => {
  const headers = normalizedHeaders(Headers.fromInput(input.responseHeaders))
  const retryAfter = retryAfterMs(headers)
  const rateLimit = rateLimitDetails(headers, retryAfter)
-  return new AIError({
-    reason: classifyProviderFailure({
-      message: input.message,
-      status: input.status,
-      data: input.data,
-      rawBody: input.responseBody,
-      retryAfterMs: retryAfter,
-      rateLimit,
-      cause: input.cause,
-      http:
-        input.status === undefined || input.url === undefined
+  const details = responseBody(input.responseBody)
+  return classifyProviderFailure({
+    message: input.message,
+    status: input.status,
+    code: input.code,
+    retryAfterMs: retryAfter,
+    rateLimit,
+    http: new HttpContext({
+      request: new HttpRequestDetails({ method: "POST", url: input.url, headers: {} }),
+      response:
+        input.status === undefined
          ? undefined
-          : new HttpContext({ url: input.url, status: input.status, headers }),
+          : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
+      ...details,
+      rateLimit,
    }),
  })
 }
@@ -180,25 +229,25 @@ const httpError = (input: {
  readonly error: unknown
  readonly request: HttpClientRequest.HttpClientRequest
  readonly operation: HttpOperation
-  readonly http?: HttpContext
 }) => {
  const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request
  const transportError = (failure: { readonly message: string; readonly code?: string | undefined }) =>
    new AIError({
-      reason: new TransportError({
+      module: "RequestExecutor",
+      method: input.operation,
+      reason: new TransportReason({
        message: failure.message,
-        cause: source,
-        http: input.http,
        transport: "http",
        operation: input.operation,
        code: failure.code,
        url: request.url,
+        http: new HttpContext({ request: requestDetails(request) }),
      }),
    })

  const source =
    HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
-      ? (input.error.reason.cause ?? input.error)
+      ? input.error.reason.cause
      : input.error
  const native = nativeTransportFailure(source)
  const code = native?.code
@@ -222,13 +271,6 @@ const httpError = (input: {
  })
 }

-export const responseStream = (response: HttpClientResponse.HttpClientResponse): Stream.Stream<Uint8Array, AIError> =>
-  response.stream.pipe(
-    Stream.mapError((error) =>
-      httpError({ error, request: response.request, operation: "read", http: responseHttp(response) }),
-    ),
-  )
-
 export const stream = (
  executor: Interface,
  request: HttpClientRequest.HttpClientRequest,
@@ -237,7 +279,9 @@ export const stream = (
  Stream.unwrap(
    Effect.gen(function* () {
      const response = yield* executor.execute(request, middleware)
-      return responseStream(response)
+      return response.stream.pipe(
+        Stream.mapError((error) => httpError({ error, request: response.request, operation: "read" })),
+      )
    }),
  )

@@ -250,7 +294,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
        if (!middleware)
          return yield* http.execute(request).pipe(
            Effect.mapError((error) => httpError({ error, request, operation: "request" })),
-            Effect.flatMap(statusError),
+            Effect.flatMap(statusError(request)),
          )

        const response = yield* middleware(request, (input) =>
@@ -258,7 +302,7 @@ export const layer: Layer.Layer<Service, never, HttpClient.HttpClient> = Layer.e
            .execute(input)
            .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause))))),
        ).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })))
-        return yield* statusError(response)
+        return yield* statusError(response.request)(response)
      })
    return Service.of({
      execute: executeOnce,
@@ -19,8 +19,6 @@ import type { AIError } from "../schema/index.js"
 export interface Definition<Frame> {
  readonly id: string
  readonly frame: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<Frame, AIError>
-  /** Original wire representation when framing transforms the provider payload. */
-  readonly body?: (frame: Frame) => string | undefined
 }

 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
@@ -88,13 +88,8 @@ export const httpJson = <Body, Frame>(input: HttpJsonInput<Body, Frame>): HttpJs
      }
    }),
  execute: (prepared, _request, runtime) =>
-    Effect.gen(function* () {
-      const response = yield* runtime.http.execute(prepared.request, prepared.middleware)
-      return {
-        frames: prepared.framing.frame(RequestExecutor.responseStream(response)),
-        http: RequestExecutor.responseHttp(response),
-        body: prepared.framing.body,
-      }
+    Effect.succeed({
+      frames: prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
    }),
 })

@@ -3,7 +3,7 @@ import { Endpoint } from "../endpoint.js"
 import { Auth } from "../auth.js"
 import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor.js"
 import type { WebSocketChannelExecutor } from "./websocket-channel.js"
-import type { AIError, HttpContext, LLMRequest } from "../../schema/index.js"
+import type { AIError, LLMRequest } from "../../schema/index.js"

 export interface TransportRuntime {
  readonly http: RequestExecutorInterface
@@ -11,8 +11,6 @@ export interface TransportRuntime {

 export interface TransportExecution<Frame> {
  readonly frames: Stream.Stream<Frame, AIError>
-  readonly http?: HttpContext
-  body?(frame: Frame): string | undefined
  /** Optional successful-consumption acknowledgement. HTTP leaves this absent. */
  readonly complete?: Effect.Effect<void>
 }
@@ -1,6 +1,6 @@
 import type { Effect, Scope, Stream } from "effect"
 import type { Headers } from "effect/unstable/http"
-import type { AIError, HttpContext } from "../../schema/index.js"
+import type { AIError } from "../../schema/index.js"

 export interface WebSocketChannelExecutor {
  readonly execute: (
@@ -10,7 +10,6 @@ export interface WebSocketChannelExecutor {

 export interface WebSocketChannelExecution {
  readonly frames: Stream.Stream<string, AIError>
-  readonly http?: HttpContext
  /** Commits staged state after the decoded Route stream ends successfully. */
  readonly complete: Effect.Effect<void>
 }
@@ -1,13 +1,7 @@
 import { Cause, Effect, Queue, Stream } from "effect"
 import { Headers } from "effect/unstable/http"
 import { Socket } from "effect/unstable/socket"
-import {
-  AIError,
-  AIErrorReason,
-  TransportError,
-  type HttpContext,
-  type TransportOperation,
-} from "../../schema/index.js"
+import { AIError, TransportReason, type TransportOperation } from "../../schema/index.js"
 import * as HttpTransport from "./http.js"
 import type { Transport } from "./index.js"
 import type {
@@ -23,7 +17,6 @@ export interface WebSocketRequest {
 }

 export interface WebSocketConnection {
-  readonly http?: HttpContext
  readonly sendText: (message: string) => Effect.Effect<void, AIError>
  readonly messages: Stream.Stream<string | Uint8Array, AIError>
  readonly close: Effect.Effect<void, never>
@@ -40,22 +33,21 @@ type WebSocketConstructorWithHeaders = (

 const MAX_FRAME_BYTES = 16 * 1024 * 1024
 const transportError = (
+  method: string,
  message: string,
  input: {
    readonly operation: TransportOperation
    readonly url?: string
    readonly code?: string
-    readonly phase?: TransportError["phase"]
-    readonly delivery?: TransportError["delivery"]
-    readonly body?: string
-    readonly cause?: unknown
+    readonly phase?: TransportReason["phase"]
+    readonly delivery?: TransportReason["delivery"]
  },
 ) =>
  new AIError({
-    reason: new TransportError({
+    module: "WebSocketConnector",
+    method,
+    reason: new TransportReason({
      message,
-      body: input.body,
-      cause: input.cause,
      transport: "websocket",
      operation: input.operation,
      url: input.url,
@@ -67,16 +59,22 @@ const transportError = (

 const annotateTransportError = (
  error: AIError,
-  input: { readonly phase: TransportError["phase"]; readonly delivery: TransportError["delivery"] },
+  input: { readonly phase: TransportReason["phase"]; readonly delivery: TransportReason["delivery"] },
 ) =>
  error.reason._tag === "Transport"
    ? new AIError({
-        reason: new TransportError({
-          ...error.reason,
+        module: error.module,
+        method: error.method,
+        reason: new TransportReason({
          message: error.reason.message,
-          cause: error.reason.cause,
+          transport: error.reason.transport,
+          operation: error.reason.operation,
+          code: error.reason.code,
+          url: error.reason.url,
+          http: error.reason.http,
          phase: input.phase,
          delivery: input.delivery,
+          recovery: error.reason.recovery,
        }),
      })
    : error
@@ -97,7 +95,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
  if (ws.readyState === globalThis.WebSocket.OPEN) return Effect.void
  if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
    return Effect.fail(
-      transportError(`WebSocket closed before opening (state ${ws.readyState})`, {
+      transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
        url: input.url,
        operation: "request",
        code: "closed",
@@ -126,8 +124,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
      cleanup()
      resume(
        Effect.fail(
-          transportError(`Failed to open WebSocket: ${eventMessage(event)}`, {
-            cause: "error" in event ? (event.error ?? event) : event,
+          transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
            url: input.url,
            operation: "request",
            phase: "connect",
@@ -140,9 +137,7 @@ const waitOpen = (ws: globalThis.WebSocket, input: WebSocketRequest) => {
      cleanup()
      resume(
        Effect.fail(
-          transportError(`WebSocket closed before opening with code ${event.code}`, {
-            body: event.reason,
-            cause: event,
+          transportError("open", `WebSocket closed before opening with code ${event.code}`, {
            url: input.url,
            operation: "request",
            code: String(event.code),
@@ -174,8 +169,7 @@ export const toWebSocketUrl = (value: string) =>
      throw new Error(`Unsupported WebSocket URL protocol ${url.protocol}`)
    },
    catch: (error) =>
-      transportError(error instanceof Error ? error.message : "Invalid WebSocket URL", {
-        cause: error,
+      transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
        url: value,
        operation: "request",
        code: "invalid-url",
@@ -195,8 +189,7 @@ export const open = (input: WebSocketRequest) =>
          headers: input.headers,
        }),
      catch: (error) =>
-        transportError(error instanceof Error ? error.message : "Failed to construct WebSocket", {
-          cause: error,
+        transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
          url: input.url,
          operation: "request",
          phase: "connect",
@@ -221,8 +214,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("WebSocket message exceeds the 16 MiB limit", {
-            body: typeof message === "string" ? message : new TextDecoder().decode(message),
+          transportError("message", "WebSocket message exceeds the 16 MiB limit", {
            url: input.url,
            operation: "read",
            code: "message-too-large",
@@ -239,8 +231,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("WebSocket inbound queue overflow", {
-            body: typeof message === "string" ? message : new TextDecoder().decode(message),
+          transportError("message", "WebSocket inbound queue overflow", {
            url: input.url,
            operation: "read",
            code: "queue-overflow",
@@ -257,8 +248,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError("Unsupported WebSocket message payload", {
-            cause: event,
+          transportError("message", "Unsupported WebSocket message payload", {
            url: input.url,
            operation: "read",
            code: "message",
@@ -271,8 +261,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError(`WebSocket error: ${eventMessage(event)}`, {
-            cause: "error" in event ? (event.error ?? event) : event,
+          transportError("message", `WebSocket error: ${eventMessage(event)}`, {
            url: input.url,
            operation: "read",
            code: "message",
@@ -285,9 +274,7 @@ export const fromWebSocket = (
      Queue.failCauseUnsafe(
        messages,
        Cause.fail(
-          transportError(`WebSocket closed with code ${event.code}`, {
-            body: event.reason,
-            cause: event,
+          transportError("message", `WebSocket closed with code ${event.code}`, {
            url: input.url,
            operation: "read",
            code: String(event.code),
@@ -311,7 +298,7 @@ export const fromWebSocket = (
        Effect.suspend(() => {
          if (ws.readyState !== globalThis.WebSocket.OPEN)
            return Effect.fail(
-              transportError(`WebSocket is not open (state ${ws.readyState})`, {
+              transportError("sendText", `WebSocket is not open (state ${ws.readyState})`, {
                url: input.url,
                operation: "write",
                phase: "send",
@@ -321,8 +308,7 @@ export const fromWebSocket = (
          return Effect.try({
            try: () => ws.send(message),
            catch: (error) =>
-              transportError(error instanceof Error ? error.message : "Failed to send WebSocket message", {
-                cause: error,
+              transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
                url: input.url,
                operation: "write",
                phase: "send",
@@ -363,23 +349,10 @@ export const makeDirect = (connector: WebSocketConnector): WebSocketChannelExecu
        (connection) => connection.close,
      )
      const create = yield* exchange.driver.create(undefined)
-      yield* connection.sendText(create.message).pipe(
-        Effect.mapError(
-          (error) =>
-            new AIError({
-              reason: AIErrorReason.make({
-                ...error.reason,
-                message: error.reason.message,
-                cause: error.reason.cause,
-                http: error.reason.http ?? connection.http,
-              }),
-            }),
-        ),
-      )
+      yield* connection.sendText(create.message)
      const decoder = new TextDecoder()
      let observed = false
      return {
-        http: connection.http,
        frames: connection.messages.pipe(
          Stream.map((message) => {
            observed = true
@@ -391,49 +364,9 @@ export const makeDirect = (connector: WebSocketConnector): WebSocketChannelExecu
              delivery: observed ? "accepted" : "ambiguous",
            }),
          ),
-          Stream.mapEffect((frame) =>
-            exchange.driver.observe(create, frame).pipe(
-              Effect.mapError(
-                (error) =>
-                  new AIError({
-                    reason: AIErrorReason.make({
-                      ...error.reason,
-                      message: error.reason.message,
-                      cause: error.reason.cause,
-                      body: frame,
-                    }),
-                  }),
-              ),
-              Effect.map((observation) =>
-                "error" in observation
-                  ? {
-                      ...observation,
-                      error: new AIError({
-                        reason: AIErrorReason.make({
-                          ...observation.error.reason,
-                          message: observation.error.reason.message,
-                          cause: observation.error.reason.cause,
-                          body: frame,
-                        }),
-                      }),
-                    }
-                  : observation,
-              ),
-            ),
-          ),
+          Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
          Stream.takeUntil(observationTerminal),
          Stream.mapEffect(observationFrame),
-          Stream.mapError(
-            (error) =>
-              new AIError({
-                reason: AIErrorReason.make({
-                  ...error.reason,
-                  message: error.reason.message,
-                  cause: error.reason.cause,
-                  http: error.reason.http ?? connection.http,
-                }),
-              }),
-          ),
        ),
        complete: Effect.void,
      }
@@ -484,7 +417,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
    const webSocket = options?.webSocket
    if (!webSocket) {
      return Effect.fail(
-        transportError("WebSocket JSON transport requires StreamOptions.webSocket", {
+        transportError("json", "WebSocket JSON transport requires StreamOptions.webSocket", {
          url: prepared.url,
          operation: "request",
          code: "unavailable",
@@ -502,7 +435,7 @@ export const json = <Body, Message>(input: JsonInput<Body, Message>): JsonTransp
      connect: { url: prepared.url, headers: prepared.headers },
      fallback: () =>
        Stream.fail(
-          transportError("WebSocket JSON transport does not provide HTTP fallback", {
+          transportError("fallback", "WebSocket JSON transport does not provide HTTP fallback", {
            url: prepared.url,
            operation: "request",
            code: "websocket",
@@ -1,13 +1,19 @@
 import { Schema } from "effect"
 import { Tool } from "@opencode-ai/schema/tool"
 import { ModelID, ProviderID, RouteID } from "./ids.js"
+import { ProviderMetadata } from "./messages.js"

 export const ProviderFailureClassification = Schema.Literals(["context-overflow", "payload-too-large"])
 export type ProviderFailureClassification = typeof ProviderFailureClassification.Type

-export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
+export class HttpRequestDetails extends Schema.Class<HttpRequestDetails>("AI.HttpRequestDetails")({
+  method: Schema.String,
  url: Schema.String,
-  status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })),
+  headers: Schema.Record(Schema.String, Schema.String),
+}) {}
+
+export class HttpResponseDetails extends Schema.Class<HttpResponseDetails>("AI.HttpResponseDetails")({
+  status: Schema.Number,
  headers: Schema.Record(Schema.String, Schema.String),
 }) {}

@@ -18,61 +24,73 @@ export class HttpRateLimitDetails extends Schema.Class<HttpRateLimitDetails>("AI
  reset: Schema.optional(Schema.Record(Schema.String, Schema.String)),
 }) {}

-const ReasonFields = {
-  message: Schema.String,
-  // Preserve the complete original response or triggering event before decoding narrows it.
+export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
+  request: HttpRequestDetails,
+  response: Schema.optional(HttpResponseDetails),
  body: Schema.optional(Schema.String),
-  http: Schema.optional(HttpContext),
-  cause: Schema.optional(Schema.Defect({ includeStack: true })),
-}
-
-export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>("AI.Error.InvalidRequest")(
-  "InvalidRequest",
-  {
-    ...ReasonFields,
-    parameter: Schema.optional(Schema.String),
-    classification: Schema.optional(ProviderFailureClassification),
-  },
-) {}
-
-export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoRoute")("NoRoute", {
-  ...ReasonFields,
-  route: RouteID,
-  provider: ProviderID,
-  model: ModelID,
-}) {}
-
-export class AuthenticationError extends Schema.TaggedError<AuthenticationError>("AI.Error.Authentication")(
-  "Authentication",
-  {
-    ...ReasonFields,
-    kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-  },
-) {}
-
-export class RateLimitError extends Schema.TaggedError<RateLimitError>("AI.Error.RateLimit")("RateLimit", {
-  ...ReasonFields,
-  retryAfterMs: Schema.optional(Schema.Number),
+  bodyTruncated: Schema.optional(Schema.Boolean),
  rateLimit: Schema.optional(HttpRateLimitDetails),
 }) {}

-export class QuotaExceededError extends Schema.TaggedError<QuotaExceededError>("AI.Error.QuotaExceeded")(
-  "QuotaExceeded",
-  ReasonFields,
-) {}
+export class InvalidRequestReason extends Schema.Class<InvalidRequestReason>("AI.Error.InvalidRequest")({
+  _tag: Schema.tag("InvalidRequest"),
+  message: Schema.String,
+  parameter: Schema.optional(Schema.String),
+  classification: Schema.optional(ProviderFailureClassification),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}

-export class ContentPolicyError extends Schema.TaggedError<ContentPolicyError>("AI.Error.ContentPolicy")(
-  "ContentPolicy",
-  ReasonFields,
-) {}
+export class NoRouteReason extends Schema.Class<NoRouteReason>("AI.Error.NoRoute")({
+  _tag: Schema.tag("NoRoute"),
+  route: RouteID,
+  provider: ProviderID,
+  model: ModelID,
+}) {
+  get message() {
+    return `No AI route for ${this.provider}/${this.model} using ${this.route}`
+  }
+}

-export class ProviderInternalError extends Schema.TaggedError<ProviderInternalError>("AI.Error.ProviderInternal")(
-  "ProviderInternal",
-  {
-    ...ReasonFields,
-    retryAfterMs: Schema.optional(Schema.Number),
-  },
-) {}
+export class AuthenticationReason extends Schema.Class<AuthenticationReason>("AI.Error.Authentication")({
+  _tag: Schema.tag("Authentication"),
+  message: Schema.String,
+  kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class RateLimitReason extends Schema.Class<RateLimitReason>("AI.Error.RateLimit")({
+  _tag: Schema.tag("RateLimit"),
+  message: Schema.String,
+  retryAfterMs: Schema.optional(Schema.Number),
+  rateLimit: Schema.optional(HttpRateLimitDetails),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class QuotaExceededReason extends Schema.Class<QuotaExceededReason>("AI.Error.QuotaExceeded")({
+  _tag: Schema.tag("QuotaExceeded"),
+  message: Schema.String,
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class ContentPolicyReason extends Schema.Class<ContentPolicyReason>("AI.Error.ContentPolicy")({
+  _tag: Schema.tag("ContentPolicy"),
+  message: Schema.String,
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}
+
+export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>("AI.Error.ProviderInternal")({
+  _tag: Schema.tag("ProviderInternal"),
+  message: Schema.String,
+  status: Schema.optional(Schema.Number),
+  retryAfterMs: Schema.optional(Schema.Number),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}

 export const TransportType = Schema.Literals(["http", "websocket"])
 export type TransportType = typeof TransportType.Type
@@ -80,12 +98,14 @@ export type TransportType = typeof TransportType.Type
 export const TransportOperation = Schema.Literals(["request", "read", "write"])
 export type TransportOperation = typeof TransportOperation.Type

-export class TransportError extends Schema.TaggedError<TransportError>("AI.Error.Transport")("Transport", {
-  ...ReasonFields,
+export class TransportReason extends Schema.Class<TransportReason>("AI.Error.Transport")({
+  _tag: Schema.tag("Transport"),
+  message: Schema.String,
  transport: TransportType,
  operation: TransportOperation,
  code: Schema.optional(Schema.String),
  url: Schema.optional(Schema.String),
+  http: Schema.optional(HttpContext),
  phase: Schema.optional(
    Schema.Literals(["prepare", "queue", "connect", "send", "receive", "decode", "complete", "fallback", "close"]),
  ),
@@ -95,40 +115,51 @@ export class TransportError extends Schema.TaggedError<TransportError>("AI.Error
  ),
 }) {}

-export class InvalidProviderOutputError extends Schema.TaggedError<InvalidProviderOutputError>(
+export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOutputReason>(
  "AI.Error.InvalidProviderOutput",
-)("InvalidProviderOutput", {
-  ...ReasonFields,
+)({
+  _tag: Schema.tag("InvalidProviderOutput"),
+  message: Schema.String,
  classification: Schema.optional(Schema.Literals(["incomplete-stream"])),
  route: Schema.optional(Schema.String),
+  raw: Schema.optional(Schema.String),
+  providerMetadata: Schema.optional(ProviderMetadata),
 }) {}

-export class UnknownProviderError extends Schema.TaggedError<UnknownProviderError>("AI.Error.UnknownProvider")(
-  "UnknownProvider",
-  ReasonFields,
-) {}
+export class UnknownProviderReason extends Schema.Class<UnknownProviderReason>("AI.Error.UnknownProvider")({
+  _tag: Schema.tag("UnknownProvider"),
+  message: Schema.String,
+  status: Schema.optional(Schema.Number),
+  providerMetadata: Schema.optional(ProviderMetadata),
+  http: Schema.optional(HttpContext),
+}) {}

 export const AIErrorReason = Schema.Union([
-  InvalidRequestError,
-  NoRouteError,
-  AuthenticationError,
-  RateLimitError,
-  QuotaExceededError,
-  ContentPolicyError,
-  ProviderInternalError,
-  TransportError,
-  InvalidProviderOutputError,
-  UnknownProviderError,
+  InvalidRequestReason,
+  NoRouteReason,
+  AuthenticationReason,
+  RateLimitReason,
+  QuotaExceededReason,
+  ContentPolicyReason,
+  ProviderInternalReason,
+  TransportReason,
+  InvalidProviderOutputReason,
+  UnknownProviderReason,
 ]).pipe(Schema.toTaggedUnion("_tag"))
 export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>

 export class AIError extends Schema.TaggedError<AIError>()("AI.Error", {
+  module: Schema.String,
+  method: Schema.String,
  reason: AIErrorReason,
+  // Raw provider payload as a string, so classified failures never lose the
+  // original error detail even when the pretty message is a summary.
+  body: Schema.optional(Schema.String),
 }) {
  override readonly cause = this.reason

-  override get message(): string {
-    return this.reason.message
+  override get message() {
+    return `${this.module}.${this.method}: ${this.reason.message}`
  }
 }

@@ -115,6 +115,7 @@ export const mergeGenerationOptions = (...items: ReadonlyArray<GenerationOptions
 }

 export class LanguageModelDefaults extends Schema.Class<LanguageModelDefaults>("LLM.LanguageModelDefaults")({
+  promptCacheKey: Schema.optional(Schema.String),
  generation: Schema.optional(GenerationOptions),
  providerOptions: Schema.optional(ProviderOptions),
  http: Schema.optional(HttpOptions),
@@ -124,6 +125,7 @@ export namespace LanguageModelDefaults {
  export type Input =
    | LanguageModelDefaults
    | {
+        readonly promptCacheKey?: string
        readonly generation?: GenerationOptions.Input
        readonly providerOptions?: ProviderOptions
        readonly http?: HttpOptions.Input
@@ -133,6 +135,7 @@ export namespace LanguageModelDefaults {
  export const make = (input: Input) => {
    if (input instanceof LanguageModelDefaults) return input
    return new LanguageModelDefaults({
+      promptCacheKey: input.promptCacheKey,
      generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
      providerOptions: input.providerOptions,
      http: input.http === undefined ? undefined : HttpOptions.make(input.http),
@@ -1,8 +1,8 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Ref, Schema } from "effect"
 import { HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLM, Message, ToolCallPart, mergeProviderOptions } from "../src/index.js"
-import { AnthropicMessages, OpenAIChat } from "../src/protocols.js"
+import { LLM, LLMRequest, Message, ToolCallPart, mergeProviderOptions } from "../src/index.js"
+import { AnthropicMessages, OpenAIChat, OpenAIResponses } from "../src/protocols.js"
 import { Auth, LLMClient } from "../src/route.js"
 import { compileRequest } from "../src/route/client.js"
 import { it } from "./lib/effect.js"
@@ -14,6 +14,37 @@ const TargetJson = Schema.fromJsonString(Schema.Unknown)
 const decodeJson = Schema.decodeUnknownSync(TargetJson)

 describe("request option precedence", () => {
+  it.effect("resolves top-level prompt cache keys from request, model, and route defaults", () =>
+    Effect.gen(function* () {
+      for (const route of [OpenAIChat.route, OpenAIResponses.route]) {
+        for (const [routeKey, modelKey, requestKey, expected] of [
+          [undefined, undefined, undefined, undefined],
+          ["route", undefined, undefined, "route"],
+          ["route", "model", undefined, "model"],
+          ["route", "model", "request", "request"],
+          ["route", "", undefined, ""],
+          ["route", "model", "", ""],
+        ]) {
+          const model = route
+            .with({ auth: Auth.bearer("test"), promptCacheKey: routeKey })
+            .with({ headers: { "x-test": "value" }, promptCacheKey: undefined })
+            .model({ id: "gpt-4o-mini", defaults: { promptCacheKey: modelKey } })
+          const request = LLM.request({ model, prompt: "Hi", promptCacheKey: requestKey })
+          const prepared = yield* compileRequest(request)
+          const disabled = yield* compileRequest(LLMRequest.update(request, { cache: "none" }))
+
+          expect(model.route.defaults.promptCacheKey).toBe(routeKey)
+          expect(model.defaults?.promptCacheKey).toBe(modelKey)
+          if (expected) expect(prepared.body).toMatchObject({ prompt_cache_key: expected })
+          if (!expected) expect(prepared.body).not.toHaveProperty("prompt_cache_key")
+          expect(disabled.body).not.toHaveProperty("prompt_cache_key")
+          expect(request.promptCacheKey).toBe(requestKey)
+          expect(request.providerOptions).toBeUndefined()
+        }
+      }
+    }),
+  )
+
  test("deep-merges provider option records and replaces arrays, primitives, and null", () => {
    const merged = mergeProviderOptions(
      {
@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { Deferred, Effect, Fiber, Layer, Ref, Stream } from "effect"
 import { Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { LLM, AIError, HttpContext, InvalidProviderOutputError, TransportError } from "../src/index.js"
+import { LLM, AIError } from "../src/index.js"
 import { LLMClient, RequestExecutor, WebSocketTransport, type WebSocketChannelExecutor } from "../src/route.js"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAI from "../src/providers/openai.js"
@@ -62,85 +62,22 @@ const countedResponsesLayer = (attempts: Ref.Ref<number>, responses: ReadonlyArr
 const expectAIError = (error: unknown) => {
  expect(error).toBeInstanceOf(AIError)
  if (!(error instanceof AIError)) throw new Error("expected AIError")
-  expect(error.reason).toBeInstanceOf(Error)
-  expect(error.cause).toBe(error.reason)
  return error
 }

+const errorHttp = (error: AIError) => ("http" in error.reason ? error.reason.http : undefined)
 const largeProviderMessage = `Upstream request failed: ${"validation failed; ".repeat(1_000)}`

 describe("RequestExecutor", () => {
-  it.effect("preserves externally captured HTTP errors without inventing response context", () =>
-    Effect.sync(() => {
-      const cause = new Error("upstream request failed")
-      const body = '{"error":{"message":"Rate limited","trace":"original"}}'
-      const error = RequestExecutor.httpFailure({
-        message: "Rate limited",
-        url: request.url,
-        status: 429,
-        responseHeaders: { "Retry-After": "2", "X-Request-ID": "req_external" },
-        responseBody: body,
-        cause,
-      })
-
-      expect(error.message).toBe("Rate limited")
-      expect(error.reason).toMatchObject({ _tag: "RateLimit", retryAfterMs: 2000 })
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http).toEqual(
-        new HttpContext({
-          url: request.url,
-          status: 429,
-          headers: { "retry-after": "2", "x-request-id": "req_external" },
-        }),
-      )
-      expect(RequestExecutor.httpFailure({ message: "No response", url: request.url }).reason.http).toBeUndefined()
-      expect(RequestExecutor.httpFailure({ message: "No URL", status: 500 }).reason.http).toBeUndefined()
-    }),
-  )
-
-  it.effect("retains the original body-read failure on an HTTP status error", () =>
-    Effect.gen(function* () {
-      const cause = new Error("response body disconnected")
-      const error = yield* Effect.gen(function* () {
-        const executor = yield* RequestExecutor.Service
-        return yield* executor.execute(request).pipe(Effect.flip)
-      }).pipe(
-        Effect.provide(
-          responsesLayer([
-            new Response(
-              new ReadableStream({
-                start(controller) {
-                  controller.error(cause)
-                },
-              }),
-              {
-                status: 503,
-                headers: { "x-request-id": "req_failed_body" },
-              },
-            ),
-          ]),
-        ),
-      )
-
-      expect(error.reason._tag).toBe("ProviderInternal")
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.body).toBeUndefined()
-      expect(error.reason.http).toMatchObject({ status: 503, headers: { "x-request-id": "req_failed_body" } })
-    }),
-  )
-
  it.effect("parses response body failures at the executor seam", () =>
    Effect.gen(function* () {
      const executor = yield* RequestExecutor.Service
      const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)

      expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: disconnected query-secret-123 header-secret-456")
-      expect(error.reason.http).toMatchObject({ status: 200, url: secretRequest.url })
-      expect(error.reason.cause).toMatchObject({ code: "ECONNRESET" })
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: disconnected query-secret-123 header-secret-456",
        transport: "http",
        operation: "read",
        code: "ECONNRESET",
@@ -167,10 +104,9 @@ describe("RequestExecutor", () => {
      const error = yield* RequestExecutor.stream(executor, secretRequest).pipe(Stream.runDrain, Effect.flip)

      expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: socket closed")
-      expect(error.reason.cause).toBeInstanceOf(TypeError)
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: socket closed",
        operation: "read",
        code: "ECONNRESET",
      })
@@ -197,9 +133,7 @@ describe("RequestExecutor", () => {
        .pipe(Effect.flip)

      expectAIError(error)
-      expect(error.message).toBe("plugin rejected request")
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http).toBeUndefined()
+      expect(error.reason.message).toBe("plugin rejected request")
    }).pipe(Effect.provide(responsesLayer([]))),
  )

@@ -218,11 +152,16 @@ describe("RequestExecutor", () => {
        .pipe(Effect.flip)

      expectAIError(error)
-      expect(error.message).toBe("ECONNRESET: proxy disconnected proxy-secret")
-      expect(error.reason.http).toBeUndefined()
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: proxy disconnected proxy-secret",
        url: "https://proxy.test/v1/chat?api_key=proxy-secret",
+        http: {
+          request: {
+            url: "https://proxy.test/v1/chat?api_key=proxy-secret",
+            headers: { authorization: "Bearer proxy-secret" },
+          },
+        },
      })
    }).pipe(
      Effect.provide(
@@ -267,8 +206,8 @@ describe("RequestExecutor", () => {
      expect(error.reason).toMatchObject({
        _tag: "InvalidRequest",
        classification: "payload-too-large",
+        http: { response: { status: 413 } },
      })
-      expect(error.reason.http?.status).toBe(413)
    }).pipe(Effect.provide(responsesLayer([new Response("request too large", { status: 413 })]))),
  )

@@ -281,8 +220,8 @@ describe("RequestExecutor", () => {
      expect(error.reason).toMatchObject({
        _tag: "InvalidRequest",
        classification: "context-overflow",
+        http: { response: { status: 413 } },
      })
-      expect(error.reason.http?.status).toBe(413)
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -302,7 +241,7 @@ describe("RequestExecutor", () => {
      expectAIError(error)
      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
      expect("classification" in error.reason ? error.reason.classification : undefined).toBeUndefined()
-      expect(error.message).toBe("Provider request failed with HTTP 400")
+      expect(error.reason.message).toBe("Provider request failed with HTTP 400")
    }).pipe(Effect.provide(responsesLayer([new Response("invalid parameter", { status: 400 })]))),
  )

@@ -312,9 +251,9 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toBe(largeProviderMessage)
-      expect(error.reason.body).toContain(largeProviderMessage)
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: largeProviderMessage })
+      expect(errorHttp(error)?.body).toContain(largeProviderMessage)
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -338,8 +277,8 @@ describe("RequestExecutor", () => {
      expectAIError(error)
      expect(error.reason).toMatchObject({
        _tag: "InvalidRequest",
+        message: "Provider request failed with HTTP 400",
      })
-      expect(error.message).toBe("Provider request failed with HTTP 400")
    }).pipe(Effect.provide(responsesLayer([new Response('{"error":{"message":"  "}}', { status: 400 })]))),
  )

@@ -382,21 +321,29 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason).toMatchObject({
-        _tag: "RateLimit",
-        retryAfterMs: 0,
-        rateLimit: { retryAfterMs: 0 },
-        http: {
-          url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
-          status: 429,
-          headers: {
-            "retry-after-ms": "0",
-            "x-request-id": "req_123",
-            "x-api-key": "secret",
+      expect(error).toMatchObject({
+        reason: {
+          _tag: "RateLimit",
+          retryAfterMs: 0,
+          rateLimit: { retryAfterMs: 0 },
+          http: {
+            request: {
+              method: "POST",
+              url: "https://provider.test/v1/chat?api_key=secret&key=secret&debug=1",
+              headers: { authorization: "Bearer secret", "x-safe": "visible" },
+            },
+            response: {
+              status: 429,
+              headers: {
+                "retry-after-ms": "0",
+                "x-request-id": "req_123",
+                "x-api-key": "secret",
+              },
+            },
          },
        },
      })
-      expect(error.reason.body).toBe("rate limited")
+      expect(errorHttp(error)?.body).toBe("rate limited")
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -415,7 +362,8 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason.http?.headers["x-safe"]).toBe("response-secret")
+      expect(errorHttp(error)?.request.headers["x-safe"]).toBe("visible")
+      expect(errorHttp(error)?.response?.headers["x-safe"]).toBe("response-secret")
    }).pipe(
      Effect.provide(responsesLayer([new Response("bad", { status: 400, headers: { "x-safe": "response-secret" } })])),
      Effect.provideService(Headers.CurrentRedactedNames, ["x-safe"]),
@@ -461,8 +409,8 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "RateLimit" })
-      expect(error.reason._tag === "RateLimit" ? error.reason.rateLimit : undefined).toEqual({
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
+      expect(errorHttp(error)?.rateLimit).toEqual({
        retryAfterMs: 0,
        limit: { requests: "100", "input-tokens": "10000" },
        remaining: { requests: "12", "input-tokens": "9000" },
@@ -471,8 +419,8 @@ describe("RequestExecutor", () => {
    }).pipe(
      Effect.provide(
        responsesLayer([
-          new Response("rate limited", {
-            status: 429,
+          new Response("overloaded", {
+            status: 529,
            headers: {
              "retry-after-ms": "0",
              "anthropic-ratelimit-requests-limit": "100",
@@ -504,8 +452,7 @@ describe("RequestExecutor", () => {
      )

      expectAIError(error)
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(error.reason.http?.status).toBe(503)
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status: 503 })
      expect(yield* Ref.get(attempts)).toBe(1)
    }),
  )
@@ -518,8 +465,7 @@ describe("RequestExecutor", () => {
          const error = yield* executor.execute(request).pipe(Effect.flip)

          expectAIError(error)
-          expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-          expect(error.reason.http?.status).toBe(status)
+          expect(error.reason).toMatchObject({ _tag: "ProviderInternal", status })
        }).pipe(
          Effect.provide(
            responsesLayer([
@@ -543,7 +489,8 @@ describe("RequestExecutor", () => {

      expectAIError(error)
      expect(error.reason).toMatchObject({ _tag: "Authentication" })
-      expect(error.reason.body).toHaveLength(20_000)
+      expect(errorHttp(error)?.bodyTruncated).toBeUndefined()
+      expect(errorHttp(error)?.body).toHaveLength(20_000)
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -560,7 +507,9 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(request).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason.body).toBe('{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}')
+      expect(errorHttp(error)?.body).toBe(
+        '{"error":{"message":"bad","key":"body-secret","detail":"api_key=query-secret"}}',
+      )
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -578,7 +527,7 @@ describe("RequestExecutor", () => {
      const error = yield* executor.execute(secretRequest).pipe(Effect.flip)

      expectAIError(error)
-      expect(error.reason.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
+      expect(errorHttp(error)?.body).toBe("provider echoed query-secret-123 and authorization header-secret-456")
    }).pipe(
      Effect.provide(
        responsesLayer([
@@ -615,9 +564,6 @@ describe("RequestExecutor", () => {

      expectAIError(error)
      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput" })
-      expect(error.reason.body).toBe("not-json")
-      expect(error.reason.cause).toBeDefined()
-      expect(error.reason.http).toMatchObject({ status: 200, headers: { "content-type": "text/event-stream" } })
      expect(yield* Ref.get(attempts)).toBe(1)
    }),
  )
@@ -631,154 +577,6 @@ describe("WebSocket channel execution", () => {
    JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }),
  ]

-  it.effect("preserves close reasons and native event causes without fabricated HTTP metadata", () =>
-    Effect.gen(function* () {
-      class TestSocket extends EventTarget {
-        readyState = globalThis.WebSocket.OPEN
-        send() {}
-        close() {}
-      }
-      const socket = new TestSocket()
-      const connection = yield* WebSocketTransport.fromWebSocket(
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        socket as unknown as globalThis.WebSocket,
-        { url: "wss://provider.test/responses", headers: Headers.empty },
-      )
-      const event = new CloseEvent("close", { code: 1011, reason: "upstream trace: req_close" })
-      socket.dispatchEvent(event)
-      const error = yield* connection.messages.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "Transport", code: "1011", phase: "close" })
-      expect(error.message).toBe("WebSocket closed with code 1011")
-      expect(error.reason.body).toBe(event.reason)
-      expect(error.reason.cause).toBe(event)
-      expect(error.reason.http).toBeUndefined()
-      yield* connection.close
-    }),
-  )
-
-  it.effect("preserves opening event errors and native send exceptions", () =>
-    Effect.gen(function* () {
-      const cause = new Error("native send failed")
-      class TestSocket extends EventTarget {
-        readyState = globalThis.WebSocket.CONNECTING
-        send() {
-          throw cause
-        }
-        close() {}
-      }
-      const socket = new TestSocket()
-      const open = WebSocketTransport.fromWebSocket(
-        // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion
-        socket as unknown as globalThis.WebSocket,
-        { url: "wss://provider.test/responses", headers: Headers.empty },
-      )
-      const fiber = yield* open.pipe(Effect.flip, Effect.forkChild({ startImmediately: true }))
-      const event = new ErrorEvent("error", { message: "handshake rejected", error: cause })
-      socket.dispatchEvent(event)
-      const error = yield* Fiber.join(fiber)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.message).toContain("handshake rejected")
-      expect(error.reason.http).toBeUndefined()
-
-      socket.readyState = globalThis.WebSocket.OPEN
-      const connection = yield* open
-      const sent = yield* connection.sendText("create").pipe(Effect.flip)
-      expect(sent.reason.cause).toBe(cause)
-      expect(sent.message).toBe(cause.message)
-      yield* connection.close
-    }),
-  )
-
-  it.effect("preserves raw driver failures and known upgrade metadata", () =>
-    Effect.gen(function* () {
-      const cause = new Error("driver validation failed")
-      const frame = '{ "error": "failed", "trace": "original" }'
-      const http = new HttpContext({
-        url: "https://provider.test/responses",
-        status: 101,
-        headers: { upgrade: "websocket" },
-      })
-      const executor = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            http,
-            sendText: () => Effect.void,
-            messages: Stream.make(frame),
-            close: Effect.void,
-          }),
-      })
-      const execution = yield* executor.execute({
-        id: "exchange_error",
-        connect: { url: "wss://provider.test/responses", headers: Headers.empty },
-        fallback: () => Stream.empty,
-        driver: {
-          create: () => Effect.succeed({ message: "create", mode: "full" }),
-          observe: () =>
-            Effect.succeed({
-              type: "provider-failure",
-              error: new AIError({
-                reason: new InvalidProviderOutputError({
-                  message: "Driver failed",
-                  cause,
-                  body: "narrowed",
-                }),
-              }),
-            }),
-        },
-      })
-      const error = yield* execution.frames.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.message).toBe("Driver failed")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http).toBe(http)
-      expect(execution.http).toBe(http)
-    }),
-  )
-
-  it.effect("retains diagnostic fields when annotating transport delivery", () =>
-    Effect.gen(function* () {
-      const cause = new Error("connection closed")
-      const executor = WebSocketTransport.makeDirect({
-        open: () =>
-          Effect.succeed({
-            sendText: () => Effect.void,
-            messages: Stream.fail(
-              new AIError({
-                reason: new TransportError({
-                  message: "Socket closed",
-                  transport: "websocket",
-                  operation: "read",
-                  phase: "close",
-                  recovery: "retry-full",
-                  body: "server close detail",
-                  cause,
-                }),
-              }),
-            ),
-            close: Effect.void,
-          }),
-      })
-      const execution = yield* executor.execute({
-        id: "exchange_closed",
-        connect: { url: "wss://provider.test/responses", headers: Headers.empty },
-        fallback: () => Stream.empty,
-        driver: {
-          create: () => Effect.succeed({ message: "create", mode: "full" }),
-          observe: (_create, frame) => Effect.succeed({ type: "frame", frame }),
-        },
-      })
-      const error = yield* execution.frames.pipe(Stream.runDrain, Effect.flip)
-
-      expect(error.message).toBe("Socket closed")
-      expect(error.reason.body).toBe("server close detail")
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason).toMatchObject({ phase: "close", delivery: "ambiguous", recovery: "retry-full" })
-      expect(error.reason.http).toBeUndefined()
-    }),
-  )
-
  it.effect("runs a channel driver through the direct executor", () =>
    Effect.gen(function* () {
      const sent = yield* Ref.make("")
@@ -7,37 +7,6 @@ import { it } from "./lib/effect.js"
 import { dynamicResponse } from "./lib/http.js"

 describe("Image", () => {
-  for (const provider of [OpenAI, Google, XAI, ZAI]) {
-    const model = provider.configure({ apiKey: "test", baseURL: "https://image.test" }).image("image-model")
-    for (const body of ['{"data":42,"candidates":42,"opaque":{"nested":[1,2]},"trace":"outer"}', '{"invalid":']) {
-      it.effect(`retains ${model.provider} image response body and decode cause: ${body}`, () =>
-        Effect.gen(function* () {
-          const error = yield* Image.generate({ model, prompt: "hello" }).pipe(Effect.flip)
-          expect(error.reason._tag).toBe("InvalidProviderOutput")
-          expect(error.message).toContain("invalid response")
-          expect(error.reason.body).toBe(body)
-          expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-image-trace": "trace-1" } })
-          expect(error.reason.http?.url).toStartWith("https://image.test/")
-          expect(error.reason.cause).toBeInstanceOf(Error)
-        }).pipe(
-          Effect.provide(
-            ImageClient.layer.pipe(
-              Layer.provide(
-                dynamicResponse((input) =>
-                  Effect.succeed(
-                    input.respond(body, {
-                      headers: { "content-type": "application/json", "x-image-trace": "trace-1" },
-                    }),
-                  ),
-                ),
-              ),
-            ),
-          ),
-        ),
-      )
-    }
-  }
-
  it.effect("generates images through the OpenAI Images API", () =>
    Effect.gen(function* () {
      const response = yield* Image.generate({
@@ -561,17 +530,22 @@ describe("Image", () => {
        Effect.sync(() => {
          expect(error.reason._tag).toBe("InvalidProviderOutput")
          if (error.reason._tag !== "InvalidProviderOutput") return
-          expect(error.message).toContain("finish reasons: IMAGE_SAFETY")
-          expect(JSON.parse(error.reason.body ?? "")).toEqual({
-            promptFeedback: { blockReason: "SAFETY" },
-            candidates: [
-              {
-                finishReason: "IMAGE_SAFETY",
-                finishMessage: "The generated image was blocked by safety filters.",
-                safetyRatings: [{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", blocked: true }],
-                content: { parts: [{ text: "blocked", thought: false }] },
-              },
-            ],
+          expect(error.reason.message).toContain("finish reasons: IMAGE_SAFETY")
+          expect(error.reason.providerMetadata).toEqual({
+            google: {
+              promptFeedback: { blockReason: "SAFETY" },
+              candidates: [
+                {
+                  index: 0,
+                  finishReason: "IMAGE_SAFETY",
+                  finishMessage: "The generated image was blocked by safety filters.",
+                  safetyRatings: [{ category: "HARM_CATEGORY_DANGEROUS_CONTENT", blocked: true }],
+                  citationMetadata: undefined,
+                  groundingMetadata: undefined,
+                  parts: [{ type: "text", text: "blocked", thought: false, thoughtSignature: undefined }],
+                },
+              ],
+            },
          })
        }),
      ),
@@ -121,6 +121,7 @@ describe("llm constructors", () => {
    const model = chatRoute.model({
      id: "kimi-k2",
      defaults: {
+        promptCacheKey: "model-cache",
        generation: { maxTokens: 1_024, stop: ["END"] },
        providerOptions: { parallelToolCalls: false },
        http: { body: { extra_body: true } },
@@ -129,6 +130,8 @@ describe("llm constructors", () => {
    })
    const request = LLM.request({ model, prompt: "Say hello." })

+    expect(request.model.defaults?.promptCacheKey).toBe("model-cache")
+    expect(request.promptCacheKey).toBeUndefined()
    expect(request.model.defaults?.generation).toEqual({ maxTokens: 1_024, stop: ["END"] })
    expect(request.model.defaults?.providerOptions).toEqual({ parallelToolCalls: false })
    expect(request.model.defaults?.http).toEqual({ body: { extra_body: true } })
@@ -111,39 +111,6 @@ describe("provider error classification", () => {
 })

 describe("provider error rawBody classification", () => {
-  test("classifies provider envelopes without separate code inputs", () => {
-    const cases = [
-      ['{"type":"error","error":{"type":"overloaded_error","message":"Try again"}}', "ProviderInternal"],
-      ['{"error":{"code":"insufficient_quota","message":"Request failed"}}', "QuotaExceeded"],
-      [
-        '{"type":"response.failed","response":{"error":{"code":"authentication_error","message":"Denied"}}}',
-        "Authentication",
-      ],
-      ['{"error":{"code":429,"status":"RESOURCE_EXHAUSTED","message":"Try again"}}', "ProviderInternal"],
-      ['{"exception":{"type":"throttlingException","details":{"message":"Try again"}}}', "RateLimit"],
-    ] as const
-    for (const [rawBody, expected] of cases) {
-      const reason = classifyProviderFailure({ message: "Request failed", rawBody })
-      expect(reason._tag).toBe(expected)
-      expect(reason.body).toBe(rawBody)
-      expect(reason).not.toHaveProperty("code")
-    }
-  })
-
-  test("classifies separately supplied SDK data without replacing the response body", () => {
-    const data = { error: { code: "authentication_error" } }
-    for (const value of [data, JSON.stringify(data)]) {
-      const reason = classifyProviderFailure({
-        message: "Request failed",
-        status: 400,
-        rawBody: '{"message":"Request failed"}',
-        data: value,
-      })
-      expect(reason._tag).toBe("Authentication")
-      expect(reason.body).toBe('{"message":"Request failed"}')
-    }
-  })
-
  test("classifies overflow signals buried in the raw payload when the summary is vague", () => {
    const reason = classifyProviderFailure({
      message: "Request failed",
@@ -39,7 +39,7 @@ describe("Anthropic Messages sad-path recorded", () => {

      expect(error).toBeInstanceOf(AIError)
      expect(error.reason).toMatchObject({ _tag: "InvalidRequest" })
-      expect(error.message).toContain("`tool_use` ids were found without `tool_result` blocks")
+      expect(error.reason.message).toContain("`tool_use` ids were found without `tool_result` blocks")
    }),
  )
 })
@@ -966,8 +966,9 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput", classification: "incomplete-stream" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
        message: "The provider response ended unexpectedly.",
      })
    }),
@@ -1056,8 +1057,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1078,8 +1079,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1105,8 +1106,8 @@ describe("Anthropic Messages route", () => {
            Effect.flip,
          )

-          expect(error).toMatchObject({
-            reason: { _tag: "InvalidProviderOutput" },
+          expect(error.reason).toMatchObject({
+            _tag: "InvalidProviderOutput",
            message: "Invalid anthropic/anthropic-messages stream event",
          })
        }),
@@ -1121,8 +1122,8 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "Invalid anthropic/anthropic-messages stream event",
      })
    }),
@@ -1644,7 +1645,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "overloaded_error: Overloaded" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error: Overloaded" })
    }),
  )

@@ -1662,9 +1663,10 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "invalid_request_error: prompt is too long: 210000 tokens",
+        classification: "context-overflow",
      })
    }),
  )
@@ -1676,7 +1678,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "overloaded_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error" })
    }),
  )

@@ -1687,7 +1689,7 @@ describe("Anthropic Messages route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "Anthropic Messages stream error" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Anthropic Messages stream error" })
    }),
  )

@@ -1704,7 +1706,7 @@ describe("Anthropic Messages route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )

@@ -789,32 +789,19 @@ describe("Bedrock Converse route", () => {
      ])
      const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "A future provider failure" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "A future provider failure" })
    }),
  )

  it.effect("classifies throttlingException as a rate limit", () =>
    Effect.gen(function* () {
-      const payload = { message: "Slow down", details: { opaque: [1, 2] }, trace: "outer", p: "padding" }
      const body = concat([
        eventFrame("messageStart", { role: "assistant" }),
-        exceptionFrame("throttlingException", payload),
+        exceptionFrame("throttlingException", { message: "Slow down" }),
      ])
      const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)

-      expect(error).toMatchObject({ reason: { _tag: "RateLimit" }, message: "Slow down" })
-      expect(JSON.parse(error.reason.body ?? "")).toEqual({
-        headers: {
-          ":message-type": { type: "string", value: "exception" },
-          ":exception-type": { type: "string", value: "throttlingException" },
-          ":content-type": { type: "string", value: "application/json" },
-        },
-        body: JSON.stringify(payload),
-      })
-      expect(error.reason.http).toMatchObject({
-        status: 200,
-        headers: { "content-type": "application/vnd.amazon.eventstream" },
-      })
+      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
    }),
  )

@@ -827,9 +814,10 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "Input is too long for requested model",
+        classification: "context-overflow",
      })
    }),
  )
@@ -848,7 +836,7 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "Upstream model failed" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Upstream model failed" })
    }),
  )

@@ -859,32 +847,10 @@ describe("Bedrock Converse route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
        message: "BadStream: Stream failed",
      })
-      expect(JSON.parse(error.reason.body ?? "")).toMatchObject({
-        headers: { ":error-code": { value: "BadStream" } },
-        body: "",
-      })
-    }),
-  )
-
-  it.effect("retains malformed AWS payloads with headers and decode cause", () =>
-    Effect.gen(function* () {
-      const headers = {
-        ":message-type": { type: "string" as const, value: "event" },
-        ":event-type": { type: "string" as const, value: "messageStart" },
-      }
-      const body = '{"malformed":'
-      const error = yield* LLMClient.generate(baseRequest).pipe(
-        Effect.provide(fixedBytes(codec.encode({ headers, body: utf8Encoder.encode(body) }))),
-        Effect.flip,
-      )
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(JSON.parse(error.reason.body ?? "")).toEqual({ headers, body })
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http?.status).toBe(200)
    }),
  )

@@ -3,7 +3,6 @@ import { Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message } from "../../src/index.js"
 import { AmazonBedrockMantle } from "../../src/providers.js"
-import { model } from "../../src/providers/amazon-bedrock/mantle.js"
 import { OpenAIResponses } from "../../src/protocols/openai-responses.js"
 import { compileRequest, LLMClient } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
@@ -18,16 +17,13 @@ const credentials = {
 }

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

      expect(chat).toMatchObject({
@@ -41,7 +37,7 @@ describe("Amazon Bedrock Mantle provider", () => {
        body: { model: "openai.gpt-oss-120b", store: false },
      })
      expect(provider.model("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
-      expect(provider.chat("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
+      expect(provider.responses("openai.gpt-oss-120b").route.providerMetadataKey).toBe("mantle")
    }),
  )

@@ -1,102 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM } from "../../src/index.js"
-import { Anthropic, Google, OpenAI } from "../../src/providers.js"
-import { LLMClient } from "../../src/route.js"
-import { it } from "../lib/effect.js"
-import { fixedResponse } from "../lib/http.js"
-import { sseEvents } from "../lib/sse.js"
-
-describe("provider error retention", () => {
-  const options = { apiKey: "test", baseURL: "https://provider.test" }
-  const cases = [
-    {
-      name: "Anthropic",
-      model: Anthropic.configure(options).model("claude"),
-      event: { type: "error", error: { type: "rate_limit_error", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-    {
-      name: "OpenAI Chat",
-      model: OpenAI.configure(options).chat("gpt"),
-      event: { error: { code: "rate_limit_exceeded", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-    {
-      name: "OpenAI Responses",
-      model: OpenAI.configure(options).responses("gpt"),
-      event: {
-        type: "response.failed",
-        response: {
-          id: "resp_error",
-          error: { code: "rate_limit_exceeded", message: "Slow down", details: { opaque: [1, 2] } },
-          opaque: { upstream: true },
-        },
-      },
-    },
-    {
-      name: "Gemini",
-      model: Google.configure(options).model("gemini"),
-      event: { error: { code: 429, status: "RESOURCE_EXHAUSTED", message: "Slow down", details: { opaque: [1, 2] } } },
-    },
-  ]
-
-  for (const entry of cases) {
-    it.effect(`retains the complete ${entry.name} event and HTTP context`, () =>
-      Effect.gen(function* () {
-        const body = JSON.stringify({ ...entry.event, trace: { opaque: "outer" } })
-        const error = yield* LLMClient.generate(LLM.request({ model: entry.model, prompt: "hello" })).pipe(
-          Effect.provide(
-            fixedResponse(sseEvents(body), {
-              headers: { "content-type": "text/event-stream", "x-provider-trace": "trace-1" },
-            }),
-          ),
-          Effect.flip,
-        )
-        expect(error.message).toContain("Slow down")
-        expect(error.reason._tag).toBe(entry.name === "Gemini" ? "ProviderInternal" : "RateLimit")
-        expect(error.reason.body).toBe(body)
-        expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-provider-trace": "trace-1" } })
-        expect(error.reason.http?.url).toStartWith("https://provider.test/")
-        expect(error.reason.cause).toBeUndefined()
-        expect(error.cause).toBe(error.reason)
-      }),
-    )
-  }
-
-  it.effect("retains malformed provider frames and the original decode cause", () =>
-    Effect.gen(function* () {
-      const body = '{"type":"error","error":{"message":42,"opaque":{"nested":true}},"trace":"outer"}'
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: Anthropic.configure(options).model("claude"), prompt: "hello" }),
-      ).pipe(Effect.provide(fixedResponse(sseEvents(body))), Effect.flip)
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http?.status).toBe(200)
-    }),
-  )
-
-  it.effect("retains the HTTP response context when a channel falls back", () =>
-    Effect.gen(function* () {
-      const body = '{"type":"error","error":{"code":"rate_limit_exceeded","message":"Slow down","extra":42}}'
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: OpenAI.configure(options).responses("gpt"), prompt: "hello" }),
-        {
-          webSocket: {
-            execute: (exchange) => Effect.succeed({ frames: exchange.fallback(), complete: Effect.void }),
-          },
-        },
-      ).pipe(
-        Effect.provide(fixedResponse(sseEvents(body), { headers: { "x-provider-trace": "fallback-1" } })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("RateLimit")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.http).toMatchObject({
-        url: "https://provider.test/responses",
-        status: 200,
-        headers: { "x-provider-trace": "fallback-1" },
-      })
-    }),
-  )
-})
@@ -1457,7 +1457,7 @@ describe("OpenAI Chat route", () => {
      expect(error.message).toContain("OpenAI Chat tool call delta is missing id or name")
      expect(error.reason._tag).toBe("InvalidProviderOutput")
      if (error.reason._tag !== "InvalidProviderOutput") return
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.reason.raw ?? "")).toMatchObject({
        choices: [{ finish_reason: "tool_calls" }],
      })
    }),
@@ -1534,9 +1534,9 @@ describe("OpenAI Chat route", () => {
      )

      expect((yield* Ref.get(events)).some((event) => event.type === "text-delta")).toBeTrue()
-      expect(error.message).toBe("ECONNRESET: socket closed unexpectedly")
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: socket closed unexpectedly",
        transport: "http",
        operation: "read",
        code: "ECONNRESET",
@@ -1552,9 +1552,9 @@ describe("OpenAI Chat route", () => {
        Effect.flip,
      )

-      expect(error.message).toBe("ECONNRESET: socket closed before output")
      expect(error.reason).toMatchObject({
        _tag: "Transport",
+        message: "ECONNRESET: socket closed before output",
        transport: "http",
        operation: "read",
        code: "ECONNRESET",
@@ -1575,7 +1575,7 @@ describe("OpenAI Chat route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )

@@ -489,8 +489,9 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidProviderOutput", classification: "incomplete-stream" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidProviderOutput",
+        classification: "incomplete-stream",
        message: "OpenAI Chat stream ended without finish_reason",
      })
    }),
@@ -526,11 +527,11 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "ProviderInternal" },
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
        message: "Provider reported a network error (finish_reason: network_error)",
      })
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.body ?? "")).toMatchObject({
        id: "chatcmpl_fixture",
        choices: [{ finish_reason: "network_error" }],
      })
@@ -539,8 +540,8 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.provide(fixedResponse(sseEvents(deltaChunk({}, "error")))),
        Effect.flip,
      )
-      expect(generic).toMatchObject({
-        reason: { _tag: "UnknownProvider" },
+      expect(generic.reason).toMatchObject({
+        _tag: "UnknownProvider",
        message: "Provider reported an error (finish_reason: error)",
      })
    }),
@@ -561,8 +562,8 @@ describe("OpenAI-compatible Chat route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "Provider disconnected" })
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "Provider disconnected", status: 502 })
+      expect(decodeJson(error.body ?? "")).toMatchObject({
        id: "chatcmpl_error",
        error: { code: 502, message: "Provider disconnected", details: { upstream: "vendor" } },
        trace_id: "trace_1",
@@ -602,7 +603,7 @@ describe("OpenAI-compatible Chat route", () => {
      expect(error.message).toContain("OpenAI Chat received content after the finish reason")
      expect(error.reason._tag).toBe("InvalidProviderOutput")
      if (error.reason._tag !== "InvalidProviderOutput") return
-      expect(decodeJson(error.reason.body ?? "")).toMatchObject({
+      expect(decodeJson(error.reason.raw ?? "")).toMatchObject({
        choices: [{ delta: { tool_calls: [{ id: "call_1" }] } }],
      })
    }),
@@ -4,7 +4,6 @@ import { Headers, HttpClientRequest } from "effect/unstable/http"
 import {
  LLM,
  AIError,
-  HttpContext,
  HttpOptions,
  LLMEvent,
  LLMRequest,
@@ -13,7 +12,7 @@ import {
  ToolCallPart,
  ToolDefinition,
  ToolResultPart,
-  TransportError,
+  TransportReason,
  Usage,
 } from "../../src/index.js"
 import {
@@ -53,11 +52,10 @@ const baseChannelDriver = (message: string): WebSocketChannelDriver => ({
      return Effect.succeed({
        type: "provider-failure",
        error: new AIError({
-          reason: new TransportError({
+          module: "test",
+          method: "stream",
+          reason: new TransportReason({
            message: "provider rejected request",
-            body: frame,
-            cause: new Error("provider cause"),
-            http: new HttpContext({ url: "https://provider.test", status: 200, headers: { "x-trace": "trace-1" } }),
            transport: "websocket",
            operation: "read",
            phase: "receive",
@@ -746,18 +744,6 @@ describe("OpenAI Responses route", () => {
          reason: { _tag: "Transport", delivery: "rejected", recovery: "rotate-and-retry-full" },
        },
      })
-      for (const observation of [missing, limit]) {
-        expect(observation.type).toBe("rejected")
-        if (observation.type !== "rejected") continue
-        expect(observation.error.message).toBe("provider rejected request")
-        expect(observation.error.reason.cause).toBeInstanceOf(Error)
-        expect(observation.error.reason.cause).toMatchObject({ message: "provider cause" })
-        expect(observation.error.reason.http).toMatchObject({ status: 200, headers: { "x-trace": "trace-1" } })
-        expect(ProviderShared.decodeJson(observation.error.reason.body ?? "")).toMatchObject({
-          type: "error",
-          error: { code: expect.any(String) },
-        })
-      }
    }),
  )

@@ -1124,7 +1110,9 @@ describe("OpenAI Responses route", () => {
  it.effect("marks post-send WebSocket failures with delivery state", () =>
    Effect.gen(function* () {
      const failure = new AIError({
-        reason: new TransportError({
+        module: "test",
+        method: "receive",
+        reason: new TransportReason({
          message: "socket closed",
          transport: "websocket",
          operation: "read",
@@ -4447,7 +4435,7 @@ describe("OpenAI Responses route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "RateLimit" }, message: "rate_limit_exceeded: Slow down" })
+      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "rate_limit_exceeded: Slow down" })
    }),
  )

@@ -4458,7 +4446,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "internal_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
    }),
  )

@@ -4469,7 +4457,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "ProviderInternal" }, message: "internal_error" })
+      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "internal_error" })
    }),
  )

@@ -4494,8 +4482,8 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "ProviderInternal" },
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
        message: "server_error: Upstream model unavailable",
      })
    }),
@@ -4515,7 +4503,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "invalid_prompt" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "invalid_prompt" })
    }),
  )

@@ -4538,9 +4526,10 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "context_length_exceeded: prompt too long",
+        classification: "context-overflow",
      })
    }),
  )
@@ -4565,9 +4554,10 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({
-        reason: { _tag: "InvalidRequest", classification: "context-overflow" },
+      expect(error.reason).toMatchObject({
+        _tag: "InvalidRequest",
        message: "context_length_exceeded: prompt too long",
+        classification: "context-overflow",
      })
    }),
  )
@@ -4589,7 +4579,7 @@ describe("OpenAI Responses route", () => {
        Effect.flip,
      )

-      expect(error).toMatchObject({ reason: { _tag: "UnknownProvider" }, message: "Something went wrong" })
+      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Something went wrong" })
    }),
  )

@@ -4601,8 +4591,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.message).toContain('"error":null')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"error":null')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4614,8 +4604,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(error.message).toContain('"type":"error"')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"type":"error"')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4627,8 +4617,8 @@ describe("OpenAI Responses route", () => {
      )

      expect(error.reason).toMatchObject({ _tag: "UnknownProvider" })
-      expect(error.message).toContain('"resp_failed_3"')
-      expect(error.reason.body).toBe(error.message)
+      expect(error.reason.message).toContain('"resp_failed_3"')
+      expect(error.body).toBe(error.reason.message)
    }),
  )

@@ -4645,7 +4635,7 @@ describe("OpenAI Responses route", () => {
      )

      expect(error).toBeInstanceOf(AIError)
-      expect(error).toMatchObject({ reason: { _tag: "InvalidRequest" }, message: "Bad request" })
+      expect(error.reason).toMatchObject({ _tag: "InvalidRequest", message: "Bad request" })
    }),
  )
 })
@@ -1,12 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { Effect, Schema, Stream } from "effect"
 import * as OpenAIChat from "../src/protocols/openai-chat.js"
-import { AIError, HttpContext, InvalidProviderOutputError, LLM } from "../src/index.js"
-import { Anthropic } from "../src/providers.js"
-import { Auth, Framing, HttpTransport, LLMClient, Route } from "../src/route.js"
-import { fixedResponse, truncatedStream } from "./lib/http.js"
-import { sseEvents } from "./lib/sse.js"
-import { it } from "./lib/effect.js"
+import { Auth } from "../src/route.js"

 describe("Route.with", () => {
  test("merges endpoint query and header defaults while replacing auth and id", () => {
@@ -56,175 +50,3 @@ describe("Route.with", () => {
    expect(overridden.defaults).not.toHaveProperty("providerMetadataKey")
  })
 })
-
-describe("Route diagnostics", () => {
-  const route = OpenAIChat.route.with({ endpoint: { baseURL: "https://provider.test/v1" } })
-  const request = LLM.request({ model: route.model({ id: "test" }), prompt: "Hello" })
-  const headers = { "content-type": "text/event-stream", "x-request-id": "req_stream" }
-
-  it.effect("retains an entire invalid event and its validation cause", () =>
-    Effect.gen(function* () {
-      const frame = '{ "choices": "invalid", "diagnostic": { "detail": "original" } }'
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseEvents(frame), { headers })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.cause).toMatchObject({ _tag: "SchemaError" })
-      expect(error.reason.http).toEqual(
-        new HttpContext({ url: "https://provider.test/v1/chat/completions", status: 200, headers }),
-      )
-    }),
-  )
-
-  it.effect("retains original provider error fields discarded by the event schema", () =>
-    Effect.gen(function* () {
-      const frame =
-        '{ "error": { "message": "Rate limit exceeded", "code": "rate_limit_exceeded", "debug": { "trace": "original" } }, "request_id": "req_original" }'
-      const error = yield* LLMClient.generate(request).pipe(
-        Effect.provide(fixedResponse(sseEvents(frame), { headers })),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("RateLimit")
-      expect(error.message).toBe("Rate limit exceeded")
-      expect(error.reason.body).toBe(frame)
-      expect(error.reason.http?.headers["x-request-id"]).toBe("req_stream")
-    }),
-  )
-
-  it.effect("preserves semantic parser bodies while replacing serialized event fallbacks", () =>
-    Effect.forEach([undefined, '{"query": BROKEN}', ""], (body) =>
-      Effect.gen(function* () {
-        const cause = new Error("parser failure")
-        const http = new HttpContext({
-          url: "https://upstream.test/v1",
-          status: 202,
-          headers: { "x-trace": "precise" },
-        })
-        const frame = '{ "type": "failure", "debug": "not in schema" }'
-        const failing = Route.make({
-          id: "diagnostics",
-          provider: "test",
-          endpoint: route.endpoint,
-          framing: Framing.sse,
-          protocol: {
-            ...OpenAIChat.protocol,
-            stream: {
-              event: Schema.fromJsonString(Schema.Struct({ type: Schema.String })),
-              initial: () => undefined,
-              step: (_state, event) =>
-                Effect.fail(
-                  new AIError({
-                    reason: new InvalidProviderOutputError({
-                      message: "Parser failed",
-                      body: body ?? JSON.stringify(event),
-                      http,
-                      cause,
-                    }),
-                  }),
-                ),
-            },
-          },
-        })
-        const error = yield* LLMClient.generate(
-          LLM.request({ model: failing.model({ id: "test" }), prompt: "Hello" }),
-        ).pipe(Effect.provide(fixedResponse(sseEvents(frame), { headers })), Effect.flip)
-
-        expect(error.message).toBe("Parser failed")
-        expect(error.reason.body).toBe(body ?? frame)
-        expect(error.reason.cause).toBe(cause)
-        expect(error.reason.http).toBe(http)
-      }),
-    ),
-  )
-
-  it.effect("retains malformed assembled Anthropic hosted-tool arguments", () =>
-    Effect.gen(function* () {
-      const body = '{"query": BROKEN}'
-      const error = yield* LLMClient.generate(
-        LLM.request({
-          model: Anthropic.configure({ apiKey: "test", baseURL: "https://provider.test" }).model("claude"),
-          prompt: "Hello",
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "server_tool_use", id: "srv1", name: "web_search" },
-              },
-              {
-                type: "content_block_delta",
-                index: 0,
-                delta: { type: "input_json_delta", partial_json: '{"query": ' },
-              },
-              { type: "content_block_delta", index: 0, delta: { type: "input_json_delta", partial_json: "BROKEN}" } },
-              { type: "content_block_stop", index: 0 },
-            ),
-            { headers },
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason._tag).toBe("InvalidProviderOutput")
-      expect(error.message).toContain("Invalid JSON input for anthropic-messages tool call web_search")
-      expect(error.reason.body).toBe(body)
-      expect(error.reason.cause).toBeInstanceOf(Error)
-      expect(error.reason.http).toMatchObject({ status: 200, headers })
-    }),
-  )
-
-  it.effect("adds successful HTTP metadata without replacing framing diagnostics", () =>
-    Effect.gen(function* () {
-      const cause = new Error("frame checksum mismatch")
-      const failure = new AIError({
-        reason: new InvalidProviderOutputError({
-          message: "Invalid frame",
-          body: "original frame representation",
-          cause,
-        }),
-      })
-      const failing = route.with({
-        transport: HttpTransport.httpJson({ framing: { id: "failure", frame: () => Stream.fail(failure) } }),
-      })
-      const error = yield* LLMClient.generate(
-        LLM.request({ model: failing.model({ id: "test" }), prompt: "Hello" }),
-      ).pipe(Effect.provide(fixedResponse("wire bytes", { headers })), Effect.flip)
-
-      expect(error.reason.body).toBe(failure.reason.body)
-      expect(error.reason.cause).toBe(cause)
-      expect(error.message).toBe(failure.message)
-      expect(error.reason.http?.status).toBe(200)
-      expect(error.reason.http?.headers).toEqual(headers)
-    }),
-  )
-
-  it.effect("retains the original read error after successful response headers", () =>
-    Effect.gen(function* () {
-      const cause = new Error("socket disconnected")
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(truncatedStream([], cause)), Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "Transport", operation: "read" })
-      expect(error.reason.cause).toBe(cause)
-      expect(error.reason.http?.status).toBe(200)
-      expect(error.reason.body).toBeUndefined()
-    }),
-  )
-
-  it.effect("retains successful response headers on an incomplete stream", () =>
-    Effect.gen(function* () {
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse("", { headers })), Effect.flip)
-
-      expect(error.reason).toMatchObject({ _tag: "InvalidProviderOutput", classification: "incomplete-stream" })
-      expect(error.reason.http?.headers).toEqual(headers)
-      expect(error.reason.body).toBeUndefined()
-    }),
-  )
-})
@@ -4,25 +4,14 @@ import * as OpenAIChat from "../src/protocols/openai-chat.js"
 import * as OpenAIResponses from "../src/protocols/openai-responses.js"
 import {
  AIError,
-  AIErrorReason,
-  AuthenticationError,
  ContentPart,
-  ContentPolicyError,
-  HttpContext,
-  InvalidProviderOutputError,
-  InvalidRequestError,
+  InvalidRequestReason,
  LLMEvent,
  LLMRequest,
  LanguageModel,
  ModelID,
-  NoRouteError,
  ProviderID,
-  ProviderInternalError,
-  QuotaExceededError,
-  RateLimitError,
-  RouteID,
-  TransportError,
-  UnknownProviderError,
+  TransportReason,
  Usage,
 } from "../src/schema/index.js"
 import { ProviderShared } from "../src/protocols/shared.js"
@@ -155,20 +144,19 @@ describe("AI.Usage", () => {

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

 test("transport errors serialize execution facts", () => {
-  const reason = new TransportError({
-    message: "Connection closed",
+  const reason = new TransportReason({
+    message: "connection closed",
    transport: "websocket",
    operation: "read",
    phase: "receive",
@@ -176,176 +164,14 @@ test("transport errors serialize execution facts", () => {
    recovery: "fail",
  })

-  expect(Schema.encodeSync(TransportError)(reason)).toEqual({
+  expect(Schema.encodeSync(TransportReason)(reason)).toEqual({
    _tag: "Transport",
-    message: "Connection closed",
+    message: "connection closed",
    transport: "websocket",
    operation: "read",
    phase: "receive",
    delivery: "ambiguous",
    recovery: "fail",
  })
-  expect(Schema.decodeUnknownSync(TransportError)(Schema.encodeSync(TransportError)(reason))).toEqual(reason)
-})
-
-test("AI errors serialize diagnostics only on their typed reason", () => {
-  const cause = new SyntaxError("Unexpected end of JSON input")
-  const error = new AIError({
-    reason: new InvalidRequestError({
-      message: "Invalid provider response",
-      body: '{"error":',
-      http: new HttpContext({
-        url: "https://provider.test/v1/messages",
-        status: 400,
-        headers: { "request-id": "req_123" },
-      }),
-      cause,
-      parameter: "messages",
-      classification: "context-overflow",
-    }),
-  })
-  const encoded = Schema.encodeSync(AIError)(error)
-  expect(encoded).toEqual({
-    _tag: "AI.Error",
-    reason: {
-      _tag: "InvalidRequest",
-      message: "Invalid provider response",
-      body: '{"error":',
-      http: {
-        url: "https://provider.test/v1/messages",
-        status: 400,
-        headers: { "request-id": "req_123" },
-      },
-      cause: { name: "SyntaxError", message: cause.message, stack: cause.stack },
-      parameter: "messages",
-      classification: "context-overflow",
-    },
-  })
-  const decoded = Schema.decodeUnknownSync(Schema.fromJsonString(AIError))(
-    Schema.encodeSync(Schema.fromJsonString(AIError))(error),
-  )
-
-  expect(error).not.toHaveProperty("body")
-  expect(error).not.toHaveProperty("http")
-  expect(error.cause).toBe(error.reason)
-  expect(error.reason.cause).toBe(cause)
-  expect(decoded).toBeInstanceOf(AIError)
-  expect(decoded.reason).toBeInstanceOf(InvalidRequestError)
-  expect(decoded.message).toBe("Invalid provider response")
-  expect(decoded.reason.message).toBe(decoded.message)
-  expect(decoded.reason.body).toBe('{"error":')
-  expect(decoded.reason.http).toEqual(error.reason.http)
-  expect(decoded.cause).toBe(decoded.reason)
-  expect(decoded.reason.cause).toBeInstanceOf(Error)
-  expect(decoded.reason.cause).toMatchObject({ name: "SyntaxError", message: cause.message, stack: cause.stack })
-  expect(decoded.reason).toMatchObject({ parameter: "messages", classification: "context-overflow" })
-})
-
-test("AI error reasons are tagged Errors with required messages", () => {
-  const reasons = [
-    new InvalidRequestError({ message: "Invalid request" }),
-    new NoRouteError({
-      message: "No route",
-      route: RouteID.make("missing"),
-      provider: model.provider,
-      model: model.id,
-    }),
-    new AuthenticationError({ message: "Missing credentials", kind: "missing" }),
-    new RateLimitError({ message: "Rate limited" }),
-    new QuotaExceededError({ message: "Quota exceeded" }),
-    new ContentPolicyError({ message: "Content blocked" }),
-    new ProviderInternalError({ message: "Provider failed" }),
-    new TransportError({ message: "Connection failed", transport: "http", operation: "request" }),
-    new InvalidProviderOutputError({ message: "Invalid output" }),
-    new UnknownProviderError({ message: "Unknown failure" }),
-  ]
-  expect(reasons.map((reason) => reason._tag)).toEqual([
-    "InvalidRequest",
-    "NoRoute",
-    "Authentication",
-    "RateLimit",
-    "QuotaExceeded",
-    "ContentPolicy",
-    "ProviderInternal",
-    "Transport",
-    "InvalidProviderOutput",
-    "UnknownProvider",
-  ])
-  reasons.forEach((reason) => {
-    expect(reason).toBeInstanceOf(Error)
-    const encoded = Schema.encodeSync(AIErrorReason)(reason)
-    const decoded = Schema.decodeUnknownSync(AIErrorReason)(encoded)
-    expect(decoded).toBeInstanceOf(reason.constructor)
-    expect(decoded.message).toBe(reason.message)
-    expect(Schema.decodeUnknownOption(AIErrorReason)({ ...encoded, message: undefined })._tag).toBe("None")
-  })
-})
-
-test("AI error reason enrichment preserves non-enumerable diagnostics", () => {
-  const cause = new Error("socket disconnected")
-  const reason = new TransportError({
-    message: "Connection closed",
-    body: "close frame detail",
-    http: new HttpContext({ url: "https://provider.test/responses", status: 101, headers: { upgrade: "websocket" } }),
-    cause,
-    transport: "websocket",
-    operation: "read",
-    phase: "close",
-  })
-  expect(Object.prototype.propertyIsEnumerable.call(reason, "message")).toBe(false)
-  expect(Object.prototype.propertyIsEnumerable.call(reason, "cause")).toBe(false)
-  const enriched = AIErrorReason.make({
-    // oxlint-disable-next-line typescript-eslint/no-misused-spread -- Copy fields rather than iterating the yieldable error.
-    ...reason,
-    message: reason.message,
-    cause: reason.cause,
-    delivery: "ambiguous",
-    recovery: "retry-full",
-  })
-  const error = new AIError({ reason: enriched })
-
-  expect(enriched).toBeInstanceOf(TransportError)
-  expect(error.message).toBe(reason.message)
-  expect(error.cause).toBe(enriched)
-  expect(enriched.cause).toBe(cause)
-  expect(enriched.body).toBe(reason.body)
-  expect(enriched.http).toBe(reason.http)
-  expect(enriched).toMatchObject({ phase: "close", delivery: "ambiguous", recovery: "retry-full" })
-})
-
-test("AI errors support reason-specific handlers", async () => {
-  const limited = new AIError({ reason: new RateLimitError({ message: "Slow down", retryAfterMs: 2000 }) })
-  const invalid = new AIError({ reason: new InvalidRequestError({ message: "Invalid request", parameter: "model" }) })
-  expect(
-    await Effect.runPromise(
-      Effect.fail(limited).pipe(
-        Effect.catchReason("AI.Error", "RateLimit", (reason) => {
-          expect(reason).toBe(limited.reason)
-          expect(reason).toBeInstanceOf(RateLimitError)
-          return Effect.succeed(reason.retryAfterMs)
-        }),
-      ),
-    ),
-  ).toBe(2000)
-  expect(
-    await Effect.runPromise(
-      Effect.forEach([limited, invalid], (error) =>
-        Effect.fail(error).pipe(
-          Effect.catchReasons("AI.Error", {
-            RateLimit: (reason) => Effect.succeed(reason.message),
-            InvalidRequest: (reason) => Effect.succeed(reason.parameter),
-          }),
-        ),
-      ),
-    ),
-  ).toEqual(["Slow down", "model"])
-})
-
-test("HTTP error context requires an observed response", () => {
-  const decode = Schema.decodeUnknownOption(HttpContext)
-  expect(decode({ status: 400, headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: 400 })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: 0, headers: {} })._tag).toBe("None")
-  expect(decode({ url: "https://provider.test", status: Number.NaN, headers: {} })._tag).toBe("None")
+  expect(Schema.decodeUnknownSync(TransportReason)(Schema.encodeSync(TransportReason)(reason))).toEqual(reason)
 })
@@ -109,7 +109,7 @@ describe("ToolStream", () => {
      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")
+      if (ToolStream.isError(error)) expect(error.reason.message).toBe("missing tool")
    }),
  )

@@ -31,7 +31,7 @@ Your app is ready to be deployed!

 ## E2E Testing

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

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

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

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

 ## Deployment

@@ -44,7 +44,6 @@ The suite contains:
 - single-session tab close timing through stable home restoration
 - cached session repaint and mutation tracing
 - streaming timeline throughput, RAF-gap, long-task, geometry, and remount diagnostics
- retained renderer heap with a large model catalog across repeated session navigation

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

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

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

-Tab-switch timing starts at `mousedown`, when mouse-selected tabs actually navigate, with a `click` fallback for keyboard activation. The probe excludes hidden/transparent content and intersects answers with their virtual-row clip and viewport. The tab workload requires the destination's final answer to be visible with Markdown ready. These results are not directly comparable to older click-start, geometry-only measurements. `stableObservedMs` includes confirmation across three correct samples; `firstCorrectObservedMs` is the first sample meeting all content and geometry checks. Neither is a compositor presentation timestamp.
-
-Each tab scenario reports one sample, including its raw observations. Use Playwright's `--repeat-each=5` for repeated measurements. Cached scenarios warm the destination at the same panel width before leaving it; a separate resized scenario validates reuse after opening the review pane changes that width.
-
-```sh
-bunx playwright test --config e2e/performance/playwright.config.ts \
-  timeline/session-tab-switch-benchmark.spec.ts --repeat-each=5
-```
-
-## Retained renderer memory
-
-Run the catalog workload against the production app bundle:
-
-```sh
-bunx playwright test --config e2e/performance/playwright.config.ts \
-  timeline/provider-memory-benchmark.spec.ts --repeat-each=3
-```
-
-`PROVIDER_MEMORY_MODELS` defaults to 1,200 and `PROVIDER_MEMORY_SWITCHES` defaults to 10. Each sample records Chromium's `Runtime.getHeapUsage` and `Memory.getDOMCounters` after an explicit garbage collection. This measures retained state, not allocation peaks or normal GC timing. It does not include worker heaps, the Electron main/GPU processes, or the OpenCode server, and must not be reported as total desktop RAM. Use identical model counts and navigation sequences for before/after comparisons.
-
 ## Chrome traces

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

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

 export default {
@@ -12,11 +12,9 @@ export default {
  fullyParallel: false,
  workers: 1,
  reporter: [["html", { outputFolder: "../playwright-report/performance", open: "never" }], ["line"]],
-  webServer: config.webServer
-    ? {
-        ...config.webServer,
-        command: `bun run build && bun run serve -- --host 0.0.0.0 --port ${port} --strictPort`,
-        reuseExistingServer: false,
-      }
-    : undefined,
+  webServer: {
+    ...config.webServer,
+    command: `bun run build && bun run serve -- --host 0.0.0.0 --port ${port} --strictPort`,
+    reuseExistingServer: false,
+  },
 }
@@ -126,19 +126,13 @@ test("keeps moving upward while drag-selecting above the timeline", async ({ pag
      )
    })
  })
-  const textBox = await text.evaluate((element) => {
-    const range = document.createRange()
-    range.selectNodeContents(element)
-    const rect = range.getClientRects()[0]
-    return rect ? { x: rect.x, y: rect.y, width: rect.width, height: rect.height } : null
-  })
+  const textBox = await text.boundingBox()
  const scrollBox = await scroller.boundingBox()
  expect(textBox).not.toBeNull()
  expect(scrollBox).not.toBeNull()
  if (!textBox || !scrollBox) return

-  // Start on a text line, not the empty right edge or gap between wrapped lines.
-  await page.mouse.move(textBox.x + Math.min(20, textBox.width / 2), textBox.y + textBox.height / 2)
+  await page.mouse.move(textBox.x + textBox.width - 10, textBox.y + textBox.height / 2)
  await page.mouse.down()
  await page.mouse.move(textBox.x + 20, scrollBox.y - 120, { steps: 30 })

@@ -201,45 +195,6 @@ test("does not pull a keyboard-scrolled user during shell remeasurement", async
  await reportVisualStability(testInfo, "keyboard-during-resize", trace, anchorPlan(regions))
 })

-test("keeps an older answer selected while scrolling within the interaction buffer", async ({ page }) => {
-  await setupTimeline(page, {
-    messages: history(80),
-    viewport: { width: 1400, height: 700 },
-    reducedMotion: true,
-  })
-  const scroller = page.locator(".scroll-view__viewport", { has: page.locator("[data-timeline-row]") })
-  const answer = page.getByText("History 78.", { exact: false })
-  await expect(answer).toBeVisible()
-  await expect
-    .poll(() =>
-      answer.evaluate((element) => element.closest('[data-component="markdown"]')?.hasAttribute("data-markdown-ready")),
-    )
-    .toBe(true)
-  const textBox = await answer.evaluate((element) => {
-    const range = document.createRange()
-    range.selectNodeContents(element)
-    const rect = range.getClientRects()[0]
-    return { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
-  })
-  const scrollBox = await scroller.boundingBox()
-  expect(scrollBox).not.toBeNull()
-  if (!scrollBox) return
-  await page.mouse.move(textBox.x + Math.min(180, textBox.width - 2), textBox.y + textBox.height / 2)
-  await page.mouse.down()
-  await page.mouse.move(textBox.x + 2, textBox.y + textBox.height / 2, { steps: 30 })
-  await page.mouse.up()
-  await expect.poll(() => page.evaluate(() => window.getSelection()?.toString())).toContain("History 78.")
-  await page.mouse.move(scrollBox.x + scrollBox.width / 2, scrollBox.y + scrollBox.height / 2)
-  await page.mouse.wheel(0, -450)
-  await expect
-    .poll(() => scroller.evaluate((element) => element.scrollHeight - element.clientHeight - element.scrollTop))
-    .toBeGreaterThan(400)
-  await expect(answer).toHaveCount(1)
-  await expect.poll(() => page.evaluate(() => window.getSelection()?.toString())).toContain("History 78.")
-  await page.getByRole("heading", { name: "Timeline visual stability" }).click()
-  await expect.poll(() => page.evaluate(() => window.getSelection()?.isCollapsed)).toBe(true)
-})
-
 test("tracks keyboard scrolling from a focused timeline descendant", async ({ page }, testInfo) => {
  const shellID = "prt_descendant_keyboard_01_shell"
  const timeline = await setupTimeline(page, {
@@ -304,16 +259,12 @@ test("does not claim keyboard scrolling owned by a nested scrollable", async ({
  const before = await scroller.evaluate((element) => element.scrollTop)
  const nestedBefore = await nested.evaluate((element) => element.scrollTop)
  await nested.press("PageUp")
-  await expect.poll(() => nested.evaluate((element) => element.scrollTop)).toBeLessThan(nestedBefore)
+  await page.waitForTimeout(300)
  expect(await scroller.evaluate((element) => element.scrollTop)).toBe(before)
+  expect(await nested.evaluate((element) => element.scrollTop)).toBeLessThan(nestedBefore)

-  await nested.evaluate((element) => element.scrollTo({ top: 0, behavior: "instant" }))
-  await expect.poll(() => nested.evaluate((element) => element.scrollTop)).toBe(0)
-  await scroller.evaluate((element) => {
-    element.dispatchEvent(new WheelEvent("wheel", { bubbles: true, cancelable: true, deltaY: -1 }))
-    element.scrollTo({ top: Math.min(300, element.scrollHeight - element.clientHeight), behavior: "instant" })
-  })
-  await expect.poll(() => scroller.evaluate((element) => element.scrollTop)).toBeLessThan(500)
+  await nested.evaluate((element) => (element.scrollTop = 0))
+  await scroller.evaluate((element) => (element.scrollTop = Math.min(300, element.scrollHeight - element.clientHeight)))
  const boundaryBefore = await scroller.evaluate((element) => element.scrollTop)
  expect(boundaryBefore).toBeGreaterThan(0)
  await nested.press("PageUp")
@@ -1,98 +0,0 @@
-import { benchmark, expect } from "../benchmark"
-import { mockOpenCodeServer } from "../../utils/mock-server"
-import { expectSessionTitle } from "../../utils/waits"
-import { fixture, pageMessages } from "./session-timeline-stress.fixture"
-import { installStressSessionTabs, installTimelineSettings, stressSessionHref } from "./timeline-test-helpers"
-import { waitForStableTimeline } from "./session-tab-switch-probe"
-import type { CatalogUpdated } from "@opencode-ai/client/promise"
-
-benchmark("measures retained renderer memory with a large model catalog", async ({ page, report }) => {
-  benchmark.setTimeout(120_000)
-  const count = Number(process.env.PROVIDER_MEMORY_MODELS ?? 1200)
-  const switches = Number(process.env.PROVIDER_MEMORY_SWITCHES ?? 10)
-  const provider = fixture.provider.all[0]
-  const selected = { ...provider.models["claude-opus-4-6"] }
-  await mockOpenCodeServer(page, {
-    directory: fixture.directory,
-    project: fixture.project,
-    sessions: fixture.sessions,
-    pageMessages,
-    provider: {
-      ...fixture.provider,
-      all: [
-        {
-          ...provider,
-          models: {
-            [selected.id]: selected,
-            ...Object.fromEntries(
-              Array.from({ length: count - 1 }, (_, index) => {
-                const id = `catalog-model-${index}`
-                return [
-                  id,
-                  {
-                    id,
-                    name: `Catalog model ${index}`,
-                    cost: { input: 1, output: 2 },
-                    limit: { context: 200_000, output: 8192 },
-                    variants: { high: { reasoningEffort: "high" } },
-                  },
-                ]
-              }),
-            ),
-          },
-        },
-      ],
-    },
-  })
-  await installTimelineSettings(page)
-  await installStressSessionTabs(page)
-  await page.goto(stressSessionHref(fixture.sourceID))
-  await expectSessionTitle(page, fixture.expected.sourceTitle)
-  await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
-  await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6")
-  const cdp = await page.context().newCDPSession(page)
-  const samples = []
-  for (let index = 0; index <= switches; index++) {
-    if (index > 0) {
-      const target = index % 2 === 1
-      const id = target ? fixture.targetID : fixture.sourceID
-      await page.locator(`[data-slot="titlebar-tabs"] a[href="${stressSessionHref(id)}"]`).click()
-      await expectSessionTitle(page, target ? fixture.expected.targetTitle : fixture.expected.sourceTitle)
-      await waitForStableTimeline(
-        page,
-        (target ? fixture.expected.targetMessageIDs : fixture.expected.sourceMessageIDs).at(-1)!,
-      )
-      await expect(page.locator('[data-action="composer-model"]')).toContainText("Claude Opus 4.6")
-    }
-    // GC is an explicit retained-heap measurement, not an application optimization or readiness wait.
-    await cdp.send("HeapProfiler.collectGarbage")
-    samples.push({
-      switches: index,
-      heap: await cdp.send("Runtime.getHeapUsage"),
-      dom: await cdp.send("Memory.getDOMCounters"),
-    })
-  }
-  expect(samples).toHaveLength(switches + 1)
-  expect(samples.every((sample) => sample.heap.usedSize > 0)).toBe(true)
-  selected.name = "Updated catalog model"
-  await page.evaluate(
-    (event) => {
-      const host = window as Window & { __mockServerStream?: { push: (events: CatalogUpdated[]) => void } }
-      if (!host.__mockServerStream) throw new Error("Missing fixture event stream")
-      host.__mockServerStream.push([event])
-    },
-    {
-      id: "evt_catalog_refresh",
-      created: Date.now(),
-      type: "catalog.updated",
-      location: { directory: fixture.directory },
-      data: {},
-    } satisfies CatalogUpdated,
-  )
-  await expect(page.locator('[data-action="composer-model"]')).toContainText(selected.name)
-  report(
-    { samples },
-    { models: count, switches, gc: "explicit", scope: "renderer main isolate; not total desktop RAM" },
-  )
-  await cdp.detach()
-})
@@ -11,73 +11,115 @@ import {
 } from "./timeline-test-helpers"
 import { measureSessionSwitch, waitForStableTimeline } from "./session-tab-switch-probe"

-const scenarios = [
-  { cached: false, review: false, resized: false },
-  { cached: false, review: true, resized: false },
-  { cached: true, review: false, resized: false },
-  { cached: true, review: true, resized: false },
-  { cached: true, review: true, resized: true },
-]
+type Result = Awaited<ReturnType<typeof measureSessionSwitch>>

-scenarios.forEach((scenario) => {
-  const name = `tab switch: ${scenario.cached ? "cached" : "unmounted"}, review ${scenario.review ? "open" : "closed"}${scenario.resized ? ", resized" : ""}`
-  benchmark(name, async ({ browser, report }, testInfo) => {
-    const result = await withBenchmarkPage(
-      browser,
-      name,
-      async (page) => {
-        await mockStressTimeline(page, { vcsDiff: createReviewDiffs() })
-        await installTimelineSettings(page)
-        await installStressSessionTabs(page)
-        await page.goto(stressSessionHref(fixture.sourceID))
-        await expectSessionTitle(page, fixture.expected.sourceTitle)
-        await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
-        if (scenario.review && !scenario.resized) await openReviewPane(page)
-        if (scenario.cached) {
-          await switchSession(page, fixture.targetID, fixture.expected.targetTitle)
-          const answer = page.locator(`[data-timeline-part-id="${fixture.expected.targetPartIDs.at(-1)}"]`)
-          await expect(answer.locator('[data-component="markdown"]')).toHaveAttribute("data-markdown-ready", "")
-          await expect
-            .poll(() =>
-              answer.evaluate((element) => element.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })),
-            )
-            .toBe(true)
-          await waitForStableTimeline(page, fixture.expected.targetMessageIDs.at(-1)!)
-          await switchSession(page, fixture.sourceID, fixture.expected.sourceTitle)
+benchmark(
+  "benchmarks session tab switching with and without the review pane",
+  async ({ browser, report }, testInfo) => {
+    benchmark.setTimeout(360_000)
+    const runs = Number(process.env.SESSION_TAB_SWITCH_RUNS ?? 5)
+    const results = {
+      closed: { cold: [] as Result[], hot: [] as Result[] },
+      open: { cold: [] as Result[], hot: [] as Result[] },
+    }
+    for (const reviewPane of ["closed", "open"] as const) {
+      for (const mode of ["cold", "hot"] as const) {
+        for (let run = 0; run < runs; run++) {
+          results[reviewPane][mode].push(
+            await withBenchmarkPage(
+              browser,
+              `session-tab-switch-${reviewPane}-${mode}-${run}`,
+              (page) => trial(page, mode, reviewPane),
+              testInfo,
+            ),
+          )
        }
-        if (scenario.resized) await openReviewPane(page)
-        await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
+      }
+    }
+    report({ results, summary: summarizeReviewPane(results) }, { runs, reviewDiffs: createReviewDiffs().length })
+  },
+)

-        return measureSessionSwitch(page, {
-          destinationIDs: fixture.messages[fixture.targetID].map((message) => message.id),
-          sourceIDs: fixture.messages[fixture.sourceID].map((message) => message.id),
-          lastID: fixture.expected.targetMessageIDs.at(-1)!,
-          requiredPartID: fixture.expected.targetPartIDs.at(-1),
-          href: stressSessionHref(fixture.targetID),
-          switch: () => switchSession(page, fixture.targetID, fixture.expected.targetTitle),
-        })
-      },
-      testInfo,
-    )
-    expect(result.unknownSamples).toBe(0)
-    expect(result.wrongDestinationSamples).toBe(0)
-    if (scenario.cached) expect(result.blankSamples).toBe(0)
-    report(result, { ...scenario, inputEvent: "mousedown", requireReadyAnswer: true })
+async function trial(page: Page, mode: "cold" | "hot", reviewPane: "closed" | "open") {
+  const reviewDiffs = createReviewDiffs()
+  await mockStressTimeline(page, { vcsDiff: reviewDiffs })
+  await installTimelineSettings(page)
+  await installStressSessionTabs(page)
+  if (mode === "hot") {
+    await page.goto(stressSessionHref(fixture.targetID))
+    await expectSessionTitle(page, fixture.expected.targetTitle)
+    await waitForStableTimeline(page, fixture.expected.targetMessageIDs.at(-1)!)
+    await switchSession(page, fixture.sourceID, fixture.expected.sourceTitle)
+  } else {
+    await page.goto(stressSessionHref(fixture.sourceID))
+    await expectSessionTitle(page, fixture.expected.sourceTitle)
+  }
+  await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
+  if (reviewPane === "open") {
+    await openReviewPane(page)
+    await waitForStableTimeline(page, fixture.expected.sourceMessageIDs.at(-1)!)
+  }
+
+  const destinationIDs = fixture.messages[fixture.targetID].map((message) => message.id)
+  const sourceIDs = fixture.messages[fixture.sourceID].map((message) => message.id)
+  const lastID = fixture.expected.targetMessageIDs.at(-1)!
+  const href = stressSessionHref(fixture.targetID)
+  const result = await measureSessionSwitch(page, {
+    destinationIDs,
+    sourceIDs,
+    lastID,
+    href,
+    switch: () => switchSession(page, fixture.targetID, fixture.expected.targetTitle),
  })
-})
+  return result
+}
+
+function summarize(results: Record<"cold" | "hot", Result[]>) {
+  const stats = (values: (number | null)[]) => {
+    const sorted = values.filter((value): value is number => value !== null).sort((a, b) => a - b)
+    return {
+      min: sorted[0] ?? null,
+      median: sorted[Math.floor(sorted.length / 2)] ?? null,
+      max: sorted.at(-1) ?? null,
+      missing: values.length - sorted.length,
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(results).map(([mode, values]) => [
+      mode,
+      {
+        firstDestinationObservedMs: stats(values.map((value) => value.firstDestinationObservedMs)),
+        firstCorrectObservedMs: stats(values.map((value) => value.firstCorrectObservedMs)),
+        stableObservedMs: stats(values.map((value) => value.stableObservedMs)),
+      },
+    ]),
+  )
+}
+
+function summarizeReviewPane(results: Record<"closed" | "open", Record<"cold" | "hot", Result[]>>) {
+  return Object.fromEntries(
+    Object.entries(results).map(([reviewPane, values]) => [
+      reviewPane,
+      summarize(values as Record<"cold" | "hot", Result[]>),
+    ]),
+  )
+}

 async function switchSession(page: Page, sessionID: string, title: string) {
-  const tab = page.locator(`[data-slot="titlebar-tabs"] a[href="${stressSessionHref(sessionID)}"]`)
-  await expect(tab).toHaveCount(1)
+  const href = stressSessionHref(sessionID)
+  const tab = page.locator(`[data-slot="titlebar-tabs"] a[href="${href}"]`).first()
+  await expect(tab).toBeVisible()
  await tab.click()
  await expectSessionTitle(page, title)
 }

 async function openReviewPane(page: Page) {
  await page.getByRole("button", { name: "Toggle review" }).click()
-  await expect(page.locator("#review-panel")).toBeVisible()
+  const panel = page.locator("#review-panel")
+  await expect(panel).toBeVisible()
  await page.waitForFunction(() => {
-    const text = document.querySelector("#review-panel")?.textContent ?? ""
+    const panel = document.querySelector<HTMLElement>("#review-panel")
+    const text = panel?.textContent ?? ""
    return text.includes("generated-000.ts") && text.includes("+3")
  })
 }
@@ -20,10 +20,9 @@ export function classifySessionSwitch(samples: SessionSwitchSample[]) {
  const firstCorrect = samples.findIndex(isCorrectDestination)
  const stable = samples.findIndex((_, index) => isStableSessionSwitch(samples.slice(index, index + 3)))
  return {
-    samples,
    firstDestinationObservedMs: samples[firstDestination]?.observedAtMs ?? null,
    firstCorrectObservedMs: samples[firstCorrect]?.observedAtMs ?? null,
-    stableObservedMs: stable < 0 ? null : samples[stable + 2].observedAtMs,
+    stableObservedMs: samples[stable + 2]?.observedAtMs ?? null,
    wrongDestinationSamples: samples
      .slice(firstDestination)
      .filter((sample) => sample.destination.length > 0 && !sample.last).length,
@@ -1,67 +0,0 @@
-import { benchmark, expect } from "../benchmark"
-import { measureSessionSwitch } from "./session-tab-switch-probe"
-import type { SessionSwitchSample } from "./session-tab-switch-metrics"
-
-benchmark("starts at mousedown and excludes hidden or unfinished destination content", async ({ page, report }) => {
-  await page.setContent(`
-    <a href="/session/destination">Destination</a>
-    <div class="scroll-view__viewport" style="height:200px;overflow:auto">
-      <div data-timeline-row="message" data-timeline-key="row" data-message-id="source">
-        <div data-timeline-part-id="answer"><div data-component="markdown">Destination answer</div></div>
-      </div>
-    </div>
-  `)
-  await page.evaluate(() => {
-    document.querySelector("a")!.addEventListener("mousedown", () => {
-      const row = document.querySelector<HTMLElement>("[data-message-id]")!
-      row.dataset.messageId = "destination"
-      row.style.visibility = "hidden"
-    })
-  })
-  const result = await measureSessionSwitch(page, {
-    destinationIDs: ["destination"],
-    sourceIDs: ["source"],
-    lastID: "destination",
-    requiredPartID: "answer",
-    requireBottomAnchor: false,
-    href: "/session/destination",
-    switch: async () => {
-      // No click is dispatched: the probe must observe the event that activates tabs.
-      await page.getByRole("link", { name: "Destination" }).dispatchEvent("mousedown", { button: 0 })
-      await page.waitForFunction(() => {
-        const host = window as Window & { __sessionSwitchProbe?: { samples: SessionSwitchSample[] } }
-        return host.__sessionSwitchProbe?.samples.some((sample) => !sample.hasVisibleRows)
-      })
-      await page.locator("[data-message-id]").evaluate((row) => row.style.removeProperty("visibility"))
-      await page.waitForFunction(() => {
-        const host = window as Window & { __sessionSwitchProbe?: { samples: SessionSwitchSample[] } }
-        return host.__sessionSwitchProbe?.samples.some(
-          (sample) => sample.destination.length > 0 && sample.requiredPartVisible === false,
-        )
-      })
-      const beforeClip = await page.evaluate(() => {
-        const row = document.querySelector<HTMLElement>("[data-timeline-key]")!
-        row.style.cssText = "height:10px;position:relative;overflow:clip"
-        const answer = row.querySelector<HTMLElement>("[data-timeline-part-id]")!
-        answer.style.cssText = "position:absolute;top:30px;width:150px"
-        answer.querySelector('[data-component="markdown"]')!.setAttribute("data-markdown-ready", "")
-        return (
-          (window as Window & { __sessionSwitchProbe?: { samples: SessionSwitchSample[] } }).__sessionSwitchProbe
-            ?.samples.length ?? 0
-        )
-      })
-      await page.waitForFunction((count) => {
-        const host = window as Window & { __sessionSwitchProbe?: { samples: SessionSwitchSample[] } }
-        return host.__sessionSwitchProbe?.samples.slice(count).some((sample) => sample.requiredPartVisible === false)
-      }, beforeClip)
-      await page.locator("[data-timeline-key]").evaluate((row) => {
-        row.style.height = "100px"
-      })
-    },
-  })
-  expect(result.blankSamples).toBeGreaterThan(0)
-  expect(result.firstCorrectObservedMs).not.toBeNull()
-  expect(result.stableObservedMs).not.toBeNull()
-  expect(result.firstCorrectObservedMs).toBeGreaterThan(result.firstDestinationObservedMs!)
-  report(result)
-})
@@ -25,7 +25,7 @@ async function installSessionSwitchProbe(
    let running = true
    const reviewLevels: Record<string, string> = {
      panel: "#review-panel",
-      tabs: '#review-panel [data-component="tabs"]',
+    tabs: '#review-panel [data-component="tabs"]',
      body: '#review-panel [data-slot="session-review-v2-body"]',
      review: '#review-panel [data-component="session-review-v2"]',
      preview: '#review-panel [data-slot="session-review-v2-preview"]',
@@ -37,6 +37,7 @@ async function installSessionSwitchProbe(
      if (!running || started === undefined) return
      setTimeout(() => {
        if (!running || started === undefined) return
+        const observedAtMs = performance.now() - started
        const reviewPanel = document.querySelector<HTMLElement>("#review-panel")
        const reviewFile = reviewPanel?.querySelector('[data-component="file"][data-mode="diff"]')
        const initialReviewFile = initialReviewNodes.file
@@ -62,30 +63,26 @@ async function installSessionSwitchProbe(
        )
        if (root) {
          const view = root.getBoundingClientRect()
-          const inViewport = (element: HTMLElement) => {
-            if (!element.checkVisibility({ checkOpacity: true, checkVisibilityCSS: true })) return false
-            const rect = element.getBoundingClientRect()
-            const clip = element.closest<HTMLElement>("[data-timeline-key]")?.getBoundingClientRect() ?? view
-            return (
-              Math.min(rect.bottom, clip.bottom, view.bottom) > Math.max(rect.top, clip.top, view.top) &&
-              Math.min(rect.right, clip.right, view.right) > Math.max(rect.left, clip.left, view.left)
-            )
-          }
          const visible = [...root.querySelectorAll<HTMLElement>("[data-message-id]")]
-            .filter(inViewport)
+            .filter((element) => {
+              const rect = element.getBoundingClientRect()
+              return rect.bottom > view.top && rect.top < view.bottom
+            })
            .map((element) => element.dataset.messageId!)
-          const hasVisibleRows = [...root.querySelectorAll<HTMLElement>("[data-timeline-key]")].some(inViewport)
+          const hasVisibleRows = [...root.querySelectorAll<HTMLElement>("[data-timeline-key]")].some((element) => {
+            const rect = element.getBoundingClientRect()
+            return rect.bottom > view.top && rect.top < view.bottom
+          })
          const requiredPartVisible = requiredPartID
            ? [...root.querySelectorAll<HTMLElement>("[data-timeline-part-id]")].some((element) => {
                if (element.dataset.timelinePartId !== requiredPartID) return false
-                if (!element.textContent?.trim()) return false
-                if (element.querySelector('[data-component="markdown"]:not([data-markdown-ready])')) return false
-                return inViewport(element)
+                const rect = element.getBoundingClientRect()
+                return rect.width > 0 && rect.height > 0 && rect.bottom > view.top && rect.top < view.bottom
              })
            : undefined
          const spacer = root.querySelector<HTMLElement>('[data-timeline-row="bottom-spacer"]')?.getBoundingClientRect()
          samples.push({
-            observedAtMs: performance.now() - started,
+            observedAtMs,
            destination: visible.filter((id) => destination.has(id)),
            source: visible.filter((id) => source.has(id)),
            hasVisibleRows,
@@ -97,7 +94,7 @@ async function installSessionSwitchProbe(
          })
        } else {
          samples.push({
-            observedAtMs: performance.now() - started,
+            observedAtMs,
            destination: [],
            source: [],
            hasVisibleRows: false,
@@ -110,25 +107,23 @@ async function installSessionSwitchProbe(
        requestAnimationFrame(sample)
      }, 0)
    }
-    const start = (event: MouseEvent) => {
-      if (started !== undefined || event.button !== 0) return
-      const link = event.target instanceof Element ? event.target.closest("a") : undefined
-      if (link?.getAttribute("href") !== href) return
-      started = performance.now()
-      for (const [name, selector] of Object.entries(reviewLevels)) {
-        initialReviewNodes[name] = document.querySelector(selector)
-      }
-      requestAnimationFrame(sample)
-    }
-    // Tabs activate on mousedown; click alone misses the synchronous navigation work.
-    document.addEventListener("mousedown", start, true)
-    document.addEventListener("click", start, true)
+    document.addEventListener(
+      "click",
+      (event) => {
+        const link = event.target instanceof Element ? event.target.closest("a") : undefined
+        if (link?.getAttribute("href") !== href) return
+        started = performance.now()
+        for (const [name, selector] of Object.entries(reviewLevels)) {
+          initialReviewNodes[name] = document.querySelector(selector)
+        }
+        requestAnimationFrame(sample)
+      },
+      { capture: true, once: true },
+    )
    ;(window as Window & { __sessionSwitchProbe?: SessionSwitchProbe }).__sessionSwitchProbe = {
      samples,
      stop: () => {
        running = false
-        document.removeEventListener("mousedown", start, true)
-        document.removeEventListener("click", start, true)
      },
    }
  }, input)
@@ -53,15 +53,6 @@ test("reports missing correctness without throwing", () => {
  expect(result.stableObservedMs).toBeNull()
 })

-test("does not report stability for only two correct samples", () => {
-  const result = classifySessionSwitch([
-    { observedAtMs: 16, destination: ["destination"], source: [], hasVisibleRows: true, last: true, bottomErrorPx: 0 },
-    { observedAtMs: 32, destination: ["destination"], source: [], hasVisibleRows: true, last: true, bottomErrorPx: 0 },
-  ])
-  expect(result.firstCorrectObservedMs).toBe(16)
-  expect(result.stableObservedMs).toBeNull()
-})
-
 test("requires an explicitly tracked part to be visible", () => {
  const result = classifySessionSwitch([
    {
@@ -1,120 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectAppVisible } from "../utils/waits"
-
-const draftID = "draft_large_paste"
-const directory = "/repo/large-paste"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-
-test.use({ permissions: ["clipboard-read", "clipboard-write"] })
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_large_paste",
-      worktree: directory,
-      vcs: "git",
-      name: "large-paste",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.addInitScript(
-    ({ directory, draftID, server }) => {
-      localStorage.setItem("opencode-theme-id", "oc-2")
-      localStorage.setItem("opencode-color-scheme", "dark")
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({
-          projects: { local: [{ worktree: directory, expanded: true }] },
-          lastProject: { local: directory },
-        }),
-      )
-      localStorage.setItem(
-        "opencode.window.browser.dat:tabs",
-        JSON.stringify([{ type: "draft", draftID, server, directory }]),
-      )
-    },
-    { directory, draftID, server },
-  )
-  await page.goto(`/new-session?draftId=${draftID}`)
-  const input = page.locator('[data-component="composer-editor"]')
-  await expectAppVisible(input)
-  await expect(input).toBeEditable()
-  await expect
-    .poll(() => input.evaluate((element) => getComputedStyle(element, "::before").content))
-    .toBe(`"${String.fromCodePoint(0x200b)}"`)
-  await input.click()
-})
-
-for (const lines of [6000, 25000]) {
-  test(`keeps a ${lines}-line crash report editable in a new session`, async ({ page }) => {
-    const input = page.getByRole("textbox", { name: "Prompt", exact: true })
-    const text = "Thread 0 Crashed:\n" + "0   Example  0x0000000100000000 frame + 32\n".repeat(lines) + "End of report"
-    await page.evaluate((text) => navigator.clipboard.writeText(text), text)
-    const events = await input.evaluateHandle((element) => {
-      const events = { count: 0 }
-      element.addEventListener("input", () => events.count++)
-      return events
-    })
-    await page.keyboard.press("ControlOrMeta+V")
-    await expect.poll(async () => (await input.innerText()) === text).toBe(true)
-    expect(await events.evaluate((events) => events.count)).toBe(1)
-    await expect(input).toBeFocused()
-    await page.keyboard.type("!")
-    await expect.poll(async () => (await input.innerText()) === text + "!").toBe(true)
-  })
-}
-
-for (const text of [
-  "single line <b> &amp;",
-  "first\nsecond",
-  "\n\n  indented\ttext  \n\nlast\n\n",
-  'literal <b>bold</b> &amp; & < > "quotes"\n<script>not code</script>\n<img src="example">',
-  "first\r\nsecond\rthird",
-]) {
-  test(`preserves text and native undo: ${JSON.stringify(text)}`, async ({ page }) => {
-    const input = page.getByRole("textbox", { name: "Prompt", exact: true })
-    await page.evaluate((text) => navigator.clipboard.writeText(text), text)
-    await page.keyboard.press("ControlOrMeta+V")
-    const expected = text.replace(/\r\n?/g, "\n")
-    await expect.poll(() => input.innerText()).toBe(expected)
-    await expect(input.locator("b, script, img")).toHaveCount(0)
-    await page.keyboard.press("ControlOrMeta+Z")
-    await expect(input).toBeEmpty()
-    await page.keyboard.press("ControlOrMeta+Shift+Z")
-    await expect.poll(() => input.innerText()).toBe(expected)
-  })
-}
-
-test("replaces only the selected text and leaves the caret after the paste", async ({ page }) => {
-  const input = page.getByRole("textbox", { name: "Prompt", exact: true })
-  await page.evaluate(() => navigator.clipboard.writeText("one\ntwo"))
-  await page.keyboard.type("before replace after")
-  await expect(input).toHaveText("before replace after")
-  await page.evaluate(() => document.fonts.ready)
-  const word = await input.evaluate((element) => {
-    const range = document.createRange()
-    range.setStart(element.firstChild!, 7)
-    range.setEnd(element.firstChild!, 14)
-    const rect = range.getBoundingClientRect()
-    return { x: rect.x, y: rect.y + rect.height / 2, width: rect.width }
-  })
-  await page.mouse.move(word.x, word.y)
-  await page.mouse.down()
-  await page.mouse.move(word.x + word.width, word.y, { steps: 5 })
-  await page.mouse.up()
-  await expect.poll(() => page.evaluate(() => window.getSelection()?.toString())).toBe("replace")
-  await page.keyboard.press("ControlOrMeta+V")
-  await expect.poll(() => input.innerText()).toBe("before one\ntwo after")
-  await page.keyboard.press("ControlOrMeta+Z")
-  await expect(input).toHaveText("before replace after")
-  await page.keyboard.press("ControlOrMeta+Shift+Z")
-  await expect.poll(() => input.innerText()).toBe("before one\ntwo after")
-  await page.keyboard.type("!")
-  await expect.poll(() => input.innerText()).toBe("before one\ntwo! after")
-})
@@ -3,7 +3,7 @@ import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
 import { installSseTransport } from "../utils/sse-transport"

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

  const hrefA = `/server/${base64Encode(serverA)}/session/${sessionA.id}`
@@ -55,7 +55,7 @@ function session(id: string, directory: string, title: string) {
 async function mockServers(page: Page, requests: string[]) {
  await installSseTransport(page, { server: serverA })
  await installSseTransport(page, { server: serverB })
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    requests.push(url.toString())
@@ -1,178 +0,0 @@
-import { base64Encode } from "@opencode-ai/util/encode"
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectSessionTitle } from "../utils/waits"
-
-const directory = "C:\\OpenCode\\main"
-const workspace = "C:\\OpenCode\\worktree"
-const projectID = "proj_mcp_workspace"
-const sessionID = "ses_mcp_workspace"
-const title = "Workspace MCP routing"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-
-for (const shared of [true, false]) {
-  test(`toggles the workspace MCP when the default location ${shared ? "has" : "does not have"} the server`, async ({
-    page,
-  }, testInfo) => {
-    const connected = new Set<string>()
-    const requests: { path: string; directory: string }[] = []
-    await mockOpenCodeServer(page, {
-      directory,
-      project: {
-        id: projectID,
-        worktree: directory,
-        vcs: "git",
-        name: "mcp-workspace",
-        time: { created: 1700000000000, updated: 1700000000000 },
-        sandboxes: [workspace],
-      },
-      provider: { all: [], connected: [], default: {} },
-      sessions: [{ id: sessionID, projectID, directory: workspace, title }],
-      pageMessages: () => ({ items: [] }),
-    })
-    await page.route("**/api/mcp**", async (route) => {
-      if (route.request().method() === "OPTIONS") return route.fallback()
-      const url = new URL(route.request().url())
-      const target = url.searchParams.get("location[directory]") ?? directory
-      requests.push({ path: url.pathname, directory: target })
-      if (url.pathname === "/api/mcp/figma-desktop/connect") {
-        connected.add(target)
-        return route.fulfill({ status: 204 })
-      }
-      if (url.pathname === "/api/mcp/figma-desktop/disconnect") {
-        connected.delete(target)
-        return route.fulfill({ status: 204 })
-      }
-      return route.fulfill({
-        json: {
-          location: { directory: target },
-          data:
-            url.pathname === "/api/mcp/resource"
-              ? { resources: [], templates: [] }
-              : !shared && target !== workspace
-                ? []
-                : [{ name: "figma-desktop", status: { status: connected.has(target) ? "connected" : "disabled" } }],
-        },
-      })
-    })
-
-    await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-    await expectSessionTitle(page, title)
-    await expect(page.getByRole("textbox", { name: "Prompt", exact: true })).toBeEditable()
-    await page.keyboard.press("ControlOrMeta+;")
-    const dialog = page.getByRole("dialog", { name: "MCPs", exact: true })
-    await expect(dialog.getByText("figma-desktop", { exact: true })).toBeVisible()
-    const toggle = dialog.getByRole("switch")
-    await expect(toggle).not.toBeChecked()
-    await expect(toggle).toBeEnabled()
-    requests.length = 0
-
-    await dialog.locator('[data-slot="switch-control"]').click()
-    await expect(toggle).toBeChecked()
-    await expect(toggle).toBeEnabled()
-    expect(connected).toEqual(new Set([workspace]))
-    expect(requests).toContainEqual({ path: "/api/mcp/figma-desktop/connect", directory: workspace })
-    expect(requests).toContainEqual({ path: "/api/mcp/resource", directory: workspace })
-    expect(requests.every((request) => request.directory === workspace)).toBe(true)
-    await testInfo.attach("workspace-connected", { body: await page.screenshot(), contentType: "image/png" })
-
-    requests.length = 0
-    await dialog.getByText("figma-desktop", { exact: true }).click()
-    await expect(toggle).not.toBeChecked()
-    await expect(toggle).toBeEnabled()
-    expect(connected.size).toBe(0)
-    expect(requests).toContainEqual({ path: "/api/mcp/figma-desktop/disconnect", directory: workspace })
-    expect(requests.every((request) => request.directory === workspace)).toBe(true)
-  })
-}
-
-for (const surface of ["popover", "dialog"] as const) {
-  test(`shows connection failures from the MCP ${surface} and allows reconnecting`, async ({ page }, testInfo) => {
-    const error = "Streamable HTTP error: Error POSTing to endpoint: 404 Not Found"
-    const state = { fail: true, status: surface === "popover" ? "failed" : "disabled" }
-    const requests: { path: string; directory: string }[] = []
-    await page.addInitScript(() => {
-      localStorage.setItem("settings.v3", JSON.stringify({ general: { showStatus: true } }))
-    })
-    await mockOpenCodeServer(page, {
-      directory,
-      project: {
-        id: projectID,
-        worktree: directory,
-        vcs: "git",
-        name: "mcp-workspace",
-        time: { created: 1700000000000, updated: 1700000000000 },
-        sandboxes: [workspace],
-      },
-      provider: { all: [], connected: [], default: {} },
-      sessions: [{ id: sessionID, projectID, directory: workspace, title }],
-      pageMessages: () => ({ items: [] }),
-    })
-    await page.route("**/api/mcp**", async (route) => {
-      if (route.request().method() === "OPTIONS") return route.fallback()
-      const url = new URL(route.request().url())
-      const target = url.searchParams.get("location[directory]") ?? directory
-      requests.push({ path: url.pathname, directory: target })
-      if (url.pathname === "/api/mcp/figma-desktop/connect") {
-        state.status = state.fail ? "failed" : "connected"
-        // Connection failures are reported by the refreshed status, not the HTTP response.
-        return route.fulfill({ status: 204 })
-      }
-      return route.fulfill({
-        json: {
-          location: { directory: target },
-          data:
-            url.pathname === "/api/mcp/resource"
-              ? { resources: [], templates: [] }
-              : [
-                  {
-                    name: "figma-desktop",
-                    status: { status: target === workspace ? state.status : "connected", error },
-                  },
-                ],
-        },
-      })
-    })
-
-    await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-    await expectSessionTitle(page, title)
-    await expect(page.getByRole("textbox", { name: "Prompt", exact: true })).toBeEditable()
-    if (surface === "popover") await page.getByRole("button", { name: "Status", exact: true }).click()
-    if (surface === "dialog") await page.keyboard.press("ControlOrMeta+;")
-    const panel =
-      surface === "popover" ? page.getByRole("tabpanel") : page.getByRole("dialog", { name: "MCPs", exact: true })
-    const toggle = panel.getByRole("switch")
-    await expect(panel.getByText("figma-desktop", { exact: true })).toBeVisible()
-    await expect(toggle).not.toBeChecked()
-    await expect(toggle).toBeEnabled()
-    requests.length = 0
-
-    await panel.locator('[data-slot="switch-control"]').click()
-    const toast = page
-      .getByRole("listitem", { includeHidden: true })
-      .filter({ has: page.getByText("Request failed", { exact: true }) })
-    await expect(toast.getByText(`figma-desktop: ${error}`, { exact: true })).toBeVisible()
-    await expect(toggle).not.toBeChecked()
-    await expect(toggle).toBeEnabled()
-    expect(requests.filter((request) => request.path.endsWith("/connect"))).toEqual([
-      { path: "/api/mcp/figma-desktop/connect", directory: workspace },
-    ])
-    expect(requests.every((request) => request.directory === workspace)).toBe(true)
-    await expect(toast).toHaveCSS("opacity", "1")
-    await testInfo.attach("mcp-connection-error", { body: await page.screenshot(), contentType: "image/png" })
-
-    if (surface === "popover") await page.keyboard.press("Escape")
-    if (surface === "dialog") await panel.getByRole("button", { name: "Close", exact: true }).click()
-    await expect(panel).toBeHidden()
-    await toast.getByRole("button", { name: "Dismiss", exact: true }).click()
-    await expect(toast).toBeHidden()
-    state.fail = false
-    if (surface === "popover") await page.getByRole("button", { name: "Status", exact: true }).click()
-    if (surface === "dialog") await page.keyboard.press("ControlOrMeta+;")
-    await expect(toggle).toBeEnabled()
-    await panel.locator('[data-slot="switch-control"]').click()
-    await expect(toggle).toBeChecked()
-    await expect(toggle).toBeEnabled()
-    await expect(toast).toBeHidden()
-  })
-}
@@ -1,303 +0,0 @@
-import { expect, test, type Page } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { currentSession, mockOpenCodeServer } from "../utils/mock-server"
-import { expectAppVisible } from "../utils/waits"
-
-const directory = "C:/OpenCode/WorkspacePending"
-const workspace = "C:/OpenCode/pending-workspace"
-const projectID = "proj_workspace_pending"
-const draftID = "draft_workspace_pending"
-const otherID = "ses_workspace_pending_other"
-const text = "Create the workspace, then explain the pending session."
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const sessionPath = `/server/${base64Encode(server)}/session/`
-const draftPath = `/new-session?draftId=${draftID}`
-const headers = { "access-control-allow-origin": "*" }
-
-test.use({ serviceWorkers: "block", viewport: { width: 1280, height: 900 } })
-
-for (const viewport of [
-  { name: "desktop", width: 1280, height: 900 },
-  { name: "mobile", width: 390, height: 844 },
-]) {
-  test(`shows a pending workspace session immediately on ${viewport.name}`, async ({ page }, testInfo) => {
-    await page.setViewportSize(viewport)
-    const mock = await openDraft(page)
-    const pending = await submitPending(page, mock)
-
-    await expect(pending.message).toBeInViewport()
-    await expect(pending.shimmer).toBeInViewport()
-    await testInfo.attach("creating-worktree", {
-      body: await page.screenshot({ path: testInfo.outputPath(`pending-${viewport.name}.png`) }),
-      contentType: "image/png",
-    })
-
-    if (viewport.name === "mobile") {
-      await page.locator("html").evaluate((element) => {
-        element.dir = "rtl"
-      })
-      await expect(page.locator("html")).toHaveAttribute("dir", "rtl")
-      await expect(pending.message).toBeInViewport()
-      await expect(pending.shimmer).toBeInViewport()
-      await expect(page.locator('[data-component="session-preparing"]')).toHaveCSS("direction", "rtl")
-      expect(
-        await page
-          .locator('[data-component="session-preparing"]')
-          .evaluate((element) => element.scrollWidth <= element.clientWidth),
-      ).toBe(true)
-    }
-
-    if (viewport.name === "desktop") {
-      await page.locator(`[data-titlebar-tab-link][href="${sessionPath}${otherID}"]`).click()
-      await expect(page).toHaveURL(`${sessionPath}${otherID}`)
-      await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-      await expect(pending.shimmer).toBeHidden()
-
-      await page.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`).click()
-      await expect(page).toHaveURL(pending.url)
-      await expect(pending.message).toHaveAttribute("data-timeline-part-id", `${pending.messageID}:text:0`)
-      await expect(pending.shimmer).toHaveAttribute("data-active", "true")
-      expect(mock.calls).toEqual(["worktree"])
-
-      await page.locator(`[data-titlebar-tab-link][href="${sessionPath}${otherID}"]`).click()
-      await expect(page).toHaveURL(`${sessionPath}${otherID}`)
-      await page.locator('[data-component="composer-editor"]').fill("Keep focus in this other session")
-      await expect(page.locator('[data-component="composer-editor"]')).toBeFocused()
-    }
-
-    expect(mock.calls).toEqual(["worktree"])
-    mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-    await expect
-      .poll(() => mock.prompts)
-      .toEqual([{ sessionID: pending.sessionID, body: expect.objectContaining({ id: pending.messageID, text }) }])
-    expect(mock.creates).toEqual([
-      expect.objectContaining({ id: pending.sessionID, location: { directory: workspace } }),
-    ])
-    expect(mock.calls).toEqual(["worktree", "session", "prompt"])
-
-    if (viewport.name === "desktop") {
-      await expect(page.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`)).toContainText(
-        "Created workspace session",
-      )
-      await expect(page).toHaveURL(`${sessionPath}${otherID}`)
-      await expect(page.locator('[data-component="composer-editor"]')).toHaveText("Keep focus in this other session")
-      await expect(page.locator('[data-component="composer-editor"]')).toBeFocused()
-      await page.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`).click()
-    }
-
-    await expect(page).toHaveURL(pending.url)
-    await expect(pending.shimmer).toHaveCount(0)
-    await expect(pending.message).toHaveCount(1)
-    await expect(pending.message.locator('[data-slot="user-message-text"]')).toHaveText(text)
-    await expect(pending.message).toHaveAttribute("data-timeline-part-id", `${pending.messageID}:text:0`)
-  })
-}
-
-test("restores the original draft when worktree creation fails", async ({ page }) => {
-  const mock = await openDraft(page)
-  const pending = await submitPending(page, mock)
-
-  mock.worktree.resolve({ status: 500, json: { message: "Worktree creation failed in the fixture" } })
-
-  await expect(page).toHaveURL(draftPath)
-  await expect(page.getByText("Failed to create worktree", { exact: true })).toBeVisible()
-  await expect(page.locator('[data-component="composer-editor"]')).toHaveText(text)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  await expect(page.getByRole("button", { name: "New workspace", exact: true })).toBeVisible()
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(pending.message).toHaveCount(0)
-  await expect(page.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`)).toHaveCount(0)
-  expect(mock.calls).toEqual(["worktree"])
-  expect(mock.creates).toEqual([])
-  expect(mock.prompts).toEqual([])
-})
-
-test("retains the draft and reuses the created workspace after session creation fails", async ({ page }) => {
-  const mock = await openDraft(page, { failSessionCreate: true })
-  const pending = await submitPending(page, mock)
-
-  mock.worktree.resolve({ status: 200, json: { directory: workspace } })
-
-  await expect(page).toHaveURL(draftPath)
-  await expect(page.getByText("Failed to create session", { exact: true })).toBeVisible()
-  await expect(page.locator('[data-component="composer-editor"]')).toHaveText(text)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  await expect(page.getByRole("button", { name: "pending-workspace", exact: true })).toBeVisible()
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(pending.message).toHaveCount(0)
-  expect(mock.creates).toEqual([expect.objectContaining({ id: pending.sessionID, location: { directory: workspace } })])
-  expect(mock.calls).toEqual(["worktree", "session"])
-  expect(mock.prompts).toEqual([])
-
-  await page.locator('[data-action="composer-submit"]').click()
-
-  await expect.poll(() => mock.prompts.length).toBe(1)
-  expect(mock.creates).toHaveLength(2)
-  expect(mock.creates[1]).toMatchObject({ location: { directory: workspace } })
-  expect(mock.prompts[0]).toMatchObject({ sessionID: mock.creates[1].id, body: { text } })
-  expect(mock.calls).toEqual(["worktree", "session", "session", "prompt"])
-  await expect(page).toHaveURL(`${sessionPath}${mock.creates[1].id}`)
-  await expect(page.locator('[data-component="user-message"] [data-slot="user-message-text"]')).toHaveText(text)
-})
-
-test("restores the draft after closing and revisiting a pending session that fails", async ({ page }) => {
-  const mock = await openDraft(page)
-  const pending = await submitPending(page, mock)
-  const tab = page.locator(`[data-titlebar-tab-link][href="${sessionPath}${pending.sessionID}"]`)
-
-  await page.locator("[data-titlebar-tab-slot]").filter({ has: tab }).locator('[data-slot="tab-close"] button').click()
-
-  await expect(page).toHaveURL(`${sessionPath}${otherID}`)
-  await expect(page.locator('[data-component="composer-editor"]')).toBeEditable()
-  await expect(tab).toHaveCount(0)
-  await expect(pending.shimmer).toHaveCount(0)
-
-  await page.goBack()
-
-  await expect(page).toHaveURL(pending.url)
-  await expect(tab).toHaveCount(1)
-  await expect(tab).toBeVisible()
-  await expect(pending.message).toHaveCount(1)
-  await expect(pending.message.locator('[data-slot="user-message-text"]')).toHaveText(text)
-  await expect(pending.message).toHaveAttribute("data-timeline-part-id", `${pending.messageID}:text:0`)
-  await expect(pending.shimmer).toBeVisible()
-  await expect(pending.shimmer).toContainText("Creating worktree")
-  await expect(pending.shimmer).toHaveAttribute("data-active", "true")
-  expect(mock.calls).toEqual(["worktree"])
-
-  mock.worktree.resolve({ status: 500, json: { message: "Worktree creation failed after revisiting the session" } })
-
-  await expect(page).toHaveURL(draftPath)
-  await expect(page.getByText("Failed to create worktree", { exact: true })).toBeVisible()
-  await expect(page.locator('[data-component="composer-editor"]')).toHaveText(text)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  await expect(page.getByRole("button", { name: "New workspace", exact: true })).toBeVisible()
-  await expect(page.locator(`[data-titlebar-tab-link][href="${draftPath}"]`)).toHaveCount(1)
-  await expect(tab).toHaveCount(0)
-  await expect(pending.shimmer).toHaveCount(0)
-  await expect(pending.message).toHaveCount(0)
-  expect(mock.calls).toEqual(["worktree"])
-  expect(mock.creates).toEqual([])
-  expect(mock.prompts).toEqual([])
-})
-
-async function openDraft(page: Page, options?: { failSessionCreate?: boolean }) {
-  const worktree = Promise.withResolvers<{ status: number; json: { directory?: string; message?: string } }>()
-  const calls: string[] = []
-  const creates: Record<string, unknown>[] = []
-  const prompts: { sessionID: string; body: Record<string, unknown> }[] = []
-  const project = {
-    id: projectID,
-    worktree: directory,
-    vcs: "git",
-    name: "workspace-pending",
-    time: { created: 1700000000000, updated: 1700000000000 },
-    sandboxes: [] as string[],
-  }
-  const sessions = [currentSession({ id: otherID, projectID, title: "Other session" }, directory)]
-  await mockOpenCodeServer(page, {
-    directory,
-    project,
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { "pending-model": { id: "pending-model", name: "Pending Model", limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "pending-model" },
-    },
-    sessions,
-    pageMessages: () => ({ items: [] }),
-    onPrompt: (input) => prompts.push(input),
-  })
-  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/session") calls.push("session")
-    if (/^\/api\/session\/[^/]+\/prompt$/.test(path)) calls.push("prompt")
-  })
-  await page.route(`**/api/worktree/${projectID}`, async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    // Keep the real HTTP response pending until the test has checked the preview.
-    const response = await worktree.promise
-    if (response.status === 200) project.sandboxes.push(workspace)
-    await route.fulfill({ ...response, headers })
-  })
-  await page.route("**/api/session", async (route) => {
-    if (route.request().method() !== "POST") return route.fallback()
-    const body: Record<string, unknown> = route.request().postDataJSON()
-    creates.push(body)
-    if (options?.failSessionCreate && creates.length === 1) {
-      return route.fulfill({ status: 500, json: { message: "Session creation failed in the fixture" }, headers })
-    }
-    if (typeof body.id !== "string") throw new Error("Session creation must use the client-reserved ID")
-    const session = currentSession({ ...body, id: body.id, projectID, title: "Created workspace session" }, workspace)
-    sessions.push(session)
-    return route.fulfill({ json: { data: session }, headers })
-  })
-  await page.route("**/api/location?**", (route) => {
-    if (route.request().method() !== "GET") return route.fallback()
-    return route.fulfill({
-      json: {
-        directory: new URL(route.request().url()).searchParams.get("location[directory]") ?? directory,
-        project: { id: projectID, directory, canonical: directory },
-      },
-      headers,
-    })
-  })
-  await page.addInitScript(
-    ({ directory, draftID, otherID, server }) => {
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({
-          projects: { local: [{ worktree: directory, expanded: true }] },
-          lastProject: { local: directory },
-        }),
-      )
-      localStorage.setItem(
-        "opencode.window.browser.dat:tabs",
-        JSON.stringify([
-          { type: "draft", draftID, server, directory },
-          { type: "session", sessionId: otherID, server },
-        ]),
-      )
-    },
-    { directory, draftID, otherID, server },
-  )
-  await page.goto(draftPath)
-  await expectAppVisible(page.locator('[data-component="composer-editor"]'))
-  await page.getByRole("button", { name: "Local", exact: true }).click()
-  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 }
-}
-
-async function submitPending(page: Page, mock: Awaited<ReturnType<typeof openDraft>>) {
-  await page.locator('[data-component="composer-editor"]').fill(text)
-  await expect(page.locator('[data-action="composer-submit"]')).toBeEnabled()
-  await page.locator('[data-action="composer-submit"]').click()
-  await expect(page).toHaveURL((url) => url.pathname.startsWith(sessionPath) && /\/ses_[^/]+$/.test(url.pathname))
-  const url = page.url()
-  const sessionID = new URL(url).pathname.slice(sessionPath.length)
-  const preparing = page.locator('[data-component="session-preparing"]')
-  const message = page.locator('[data-component="user-message"]')
-  const shimmer = preparing.getByRole("status").locator('[data-component="text-shimmer"]')
-  await expect(preparing).toBeVisible()
-  await expect(preparing.locator('[data-component="user-message"]')).toHaveCount(1)
-  await expect(message).toHaveCount(1)
-  await expect(message.locator('[data-slot="user-message-text"]')).toHaveText(text)
-  await expect(message).toHaveAttribute("data-timeline-part-id", /^.+:text:0$/)
-  const messageID = (await message.getAttribute("data-timeline-part-id"))!.replace(/:text:0$/, "")
-  await expect(shimmer).toBeVisible()
-  await expect(shimmer).toContainText("Creating worktree")
-  await expect(shimmer).toHaveAttribute("data-active", "true")
-  await expect.poll(() => mock.calls).toEqual(["worktree"])
-  expect(mock.creates).toEqual([])
-  expect(mock.prompts).toEqual([])
-  return { url, sessionID, messageID, message, shimmer }
-}
@@ -1,103 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "C:/Projects/extensions-demo"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const session = {
-  id: "ses_project_extensions",
-  title: "Existing session",
-  directory,
-  projectID: "proj_extensions_demo",
-  time: { created: 1700000000000, updated: 1700000000000 },
-}
-
-test.use({ viewport: { width: 1440, height: 1000 }, colorScheme: "dark" })
-
-test("project Extensions stays inside settings while plugins load", async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: session.projectID,
-      canonical: directory,
-      name: "Extensions demo",
-      vcs: "git",
-      time: session.time,
-      sandboxes: [],
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: [session],
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.addInitScript(
-    ({ server, sessionID, directory }) => {
-      localStorage.setItem(
-        "opencode.global.dat:server",
-        JSON.stringify({ projects: { local: [{ worktree: directory, expanded: true }] } }),
-      )
-      localStorage.setItem(
-        "opencode.window.browser.dat:tabs",
-        JSON.stringify([{ type: "session", server, sessionId: sessionID }]),
-      )
-    },
-    { server, sessionID: session.id, directory },
-  )
-  const href = `/server/${base64Encode(server)}/session/${session.id}`
-  await page.goto(href)
-  await expect(page.getByRole("heading", { name: session.title, exact: true })).toBeVisible()
-  await page.keyboard.press("Control+,")
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Projects", exact: true }).click()
-  await settings.getByText("Extensions demo", { exact: true }).click()
-  const dialog = page.getByRole("dialog")
-  await expect(dialog.getByRole("textbox", { name: "Name", exact: true })).toBeFocused()
-
-  const globalPlugins = Promise.withResolvers<void>()
-  const projectPlugins = Promise.withResolvers<void>()
-  await page.route(
-    (url) => url.pathname === "/api/plugin",
-    async (route) => {
-      const project = new URL(route.request().url()).searchParams.get("location[directory]")
-      await (project ? projectPlugins : globalPlugins).promise
-      await route.fulfill({
-        json: {
-          location: project ? { directory: project } : {},
-          data: (project ? ["shared-plugin", "project-plugin"] : ["shared-plugin"]).map((id) => ({
-            id,
-            source: { type: "package", package: id },
-            status: "active",
-            tui: false,
-          })),
-        },
-      })
-    },
-  )
-  const requested = page.waitForRequest((request) => {
-    const url = new URL(request.url())
-    return url.pathname === "/api/plugin" && url.searchParams.get("location[directory]") === directory
-  })
-  await dialog.getByRole("tab", { name: "Extensions", exact: true }).click()
-  await requested
-  await expect(page).toHaveURL(href)
-  await expect(dialog.getByRole("heading", { name: "Extensions", exact: true })).toBeVisible()
-  await expect(settings).toBeVisible()
-  await expect(page.getByRole("heading", { name: session.title, exact: true, includeHidden: true })).toBeHidden()
-  await dialog.getByRole("tab", { name: "Plugins", exact: true }).click()
-  await expect(dialog.getByRole("tab", { name: "Plugins", exact: true })).toHaveAttribute("aria-selected", "true")
-
-  globalPlugins.resolve()
-  await dialog.getByRole("tab", { name: "Scripts", exact: true }).click()
-  await expect(dialog.getByRole("heading", { name: "Scripts", exact: true })).toBeVisible()
-  await dialog.getByRole("tab", { name: "Extensions", exact: true }).click()
-  projectPlugins.resolve()
-  await dialog.getByRole("tab", { name: "Plugins", exact: true }).click()
-  await expect(dialog.getByText("project-plugin", { exact: true })).toBeVisible()
-  await dialog.getByRole("button", { name: "Shared with all projects 1", exact: true }).click()
-  await expect(dialog.getByText("shared-plugin", { exact: true })).toBeVisible()
-  await expect(page).toHaveURL(href)
-
-  await page.keyboard.press("Escape")
-  await expect(dialog).toBeHidden()
-  await expect(settings.getByRole("tab", { name: "Projects", exact: true })).toHaveAttribute("aria-selected", "true")
-  await expect(page.getByRole("heading", { name: session.title, exact: true, includeHidden: true })).toBeHidden()
-})
@@ -3,7 +3,7 @@ import { expect, test, type Page, type Route } from "@playwright/test"
 import { installSseTransport } from "../utils/sse-transport"
 import { currentSession } from "../utils/mock-server"

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

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

 async function mockServers(page: Page) {
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== serverA && url.origin !== serverB) return route.fallback()
    const current = url.origin === serverA ? sessionA : sessionB
@@ -1,89 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { setupTimeline } from "../performance/timeline-stability/fixture"
-
-for (const width of [1400, 390]) {
-  for (const profile of [
-    { locale: "en", direction: "ltr" },
-    { locale: "en", direction: "rtl" },
-    { locale: "ar", direction: "rtl" },
-  ]) {
-    test(`keeps notices on one line: ${profile.locale} ${profile.direction} ${width}`, async ({ page }, info) => {
-      const command =
-        "bun run inspect --target src/renderer/session-timeline.ts --output artifacts/inspection-report.json ".repeat(5)
-      const descriptions = [
-        `${command}--finished`,
-        `Instructions changed\n${command}--updated`,
-        `\u0645\u0631\u0627\u062c\u0639\u0629 ${command}--reviewed`,
-      ]
-      await setupTimeline(page, {
-        locale: profile.locale,
-        viewport: { width, height: 900 },
-        sessionMessages: [
-          {
-            id: "msg_notice_user",
-            type: "user",
-            text: "Inspect the project and report completion.",
-            time: { created: 1 },
-          },
-          {
-            id: "msg_notice_shell",
-            type: "synthetic",
-            text: "Complete",
-            description: descriptions[0],
-            metadata: { source: "shell", state: "completed" },
-            time: { created: 2 },
-          },
-          { id: "msg_notice_system", type: "system", text: descriptions[1], time: { created: 3 } },
-          {
-            id: "msg_notice_agent",
-            type: "synthetic",
-            text: "Complete",
-            description: descriptions[2],
-            metadata: { source: "subagent", state: "completed", agent: "general" },
-            time: { created: 4 },
-          },
-        ],
-      })
-      await page
-        .locator("html")
-        .evaluate((element, direction) => element.setAttribute("dir", direction), profile.direction)
-      const notices = page.locator('[data-slot="session-timeline-notice"]')
-      await expect(notices).toHaveCount(3)
-      await expect(notices).toContainText(descriptions)
-      await page.locator("[data-timeline-virtual-content]").screenshot({ path: info.outputPath("notices.png") })
-      await expect
-        .poll(() =>
-          notices.evaluateAll((nodes) =>
-            nodes.map((node) => {
-              const style = getComputedStyle(node)
-              const element = node as HTMLElement
-              return {
-                direction: style.direction,
-                whiteSpace: style.whiteSpace,
-                textOverflow: style.textOverflow,
-                overflow: style.overflowX,
-                singleLine:
-                  Math.abs(
-                    element.clientHeight -
-                      parseFloat(style.paddingTop) -
-                      parseFloat(style.paddingBottom) -
-                      parseFloat(style.lineHeight),
-                  ) <= 1,
-                clipped: element.scrollWidth > element.clientWidth,
-              }
-            }),
-          ),
-        )
-        .toEqual(
-          Array.from({ length: 3 }, () => ({
-            direction: profile.direction,
-            whiteSpace: "nowrap",
-            textOverflow: "ellipsis",
-            overflow: "hidden",
-            singleLine: true,
-            clipped: true,
-          })),
-        )
-    })
-  }
-}
@@ -1,5 +1,5 @@
 import { expect, test, type Page } from "@playwright/test"
-import type { OpenCodeEvent, SessionMessageInfo } from "@opencode-ai/client/promise"
+import type { OpenCodeEvent } from "@opencode-ai/client/promise"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { mockOpenCodeServer } from "../utils/mock-server"
 import { expectAppVisible } from "../utils/waits"
@@ -18,7 +18,7 @@ type InboxRow = {
  delivery: "steer" | "queue"
 }

-function createQueueMock(seed: string[], messages: SessionMessageInfo[] = []) {
+function createQueueMock(seed: string[]) {
  const rows: InboxRow[] = seed.map((text, index) => ({
    id: `inb_seed_${index + 1}`,
    sessionID,
@@ -32,16 +32,13 @@ function createQueueMock(seed: string[], messages: SessionMessageInfo[] = []) {
  const changes: { inboxID: string; action: "cancel" | "steer" }[] = []
  const log: string[] = []
  let sequence = 0
-  const emit = <Type extends OpenCodeEvent["type"]>(
-    type: Type,
-    data: Extract<OpenCodeEvent, { type: Type }>["data"],
-  ) => {
+  const emit = (type: OpenCodeEvent["type"], data: OpenCodeEvent["data"]) => {
    sequence += 1
    events.push({
      id: `evt_queue_${sequence}`,
      type,
      created: Date.now(),
-      durable: { aggregateID: sessionID, seq: sequence, version: type === "session.tool.success" ? 2 : 1 },
+      durable: { aggregateID: sessionID, seq: sequence, version: 1 },
      data,
    } as OpenCodeEvent)
  }
@@ -50,8 +47,6 @@ function createQueueMock(seed: string[], messages: SessionMessageInfo[] = []) {
    prompts,
    changes,
    log,
-    messages,
-    emit,
    events: () => events.splice(0),
    onPrompt: (input: { sessionID: string; body: Record<string, unknown> }) => {
      prompts.push(input.body)
@@ -131,11 +126,10 @@ async function openSession(page: Page, mock: ReturnType<typeof createQueueMock>,
        directory,
        title: "Session queue regression",
        version: "dev",
-        model: { id: "queue-model", providerID: "opencode" },
        time: { created: 1700000000000, updated: 1700000000000 },
      },
    ],
-    pageMessages: () => ({ items: mock.messages }),
+    pageMessages: () => ({ items: [] }),
    sessionStatus: () => ({ [sessionID]: { type: "running" } }),
    inbox: () => mock.rows.map((row) => ({ ...row, payload: { ...row.payload } })),
    onPrompt: mock.onPrompt,
@@ -233,126 +227,3 @@ test("editing restores the existing draft and replaces only the original queue p
  expect(mock.changes.map((change) => change.action)).toEqual(["cancel", "cancel", "cancel"])
  expect(mock.log[0]).toBe("prompt:queue")
 })
-
-for (const delivery of ["steer", "queue"] as const) {
-  test(`keeps finished tools above a pending ${delivery === "queue" ? "queue-to-steer" : "steer"} follow-up`, async ({
-    page,
-  }, testInfo) => {
-    const model = { id: "queue-model", providerID: "opencode" }
-    const userID = "msg_queue_initial_user"
-    const assistantID = "msg_queue_continued_assistant"
-    const followUp = "U2: Also check the retry path."
-    const mock = createQueueMock(
-      [],
-      [
-        { id: userID, type: "user", text: "U1: Inspect the queue ordering.", time: { created: 1700000000000 } },
-        {
-          id: "msg_queue_initial_assistant",
-          type: "assistant",
-          agent: "build",
-          model,
-          content: [{ type: "text", text: "A1: I will inspect the current implementation." }],
-          finish: "tool-calls",
-          time: { created: 1700000000001, completed: 1700000000002 },
-        },
-      ],
-    )
-    const view = await openSession(page, mock, delivery)
-    const transcript = page.locator("[data-timeline-virtual-content]")
-    const thinking = transcript.locator('[data-timeline-row="Thinking"]')
-    await expect(transcript.getByText("A1: I will inspect the current implementation.", { exact: true })).toBeVisible()
-    await expect(thinking).toHaveCount(0)
-    await expect(view.input).toBeEditable()
-    await view.input.fill(followUp)
-    await view.input.press("Enter")
-    await expect.poll(() => mock.rows.map((row) => row.delivery)).toEqual([delivery])
-    await expect(view.input).toHaveText("")
-
-    const inboxID = mock.rows[0].id
-    const pending = transcript.locator(`[data-timeline-row="UserMessage"][data-message-id="${inboxID}"]`)
-    if (delivery === "queue") {
-      const queued = view.rows.filter({ hasText: followUp })
-      await expect(queued).toBeVisible()
-      await expect(pending).toHaveCount(0)
-      await expect(thinking).toHaveCount(0)
-      await queued.hover()
-      await queued.getByRole("button", { name: "Steer", exact: true }).click()
-      await expect.poll(() => mock.changes).toEqual([{ inboxID, action: "steer" }])
-    }
-    await expect(view.rows).toHaveCount(0)
-    await expect(pending).toContainText(followUp)
-    await expect(thinking).toHaveCount(0)
-
-    // The next assistant step still belongs to U1: U2 has been admitted, not delivered.
-    mock.emit("session.step.started", { sessionID, assistantMessageID: assistantID, agent: "build", model })
-    for (const tool of [
-      { id: "tool_queue_read", name: "read", input: { path: "src/queue.ts" } },
-      { id: "tool_queue_grep", name: "grep", input: { pattern: "retry", path: "src" } },
-    ]) {
-      const ref = { sessionID, assistantMessageID: assistantID, id: tool.id }
-      mock.emit("session.tool.input.started", { ...ref, name: tool.name })
-      mock.emit("session.tool.input.ended", { ...ref, text: JSON.stringify(tool.input) })
-      mock.emit("session.tool.called", { ...ref, input: tool.input, executed: true })
-      mock.emit("session.tool.success", {
-        ...ref,
-        content: [{ type: "text", text: "Inspection complete." }],
-        executed: true,
-      })
-    }
-    mock.emit("session.step.ended", {
-      sessionID,
-      assistantMessageID: assistantID,
-      finish: "tool-calls",
-      cost: 0,
-      tokens: { input: 100, output: 20, reasoning: 0, cache: { read: 0, write: 0 } },
-    })
-    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(thinking).toHaveCount(0)
-    await expect(pending).toBeVisible()
-    expect(mock.rows.map((row) => ({ id: row.id, delivery: row.delivery }))).toEqual([
-      { id: inboxID, delivery: "steer" },
-    ])
-    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(transcript.locator('[data-timeline-row="AssistantPart"]').filter({ has: tools }))
-      .toHaveAttribute("data-message-id", userID)
-    await expect
-      .configure({ soft: true })
-      .poll(async () => {
-        const boxes = await Promise.all([tools.boundingBox(), pending.boundingBox()])
-        return boxes.every((box) => box !== null) && boxes[0]!.y + boxes[0]!.height <= boxes[1]!.y
-      })
-      .toBe(true)
-
-    mock.rows.splice(0, 1)
-    mock.emit("session.inbox.delivered", { sessionID, inboxID })
-    await expect(thinking).toHaveCount(0)
-    await expect(pending).toHaveCount(1)
-    await expect(transcript.locator('[data-timeline-row="UserMessage"]')).toHaveCount(2)
-    await expect(transcript.locator('[data-timeline-row="AssistantPart"]').filter({ has: tools })).toHaveAttribute(
-      "data-message-id",
-      userID,
-    )
-
-    const later = { sessionID, assistantMessageID: "msg_queue_follow_up_assistant" }
-    mock.emit("session.step.started", { ...later, agent: "build", model })
-    mock.emit("session.text.started", { ...later, ordinal: 0 })
-    mock.emit("session.text.ended", { ...later, ordinal: 0, text: "A3: Now checking the retry path for U2." })
-    const response = transcript
-      .locator('[data-timeline-row="AssistantPart"]')
-      .filter({ hasText: "A3: Now checking the retry path for U2." })
-    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/,
-      /U2: Also check the retry path\./,
-      /A3: Now checking the retry path for U2\./,
-    ])
-  })
-}
@@ -1,191 +0,0 @@
-import { expect, test } from "@playwright/test"
-import type { SessionMessageAssistant, ShellInfo } from "@opencode-ai/client/promise"
-import { directory, sessionID, setupTimeline } from "../performance/timeline-stability/fixture"
-
-const shell = {
-  id: "sh_background",
-  status: "running",
-  command: "bun run check",
-  cwd: directory,
-  shell: "bash",
-  file: "/tmp/check.out",
-  metadata: { sessionID },
-  time: { started: 2 },
-} satisfies ShellInfo
-
-for (const grouped of [false, true]) {
-  for (const status of ["exited", "killed", "timeout"] as const) {
-    test(`stops ${grouped ? "grouped" : "standalone"} background shell shimmer when ${status}`, async ({
-      page,
-    }, info) => {
-      const message: SessionMessageAssistant = {
-        id: "msg_background",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [shell.id, "sh_other"].map((id) => ({
-          type: "tool",
-          id: `call_${id}`,
-          name: "shell",
-          state: {
-            status: "completed",
-            input: { command: shell.command },
-            content: [{ type: "text", text: "Command moved to the background." }],
-            metadata: { shellID: id, status: "running" },
-          },
-          time: { created: 2, completed: 3 },
-        })),
-        time: { created: 2, completed: 3 },
-      }
-      if (grouped)
-        message.content.unshift({
-          type: "tool",
-          id: "call_read",
-          name: "read",
-          state: {
-            status: "completed",
-            input: { path: "package.json" },
-            content: [{ type: "text", text: "{}" }],
-            metadata: {},
-          },
-          time: { created: 1, completed: 2 },
-        })
-      const timeline = await setupTimeline(page, {
-        viewport: { width: grouped ? 390 : 1400, height: 900 },
-        settings: { shellToolPartsExpanded: !grouped },
-        sessionStatus: { [sessionID]: { type: "busy" } },
-        sessionMessages: [
-          { id: "msg_user", type: "user", text: "Run two independent checks.", time: { created: 1 } },
-          message,
-        ],
-      })
-      const state = { finished: false, requests: 0 }
-      await page.route("**/api/shell?*", (route) =>
-        route.fulfill({
-          json: { location: { directory }, data: [...(state.finished ? [] : [shell]), { ...shell, id: "sh_other" }] },
-        }),
-      )
-      await page.route("**/api/shell/*/output?*", (route) => {
-        const url = new URL(route.request().url())
-        const target = url.pathname.includes(`/${shell.id}/`)
-        if (target) state.requests++
-        const output = target && state.finished ? "Checking project\nCheck finished\n" : "Checking project\n"
-        const cursor = Number(url.searchParams.get("cursor") ?? 0)
-        const end = Math.min(output.length, cursor + 17)
-        return route.fulfill({
-          json: {
-            location: { directory },
-            data: {
-              output: output.slice(cursor, end),
-              cursor: end,
-              size: output.length,
-              truncated: false,
-            },
-          },
-        })
-      })
-      await page.clock.install()
-      await page.reload()
-      await timeline.transport.waitForConnection()
-      const group = page.locator('[data-component="collapsed-tool-group"]')
-      const groupTrigger = group.locator(':scope > [data-component="collapsible"] > [data-slot="collapsible-trigger"]')
-      if (grouped) {
-        await expect(group).toHaveAttribute("data-timeline-part-ids", "call_read,call_sh_background,call_sh_other")
-        await expect(groupTrigger).toHaveAttribute("aria-expanded", "false")
-        await groupTrigger.click()
-      }
-      const card = page.locator(`[data-timeline-part-id="call_${shell.id}"]`)
-      const shimmer = card.locator('[data-component="text-shimmer"]')
-      const other = page.locator('[data-timeline-part-id="call_sh_other"] [data-component="text-shimmer"]')
-      await expect(shimmer).toHaveAttribute("data-active", "true")
-      await expect(other).toHaveAttribute("data-active", "true")
-      if (grouped) await card.locator('[data-slot="collapsible-trigger"]').click()
-      await expect(card.locator('[data-slot="bash-result"]')).toHaveText("Checking project")
-
-      state.finished = true
-      await timeline.transport.send({
-        id: "evt_shell_exited",
-        created: 4,
-        type: "shell.exited",
-        location: { directory },
-        data: { id: shell.id, status, exit: status === "exited" ? 0 : 1 },
-      })
-      await expect(shimmer).toHaveAttribute("data-active", "false")
-      await expect(other).toHaveAttribute("data-active", "true")
-      await expect(card.locator('[data-slot="bash-result"]')).toHaveText("Checking project\nCheck finished")
-      await expect(card.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "true")
-      await page.locator("[data-timeline-virtual-content]").screenshot({ path: info.outputPath("shell-finished.png") })
-
-      const requests = state.requests
-      await page.clock.fastForward(5_000)
-      expect(state.requests).toBe(requests)
-
-      await page.reload()
-      if (grouped) await groupTrigger.click()
-      await expect(shimmer).toHaveAttribute("data-active", "false")
-      await expect(other).toHaveAttribute("data-active", "true")
-    })
-  }
-}
-
-test("shows the authoritative foreground result after streaming shell output", async ({ page }) => {
-  const timeline = await setupTimeline(page, {
-    settings: { shellToolPartsExpanded: true },
-    sessionMessages: [
-      { id: "msg_user", type: "user", text: "Run the check.", time: { created: 1 } },
-      {
-        id: "msg_foreground",
-        type: "assistant",
-        agent: "build",
-        model: { id: "model", providerID: "provider" },
-        content: [
-          {
-            type: "tool",
-            id: "call_foreground",
-            name: "shell",
-            state: { status: "running", input: { command: shell.command }, metadata: { shellID: shell.id } },
-            time: { created: 2 },
-          },
-        ],
-        time: { created: 2 },
-      },
-    ],
-  })
-  await page.route("**/api/shell/*/output?*", (route) =>
-    route.fulfill({
-      json: {
-        location: { directory },
-        data: {
-          output: Number(new URL(route.request().url()).searchParams.get("cursor")) === 0 ? "Checking project\n" : "",
-          cursor: 17,
-          size: 17,
-          truncated: false,
-        },
-      },
-    }),
-  )
-  await page.reload()
-  await timeline.transport.waitForConnection()
-  const card = page.locator('[data-timeline-part-id="call_foreground"]')
-  const shimmer = card.locator('[data-component="text-shimmer"]')
-  await expect(shimmer).toHaveAttribute("data-active", "true")
-  await expect(card.locator('[data-slot="bash-result"]')).toHaveText("Checking project")
-  await timeline.transport.send({
-    id: "evt_foreground_complete",
-    created: 3,
-    type: "session.tool.success",
-    durable: { aggregateID: sessionID, seq: 0, version: 2 },
-    data: {
-      sessionID,
-      assistantMessageID: "msg_foreground",
-      id: "call_foreground",
-      executed: true,
-      content: [{ type: "text", text: "Checking project\nCheck finished\nCommand exited with code 0." }],
-      metadata: { status: "completed", exit: 0 },
-    },
-  })
-  await expect(shimmer).toHaveAttribute("data-active", "false")
-  await expect(card.locator('[data-slot="bash-result"]')).toHaveText(
-    "Checking project\nCheck finished\nCommand exited with code 0.",
-  )
-})
@@ -84,39 +84,6 @@ const assistantMessage = {
 } satisfies SessionMessageInfo

 test.describe("regression: session timeline local row state", () => {
-  test("preserves a patch file choice as new calls join its Used group", async ({ page }) => {
-    const events: EventPayload[] = []
-    const part = { ...editPart, tool: "patch" }
-    await mockServer(page, events, [userMessage, { ...assistantMessage, content: [toolContent(part)] }])
-    await configurePage(page, false)
-    await page.goto(sessionHref())
-    await expectSessionTitle(page, title)
-
-    const group = page.locator('[data-component="collapsed-tool-group"]')
-    const summary = group.getByRole("button", { name: "Used Patch", exact: true })
-    await summary.click()
-    await group.locator(`[data-timeline-part-id="${editPartID}"]`).evaluate((element) => {
-      element.setAttribute("data-disclosure-probe", "existing")
-    })
-    const wrapper = group.locator('[data-disclosure-probe="existing"]')
-    const trigger = wrapper.locator('[data-scope="apply-patch"] button')
-    await expect(trigger).toHaveAttribute("aria-expanded", "false")
-    await trigger.click()
-    await expect(trigger).toHaveAttribute("aria-expanded", "true")
-    const original = await wrapper.elementHandle()
-
-    for (const count of [2, 3]) {
-      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(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")
-      expect(await original!.evaluate((node) => node.isConnected)).toBe(true)
-    }
-  })
-
  test("keeps a manually collapsed tool collapsed when later assistant content streams", async ({ page }) => {
    const events: EventPayload[] = []
    await mockServer(page, events)
@@ -241,19 +208,19 @@ test.describe("regression: session timeline local row state", () => {
  })
 })

-async function configurePage(page: Page, expanded = true) {
-  await page.addInitScript((expanded) => {
+async function configurePage(page: Page) {
+  await page.addInitScript(() => {
    localStorage.setItem(
      "settings.v3",
      JSON.stringify({
        general: {
-          editToolPartsExpanded: expanded,
-          shellToolPartsExpanded: expanded,
+          editToolPartsExpanded: true,
+          shellToolPartsExpanded: true,
          showReasoningSummaries: true,
        },
      }),
    )
-  }, expanded)
+  })
 }

 async function expectExpanded(locator: Locator, expected: boolean) {
@@ -109,85 +109,31 @@ test("shimmers and expands a running shell command", async ({ page }) => {
  await expect(tool.locator('[data-slot="bash-pre"]')).toContainText("still running")
 })

-for (const open of [false, true]) {
-  test(`keeps ${open ? "expanded" : "collapsed"} reasoning intent from Thinking through standalone shell into Used`, async ({
-    page,
-  }) => {
-    const reasoningID = `prt_reasoning_hidden_${open}`
-    const shellID = `prt_reasoning_shell_${open}`
-    const assistant = assistantMessage([reasoningPart(reasoningID, "## Inspecting stability")], { completed: false })
-    const timeline = await setupTimeline(page, {
-      messages: [userMessage(), assistant],
-      settings: { showReasoningSummaries: false },
-      cpuRate: 4,
-    })
-    const reasoning = page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
-    await expect(page.getByText("Inspecting stability", { exact: true })).toBeVisible()
-    const thought = reasoning.locator('[data-slot="collapsible-trigger"]')
-    await expect(thought).toHaveAttribute("aria-expanded", "false")
-    await thought.click()
-    await expect(thought).toHaveAttribute("aria-expanded", "true")
-    if (!open) await thought.click()
-    await expect(thought).toHaveAttribute("aria-expanded", String(open))
-    await timeline.send(partUpdated(shell(shellID, "running")))
-    const group = page.locator('[data-component="collapsed-tool-group"]')
-    await expect(page.locator(`[data-timeline-part-id="${shellID}"]`)).toBeVisible()
-    await expect(group).toHaveCount(0)
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-    await expect(thought).toContainText("Thought")
-    await expect(thought).not.toContainText("Inspecting stability")
-    await expect(thought).toHaveAttribute("aria-expanded", String(open))
-    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 })
-    await expect(used).toHaveAttribute("aria-expanded", "false")
-    await used.click()
-    await expect(used).toHaveAttribute("aria-expanded", "true")
-    await expect(group.locator(`[data-timeline-part-id="${shellID}"]`)).toBeVisible()
-    await expect(group.getByRole("button", { name: "Thought", exact: true })).toHaveAttribute(
-      "aria-expanded",
-      String(open),
-    )
-    await expect(group.locator('[data-component="tag"]')).toHaveText("1")
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-    await expect(used).toHaveAttribute("aria-expanded", "true")
-    if (!open) await thought.click()
-    await expect(reasoning.getByRole("heading", { name: "Inspecting stability", exact: true })).toBeVisible()
-    await used.click()
-    await expect(used).toHaveAttribute("aria-expanded", "false")
-    await used.click()
-    await expect(reasoning.getByRole("button", { name: "Thought", exact: true })).toHaveAttribute(
-      "aria-expanded",
-      "true",
-    )
-    await expect(reasoning.getByRole("heading", { name: "Inspecting stability", exact: true })).toBeVisible()
+test("transitions thinking and hidden reasoning through busy to idle", async ({ page }) => {
+  const reasoningID = "prt_reasoning_hidden"
+  const assistant = assistantMessage([reasoningPart(reasoningID, "## Inspecting stability")], { completed: false })
+  const timeline = await setupTimeline(page, {
+    messages: [userMessage(), assistant],
+    settings: { showReasoningSummaries: false },
+    cpuRate: 4,
  })
-}
+  await timeline.send(status("busy"), 150)

-for (const transition of ["reasoning-end", "idle", "retry"] as const) {
-  test(`stops active Thinking on ${transition} without a following tool`, async ({ page }) => {
-    const id = `prt_reasoning_stop_${transition}`
-    const text = "## Inspecting stability\n\nThe timeline is ready for the next step."
-    const timeline = await setupTimeline(page, {
-      messages: [userMessage(), assistantMessage([reasoningPart(id, text)], { completed: false })],
-    })
-    const part = page.locator(`[data-timeline-part-id="${renderedPartID(id)}"]`)
-    const trigger = part.locator('[data-slot="collapsible-trigger"]')
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
-    await expect(trigger).toHaveAttribute("aria-expanded", "false")
-    await timeline.send(transition === "reasoning-end" ? partUpdated(reasoningPart(id, text)) : status(transition))
-    await expect(trigger).toContainText("Thought")
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-    await expect(page.locator('[data-timeline-row="Retry"]')).toHaveCount(transition === "retry" ? 1 : 0)
-    await trigger.click()
-    await expect(trigger).toHaveAttribute("aria-expanded", "true")
-    await expect(part.getByText("The timeline is ready for the next step.", { exact: true })).toBeVisible()
-  })
-}
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
+  await expect(page.getByText("Inspecting stability", { exact: true })).toBeVisible()
+  await expect(page.locator(`[data-timeline-part-id="${reasoningID}"]`)).toHaveCount(0)
+  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)).toHaveCount(0)
+  await timeline.send(partUpdated(shell("prt_reasoning_shell", "running")), 160)
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
+  await timeline.send(partUpdated(shell("prt_reasoning_shell", "completed", "done")), 180)
+  await timeline.send(messageUpdated(completedAssistantInfo(assistant)), 100)
+  await timeline.send(status("idle"), 300)
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
+  await expect(page.locator(`[data-timeline-part-id="${reasoningID}"]`)).toHaveCount(0)
+  await expect(page.locator(`[data-timeline-part-id="${renderedPartID(reasoningID)}"]`)).toHaveCount(0)
+})

-test("does not infer Thinking from busy, retry, or recovery without reasoning", async ({ page }) => {
+test("moves busy through retry and recovery to final idle content", async ({ page }) => {
  const assistant = assistantMessage([], { completed: false })
  const timeline = await setupTimeline(page, {
    messages: [
@@ -207,17 +153,18 @@ test("does not infer Thinking from busy, retry, or recovery without reasoning",
      assistant,
    ],
  })
-  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
+  await timeline.send(status("busy"), 140)
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
  await expect(page.locator('[data-timeline-row="DiffSummary"]')).toHaveCount(0)
-  await timeline.send(status("retry"))
+  await timeline.send(status("retry"), 180)
  await expect(page.locator('[data-timeline-row="Retry"]')).toBeVisible()
  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-  await timeline.send(stepStarted(assistant))
+  await timeline.send(stepStarted(assistant), 180)
  await expect(page.locator('[data-timeline-row="Retry"]')).toHaveCount(0)
-  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
-  await timeline.send(partUpdated(textPart("prt_recovered", "Recovered response")))
-  await timeline.send(messageUpdated(completedAssistantInfo(assistant)))
-  await timeline.send(status("idle"))
+  await expect(page.locator('[data-timeline-row="Thinking"]')).toBeVisible()
+  await timeline.send(partUpdated(textPart("prt_recovered", "Recovered response")), 140)
+  await timeline.send(messageUpdated(completedAssistantInfo(assistant)), 100)
+  await timeline.send(status("idle"), 350)
  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
  await expect(page.locator(`[data-timeline-part-id="${renderedPartID("prt_recovered")}"]`)).toContainText(
    "Recovered response",
@@ -5,7 +5,6 @@ import {
  compactionEnded,
  compactionFailed,
  compactionStarted,
-  directory,
  event,
  session,
  sessionID,
@@ -209,56 +208,6 @@ test("navigates from a running subagent card and hides background controls in th
  await expect(page.getByText(/move running work to the background/i)).toHaveCount(0)
 })

-for (const name of ["shell", "subagent"] as const) {
-  test(`keeps the background shortcut available for a grouped running ${name}`, async ({ page }) => {
-    const message = assistant(false, true)
-    await setupTimeline(page, {
-      sessionMessages: [
-        user,
-        {
-          ...message,
-          content: [
-            {
-              type: "tool",
-              id: "call_read",
-              name: "read",
-              state: {
-                status: "completed",
-                input: { path: "src/example.ts" },
-                content: [{ type: "text", text: "export const example = true" }],
-                metadata: {},
-              },
-              time: { created: 1, completed: 2 },
-            },
-            {
-              type: "tool",
-              id: "call_running",
-              name,
-              state: {
-                status: "running",
-                input:
-                  name === "shell" ? { command: "echo checking" } : { agent: "general", description: "Inspect code" },
-                metadata: {},
-              },
-              time: { created: 3 },
-            },
-          ],
-        },
-      ],
-    })
-    const group = page.locator('[data-timeline-part-ids="call_read,call_running"]')
-    await expect(group).toBeVisible()
-    await expect(group.locator('[data-slot="collapsible-trigger"]')).toHaveAttribute("aria-expanded", "false")
-    await expect(page.locator('[data-component="session-background-hint"]')).toBeVisible()
-    const request = page.waitForRequest(
-      (request) =>
-        request.method() === "POST" && new URL(request.url()).pathname === `/api/session/${sessionID}/background`,
-    )
-    await page.keyboard.press("Control+b")
-    await request
-  })
-}
-
 test("shows a badge for active background work", async ({ page }) => {
  const childID = "ses_background_child"
  await setupTimeline(page, {
@@ -349,24 +298,6 @@ test("separates blocking and already-backgrounded work into two rows", async ({
    },
  })

-  await timeline.transport.send({
-    id: "evt_background_shell_created",
-    created: 3,
-    type: "shell.created",
-    location: { directory },
-    data: {
-      info: {
-        id: "shell_backgrounded",
-        status: "running",
-        command: "sleep 120",
-        cwd: directory,
-        shell: "bash",
-        file: "/tmp/background.out",
-        metadata: { sessionID },
-        time: { started: 2 },
-      },
-    },
-  })
  const backgroundCard = page.locator('[data-timeline-part-id="call_backgrounded"]')
  await expect(page.getByText(/move running work to the background/i)).toBeVisible()
  await page.getByRole("button", { name: "Session details" }).click()
@@ -4,144 +4,89 @@ import {
  assistantMessage,
  reasoningPart,
  setupTimeline,
+  status,
  textPart,
  toolPart,
  userMessage,
 } from "../performance/timeline-stability/fixture"

-test("changes live reasoning through Settings and persists Hidden, Compact, and Full", async ({ page }) => {
-  await setupTimeline(page, {
-    messages: [
-      userMessage(),
-      assistantMessage(
-        [
-          reasoningPart(
-            "prt_reasoning_settings",
-            "## Inspecting stability\n\nThe selected mode controls these details.",
-          ),
-        ],
-        { completed: false },
-      ),
-    ],
-  })
-  const part = page.locator(`[data-timeline-part-id="${assistantID}:reasoning:0"]`)
-  await expect(part.getByRole("button")).toHaveAttribute("aria-expanded", "false")
-  const settings = page.getByTestId("settings-screen")
-  const select = settings.locator('[data-action="settings-reasoning-mode"] [data-component="select-v2"]')
-  for (const label of ["Full", "Hidden", "Compact"] as const) {
-    await page.keyboard.press("Control+,")
-    await expect(settings.getByText("Model reasoning", { exact: true })).toBeVisible()
-    await expect(select).toHaveAttribute("aria-expanded", "false")
-    await select.click()
-    await expect(page.getByRole("listbox").getByRole("option")).toHaveText(["Hidden", "Compact", "Full"])
-    await page.getByRole("option", { name: label, exact: true }).click()
-    await expect(select).toHaveText(label)
-    await expect(select).toHaveAttribute("aria-expanded", "false")
-    await expect
-      .poll(() => page.evaluate(() => JSON.parse(localStorage.getItem("settings.v3") ?? "{}").general?.reasoningMode))
-      .toBe(label.toLowerCase())
-    await settings.getByRole("button", { name: "Back to app", exact: true }).click()
-    await expect(settings).toBeHidden()
-    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(label === "Hidden" ? 0 : 1)
-    await expect(part).toHaveCount(label === "Hidden" ? 0 : 1)
-    if (label === "Hidden") {
-      await expect(page.getByText("The selected mode controls these details.", { exact: true })).toBeHidden()
-      continue
-    }
-    await expect(part.getByRole("button")).toHaveAttribute("aria-expanded", String(label === "Full"))
-    if (label === "Full")
-      await expect(part.getByText("The selected mode controls these details.", { exact: true })).toBeVisible()
-    if (label === "Compact") {
-      await expect(part.getByRole("button")).toContainText("Inspecting stability")
-      await expect(part.getByText("The selected mode controls these details.", { exact: true })).toBeHidden()
-    }
-  }
-  await page.keyboard.press("Control+,")
-  await expect(select).toHaveText("Compact")
-})
+const profiles = [
+  { name: "summaries off no reasoning", summaries: false, reasoning: "", other: false, thinking: true, body: false },
+  {
+    name: "summaries off reasoning heading",
+    summaries: false,
+    reasoning: "## Inspecting stability",
+    other: false,
+    thinking: true,
+    body: false,
+  },
+  {
+    name: "summaries off with visible tool",
+    summaries: false,
+    reasoning: "## Inspecting stability",
+    other: true,
+    thinking: true,
+    body: false,
+  },
+  { name: "summaries on no content", summaries: true, reasoning: "", other: false, thinking: true, body: false },
+  {
+    name: "summaries on blank reasoning",
+    summaries: true,
+    reasoning: "   ",
+    other: false,
+    thinking: true,
+    body: false,
+  },
+  {
+    name: "summaries on visible reasoning",
+    summaries: true,
+    reasoning: "## Inspecting stability",
+    other: false,
+    thinking: false,
+    body: true,
+  },
+  {
+    name: "summaries on visible tool no reasoning",
+    summaries: true,
+    reasoning: "",
+    other: true,
+    thinking: false,
+    body: false,
+  },
+] as const

-// The persisted boolean migrates to compact (false) or full (true).
-for (const summaries of [false, true]) {
-  for (const profile of ["none", "blank", "heading", "tool", "text"] as const) {
-    test(`projects legacy ${summaries ? "full" : "compact"} reasoning with ${profile}`, async ({ page }) => {
-      await setupTimeline(page, {
-        messages: [
-          userMessage(),
-          assistantMessage(
-            [
-              ...(profile === "none"
-                ? []
-                : [
-                    reasoningPart(
-                      `prt_reasoning_${summaries}_${profile}`,
-                      profile === "blank"
-                        ? "   "
-                        : "## Inspecting stability\n\nI will inspect the timeline before changing its state.",
-                    ),
-                  ]),
-              ...(profile === "tool"
-                ? [toolPart(`prt_reasoning_tool_${summaries}`, "skill", "running", { name: "inspect" })]
-                : []),
-              ...(profile === "text" ? [textPart(`prt_reasoning_text_${summaries}`, "The timeline is stable.")] : []),
-            ],
-            { completed: false },
-          ),
-        ],
-        settings: { showReasoningSummaries: summaries },
-      })
-      const part = page.locator(`[data-timeline-part-id="${assistantID}:reasoning:0"]`)
-      await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(
-        profile === "blank" || profile === "heading" ? 1 : 0,
-      )
-      if (profile === "none") {
-        await expect(part).toHaveCount(0)
-        return
-      }
-      if (profile === "blank") {
-        await expect(part).toContainText("Thinking")
-        await expect(part.getByRole("heading")).toHaveCount(0)
-        return
-      }
-      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).toHaveAttribute("aria-expanded", "false")
-        await expect(page.getByText("Inspecting stability", { exact: true })).toBeHidden()
-        await expect(group.locator('[data-component="tag"]')).toHaveText("1")
-        await used.click()
-        await expect(used).toHaveAttribute("aria-expanded", "true")
-        await expect(group.locator(`[data-timeline-part-id="prt_reasoning_tool_${summaries}"]`)).toBeVisible()
-        await expect(group.locator('[data-component="reasoning-part"]')).toHaveCount(1)
-      }
-      if (profile === "text") await expect(page.getByText("The timeline is stable.", { exact: true })).toBeVisible()
-      const trigger = part.locator('[data-slot="collapsible-trigger"]')
-      const body = part.getByText("I will inspect the timeline before changing its state.", { exact: true })
-      await expect(trigger).toContainText(profile === "heading" ? "Thinking" : "Thought")
-      await expect(trigger).toHaveAttribute("aria-expanded", String(summaries))
-      if (!summaries) {
-        await expect(body).toBeHidden()
-        if (profile === "heading") await expect(trigger).toContainText("Inspecting stability")
-        await trigger.click()
-        await expect(trigger).toHaveAttribute("aria-expanded", "true")
-      }
-      await expect(body).toBeVisible()
-      await trigger.click()
-      await expect(trigger).toHaveAttribute("aria-expanded", "false")
-      await expect(body).toBeHidden()
-      if (profile !== "heading") await expect(trigger).not.toContainText("Inspecting stability")
+for (const profile of profiles) {
+  test(`projects busy reasoning profile ${profile.name}`, async ({ page }) => {
+    const reasoningID = `prt_reasoning_matrix_${profiles.indexOf(profile)}`
+    const parts = [
+      ...(profile.reasoning ? [reasoningPart(reasoningID, profile.reasoning)] : []),
+      ...(profile.other
+        ? [toolPart(`prt_reasoning_tool_${profiles.indexOf(profile)}`, "skill", "running", { name: "inspect" })]
+        : []),
+    ]
+    const timeline = await setupTimeline(page, {
+      messages: [userMessage(), assistantMessage(parts, { completed: false })],
+      settings: { showReasoningSummaries: profile.summaries },
    })
-  }
+    await timeline.send(status("busy"), 150)
+
+    await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(profile.thinking ? 1 : 0)
+    await expect(page.locator(`[data-timeline-part-id="${assistantID}:reasoning:0"]`)).toHaveCount(profile.body ? 1 : 0)
+    if (!profile.summaries && profile.reasoning.trim()) {
+      await expect(page.getByText("Inspecting stability", { exact: true })).toBeVisible()
+    }
+  })
 }

 test("does not infer reasoning visibility from provider identity", async ({ page }) => {
-  await setupTimeline(page, {
+  const timeline = await setupTimeline(page, {
    messages: [
      userMessage(),
      assistantMessage([textPart("prt_provider_text", "No reasoning payload")], { completed: false }),
    ],
    settings: { showReasoningSummaries: true },
  })
+  await timeline.send(status("busy"), 150)

  await expect(page.locator('[data-timeline-row="Thinking"]')).toHaveCount(0)
  await expect(page.locator('[data-timeline-part-id*="reasoning"]')).toHaveCount(0)
@@ -1,5 +1,4 @@
 import { expect, test } from "@playwright/test"
-import { createTwoFilesPatch } from "diff"
 import {
  assistantMessage,
  completedAssistantInfo,
@@ -45,7 +44,7 @@ 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 Shell, Explore, Patch" })
  await expect(summary).toHaveAttribute("aria-expanded", "false")
  await expect(summary).toHaveCSS("height", "28px")
  await expect(group.locator('[data-component="tag"]')).toHaveText("4")
@@ -79,61 +78,6 @@ test("leaves tools expanded by settings outside the collapsed stack", async ({ p
  await expect(page.locator('[data-timeline-spacing="tool"]')).toHaveCSS("padding-top", "8px")
 })

-test("combines follow-up patches into one three-file stack inside Used", async ({ page }) => {
-  const file = (path: string, before: number, after: number) => ({
-    file: path,
-    status: "modified",
-    additions: 1,
-    deletions: 1,
-    patch: createTwoFilesPatch(
-      path,
-      path,
-      `export const value = ${before}\n`,
-      `export const value = ${after}\n`,
-      "",
-      "",
-      { context: Infinity },
-    ),
-  })
-  const timeline = await setupTimeline(page, {
-    messages: [
-      userMessage(),
-      assistantMessage([
-        shell("patch_shell", "completed"),
-        toolPart(
-          "patch_first",
-          "patch",
-          "completed",
-          {},
-          {
-            metadata: { files: [file("src/a.ts", 0, 1), file("src/b.ts", 0, 1)] },
-          },
-        ),
-      ]),
-    ],
-  })
-  const group = page.locator('[data-component="collapsed-tool-group"]')
-  await group.getByRole("button", { name: "Used Shell, Patch", exact: true }).click()
-  await expect(group.getByText("2 files", { exact: true })).toBeVisible()
-  await timeline.send(
-    partUpdated(
-      toolPart(
-        "patch_next",
-        "patch",
-        "completed",
-        {},
-        {
-          metadata: { files: [file("src/a.ts", 1, 2), file("src/c.ts", 0, 1)] },
-        },
-      ),
-    ),
-  )
-  await expect(group.locator('[data-component="tag"]')).toHaveText("3")
-  await expect(group.locator('[data-component="apply-patch-tool"]')).toHaveCount(1)
-  await expect(group.getByText("3 files", { exact: true })).toBeVisible()
-  await expect(group.locator('[data-slot="apply-patch-filename"]')).toHaveText(["a.ts", "b.ts", "c.ts"])
-})
-
 test("keeps failed search calls and their error cards inside the collapsed stack", async ({ page }) => {
  const parts = [
    toolPart(
@@ -1,121 +0,0 @@
-import { expect, test } from "@playwright/test"
-import { mockOpenCodeServer } from "../utils/mock-server"
-
-const directory = "C:/Projects/settings-demo"
-const sandboxes = Array.from({ length: 12 }, (_, index) => `${directory}/workspace-${index + 1}`)
-
-test.use({ viewport: { width: 1440, height: 1000 }, colorScheme: "dark" })
-
-test.beforeEach(async ({ page }) => {
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: "proj_settings_demo",
-      canonical: directory,
-      name: "Settings demo",
-      vcs: "git",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes,
-    },
-    provider: { all: [], connected: [], default: {} },
-    sessions: sandboxes.map((directory, index) => ({
-      id: `ses_settings_${index + 1}`,
-      title: `Workspace ${index + 1} session`,
-      directory,
-      projectID: "proj_settings_demo",
-      time: { created: 1700000000000, updated: 1700000000000 },
-    })),
-    pageMessages: () => ({ items: [] }),
-  })
-  await page.goto("/")
-  await page.getByRole("button", { name: "Settings", exact: true }).click()
-  await expect(page.getByTestId("settings-screen").getByRole("tab", { name: "Preferences" })).toBeVisible()
-})
-
-test("workspaces opens without waiting for inventory or sessions", async ({ page }) => {
-  const inventory = Promise.withResolvers<void>()
-  const sessions = Promise.withResolvers<void>()
-  await page.route("**/api/worktree/*", async (route) => {
-    await inventory.promise
-    await route.fallback()
-  })
-  await page.route("**/api/session?*", async (route) => {
-    if (new URL(route.request().url()).searchParams.has("directory")) await sessions.promise
-    await route.fallback()
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest((request) => new URL(request.url()).pathname.startsWith("/api/worktree/"))
-  await settings.getByRole("tab", { name: "Workspaces", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("heading", { name: "Workspaces", exact: true })).toBeVisible()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeVisible()
-  await expect(settings.getByText("No workspaces", { exact: true })).toHaveCount(0)
-
-  inventory.resolve()
-  await expect(settings.getByText(sandboxes[0], { exact: true })).toBeVisible()
-  await expect(settings.getByText("12 workspaces", { exact: true })).toBeVisible()
-  sessions.resolve()
-  await expect(settings.getByText("Workspace 1 session", { exact: true })).toBeVisible()
-
-  const refresh = Promise.withResolvers<void>()
-  await page.route("**/api/worktree/*", async (route) => {
-    await refresh.promise
-    await route.fallback()
-  })
-  await settings.getByRole("tab", { name: "Preferences", exact: true }).click()
-  await settings.getByRole("tab", { name: "Workspaces", exact: true }).click()
-  await expect(settings.getByText("Workspace 1 session", { exact: true })).toBeVisible()
-  refresh.resolve()
-})
-
-test("extensions opens without waiting for MCPs or plugins", async ({ page }) => {
-  const mcps = Promise.withResolvers<void>()
-  const plugins = Promise.withResolvers<void>()
-  await page.route("**/api/mcp", async (route) => {
-    await mcps.promise
-    await route.fulfill({
-      json: { location: { directory }, data: [{ name: "demo-mcp", status: { status: "connected" } }] },
-    })
-  })
-  await page.route("**/api/plugin", async (route) => {
-    await plugins.promise
-    await route.fulfill({
-      json: {
-        location: { directory },
-        data: [
-          { id: "demo-plugin", source: { type: "package", package: "demo-plugin" }, status: "active", tui: false },
-        ],
-      },
-    })
-  })
-  const settings = page.getByTestId("settings-screen")
-  const requested = page.waitForRequest((request) => new URL(request.url()).pathname === "/api/mcp")
-  await settings.getByRole("tab", { name: "Extensions", exact: true }).click()
-  await requested
-  await expect(settings.getByRole("heading", { name: "Extensions", exact: true })).toBeVisible()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeVisible()
-  await settings.getByRole("tab", { name: "Plugins", exact: true }).click()
-  await expect(settings.getByRole("tab", { name: "Plugins", exact: true })).toHaveAttribute("aria-selected", "true")
-  plugins.resolve()
-  await expect(settings.getByText("demo-plugin", { exact: true })).toBeVisible()
-  mcps.resolve()
-  await settings.getByRole("tab", { name: "MCPs", exact: true }).click()
-  await expect(settings.getByRole("switch", { name: "demo-mcp" })).toBeChecked()
-})
-
-test("workspace inventory uses the settings panel scroll area", async ({ page }) => {
-  const settings = page.getByTestId("settings-screen")
-  await settings.getByRole("tab", { name: "Workspaces", exact: true }).click()
-  await expect(settings.getByText("Workspace 1 session", { exact: true })).toBeVisible()
-  const list = settings.locator('[data-component="settings-list"]')
-  await expect(list).toHaveCSS("max-height", "none")
-  await expect(list).toHaveCSS("overflow-y", "visible")
-  await settings.getByText("Workspace 12 session", { exact: true }).scrollIntoViewIfNeeded()
-  await expect(settings.getByText("Workspace 12 session", { exact: true })).toBeInViewport()
-  await expect(settings.getByRole("button", { name: "Back to app" })).toBeInViewport()
-  await page.setViewportSize({ width: 390, height: 844 })
-  await expect(list).toHaveCSS("max-height", "none")
-  await expect(list).toHaveCSS("overflow-y", "visible")
-  await settings.getByText("Workspace 12 session", { exact: true }).scrollIntoViewIfNeeded()
-  await expect(settings.getByText("Workspace 12 session", { exact: true })).toBeInViewport()
-})
@@ -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 Explore" }).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 Explore" }).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 Explore" }).click()

  const card = page.locator(`a[href="${sessionHref(childID)}"]`)
  await expect(card).toBeVisible()
@@ -1,9 +1,8 @@
 import { expect, test, type Page, type Route } from "@playwright/test"
 import { base64Encode } from "@opencode-ai/util/encode"
 import { currentSession } from "../utils/mock-server"
-import pkg from "../../package.json" with { type: "json" }

-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
+const server = "http://127.0.0.1:4096"
 const sessionA = session("ses_tab_a", "Tab A session")
 const sessionB = session("ses_tab_b", "Tab B session")
 const sessionC = session("ses_tab_c", "Tab C session")
@@ -176,9 +175,6 @@ test("appearance experimental setting switches tab orientation", async ({ page }

  const settings = page.getByTestId("settings-screen")
  await expect(settings).toBeVisible()
-  const version = settings.getByRole("tablist").getByText(`v${pkg.version}`, { exact: true })
-  await expect(settings.getByRole("tablist").getByText("OpenCode Desktop", { exact: true })).toBeInViewport()
-  await expect(version).toBeInViewport()
  await settings.getByRole("tab", { name: "Appearance" }).click()
  await expect(settings.getByRole("heading", { name: "Experimental" })).toBeVisible()

@@ -198,17 +194,6 @@ test("appearance experimental setting switches tab orientation", async ({ page }

  await page.setViewportSize({ width: 800, height: 720 })
  await expect(settings.getByRole("tablist")).toHaveCSS("width", "160px")
-  await expect(version).toBeInViewport()
-
-  await page.setViewportSize({ width: 390, height: 720 })
-  await expect(version).toBeInViewport()
-  await settings.evaluate((element) => element.setAttribute("dir", "rtl"))
-  await expect(version).toBeInViewport()
-  await expect(version).toHaveCSS("direction", "ltr")
-
-  await page.setViewportSize({ width: 390, height: 360 })
-  await version.scrollIntoViewIfNeeded()
-  await expect(version).toBeInViewport()
 })

 test("vertical tab preference falls back to horizontal on mobile", async ({ page }) => {
@@ -253,7 +238,7 @@ function session(id: string, title: string) {

 async function mockServer(page: Page) {
  const sessions = [sessionA, sessionB, sessionC]
-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    if (url.origin !== server) return route.fallback()
    if (url.pathname === `/api/session/${unresolvedSessionID}`) return new Promise(() => {})
@@ -1,194 +0,0 @@
-import { expect, test, type Locator, type Page } from "@playwright/test"
-import type { OpenCodeEvent, WorktreeDirectory } from "@opencode-ai/client/promise"
-import { base64Encode } from "@opencode-ai/util/encode"
-import { mockOpenCodeServer } from "../utils/mock-server"
-import { expectAppVisible, expectSessionReady } from "../utils/waits"
-
-const root = "C:/OpenCode/WorkspaceAccent"
-const workspace = `${root}/.worktrees/feature`
-const projectID = "proj_workspace_accent"
-const sessionID = "ses_workspace_accent"
-const title = "Workspace accent regression"
-const server = `http://${process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"}:${process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"}`
-const inventory: WorktreeDirectory[] = [
-  { directory: root },
-  { directory: workspace, strategy: "git" },
-  { directory: "C:/OpenCode/LinkedWorkspace", strategy: "git" },
-  { directory: "C:/OpenCode/WorkspaceCopy", strategy: "copy" },
-  { directory: "C:/OpenCode/RegisteredDirectory" },
-]
-
-test.use({ serviceWorkers: "block" })
-
-for (const scenario of [
-  { name: "managed Git worktree", directory: workspace, accent: true },
-  { name: "linked Git worktree outside main", directory: "C:/OpenCode/LinkedWorkspace", accent: true },
-  {
-    name: "linked Git worktree on a narrow screen",
-    directory: "C:/OpenCode/LinkedWorkspace",
-    accent: true,
-    viewport: { width: 390, height: 844 },
-  },
-  { name: "main root with Windows case and separators", directory: "c:\\OPENCODE\\workspaceaccent\\", accent: false },
-  { name: "nested main directory", directory: `${root}/packages/app`, accent: false },
-  { name: "nested workspace inside main", directory: `${workspace}/packages/app`, accent: true },
-  {
-    name: "workspace with Windows case and separators",
-    directory: "c:\\opencode\\WORKSPACEACCENT\\.worktrees\\FEATURE\\src\\",
-    accent: true,
-  },
-  { name: "unregistered sibling with the same prefix", directory: `${workspace}-unregistered`, accent: false },
-  { name: "workspace using another strategy", directory: "C:/OpenCode/WorkspaceCopy", accent: true },
-  { name: "registered directory without a strategy", directory: "C:/OpenCode/RegisteredDirectory", accent: true },
-]) {
-  test(`existing session send button: ${scenario.name}`, async ({ page }, testInfo) => {
-    if (scenario.viewport) await page.setViewportSize(scenario.viewport)
-    const view = await openSession(page, scenario.directory)
-    await view.input.fill("Inspect this fixture workspace.")
-    await expect(view.send).toBeEnabled()
-
-    if (scenario.name === "managed Git worktree") {
-      // Capture before the color assertion so both red and green runs have evidence.
-      const path = testInfo.outputPath("workspace-accent.png")
-      await view.composer.screenshot({ path })
-      await testInfo.attach("workspace-accent", { path, contentType: "image/png" })
-    }
-
-    await expectBackground(view.send, scenario.accent ? "accent" : "contrast")
-    const message = page.locator('[data-slot="user-message-text"]')
-    await expect(message).toHaveText("Check this fixture workspace.")
-    await expectBackground(message, scenario.accent ? "accent" : "layer-02", "background-color")
-  })
-}
-
-test("inventory updates recolor the send button without navigation; disabled and stop stay neutral", async ({
-  page,
-}) => {
-  const view = await openSession(page, workspace, [{ directory: root }])
-  await view.input.fill("Keep this draft while the inventory changes.")
-  await expect(view.send).toBeEnabled()
-  await expectBackground(view.send, "contrast")
-  const url = page.url()
-
-  const refreshed = page.waitForResponse(
-    (response) =>
-      new URL(response.url()).pathname === `/api/worktree/${projectID}` && response.request().method() === "GET",
-  )
-  view.worktrees.push({ directory: workspace, strategy: "git" })
-  view.events.push({
-    id: "evt_workspace_accent_inventory",
-    created: 1700000001000,
-    type: "worktree.updated",
-    data: { projectID },
-  })
-  expect((await refreshed).ok()).toBe(true)
-  await expectBackground(view.send, "accent")
-  await expect(page).toHaveURL(url)
-  await expect(view.input).toHaveText("Keep this draft while the inventory changes.")
-  await expect(view.send).toBeEnabled()
-
-  await view.input.fill("")
-  await expect(view.send).toBeDisabled()
-  await expectBackground(view.send, "contrast")
-
-  view.events.push({
-    id: "evt_workspace_accent_running",
-    created: 1700000002000,
-    type: "session.execution.started",
-    durable: { aggregateID: sessionID, seq: 1, version: 1 },
-    data: { sessionID },
-  })
-  const stop = view.composer.getByRole("button", { name: "Stop", exact: true })
-  await expect(stop).toBeEnabled()
-  await expectBackground(stop, "contrast")
-
-  await view.input.fill("Send a follow-up instead of stopping.")
-  await expect(view.send).toBeEnabled()
-  await expectBackground(view.send, "accent")
-  await expect(page).toHaveURL(url)
-})
-
-async function openSession(page: Page, directory: string, worktrees = [...inventory]) {
-  const events: OpenCodeEvent[] = []
-  await mockOpenCodeServer(page, {
-    directory,
-    project: {
-      id: projectID,
-      canonical: root,
-      worktree: root,
-      vcs: "git",
-      name: "workspace-accent",
-      time: { created: 1700000000000, updated: 1700000000000 },
-      sandboxes: [],
-    },
-    provider: {
-      all: [
-        {
-          id: "opencode",
-          name: "OpenCode",
-          models: { "accent-model": { id: "accent-model", name: "Accent Model", limit: { context: 200_000 } } },
-        },
-      ],
-      connected: ["opencode"],
-      default: { providerID: "opencode", modelID: "accent-model" },
-    },
-    sessions: [
-      {
-        id: sessionID,
-        projectID,
-        directory,
-        title,
-        model: { id: "accent-model", providerID: "opencode" },
-        time: { created: 1700000000000, updated: 1700000000000 },
-      },
-    ],
-    pageMessages: () => ({
-      items: [
-        {
-          id: "msg_workspace_accent",
-          type: "user",
-          text: "Check this fixture workspace.",
-          time: { created: 1700000000000 },
-        },
-      ],
-    }),
-    events: () => events.splice(0),
-  })
-  // Keep authoritative inventory independent of the raw project's empty sandboxes.
-  await page.route(`**/api/worktree/${projectID}`, (route) => {
-    if (route.request().method() !== "GET") return route.fallback()
-    return route.fulfill({ json: worktrees, headers: { "access-control-allow-origin": "*" } })
-  })
-  await page.addInitScript(() => {
-    localStorage.setItem("opencode-theme-id", "oc-2")
-    localStorage.setItem("opencode-color-scheme", "light")
-  })
-  const loaded = page.waitForResponse(
-    (response) =>
-      new URL(response.url()).pathname === `/api/worktree/${projectID}` && response.request().method() === "GET",
-  )
-  await page.goto(`/server/${base64Encode(server)}/session/${sessionID}`)
-  expect((await loaded).ok()).toBe(true)
-  await expectSessionReady(page, { server, sessionID, title })
-  await expect(page.locator("html")).toHaveAttribute("data-color-scheme", "light")
-  const composer = page.locator('[data-component="composer"]')
-  await expectAppVisible(composer)
-  const input = composer.getByRole("textbox", { name: "Prompt", exact: true })
-  await expect(input).toBeEditable()
-  await expect(composer.locator('[data-action="composer-model"]')).toHaveText("Accent Model")
-  return { composer, input, send: composer.getByRole("button", { name: "Send", exact: true }), events, worktrees }
-}
-
-async function expectBackground(element: Locator, token: string, property = "background-image") {
-  const color = await element.evaluate((element, token) => {
-    // Resolve semantic colors through the browser, without reproducing the button's gradient.
-    const probe = document.createElement("span")
-    probe.hidden = true
-    probe.style.backgroundColor = `var(--v2-background-bg-${token})`
-    element.append(probe)
-    const color = getComputedStyle(probe).backgroundColor
-    probe.remove()
-    return color
-  }, token)
-  await expect(element).toHaveCSS(property, new RegExp(color.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")))
-}
@@ -1,124 +1,60 @@
-import { expect, test, type Page } from "@playwright/test"
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises"
-import { createServer, type ServerResponse } from "node:http"
+import { expect, test } from "@playwright/test"
+import { readFile } from "node:fs/promises"
+import { createServer } from "node:http"
 import { once } from "node:events"
-import { createHash } from "node:crypto"
-import { join, extname, relative, sep } from "node:path"
-import { tmpdir } from "node:os"
-import { fileURLToPath } from "node:url"
-import { build } from "vite"
-import { serviceWorker } from "../../vite.pwa"

-type Site = {
-  url: string
-  deploy: (fault?: "failed" | "html" | "corrupt" | "mixed-html" | "blocked") => void
-  legacy: () => void
-  requests: string[]
-  release: () => void
-}
+const legacy = `
+self.addEventListener("install", event => event.waitUntil(
+  caches.open("workbox-precache-v2-" + self.registration.scope).then(cache =>
+    cache.addAll(["/index.html", "/assets/app-old.js", "/assets/lazy-old.js"])
+  )
+))
+self.addEventListener("fetch", event => {
+  if (event.request.mode === "navigate") {
+    event.respondWith(caches.match("/index.html"))
+    return
+  }
+  event.respondWith(caches.match(event.request).then(response => response || fetch(event.request)))
+})
+`

-const fixture = test.extend<{ site: Site }, { builds: Record<string, Record<string, Buffer>> }>({
-  builds: [
-    async ({}, use) => {
-      const directory = await mkdtemp(join(tmpdir(), "opencode-precache-"))
-      const builds: Record<string, Record<string, Buffer>> = {}
-      try {
-        for (const version of ["old", "new"]) {
-          const root = join(directory, version)
-          const outDir = join(root, "dist")
-          await mkdir(join(root, "public", "nested"), { recursive: true })
-          await Promise.all(
-            Object.entries({
-              "index.html": `<html><head></head><body><h1>Loading</h1><label>Draft<textarea></textarea></label><button>Load lazy</button><output></output><script type="module" src="/main.js"></script></body></html>`,
-              "main.js": `document.querySelector("h1").textContent = "${version}";
-            document.querySelector("button").onclick = async () => {
-              document.querySelector("output").textContent = await (await import("./lazy.js")).load()
-            };`,
-              "lazy.js": `export async function load() { return (await import("./nested.js")).value }`,
-              "nested.js": `export const value = "${version} nested lazy loaded"`,
-              "public/nested/data.json": JSON.stringify({ version }),
-              "public/nested/font.woff2": `font-${version}`,
-              "public/nested/module.wasm": Buffer.from([0, 97, 115, 109, 1, 0, 0, 0]),
-              "public/large.bin": Buffer.alloc(2 * 1024 * 1024 + 1, version === "old" ? 1 : 2),
-              "public/_headers": "/*\n  Cache-Control: no-cache",
-              "public/_redirects": "/* /index.html 200",
-            }).map(([path, contents]) => writeFile(join(root, path), contents)),
-          )
-          await build({
-            configFile: false,
-            root,
-            logLevel: "silent",
-            build: { outDir, assetsDir: "_assets", sourcemap: true },
-            plugins: serviceWorker(outDir),
-          })
-          builds[version] = Object.fromEntries(
-            await Promise.all(
-              (await readdir(outDir, { recursive: true, withFileTypes: true }))
-                .filter((entry) => entry.isFile())
-                .map(async (entry) => {
-                  const path = join(entry.parentPath, entry.name)
-                  return ["/" + relative(outDir, path).split(sep).join("/"), await readFile(path)]
-                }),
-            ),
-          )
-        }
-        await use(builds)
-      } finally {
-        await rm(directory, { recursive: true, force: true })
-      }
-    },
-    { scope: "worker" },
-  ],
-  site: async ({ builds }, use) => {
-    const state = { version: "old", fault: "", legacy: false }
-    const requests: string[] = []
-    const blocked: ServerResponse[] = []
-    const release = () => blocked.splice(0).forEach((response) => response.end(builds.new["/large.bin"]))
+const fixture = test.extend<{ site: { url: string; upgrade: () => void; repair: () => void } }>({
+  site: async ({}, use) => {
+    const worker = await readFile(new URL("../../dist/sw.js", import.meta.url), "utf8")
+    const state = { version: "old", repaired: false }
    const server = createServer((request, response) => {
-      const path = new URL(request.url ?? "/", "http://localhost").pathname
-      requests.push(path)
+      const pathname = new URL(request.url ?? "/", "http://localhost").pathname
+      const prefix = state.version === "old" ? "/assets" : "/_assets"
      response.setHeader("cache-control", "no-store")
-      if (path === "/observer.html")
-        return void response.writeHead(200, { "content-type": "text/html" }).end("<title>Worker observer</title>")
-      if (path === "/api/health")
-        return void response.writeHead(200, { "content-type": "application/json" }).end('{"healthy":true}')
-      if (path === "/sw.js" && state.legacy && state.version === "old") {
-        // Model the shipped worker's shared precache name and cache-first navigation behavior.
-        const urls = Object.keys(builds.old).filter(
-          (path) => path === "/index.html" || (path.startsWith("/_assets/") && path.endsWith(".js")),
-        )
+      if (pathname === "/sw.js") {
        response.setHeader("content-type", "text/javascript")
-        return void response.end(`
-          self.addEventListener("install", event => event.waitUntil(
-            caches.open("workbox-precache-v2-" + self.registration.scope).then(cache => cache.addAll(${JSON.stringify(urls)}))
-          ));
-          self.addEventListener("fetch", event => event.respondWith(
-            caches.match(event.request.mode === "navigate" ? "/index.html" : event.request)
-              .then(response => response || fetch(event.request))
-          ));
+        response.end(state.version === "old" ? legacy : worker)
+        return
+      }
+      if (pathname === `${prefix}/app-${state.version}.js`) {
+        response.setHeader("content-type", "text/javascript")
+        response.end(`import "${prefix}/startup-${state.version}.js"`)
+        return
+      }
+      if (pathname === `${prefix}/startup-${state.version}.js`) {
+        response.setHeader("content-type", "text/javascript")
+        response.end(`
+          document.getElementById("root").innerHTML = '<h1>${state.version}</h1><label>Draft<input></label><button>Load older chunk</button><output></output>'
+          document.querySelector("button").onclick = () => import("/assets/lazy-old.js")
        `)
+        return
      }
-      if (path === "/index.html" && state.fault === "mixed-html")
-        return void response.writeHead(200, { "content-type": "text/html" }).end(builds.old["/index.html"])
-      if (path === "/large.bin" && state.fault && state.fault !== "mixed-html") {
-        if (state.fault === "blocked") return void blocked.push(response)
-        if (state.fault === "failed") return void response.writeHead(503).end("Unavailable")
-        if (state.fault === "html")
-          return void response.writeHead(200, { "content-type": "text/html" }).end("<html>Wrong fallback</html>")
-        return void response.end("Incorrect bytes with a successful status")
+      if (
+        (pathname === "/assets/lazy-old.js" && state.version === "old") ||
+        (pathname === "/_assets/retry.js" && state.repaired)
+      ) {
+        response.setHeader("content-type", "text/javascript")
+        response.end('document.querySelector("output").textContent = "Older chunk loaded"')
+        return
      }
-      const file = builds[state.version][path]
-      const types: Record<string, string> = {
-        ".js": "text/javascript",
-        ".html": "text/html",
-        ".json": "application/json",
-        ".wasm": "application/wasm",
-      }
-      response.setHeader("content-type", types[extname(path)] ?? "application/octet-stream")
-      if (file) return void response.end(file)
-      if (extname(path)) return void response.writeHead(404).end("Not found")
+      // Deliberately retain the old server's fallback so the worker must reject HTML asset responses itself.
      response.setHeader("content-type", "text/html")
-      response.end(builds[state.version]["/index.html"])
+      response.end(`<div id="root"></div><script type="module" src="${prefix}/app-${state.version}.js"></script>`)
    })
    server.listen(0, "127.0.0.1")
    await once(server, "listening")
@@ -127,265 +63,75 @@ const fixture = test.extend<{ site: Site }, { builds: Record<string, Record<stri
    try {
      await use({
        url: `http://127.0.0.1:${address.port}`,
-        deploy: (fault = undefined) => {
-          state.version = "new"
-          state.fault = fault ?? ""
-        },
-        legacy: () => {
-          state.legacy = true
-        },
-        requests,
-        release,
+        upgrade: () => (state.version = "new"),
+        repair: () => (state.repaired = true),
      })
    } finally {
-      release()
      server.closeAllConnections()
      await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
    }
  },
 })

-async function install(page: Page, url: string) {
-  await page.goto(url)
+fixture("updates a legacy worker without reloading drafts or deleting old chunks", async ({ page, site }) => {
+  await page.goto(site.url)
  await expect(page.getByRole("heading")).toHaveText("old")
  await page.evaluate(async () => {
    await navigator.serviceWorker.register("/sw.js")
    await navigator.serviceWorker.ready
  })
-  await page.reload()
-  await expect.poll(() => page.evaluate(() => navigator.serviceWorker.controller?.state)).toBe("activated")
+  await page.goto(site.url)
  await expect(page.getByRole("heading")).toHaveText("old")
-}
+  await page.getByLabel("Draft").fill("Keep this unsent prompt")

-async function update(page: Page) {
-  return page.evaluateHandle(async () => {
+  site.upgrade()
+  await page.evaluate(async () => {
+    const cache = await caches.open("opencode-assets")
+    await cache.put(
+      "/_assets/startup-new.js",
+      new Response("<html>stale fallback</html>", {
+        headers: { "content-type": "text/html" },
+      }),
+    )
+    const changed = new Promise<void>((resolve) =>
+      navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true }),
+    )
    const registration = await navigator.serviceWorker.getRegistration()
-    if (!registration) throw new Error("Missing installed worker")
-    const found = new Promise<ServiceWorker>((resolve) =>
-      registration.addEventListener(
-        "updatefound",
-        () => {
-          if (!registration.installing) throw new Error("Missing installing worker")
-          resolve(registration.installing)
-        },
-        { once: true },
+    if (!registration) throw new Error("Missing legacy worker")
+    await registration.update()
+    await changed
+  })
+
+  await expect(page.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
+  await page.getByRole("button", { name: "Load older chunk" }).click()
+  await expect(page.getByRole("status")).toHaveText("Older chunk loaded")
+
+  await page.goto(`${site.url}/workspace/example`)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  await expect
+    .poll(() =>
+      page.evaluate(async () =>
+        (await (await caches.open("opencode-assets")).match("/_assets/startup-new.js"))?.headers.get("content-type"),
      ),
    )
-    await registration.update()
-    return found
+    .toBe("text/javascript")
+})
+
+fixture("does not cache HTML responses under asset URLs", async ({ page, site }) => {
+  site.upgrade()
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  await page.evaluate(async () => {
+    await navigator.serviceWorker.register("/sw.js")
+    await navigator.serviceWorker.ready
  })
-}
-
-async function waiting(page: Page) {
-  await expect
-    .poll(() => page.evaluate(async () => (await navigator.serviceWorker.getRegistration())?.waiting?.state))
-    .toBe("installed")
-}
-
-fixture(
-  "opens an uncached route offline and executes never-used nested lazy chunks",
-  async ({ page, context, site }) => {
-    await install(page, site.url)
-    await expect(page.getByRole("status")).toBeEmpty()
-    await context.setOffline(true)
-    await page.goto(`${site.url}/workspace/never-visited`)
-    await expect(page.getByRole("heading")).toHaveText("old")
-    await page.getByRole("button", { name: "Load lazy" }).click()
-    await expect(page.getByRole("status")).toHaveText("old nested lazy loaded")
-  },
-)
-
-fixture(
-  "precaches public files of every type and size, excluding deployment metadata and source maps",
-  async ({ page, site, builds, context }) => {
-    await install(page, site.url)
-    const files = ["/nested/data.json", "/nested/font.woff2", "/nested/module.wasm", "/large.bin"]
-    await context.setOffline(true)
-    for (const path of files) {
-      const digest = await page.evaluate(
-        async (path) =>
-          Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", await (await fetch(path)).arrayBuffer()))),
-        path,
-      )
-      expect(Buffer.from(digest)).toEqual(createHash("sha256").update(builds.old[path]).digest())
-    }
-    expect(site.requests).not.toContain("/_headers")
-    expect(site.requests).not.toContain("/_redirects")
-    expect(site.requests.filter((path) => path.endsWith(".map"))).toEqual([])
-  },
-)
-
-fixture(
-  "keeps drafts and removed old lazy chunks until every controlled tab closes",
-  async ({ page, context, site, builds }) => {
-    await install(page, site.url)
-    const second = await context.newPage()
-    await second.goto(site.url)
-    await expect(second.getByRole("heading")).toHaveText("old")
-    await second.getByLabel("Draft").fill("Keep this unsent prompt")
-
-    site.deploy()
-    const created = context.waitForEvent("serviceworker")
-    const worker = await update(page)
-    const replacement = await created
-    await waiting(page)
-    expect(await worker.evaluate((worker) => worker.state)).toBe("installed")
-    await expect(second.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
-    await page.close()
-    await waiting(second)
-    await expect(second.getByRole("heading")).toHaveText("old")
-    await expect(second.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
-
-    const removed = Object.keys(builds.old).find((path) => path.includes("/nested-") && path.endsWith(".js"))
-    expect(removed).toBeDefined()
-    expect((await second.request.get(`${site.url}${removed}`)).status()).toBe(404)
-    await second.getByRole("button", { name: "Load lazy" }).click()
-    await expect(second.getByRole("status")).toHaveText("old nested lazy loaded")
-    await expect(second.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
-    await second.close()
-
-    await expect
-      .poll(() =>
-        replacement.evaluate(() => {
-          const registration = (self as unknown as { registration: ServiceWorkerRegistration }).registration
-          return { waiting: !!registration.waiting, active: registration.active?.state }
-        }),
-      )
-      .toEqual({ waiting: false, active: "activated" })
-    await context.setOffline(true)
-    const observer = await context.newPage()
-    await observer.goto(`${site.url}/workspace/reopened`)
-    await expect(observer.getByRole("heading")).toHaveText("new")
-    await observer.getByRole("button", { name: "Load lazy" }).click()
-    await expect(observer.getByRole("status")).toHaveText("new nested lazy loaded")
-  },
-)
-
-for (const fault of ["failed", "html", "corrupt", "mixed-html"] as const) {
-  fixture(`retains the old complete build when a precache download is ${fault}`, async ({ page, context, site }) => {
-    await install(page, site.url)
-    await page.getByLabel("Draft").fill("Still editing")
-    site.deploy(fault)
-    const worker = await update(page)
-    await expect.poll(() => worker.evaluate((worker) => worker.state)).toBe("redundant")
-    expect(await page.evaluate(async () => (await navigator.serviceWorker.getRegistration())?.waiting)).toBeNull()
-    await expect(page.getByLabel("Draft")).toHaveValue("Still editing")
-    await context.setOffline(true)
-    await page.goto(`${site.url}/workspace/after-failure`)
-    await expect(page.getByRole("heading")).toHaveText("old")
-    await page.getByRole("button", { name: "Load lazy" }).click()
-    await expect(page.getByRole("status")).toHaveText("old nested lazy loaded")
-  })
-}
-
-fixture("does not expose new HTML while a precache download is blocked", async ({ page, context, site }) => {
-  await install(page, site.url)
-  site.requests.length = 0
-  site.deploy("blocked")
-  const worker = await update(page)
-  await expect.poll(() => site.requests.includes("/large.bin")).toBe(true)
-  expect(await worker.evaluate((worker) => worker.state)).toBe("installing")
-  const second = await context.newPage()
-  await second.goto(`${site.url}/workspace/during-install`)
-  await expect(second.getByRole("heading")).toHaveText("old")
-  site.release()
-  await waiting(page)
-  await second.reload()
-  await expect(second.getByRole("heading")).toHaveText("old")
-})
-
-fixture("upgrades the legacy shared precache only after old tabs close", async ({ page, context, site, builds }) => {
-  site.legacy()
-  const observer = await context.newPage()
-  await observer.goto(`${site.url}/observer.html`)
-  await install(page, site.url)
-  await page.getByLabel("Draft").fill("Legacy unsent prompt")
-  // A stale runtime-cache HTML response must not contaminate the new generated precache.
-  const entry = Object.keys(builds.new).find((path) => path.includes("/index-") && path.endsWith(".js"))
-  expect(entry).toBeDefined()
-  await page.evaluate(async (entry) => {
-    await (
-      await caches.open("opencode-assets")
-    ).put(entry!, new Response("<html>stale fallback</html>", { headers: { "content-type": "text/html" } }))
-  }, entry)
-  site.deploy()
-  await update(page)
-  await waiting(page)
-  await expect(page.getByLabel("Draft")).toHaveValue("Legacy unsent prompt")
-  await page.getByRole("button", { name: "Load lazy" }).click()
-  await expect(page.getByRole("status")).toHaveText("old nested lazy loaded")
-  await page.close()
-  await expect
-    .poll(() => observer.evaluate(async () => !!(await navigator.serviceWorker.getRegistration())?.waiting))
-    .toBe(false)
-  await context.setOffline(true)
-  await observer.goto(`${site.url}/workspace/legacy-upgraded`)
-  await expect(observer.getByRole("heading")).toHaveText("new")
-  await observer.getByRole("button", { name: "Load lazy" }).click()
-  await expect(observer.getByRole("status")).toHaveText("new nested lazy loaded")
-})
-
-fixture("does not substitute cached HTML for API or missing asset navigations", async ({ page, site }) => {
-  await install(page, site.url)
-  const api = await page.goto(`${site.url}/api/health`)
-  expect(await api?.json()).toEqual({ healthy: true })
-  expect(api?.fromServiceWorker()).toBe(false)
-  const asset = await page.goto(`${site.url}/_assets/missing.js`)
-  expect(asset?.status()).toBe(404)
-  expect(await asset?.text()).toBe("Not found")
-})
-
-test("the production build precaches every deployable file", async ({ page, context }) => {
-  const directory = new URL("../../dist/", import.meta.url)
-  const files = (await readdir(directory, { recursive: true, withFileTypes: true }))
-    .filter((entry) => entry.isFile())
-    .map((entry) => "/" + relative(fileURLToPath(directory), join(entry.parentPath, entry.name)).split(sep).join("/"))
-    .filter((path) => !path.endsWith(".map") && !["/_headers", "/_redirects", "/sw.js"].includes(path))
-  expect(files.length).toBeGreaterThan(1)
-  const server = createServer(async (request, response) => {
-    const path = new URL(request.url ?? "/", "http://localhost").pathname
-    response.setHeader("cache-control", "no-store")
-    if (path === "/probe.html")
-      return void response.writeHead(200, { "content-type": "text/html" }).end("<title>Precache probe</title>")
-    const bytes = await readFile(new URL(`.${path}`, directory)).catch(() => undefined)
-    if (!bytes) return void response.writeHead(404).end("Not found")
-    if (path.endsWith(".js")) response.setHeader("content-type", "text/javascript")
-    if (path.endsWith(".html")) {
-      response.setHeader("content-type", "text/html")
-      // Inspect the real cached HTML without executing the app or contacting a backend.
-      response.setHeader("content-security-policy", "default-src 'none'")
-    }
-    response.end(bytes)
-  })
-  server.listen(0, "127.0.0.1")
-  await once(server, "listening")
-  const address = server.address()
-  if (!address || typeof address === "string") throw new Error("Expected a TCP address")
-  const url = `http://127.0.0.1:${address.port}`
-  try {
-    await page.goto(`${url}/probe.html`)
-    await page.evaluate(async () => {
-      await navigator.serviceWorker.register("/sw.js")
-      await navigator.serviceWorker.ready
-    })
-    const cached = await page.evaluate(async () =>
-      (
-        await Promise.all(
-          (await caches.keys()).map(async (name) =>
-            (await (await caches.open(name)).keys()).map((request) => new URL(request.url).pathname),
-          ),
-        )
-      )
-        .flat()
-        .sort(),
-    )
-    expect(cached).toEqual(files.sort())
-    await context.setOffline(true)
-    const response = await page.goto(`${url}/workspace/offline-probe`)
-    expect(response?.fromServiceWorker()).toBe(true)
-    expect(await response?.text()).toBe(await readFile(new URL("index.html", directory), "utf8"))
-  } finally {
-    server.closeAllConnections()
-    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
-  }
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
+    "text/html",
+  )
+  site.repair()
+  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
+    "text/javascript",
+  )
 })
@@ -1,14 +1,9 @@
 import { defineConfig } from "@playwright/test"

-// Tiny fixture builds do not need a Rolldown thread for every host CPU.
-process.env.RAYON_NUM_THREADS ??= "2"
-
 export default defineConfig({
  testDir: ".",
  testMatch: "*.spec.ts",
  outputDir: "../test-results/service-worker",
-  timeout: 60_000,
-  workers: 1,
-  expect: { timeout: 15_000 },
+  timeout: 30_000,
  use: { browserName: "chromium" },
 })
@@ -144,14 +144,12 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
  )
  page.on("close", () => void transport.dispose())

-  await page.route("**/api/**", async (route) => {
+  await page.route("**/*", async (route) => {
    const url = new URL(route.request().url())
    const appPort = new URL(
      process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${process.env.PLAYWRIGHT_PORT ?? "3000"}`,
    ).port
    if (url.origin !== server && url.port !== appPort) return route.fallback()
-    // Production serves the UI and API from one origin; leave app assets to Vite.
-    if (!url.pathname.startsWith("/api/")) return route.fallback()
    if (route.request().method() === "OPTIONS") {
      return route.fulfill({ status: 204, headers: corsHeaders })
    }
@@ -7,8 +7,10 @@
      content="width=device-width, initial-scale=1, interactive-widget=resizes-content, viewport-fit=cover"
    />
    <title>OpenCode</title>
-    <link rel="icon" type="image/x-icon" href="%OPENCODE_FAVICON%" />
-    <link rel="apple-touch-icon" sizes="180x180" href="%OPENCODE_APPLE_TOUCH_ICON%" />
+    <link rel="icon" type="image/png" href="/favicon-96x96-v3.png" sizes="96x96" />
+    <link rel="icon" type="image/svg+xml" href="/favicon-v3.svg" />
+    <link rel="shortcut icon" href="/favicon-v3.ico" />
+    <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-v3.png" />
    <link rel="manifest" href="/site.webmanifest" />
    <meta name="theme-color" content="#fafafa" />
    <meta name="mobile-web-app-capable" content="yes" />
@@ -1,24 +0,0 @@
-{
-  "name": "OpenCode",
-  "short_name": "OpenCode",
-  "id": "/",
-  "start_url": "/",
-  "scope": "/",
-  "icons": [
-    {
-      "src": "/web-app-manifest-192x192.png",
-      "sizes": "192x192",
-      "type": "image/png",
-      "purpose": "any"
-    },
-    {
-      "src": "/web-app-manifest-512x512.png",
-      "sizes": "512x512",
-      "type": "image/png",
-      "purpose": "any"
-    }
-  ],
-  "theme_color": "#080808",
-  "background_color": "#080808",
-  "display": "standalone"
-}
@@ -25,7 +25,6 @@
    "test:browser": "bun test --conditions=browser --preload ./happydom.ts ./test-browser",
    "test:unit:watch": "bun test --conditions=solid --watch --preload ./happydom.ts ./src",
    "test:e2e": "playwright test",
-    "test:e2e:built": "PLAYWRIGHT_BUILD=1 playwright test",
    "test:e2e:local": "playwright test",
    "test:components": "playwright test --config playwright.components.config.ts",
    "test:components:ui": "playwright test --config playwright.components.config.ts --ui",
@@ -2,19 +2,10 @@ import { defineConfig, devices } from "@playwright/test"

 const port = Number(process.env.PLAYWRIGHT_PORT ?? 3000)
 const baseURL = process.env.PLAYWRIGHT_BASE_URL ?? `http://127.0.0.1:${port}`
-const url = new URL(baseURL)
-if (url.protocol !== "http:") throw new Error("E2E fixtures require an http:// app URL")
-const built = !!process.env.CI || process.env.PLAYWRIGHT_BUILD === "1"
-// Production connects to its own origin, so fixture URLs must match the preview server.
-if (built) {
-  process.env.PLAYWRIGHT_SERVER_HOST = url.hostname
-  process.env.PLAYWRIGHT_SERVER_PORT = url.port || "80"
-}
 const serverHost = process.env.PLAYWRIGHT_SERVER_HOST ?? "127.0.0.1"
 const serverPort = process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"
-const command = built
-  ? `bun run build && bun run serve -- --host 127.0.0.1 --port ${port} --strictPort`
-  : `bun run dev -- --host 127.0.0.1 --port ${port} --strictPort`
+const command = `bun run dev -- --host 0.0.0.0 --port ${port}`
+const reuse = !process.env.CI
 const workers = Number(process.env.PLAYWRIGHT_WORKERS ?? (process.env.CI ? 5 : 0)) || undefined
 export default defineConfig({
  testDir: "./e2e",
@@ -32,18 +23,16 @@ export default defineConfig({
  retries: process.env.CI ? 2 : 0,
  workers,
  reporter: [["html", { outputFolder: "e2e/playwright-report", open: "never" }], ["line"]],
-  webServer: process.env.PLAYWRIGHT_BASE_URL
-    ? undefined
-    : {
-        command,
-        url: baseURL,
-        reuseExistingServer: !built,
-        timeout: 120_000,
-        env: {
-          VITE_OPENCODE_SERVER_HOST: serverHost,
-          VITE_OPENCODE_SERVER_PORT: serverPort,
-        },
-      },
+  webServer: {
+    command,
+    url: baseURL,
+    reuseExistingServer: reuse,
+    timeout: 120_000,
+    env: {
+      VITE_OPENCODE_SERVER_HOST: serverHost,
+      VITE_OPENCODE_SERVER_PORT: serverPort,
+    },
+  },
  use: {
    baseURL,
    trace: "on-first-retry",
@@ -0,0 +1 @@
+../../ui/src/assets/favicon/site.webmanifest
@@ -103,8 +103,7 @@ export type NewSessionComposerAdapter = ComposerAdapterBase & {
  start: (
    selection: ComposerSelection,
    submission: ReturnType<typeof createComposerSubmission>,
-    message: SessionMessageUser,
-  ) => Promise<{ session: ComposerSession; cleanupReady: Promise<void>; complete?: () => Promise<void> } | undefined>
+  ) => Promise<{ session: ComposerSession; cleanupReady: Promise<void> } | undefined>
 }

 export type ComposerAdapter = ActiveComposerAdapter | NewSessionComposerAdapter
@@ -384,18 +384,10 @@ export function createComposerEditor(input: {
        void attachments.handlePaste(event)
        return
      }
-      const text = clipboard?.getData("text/plain").replace(/\r\n?/g, "\n")
+      const text = clipboard?.getData("text/plain")
      if (!text) return
      event.preventDefault()
-      // insertText emits input events per line, repeatedly parsing and saving the draft.
-      // Escaped HTML inserts multiline text once and preserves native selection and undo.
-      const multiline = text.includes("\n")
-      const value = multiline ? text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;") : text
-      if (
-        typeof document.execCommand === "function" &&
-        document.execCommand(multiline ? "insertHTML" : "insertText", false, value)
-      )
-        return
+      if (typeof document.execCommand === "function" && document.execCommand("insertText", false, text)) return
      const target = event.currentTarget
      const selection = window.getSelection()
      if (!(target instanceof HTMLElement) || !selection?.rangeCount || !target.contains(selection.anchorNode)) return
@@ -229,50 +229,6 @@ describe("Composer submission", () => {
    })
  })

-  test("previews the first prompt while starting and hands it off before completing preparation", async () => {
-    const draft = createMemoryComposerState({ prompt: "prepare my worktree" }).capture()
-    const preview = Promise.withResolvers<SessionMessageUser>()
-    const ready = Promise.withResolvers<void>()
-    const calls: string[] = []
-    const handoff: SessionMessageUser[] = []
-    const target = session({
-      calls,
-      handoff: { set: (message) => handoff.push(message), clear() {} },
-      prompt: async () => undefined,
-    })
-    const adapter: NewSessionComposerAdapter = {
-      kind: "new-session",
-      state: draft,
-      ready: () => true,
-      controls,
-      working: () => false,
-      submitted() {},
-      async start(_selection, _submission, message) {
-        preview.resolve(message)
-        await ready.promise
-        return {
-          session: target,
-          cleanupReady: Promise.resolve(),
-          async complete() {
-            expect(handoff).toHaveLength(1)
-            expect(handoff[0]?.id).toBe(message.id)
-            expect(handoff[0]?.text).toBe("prepare my worktree")
-            calls.push("complete")
-          },
-        }
-      },
-    }
-
-    const submitted = submitInput(adapter).submit(new Event("submit"))
-    expect(await preview.promise).toMatchObject({ type: "user", text: "prepare my worktree" })
-    expect(calls).toEqual([])
-    expect(draft.current()).toMatchObject([{ content: "prepare my worktree" }])
-    ready.resolve()
-    await submitted
-    expect(calls).toContain("complete")
-    expect(draft.current()).toEqual([{ type: "text", content: "", start: 0, end: 0 }])
-  })
-
  test("does not restore a prompt already acknowledged by the durable inbox", async () => {
    const state = createMemoryComposerState({ prompt: "admitted prompt" }).capture()
    const checked = Promise.withResolvers<void>()
@@ -70,7 +70,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
      const started =
        input.adapter.kind === "active-session"
          ? { session: input.adapter.session(), cleanupReady: Promise.resolve() }
-          : await input.adapter.start(value.selection, submission, handoffMessage(value))
+          : await input.adapter.start(value.selection, submission)
      if (!started) return
      const session = started.session

@@ -80,7 +80,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {

      const command = value.mode === "normal" ? findCommand(session, value.text) : undefined
      if (value.mode === "normal" && !command) {
-        session.handoff?.set(handoffMessage(value))
+        if (value.images.length > 0) session.handoff?.set(handoffMessage(value))
        const optimisticBusy = !input.adapter.working()
        if (optimisticBusy) session.data.session.setStatus(session.id, "running")
        const sending = sendPrompt(session, value).then(
@@ -88,7 +88,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
          (error) => ({ ok: false as const, error }),
        )
        await started.cleanupReady
-        await started.complete?.()
        input.adapter.submitted()
        submission.context
          .filter((item) => !!item.comment?.trim())
@@ -105,7 +104,6 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
      }

      await started.cleanupReady
-      await started.complete?.()
      input.adapter.submitted()

      if (value.mode === "shell") {
@@ -124,6 +122,7 @@ export function createComposerSubmit(input: ComposerSubmitInput) {
        )
        return
      }
+
    } finally {
      submitting.delete(input.adapter.state)
    }
@@ -148,19 +147,6 @@ function handoffMessage(value: ComposerSubmission): SessionMessageUser {
    })),
    metadata: {
      displayText: value.text,
-      comments: value.context.flatMap((item) =>
-        item.comment?.trim()
-          ? [
-              {
-                path: item.path,
-                comment: item.comment.trim(),
-                ...(item.selection ? { selection: { ...item.selection } } : {}),
-                ...(item.preview !== undefined ? { preview: item.preview } : {}),
-                ...(item.commentOrigin ? { origin: item.commentOrigin } : {}),
-              },
-            ]
-          : [],
-      ),
      agent: value.selection.agent,
      model: {
        ...value.selection.model,
@@ -17,7 +17,7 @@ export function Home() {
  return (
    <div
      class={`
-        mx-2 mb-2 mt-[var(--shell-top-inset,8px)] min-h-0 flex-1 self-stretch overflow-hidden rounded-[10px]
+        m-2 min-h-0 flex-1 self-stretch overflow-hidden rounded-[10px]
        bg-v2-background-bg-base shadow-[var(--v2-elevation-raised)]
      `}
    >
@@ -1,7 +1,6 @@
 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"
 import type { NewSessionComposerAdapter } from "@/composer/adapter"
 import { useComposerState } from "@/composer/persistence"
@@ -44,32 +43,20 @@ export function createNewSessionComposerAdapter(props: {
    controls,
    working: () => false,
    submitted: props.submitted,
-    async start(selection, submission, message) {
-      const draftID = props.draftID
+    async start(selection, submission) {
      const projectDirectory = location().directory
      const worktree = props.worktree()
-      const branch = props.branch()
-      const id = Session.ID.create()
-      const pending =
-        worktree === "create"
-          ? tabs.prepareSession(draftID, { server: server.key, sessionId: id }, { message, selection })
-          : undefined
-      await pending?.ready
      const sessionDirectory = await resolveSessionDirectory({
        projectDirectory,
        worktree,
-        branch,
+        branch: props.branch(),
        data,
        serverSDK,
        language,
      })
-      if (!sessionDirectory) {
-        await pending?.rollback()
-        return
-      }
+      if (!sessionDirectory) return

      const created = data.session.create({
-        id,
        agent: selection.agent,
        model: {
          id: selection.model.modelID,
@@ -88,13 +75,6 @@ export function createNewSessionComposerAdapter(props: {
          return { ok: false as const, error }
        },
      )
-      if (pending && !(await creation).ok) {
-        // Keep retries on the worktree that was already created, not another new checkout.
-        data.project.invalidate()
-        await data.project.sync().catch(() => undefined)
-        await pending.rollback(sessionDirectory)
-        return
-      }
      const afterCreation = async <T>(run: () => Promise<T>) => {
        const result = await creation
        if (!result.ok) throw result.error
@@ -105,13 +85,13 @@ export function createNewSessionComposerAdapter(props: {
        SessionRouteKey.fromRoute(base64Encode(sessionDirectory), created.id),
      )
      const cleanupReady = startTransition(() => {
-        if (!pending) tabs.updateDraft(draftID, { worktree: undefined, branch: undefined })
+        tabs.updateDraft(props.draftID, { worktree: undefined, branch: undefined })
        local.session.promote(sessionDirectory, created.id, {
          agent: selection.agent,
          model: selection.model,
          variant: selection.variant ?? null,
        })
-        if (!pending) tabs.promoteDraft(draftID, { server: server.key, sessionId: created.id })
+        tabs.promoteDraft(props.draftID, { server: server.key, sessionId: created.id })
        submission.retarget(
          prompt.capture(
            { dir: base64Encode(sessionDirectory), id: created.id },
@@ -122,7 +102,6 @@ export function createNewSessionComposerAdapter(props: {

      return {
        cleanupReady,
-        complete: pending?.complete,
        session: {
          id: created.id,
          directory: sessionDirectory,
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`../../ui/src/assets/favicon/site.webmanifest`