fix(ai): require provider error data

packages/ai/src/protocols/anthropic-messages.ts

@@ -283,21 +283,27 @@ const AnthropicStreamDelta = Schema.Struct({
   stop_sequence: optionalNull(Schema.String),
 })
 
-const AnthropicEvent = Schema.Struct({
-  type: Schema.String,
-  index: Schema.optional(Schema.Number),
-  message: Schema.optional(Schema.Struct({ usage: Schema.optional(AnthropicUsage) })),
-  content_block: Schema.optional(AnthropicStreamBlock),
-  delta: Schema.optional(AnthropicStreamDelta),
-  usage: Schema.optional(AnthropicUsage),
-  // `type` and `message` are both required per Anthropic's spec, but
-  // OpenAI-compatible proxies and gateway translations occasionally drop one
-  // or the other; mark them optional so a partial payload still parses and
-  // the parser can fall back to whichever field is populated.
-  error: Schema.optional(
-    Schema.Struct({ type: Schema.optional(Schema.String), message: Schema.optional(Schema.String) }),
-  ),
-})
+const AnthropicEvent = Schema.StructWithRest(
+  Schema.Struct({
+    type: Schema.String,
+    index: Schema.optional(Schema.Number),
+    message: Schema.optional(Schema.Struct({ usage: Schema.optional(AnthropicUsage) })),
+    content_block: Schema.optional(AnthropicStreamBlock),
+    delta: Schema.optional(AnthropicStreamDelta),
+    usage: Schema.optional(AnthropicUsage),
+    // `type` and `message` are both required per Anthropic's spec, but
+    // OpenAI-compatible proxies and gateway translations occasionally drop one
+    // or the other; mark them optional so a partial payload still parses and
+    // the parser can fall back to whichever field is populated.
+    error: Schema.optional(
+      Schema.StructWithRest(
+        Schema.Struct({ type: Schema.optional(Schema.String), message: Schema.optional(Schema.String) }),
+        [Schema.Record(Schema.String, Schema.Unknown)],
+      ),
+    ),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 type AnthropicEvent = Schema.Schema.Type<typeof AnthropicEvent>
 
 interface ParserState {
@@ -983,7 +989,11 @@ const onError = (event: AnthropicEvent) =>
   new AIError({
     module: ADAPTER,
     method: "stream",
-    reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
+    reason: classifyProviderFailure({
+      message: providerErrorMessage(event),
+      code: event.error?.type,
+      data: Schema.decodeUnknownSync(Schema.Json)(event),
+    }),
   })
 
 const step = (state: ParserState, event: AnthropicEvent) => {

packages/ai/src/protocols/bedrock-converse.ts

@@ -155,69 +155,75 @@ const BedrockUsageSchema = Schema.Struct({
 })
 type BedrockUsageSchema = Schema.Schema.Type<typeof BedrockUsageSchema>
 
-const BedrockStreamException = Schema.Struct({
-  message: Schema.optional(Schema.String),
-  originalMessage: Schema.optional(Schema.String),
-  originalStatusCode: Schema.optional(Schema.Number),
-})
+const BedrockStreamException = Schema.StructWithRest(
+  Schema.Struct({
+    message: Schema.optional(Schema.String),
+    originalMessage: Schema.optional(Schema.String),
+    originalStatusCode: Schema.optional(Schema.Number),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 
 // Streaming event shape — the AWS event stream wraps each JSON payload by its
 // `:event-type` header (e.g. `messageStart`, `contentBlockDelta`). We
 // reconstruct that wrapping in `decodeFrames` below so the event schema can
 // stay a plain discriminated record.
-const BedrockEvent = Schema.Struct({
-  messageStart: Schema.optional(Schema.Struct({ role: Schema.String })),
-  contentBlockStart: Schema.optional(
-    Schema.Struct({
-      contentBlockIndex: Schema.Number,
-      start: Schema.optional(
-        Schema.Struct({
-          toolUse: Schema.optional(Schema.Struct({ toolUseId: Schema.String, name: Schema.String })),
-        }),
-      ),
-    }),
-  ),
-  contentBlockDelta: Schema.optional(
-    Schema.Struct({
-      contentBlockIndex: Schema.Number,
-      delta: Schema.optional(
-        Schema.Struct({
-          text: Schema.optional(Schema.String),
-          toolUse: Schema.optional(Schema.Struct({ input: Schema.String })),
-          reasoningContent: Schema.optional(
-            Schema.Struct({
-              text: Schema.optional(Schema.String),
-              signature: Schema.optional(Schema.String),
-              // Blob fields in Bedrock's JSON event stream are base64 strings.
-              redactedContent: Schema.optional(Schema.String),
-              // Vercel's Bedrock provider exposes the same delta under
-              // Anthropic's shorter `data` spelling.
-              data: Schema.optional(Schema.String),
-            }),
-          ),
-        }),
-      ),
-    }),
-  ),
-  contentBlockStop: Schema.optional(Schema.Struct({ contentBlockIndex: Schema.Number })),
-  messageStop: Schema.optional(
-    Schema.Struct({
-      stopReason: Schema.String,
-      additionalModelResponseFields: Schema.optional(Schema.Unknown),
-    }),
-  ),
-  metadata: Schema.optional(
-    Schema.Struct({
-      usage: Schema.optional(BedrockUsageSchema),
-      metrics: Schema.optional(Schema.Unknown),
-    }),
-  ),
-  internalServerException: Schema.optional(BedrockStreamException),
-  modelStreamErrorException: Schema.optional(BedrockStreamException),
-  validationException: Schema.optional(BedrockStreamException),
-  throttlingException: Schema.optional(BedrockStreamException),
-  serviceUnavailableException: Schema.optional(BedrockStreamException),
-})
+const BedrockEvent = Schema.StructWithRest(
+  Schema.Struct({
+    messageStart: Schema.optional(Schema.Struct({ role: Schema.String })),
+    contentBlockStart: Schema.optional(
+      Schema.Struct({
+        contentBlockIndex: Schema.Number,
+        start: Schema.optional(
+          Schema.Struct({
+            toolUse: Schema.optional(Schema.Struct({ toolUseId: Schema.String, name: Schema.String })),
+          }),
+        ),
+      }),
+    ),
+    contentBlockDelta: Schema.optional(
+      Schema.Struct({
+        contentBlockIndex: Schema.Number,
+        delta: Schema.optional(
+          Schema.Struct({
+            text: Schema.optional(Schema.String),
+            toolUse: Schema.optional(Schema.Struct({ input: Schema.String })),
+            reasoningContent: Schema.optional(
+              Schema.Struct({
+                text: Schema.optional(Schema.String),
+                signature: Schema.optional(Schema.String),
+                // Blob fields in Bedrock's JSON event stream are base64 strings.
+                redactedContent: Schema.optional(Schema.String),
+                // Vercel's Bedrock provider exposes the same delta under
+                // Anthropic's shorter `data` spelling.
+                data: Schema.optional(Schema.String),
+              }),
+            ),
+          }),
+        ),
+      }),
+    ),
+    contentBlockStop: Schema.optional(Schema.Struct({ contentBlockIndex: Schema.Number })),
+    messageStop: Schema.optional(
+      Schema.Struct({
+        stopReason: Schema.String,
+        additionalModelResponseFields: Schema.optional(Schema.Unknown),
+      }),
+    ),
+    metadata: Schema.optional(
+      Schema.Struct({
+        usage: Schema.optional(BedrockUsageSchema),
+        metrics: Schema.optional(Schema.Unknown),
+      }),
+    ),
+    internalServerException: Schema.optional(BedrockStreamException),
+    modelStreamErrorException: Schema.optional(BedrockStreamException),
+    validationException: Schema.optional(BedrockStreamException),
+    throttlingException: Schema.optional(BedrockStreamException),
+    serviceUnavailableException: Schema.optional(BedrockStreamException),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 type BedrockEvent = Schema.Schema.Type<typeof BedrockEvent>
 
 // =============================================================================
@@ -666,6 +672,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
         reason: classifyProviderFailure({
           message: exception[1]?.message ?? exception[1]?.originalMessage ?? "Bedrock Converse stream error",
           code: exception[0],
+          data: Schema.decodeUnknownSync(Schema.Json)(event),
         }),
       })
     }

packages/ai/src/protocols/open-responses.ts

@@ -1012,7 +1012,12 @@ export const providerFailure = (id: string, event: Event, fallback: string) => {
   return new AIError({
     module: id,
     method: "stream",
-    reason: classifyProviderFailure({ message, code, status }),
+    reason: classifyProviderFailure({
+      message,
+      code,
+      status,
+      data: Schema.decodeUnknownSync(Schema.Json)(event),
+    }),
   })
 }
 

packages/ai/src/protocols/openai-chat.ts

@@ -209,16 +209,22 @@ const OpenAIChatChoice = Schema.Struct({
   native_finish_reason: optionalNull(Schema.String),
 })
 
-const OpenAIChatError = Schema.Struct({
-  code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
-  message: Schema.String,
-})
+const OpenAIChatError = Schema.StructWithRest(
+  Schema.Struct({
+    code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
+    message: Schema.String,
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 
-export const OpenAIChatEvent = Schema.Struct({
-  choices: optionalNull(Schema.Array(OpenAIChatChoice)),
-  usage: optionalNull(OpenAIChatUsage),
-  error: optionalNull(OpenAIChatError),
-})
+export const OpenAIChatEvent = Schema.StructWithRest(
+  Schema.Struct({
+    choices: optionalNull(Schema.Array(OpenAIChatChoice)),
+    usage: optionalNull(OpenAIChatUsage),
+    error: optionalNull(OpenAIChatError),
+  }),
+  [Schema.Record(Schema.String, Schema.Unknown)],
+)
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]
 
@@ -687,6 +693,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
           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,
+          data: Schema.decodeUnknownSync(Schema.Json)(event),
         }),
       })
     const events: LLMEvent[] = []

packages/ai/src/provider-error.ts

@@ -77,6 +77,7 @@ const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
 
 export interface ProviderFailure {
   readonly message: string
+  readonly data: typeof Schema.Json.Type
   readonly status?: number | undefined
   readonly code?: string | undefined
   readonly retryAfterMs?: number | undefined
@@ -93,7 +94,12 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
     .filter((code): code is string => code !== undefined)
     .map((code) => code.toLowerCase())
   const text = body || input.message
-  const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http }
+  const common = {
+    message: input.message,
+    data: input.data,
+    providerMetadata: input.providerMetadata,
+    http: input.http,
+  }
   const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500)
 
   if (

packages/ai/src/route/executor.ts

@@ -173,6 +173,7 @@ const statusError =
         reason: classifyProviderFailure({
           status: response.status,
           message: providerMessage(response.status, body),
+          data: body ?? null,
           retryAfterMs: retryAfter,
           rateLimit,
           http: responseHttp({
@@ -193,6 +194,7 @@ const statusError =
 // request headers are empty.
 export const classifyHttpFailure = (input: {
   readonly message: string
+  readonly data: typeof Schema.Json.Type
   readonly url: string
   readonly status?: number | undefined
   readonly code?: string | undefined
@@ -205,6 +207,7 @@ export const classifyHttpFailure = (input: {
   const details = responseBody(input.responseBody)
   return classifyProviderFailure({
     message: input.message,
+    data: input.data,
     status: input.status,
     code: input.code,
     retryAfterMs: retryAfter,

packages/ai/src/schema/errors.ts

@@ -35,6 +35,7 @@ export class HttpContext extends Schema.Class<HttpContext>("AI.HttpContext")({
 export class InvalidRequestReason extends Schema.Class<InvalidRequestReason>("AI.Error.InvalidRequest")({
   _tag: Schema.tag("InvalidRequest"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   parameter: Schema.optional(Schema.String),
   classification: Schema.optional(ProviderFailureClassification),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -55,6 +56,7 @@ export class NoRouteReason extends Schema.Class<NoRouteReason>("AI.Error.NoRoute
 export class AuthenticationReason extends Schema.Class<AuthenticationReason>("AI.Error.Authentication")({
   _tag: Schema.tag("Authentication"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
   providerMetadata: Schema.optional(ProviderMetadata),
   http: Schema.optional(HttpContext),
@@ -63,6 +65,7 @@ export class AuthenticationReason extends Schema.Class<AuthenticationReason>("AI
 export class RateLimitReason extends Schema.Class<RateLimitReason>("AI.Error.RateLimit")({
   _tag: Schema.tag("RateLimit"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   retryAfterMs: Schema.optional(Schema.Number),
   rateLimit: Schema.optional(HttpRateLimitDetails),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -72,6 +75,7 @@ export class RateLimitReason extends Schema.Class<RateLimitReason>("AI.Error.Rat
 export class QuotaExceededReason extends Schema.Class<QuotaExceededReason>("AI.Error.QuotaExceeded")({
   _tag: Schema.tag("QuotaExceeded"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   providerMetadata: Schema.optional(ProviderMetadata),
   http: Schema.optional(HttpContext),
 }) {}
@@ -79,6 +83,7 @@ export class QuotaExceededReason extends Schema.Class<QuotaExceededReason>("AI.E
 export class ContentPolicyReason extends Schema.Class<ContentPolicyReason>("AI.Error.ContentPolicy")({
   _tag: Schema.tag("ContentPolicy"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   providerMetadata: Schema.optional(ProviderMetadata),
   http: Schema.optional(HttpContext),
 }) {}
@@ -86,6 +91,7 @@ export class ContentPolicyReason extends Schema.Class<ContentPolicyReason>("AI.E
 export class ProviderInternalReason extends Schema.Class<ProviderInternalReason>("AI.Error.ProviderInternal")({
   _tag: Schema.tag("ProviderInternal"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   status: Schema.optional(Schema.Number),
   retryAfterMs: Schema.optional(Schema.Number),
   providerMetadata: Schema.optional(ProviderMetadata),
@@ -129,6 +135,7 @@ export class InvalidProviderOutputReason extends Schema.Class<InvalidProviderOut
 export class UnknownProviderReason extends Schema.Class<UnknownProviderReason>("AI.Error.UnknownProvider")({
   _tag: Schema.tag("UnknownProvider"),
   message: Schema.String,
+  data: Schema.optional(Schema.Json),
   status: Schema.optional(Schema.Number),
   providerMetadata: Schema.optional(ProviderMetadata),
   http: Schema.optional(HttpContext),

packages/ai/src/schema/events.ts

@@ -216,6 +216,7 @@ export type Finish = Schema.Schema.Type<typeof Finish>
 export const ProviderErrorEvent = Schema.Struct({
   type: Schema.tag("provider-error"),
   message: Schema.String,
+  data: Schema.Json,
   classification: Schema.optional(ProviderFailureClassification),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ProviderError" })

packages/ai/test/provider/anthropic-messages.test.ts

@@ -1031,12 +1031,24 @@ describe("Anthropic Messages route", () => {
     Effect.gen(function* () {
       const error = yield* LLMClient.generate(request).pipe(
         Effect.provide(
-          fixedResponse(sseEvents({ type: "error", error: { type: "overloaded_error", message: "Overloaded" } })),
+          fixedResponse(
+            sseEvents({
+              type: "error",
+              error: { type: "overloaded_error", message: "Overloaded", request_id: "req_123" },
+            }),
+          ),
         ),
         Effect.flip,
       )
 
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal", message: "overloaded_error: Overloaded" })
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
+        message: "overloaded_error: Overloaded",
+        data: {
+          type: "error",
+          error: { type: "overloaded_error", message: "Overloaded", request_id: "req_123" },
+        },
+      })
     }),
   )
 

packages/ai/test/provider/bedrock-converse.test.ts

@@ -714,11 +714,15 @@ describe("Bedrock Converse route", () => {
     Effect.gen(function* () {
       const body = concat([
         eventFrame("messageStart", { role: "assistant" }),
-        exceptionFrame("throttlingException", { message: "Slow down" }),
+        exceptionFrame("throttlingException", { message: "Slow down", requestId: "req_123" }),
       ])
       const error = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)), Effect.flip)
 
-      expect(error.reason).toMatchObject({ _tag: "RateLimit", message: "Slow down" })
+      expect(error.reason).toMatchObject({
+        _tag: "RateLimit",
+        message: "Slow down",
+        data: { throttlingException: { message: "Slow down", requestId: "req_123" } },
+      })
     }),
   )
 

packages/ai/test/provider/openai-responses.test.ts

@@ -2592,13 +2592,25 @@ describe("OpenAI Responses route", () => {
               message: "Something went wrong",
               param: null,
               sequence_number: 1,
+              diagnostic: { region: "us-east" },
             }),
           ),
         ),
         Effect.flip,
       )
 
-      expect(error.reason).toMatchObject({ _tag: "UnknownProvider", message: "Something went wrong" })
+      expect(error.reason).toMatchObject({
+        _tag: "UnknownProvider",
+        message: "Something went wrong",
+        data: {
+          type: "error",
+          code: null,
+          message: "Something went wrong",
+          param: null,
+          sequence_number: 1,
+          diagnostic: { region: "us-east" },
+        },
+      })
     }),
   )
 

packages/ai/test/provider/openrouter.test.ts

@@ -253,14 +253,17 @@ describe("OpenRouter", () => {
         Effect.provide(
           fixedResponse(
             sseEvents({
-              error: { code: 502, message: "Provider disconnected" },
+              error: { code: 502, message: "Provider disconnected", upstream: "openai" },
             }),
           ),
         ),
         Effect.flip,
       )
 
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
+      expect(error.reason).toMatchObject({
+        _tag: "ProviderInternal",
+        data: { error: { code: 502, message: "Provider disconnected", upstream: "openai" } },
+      })
       expect(error.message).toContain("Provider disconnected")
     }),
   )

packages/client/src/effect/api/api.ts

@@ -478,7 +478,12 @@ export type Endpoint5_31Output =
           readonly location?: Location.Ref | undefined
           readonly data: {
             readonly sessionID: Session.ID
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number | undefined
+              readonly data?: Schema.Json | undefined
+            }
           }
         }
       | {
@@ -605,7 +610,12 @@ export type Endpoint5_31Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number | undefined
+              readonly data?: Schema.Json | undefined
+            }
             readonly cost?: (number & Brand.Brand<"Money.USD">) | undefined
             readonly tokens?:
               | {
@@ -767,7 +777,12 @@ export type Endpoint5_31Output =
             readonly sessionID: Session.ID
             readonly assistantMessageID: SessionMessage.ID
             readonly id: string
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number | undefined
+              readonly data?: Schema.Json | undefined
+            }
             readonly content?:
               | readonly [
                   (
@@ -807,7 +822,12 @@ export type Endpoint5_31Output =
             readonly assistantMessageID: SessionMessage.ID
             readonly attempt: number
             readonly at: number
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number | undefined
+              readonly data?: Schema.Json | undefined
+            }
           }
         }
       | {
@@ -848,7 +868,12 @@ export type Endpoint5_31Output =
           readonly data: {
             readonly sessionID: Session.ID
             readonly reason: "auto" | "manual"
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number | undefined
+              readonly data?: Schema.Json | undefined
+            }
             readonly inputID?: SessionMessage.ID | undefined
           }
         }

packages/client/src/promise/generated/types.ts

@@ -104,7 +104,7 @@ export type ToolTextContent = { type: "text"; text: string }
 
 export type ToolFileContent = { type: "file"; uri: string; mime: string; name?: string | null }
 
-export type SessionStructuredError = { type: string; message: string; status?: number }
+export type SessionStructuredError = { type: string; message: string; status?: number; data?: JsonValue }
 
 export type SessionMessageCompactionRunning = {
   type: "compaction"
@@ -2647,7 +2647,12 @@ export type SessionImportInput = {
                   | {
                       readonly status: "error"
                       readonly input: { readonly [x: string]: JsonValue }
-                      readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+                      readonly error: {
+                        readonly type: string
+                        readonly message: string
+                        readonly status?: number
+                        readonly data?: JsonValue
+                      }
                       readonly content?: readonly [
                         (
                           | { readonly type: "text"; readonly text: string }
@@ -2682,11 +2687,21 @@ export type SessionImportInput = {
             readonly reasoning: number
             readonly cache: { readonly read: number; readonly write: number }
           }
-          readonly error?: { readonly type: string; readonly message: string; readonly status?: number }
+          readonly error?: {
+            readonly type: string
+            readonly message: string
+            readonly status?: number
+            readonly data?: JsonValue
+          }
           readonly retry?: {
             readonly attempt: number
             readonly at: number
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number
+              readonly data?: JsonValue
+            }
           }
         }
       | (
@@ -2717,7 +2732,12 @@ export type SessionImportInput = {
               readonly time: { readonly created: number }
               readonly status: "failed"
               readonly reason: "auto" | "manual"
-              readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+              readonly error: {
+                readonly type: string
+                readonly message: string
+                readonly status?: number
+                readonly data?: JsonValue
+              }
             }
         )
     >
@@ -2914,7 +2934,12 @@ export type SessionImportInput = {
                   | {
                       readonly status: "error"
                       readonly input: { readonly [x: string]: JsonValue }
-                      readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+                      readonly error: {
+                        readonly type: string
+                        readonly message: string
+                        readonly status?: number
+                        readonly data?: JsonValue
+                      }
                       readonly content?: readonly [
                         (
                           | { readonly type: "text"; readonly text: string }
@@ -2949,11 +2974,21 @@ export type SessionImportInput = {
             readonly reasoning: number
             readonly cache: { readonly read: number; readonly write: number }
           }
-          readonly error?: { readonly type: string; readonly message: string; readonly status?: number }
+          readonly error?: {
+            readonly type: string
+            readonly message: string
+            readonly status?: number
+            readonly data?: JsonValue
+          }
           readonly retry?: {
             readonly attempt: number
             readonly at: number
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number
+              readonly data?: JsonValue
+            }
           }
         }
       | (
@@ -2984,7 +3019,12 @@ export type SessionImportInput = {
               readonly time: { readonly created: number }
               readonly status: "failed"
               readonly reason: "auto" | "manual"
-              readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+              readonly error: {
+                readonly type: string
+                readonly message: string
+                readonly status?: number
+                readonly data?: JsonValue
+              }
             }
         )
     >
@@ -3181,7 +3221,12 @@ export type SessionImportInput = {
                   | {
                       readonly status: "error"
                       readonly input: { readonly [x: string]: JsonValue }
-                      readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+                      readonly error: {
+                        readonly type: string
+                        readonly message: string
+                        readonly status?: number
+                        readonly data?: JsonValue
+                      }
                       readonly content?: readonly [
                         (
                           | { readonly type: "text"; readonly text: string }
@@ -3216,11 +3261,21 @@ export type SessionImportInput = {
             readonly reasoning: number
             readonly cache: { readonly read: number; readonly write: number }
           }
-          readonly error?: { readonly type: string; readonly message: string; readonly status?: number }
+          readonly error?: {
+            readonly type: string
+            readonly message: string
+            readonly status?: number
+            readonly data?: JsonValue
+          }
           readonly retry?: {
             readonly attempt: number
             readonly at: number
-            readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+            readonly error: {
+              readonly type: string
+              readonly message: string
+              readonly status?: number
+              readonly data?: JsonValue
+            }
           }
         }
       | (
@@ -3251,7 +3306,12 @@ export type SessionImportInput = {
               readonly time: { readonly created: number }
               readonly status: "failed"
               readonly reason: "auto" | "manual"
-              readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+              readonly error: {
+                readonly type: string
+                readonly message: string
+                readonly status?: number
+                readonly data?: JsonValue
+              }
             }
         )
     >

packages/core/src/aisdk.ts

@@ -780,7 +780,10 @@ function llmError(method: string, error: unknown) {
       ? new InvalidProviderOutputReason({ message: error.message })
       : APICallError.isInstance(error)
         ? apiCallErrorReason(error)
-        : new UnknownProviderReason({ message: unknownErrorMessage(error) })
+        : new UnknownProviderReason({
+            message: unknownErrorMessage(error),
+            data: Schema.decodeUnknownSync(Schema.Json)(jsonValue(error)),
+          })
   return new AIError({
     module: "AISDK",
     method,
@@ -792,6 +795,7 @@ function apiCallErrorReason(error: APICallError) {
   const details = providerErrorDetails(error)
   const reason = RequestExecutor.classifyHttpFailure({
     message: details.message,
+    data: Schema.decodeUnknownSync(Schema.Json)(jsonValue(error.data ?? error.responseBody ?? null)),
     url: error.url,
     status: error.statusCode,
     code: details.code,

packages/core/src/config/plugin/formatter.ts

@@ -1,68 +0,0 @@
-export * as ConfigFormatterPlugin from "./formatter.js"
-
-import { define } from "@opencode-ai/plugin/effect/plugin"
-import { FSUtil } from "@opencode-ai/util/fs-util"
-import { Global } from "@opencode-ai/util/global"
-import { Npm } from "@opencode-ai/util/npm"
-import { AppProcess } from "@opencode-ai/util/process"
-import { Effect, Stream } from "effect"
-import { Config } from "../../config.js"
-import { Formatter } from "../../formatter.js"
-import { make, type Info } from "../../formatter/builtins.js"
-import { Location } from "../../location.js"
-
-export const Plugin = define({
-  id: "opencode.config.formatter",
-  effect: Effect.fn(function* (ctx) {
-    const config = yield* Config.Service
-    const formatter = yield* Formatter.Service
-    const fs = yield* FSUtil.Service
-    const global = yield* Global.Service
-    const location = yield* Location.Service
-    const npm = yield* Npm.Service
-    const processes = yield* AppProcess.Service
-    const loaded = { entries: yield* config.entries() }
-
-    yield* formatter.transform((draft) => {
-      const configured = Config.latest(loaded.entries, "formatter")
-      if (!configured) return
-      const builtIns = make({
-        directory: location.directory,
-        worktree: location.project.directory,
-        fs,
-        npm,
-        processes,
-        bin: global.bin,
-      })
-      builtIns.forEach(draft.set)
-      if (configured === true) return
-
-      for (const [name, entry] of Object.entries(configured)) {
-        if (entry.disabled) {
-          draft.remove(name)
-          continue
-        }
-        const builtIn = builtIns.find((formatter) => formatter.name === name)
-        const current: Info = {
-          name,
-          extensions: entry.extensions ?? builtIn?.extensions ?? [],
-          environment: { ...builtIn?.environment, ...entry.environment },
-          enabled:
-            builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
-        }
-        draft.set(current)
-      }
-    })
-
-    yield* ctx.event.subscribe().pipe(
-      Stream.filter((event) => event.type === "config.updated"),
-      Stream.runForEach(() =>
-        config.entries().pipe(
-          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
-          Effect.andThen(formatter.reload()),
-        ),
-      ),
-      Effect.forkScoped({ startImmediately: true }),
-    )
-  }),
-})

packages/core/src/database/migration/20260804233008_loose_psylocke.ts

@@ -1,43 +1,10 @@
 import { Effect } from "effect"
-import { sql } from "drizzle-orm"
 import type { DatabaseMigration } from "../migration.js"
 
-const previousV2Marker = "20260730195856_optional_session_title"
-
 const migration: DatabaseMigration.Migration = {
   id: "20260804233008_loose_psylocke",
   up(tx) {
     return Effect.gen(function* () {
-      // This marker identifies the completed pre-split V2 lineage. Its V2 tables
-      // are canonical, so rename them in place instead of replaying the V1 squash.
-      if (yield* tx.get(sql`SELECT id FROM migration WHERE id = ${previousV2Marker}`)) {
-        const v1Only = yield* tx.get(sql`
-          SELECT 1
-          FROM message
-          WHERE NOT EXISTS (
-            SELECT 1 FROM session_message WHERE session_message.session_id = message.session_id
-          )
-          LIMIT 1
-        `)
-        if (v1Only) return yield* Effect.die(new Error("Previous V2 database contains V1-only session history"))
-
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_project_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_workspace_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_parent_idx\`;`)
-        yield* tx.run(`DROP INDEX IF EXISTS \`session_time_suspended_idx\`;`)
-        yield* tx.run(`ALTER TABLE \`session\` RENAME TO \`session_v2\`;`)
-        yield* tx.run(`CREATE INDEX \`session_v2_project_idx\` ON \`session_v2\` (\`project_id\`);`)
-        yield* tx.run(`CREATE INDEX \`session_v2_workspace_idx\` ON \`session_v2\` (\`workspace_id\`);`)
-        yield* tx.run(`CREATE INDEX \`session_v2_parent_idx\` ON \`session_v2\` (\`parent_id\`);`)
-        yield* tx.run(
-          `CREATE INDEX \`session_v2_time_suspended_idx\` ON \`session_v2\` (\`time_suspended\`) WHERE "session_v2"."time_suspended" is not null;`,
-        )
-        yield* tx.run(`DROP TABLE IF EXISTS \`data_migration\`;`)
-        yield* tx.run(`DROP TABLE IF EXISTS \`session_context_epoch\`;`)
-        yield* tx.run(`DROP TABLE IF EXISTS \`session_input\`;`)
-        return
-      }
-
       yield* tx.run(`
         CREATE TABLE IF NOT EXISTS \`kv\` (
           \`key\` text PRIMARY KEY,

packages/core/src/formatter.ts

@@ -4,21 +4,15 @@ import { Context, Effect, Layer } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import path from "path"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Npm } from "@opencode-ai/util/npm"
 import { AppProcess } from "@opencode-ai/util/process"
+import { Global } from "@opencode-ai/util/global"
+import { Config } from "./config.js"
 import { Location } from "./location.js"
-import type { Info } from "./formatter/builtins.js"
-import { State } from "./state.js"
+import { make, type Info } from "./formatter/builtins.js"
 
-type Data = {
-  formatters: Info[]
-}
-
-export type Draft = {
-  set: (formatter: Info) => void
-  remove: (name: string) => void
-}
-
-export interface Interface extends State.Transformable<Draft> {
+export interface Interface {
   readonly file: (filepath: string) => Effect.Effect<boolean>
 }
 
@@ -27,24 +21,54 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/v2
 const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
+    const config = yield* Config.Service
+    const fs = yield* FSUtil.Service
     const location = yield* Location.Service
+    const npm = yield* Npm.Service
     const processes = yield* AppProcess.Service
+    const global = yield* Global.Service
     const commands = new Map<string, string[] | false>()
-    const state = State.create<Data, Draft>({
-      name: "formatter",
-      initial: () => ({ formatters: [] }),
-      draft: (draft) => ({
-        set: (formatter) => {
-          const index = draft.formatters.findIndex((item) => item.name === formatter.name)
-          if (index === -1) draft.formatters.push(formatter)
-          else draft.formatters[index] = formatter
-        },
-        remove: (name) => {
-          draft.formatters = draft.formatters.filter((formatter) => formatter.name !== name)
-        },
-      }),
-      finalize: () => Effect.sync(() => commands.clear()),
-    })
+    let formatters: Info[] = []
+
+    const load = yield* Effect.cached(
+      Effect.gen(function* () {
+        const configured = Config.latest(yield* config.entries(), "formatter")
+        if (!configured) {
+          yield* Effect.logInfo("all formatters are disabled")
+          return
+        }
+
+        const builtIns = make({
+          directory: location.directory,
+          worktree: location.project.directory,
+          fs,
+          npm,
+          processes,
+          bin: global.bin,
+        })
+        formatters = builtIns
+        if (configured === true) return
+
+        for (const [name, entry] of Object.entries(configured)) {
+          const index = formatters.findIndex((formatter) => formatter.name === name)
+          if (entry.disabled) {
+            if (index !== -1) formatters.splice(index, 1)
+            continue
+          }
+
+          const builtIn = builtIns.find((formatter) => formatter.name === name)
+          const formatter: Info = {
+            name,
+            extensions: entry.extensions ?? builtIn?.extensions ?? [],
+            environment: { ...builtIn?.environment, ...entry.environment },
+            enabled:
+              builtIn && !entry.command ? builtIn.enabled : Effect.succeed(entry.command ? [...entry.command] : false),
+          }
+          if (index === -1) formatters.push(formatter)
+          else formatters[index] = formatter
+        }
+      }).pipe(Effect.withSpan("Formatter.load")),
+    )
 
     const command = Effect.fnUntraced(function* (formatter: Info) {
       const cached = commands.get(formatter.name)
@@ -55,9 +79,8 @@ const layer = Layer.effect(
     })
 
     const file = Effect.fn("Formatter.file")(function* (filepath: string) {
-      const matching = state
-        .get()
-        .formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)))
+      yield* load
+      const matching = formatters.filter((formatter) => formatter.extensions.includes(path.extname(filepath)))
 
       for (const formatter of matching) {
         const enabled = yield* command(formatter)
@@ -95,12 +118,12 @@ const layer = Layer.effect(
       return false
     })
 
-    return Service.of({ transform: state.transform, reload: state.reload, file })
+    return Service.of({ file })
   }),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Location.node, AppProcess.node],
+  deps: [Config.node, FSUtil.node, Location.node, Npm.node, AppProcess.node, Global.node],
 })

packages/core/src/instructions/builtins.ts

@@ -33,7 +33,7 @@ const layer = Layer.effect(
                   `  Workspace root folder: ${location.project.directory}`,
                   `  Is directory a git repo: ${location.vcs?.type === "git" ? "yes" : "no"}`,
                   `  Platform: ${process.platform}`,
-                  `  Prefer ${global.tmp} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+                  `  Use ${global.tmp} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
                   "</env>",
                 ].join("\n"),
               ),

packages/core/src/plugin/internal.ts

@@ -3,7 +3,6 @@ export * as PluginInternal from "./internal.js"
 import type { Plugin } from "@opencode-ai/plugin/effect/plugin"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { httpClient } from "@opencode-ai/util/effect/app-node-platform"
-import { AppProcess } from "@opencode-ai/util/process"
 import { Context, Effect, Scope } from "effect"
 import { HttpClient } from "effect/unstable/http"
 import { Agent } from "../agent.js"
@@ -13,7 +12,6 @@ import { Config } from "../config.js"
 import { Credential } from "../credential.js"
 import { ConfigAgentPlugin } from "../config/plugin/agent.js"
 import { ConfigCommandPlugin } from "../config/plugin/command.js"
-import { ConfigFormatterPlugin } from "../config/plugin/formatter.js"
 import { ConfigInstructionPlugin } from "../config/plugin/instruction.js"
 import { ConfigProviderPlugin } from "../config/plugin/provider.js"
 import { ConfigPolicyPlugin } from "../config/plugin/policy.js"
@@ -76,7 +74,6 @@ import { WellKnownPlugin } from "../wellknown/plugin.js"
 
 const services = Effect.fn("PluginInternal.services")(function* () {
   const agent = yield* Agent.Service
-  const processes = yield* AppProcess.Service
   const catalog = yield* Catalog.Service
   const command = yield* Command.Service
   const config = yield* Config.Service
@@ -114,7 +111,6 @@ const services = Effect.fn("PluginInternal.services")(function* () {
   const wellknown = yield* WellKnown.Service
   return Context.mergeAll(
     Context.make(Agent.Service, agent),
-    Context.make(AppProcess.Service, processes),
     Context.make(Catalog.Service, catalog),
     Context.make(Command.Service, command),
     Context.make(Config.Service, config),
@@ -159,7 +155,6 @@ export type Requirements = ContextServices<Effect.Success<ReturnType<typeof serv
 
 export const requirements = LayerNode.group([
   Agent.node,
-  AppProcess.node,
   Catalog.node,
   Command.node,
   Config.node,
@@ -229,7 +224,6 @@ const post = [
   ConfigReferencePlugin.Plugin,
   ConfigAgentPlugin.Plugin,
   ConfigCommandPlugin.Plugin,
-  ConfigFormatterPlugin.Plugin,
   ConfigSkillPlugin.Plugin,
   ConfigProviderPlugin.Plugin,
   ConfigWebSearchPlugin.Plugin,

packages/core/src/session/runner/publish-llm-event.ts

@@ -528,7 +528,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         return
       case "provider-error":
         providerFailed = true
-        yield* failAssistant({ type: "provider.unknown", message: event.message })
+        yield* failAssistant({ type: "provider.unknown", message: event.message, data: event.data })
         return
     }
   })

packages/core/src/session/to-session-error.ts

@@ -61,5 +61,11 @@ export function toSessionError(cause: unknown): SessionError.Error {
 function providerError(type: string, reason: AIError["reason"]): SessionError.Error {
   const status =
     ("http" in reason ? reason.http?.response?.status : undefined) ?? ("status" in reason ? reason.status : undefined)
-  return { type, message: reason.message, ...(status === undefined ? {} : { status }) }
+  const data = "data" in reason ? reason.data : reason._tag === "InvalidProviderOutput" ? reason.raw : undefined
+  return {
+    type,
+    message: reason.message,
+    ...(status === undefined ? {} : { status }),
+    ...(data === undefined ? {} : { data }),
+  }
 }

packages/core/src/shell.ts

@@ -324,7 +324,7 @@ export const layer = (options?: ShellSelect.Options) =>
               runFork(
                 handle.exitCode.pipe(
                   Effect.flatMap((code) => finish("exited", code)),
-                  Effect.catch(() => finish("exited")),
+                  Effect.catch(() => Effect.void),
                 ),
               )
 

packages/core/test/aisdk.test.ts

@@ -487,6 +487,7 @@ it.effect("derives status and code when the AI SDK error message is empty", () =
     expect(projected.type).toBe("provider.invalid-request")
     expect(projected.status).toBe(404)
     expect(projected.message).not.toBe("")
+    expect(projected.data).toEqual({ error: { message: "", code: "not_found" } })
   }),
 )
 
@@ -504,6 +505,7 @@ it.effect("preserves complete HTTP context on AI SDK call errors", () =>
     expect(http?.response?.status).toBe(404)
     expect(http?.response?.headers["authorization"]).toBe("Bearer secret-token")
     expect(http?.body).toBe('{"error":{"message":"","code":"not_found"}}')
+    expect(error.reason).toMatchObject({ data: '{"error":{"message":"","code":"not_found"}}' })
   }),
 )
 

packages/core/test/database-migration.test.ts

@@ -13,10 +13,6 @@ import { tmpdir } from "./fixture/tmpdir"
 import type { SqlClient } from "effect/unstable/sql/SqlClient"
 import legacyCredentialsMigration from "@opencode-ai/core/database/migration/20260805200742_import_legacy_credentials"
 import worktreeMigration from "@opencode-ai/core/database/migration/20260812213948_worktree"
-import previousV2Migration from "@opencode-ai/core/database/migration/20260804233008_loose_psylocke"
-import workspaceMigration from "@opencode-ai/core/database/migration/20260808023530_workspace_domain"
-import executionClaimsMigration from "@opencode-ai/core/database/migration/20260811161259_execution_claim_attempts"
-import sessionInboxMigration from "@opencode-ai/core/database/migration/20260812181746_session_inbox"
 import { Global } from "@opencode-ai/util/global"
 
 const run = <A, E>(
@@ -132,142 +128,6 @@ describe("DatabaseMigration", () => {
     )
   })
 
-  test("preserves previous V2 state through the current migration lineage", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`PRAGMA foreign_keys = ON`)
-        yield* db.run(sql`CREATE TABLE migration (id text PRIMARY KEY, time_completed integer NOT NULL)`)
-        yield* db.run(sql`
-          INSERT INTO migration (id, time_completed)
-          VALUES ('20260730195856_optional_session_title', 1)
-        `)
-        yield* db.run(sql`CREATE TABLE project (id text PRIMARY KEY)`)
-        yield* db.run(sql`
-          CREATE TABLE project_directory (
-            project_id text NOT NULL,
-            directory text NOT NULL,
-            type text,
-            strategy text,
-            time_created integer NOT NULL,
-            PRIMARY KEY (project_id, directory)
-          )
-        `)
-        yield* db.run(sql`
-          CREATE TABLE workspace (
-            id text PRIMARY KEY,
-            type text NOT NULL,
-            name text NOT NULL,
-            project_id text NOT NULL,
-            time_used integer NOT NULL
-          )
-        `)
-        yield* db.run(sql`
-          CREATE TABLE session (
-            id text PRIMARY KEY,
-            project_id text NOT NULL REFERENCES project(id) ON DELETE CASCADE,
-            workspace_id text,
-            parent_id text,
-            time_suspended integer
-          )
-        `)
-        yield* db.run(sql`CREATE INDEX session_project_idx ON session (project_id)`)
-        yield* db.run(sql`CREATE INDEX session_workspace_idx ON session (workspace_id)`)
-        yield* db.run(sql`CREATE INDEX session_parent_idx ON session (parent_id)`)
-        yield* db.run(
-          sql`CREATE INDEX session_time_suspended_idx ON session (time_suspended) WHERE "session"."time_suspended" IS NOT NULL`,
-        )
-        yield* db.run(sql`
-          CREATE TABLE session_message (
-            id text PRIMARY KEY,
-            session_id text NOT NULL REFERENCES session(id) ON DELETE CASCADE,
-            data text NOT NULL
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`
-          CREATE TABLE session_pending (
-            id text PRIMARY KEY,
-            session_id text NOT NULL REFERENCES session(id) ON DELETE CASCADE
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE event_sequence (aggregate_id text PRIMARY KEY, seq integer NOT NULL)`)
-        yield* db.run(sql`
-          CREATE TABLE event (
-            id text PRIMARY KEY,
-            aggregate_id text NOT NULL REFERENCES event_sequence(aggregate_id) ON DELETE CASCADE,
-            seq integer NOT NULL,
-            created integer NOT NULL,
-            type text NOT NULL,
-            data text NOT NULL
-          )
-        `)
-        yield* db.run(sql`CREATE TABLE data_migration (name text PRIMARY KEY)`)
-        yield* db.run(sql`INSERT INTO project VALUES ('project')`)
-        yield* db.run(sql`INSERT INTO project_directory VALUES ('project', '/repo', 'main', NULL, 1)`)
-        yield* db.run(sql`INSERT INTO session VALUES ('session', 'project', NULL, NULL, NULL)`)
-        yield* db.run(sql`INSERT INTO session_message VALUES ('message', 'session', '{"text":"preserved"}')`)
-        yield* db.run(sql`INSERT INTO session_pending VALUES ('pending', 'session')`)
-        yield* db.run(sql`INSERT INTO event_sequence VALUES ('session', 41)`)
-        yield* db.run(sql`INSERT INTO event VALUES ('event', 'session', 41, 1, 'session.text.ended.1', '{}')`)
-
-        yield* DatabaseMigration.applyOnly(db, [
-          previousV2Migration,
-          workspaceMigration,
-          executionClaimsMigration,
-          sessionInboxMigration,
-          worktreeMigration,
-        ])
-
-        expect(yield* db.get(sql`SELECT id, resume_attempts FROM session_v2`)).toEqual({
-          id: "session",
-          resume_attempts: 0,
-        })
-        expect(yield* db.get(sql`SELECT id, data FROM session_message`)).toEqual({
-          id: "message",
-          data: '{"text":"preserved"}',
-        })
-        expect(yield* db.get(sql`SELECT id FROM session_pending`)).toEqual({ id: "pending" })
-        expect(yield* db.get(sql`SELECT seq FROM event_sequence`)).toEqual({ seq: 41 })
-        expect(yield* db.get(sql`SELECT id, seq FROM event`)).toEqual({ id: "event", seq: 41 })
-        expect(
-          yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`),
-        ).toBeUndefined()
-        expect(yield* db.get(sql`SELECT directory FROM worktree`)).toEqual({ directory: "/repo" })
-        expect(yield* db.all<{ table: string }>(sql`PRAGMA foreign_key_list(session_message)`)).toContainEqual(
-          expect.objectContaining({ table: "session_v2" }),
-        )
-        expect(yield* db.all<{ table: string }>(sql`PRAGMA foreign_key_list(session_pending)`)).toContainEqual(
-          expect.objectContaining({ table: "session_v2" }),
-        )
-      }),
-    )
-  })
-
-  test("rejects previous V2 databases with V1-only session history", async () => {
-    await run(
-      Effect.gen(function* () {
-        const db = yield* makeDb
-        yield* db.run(sql`CREATE TABLE migration (id text PRIMARY KEY, time_completed integer NOT NULL)`)
-        yield* db.run(sql`
-          INSERT INTO migration (id, time_completed)
-          VALUES ('20260730195856_optional_session_title', 1)
-        `)
-        yield* db.run(sql`CREATE TABLE session (id text PRIMARY KEY)`)
-        yield* db.run(sql`CREATE TABLE session_message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL)`)
-        yield* db.run(sql`INSERT INTO session VALUES ('session')`)
-        yield* db.run(sql`INSERT INTO message VALUES ('message', 'session')`)
-
-        expect((yield* Effect.exit(DatabaseMigration.applyOnly(db, [previousV2Migration])))._tag).toBe("Failure")
-        expect(yield* db.get(sql`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'session'`)).toEqual({
-          name: "session",
-        })
-        expect(yield* db.get(sql`SELECT id FROM migration WHERE id = ${previousV2Migration.id}`)).toBeUndefined()
-      }),
-    )
-  })
-
   test("copies project directories into worktrees without removing the old table", async () => {
     await run(
       Effect.gen(function* () {

packages/core/test/formatter.test.ts

@@ -1,30 +1,41 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Layer, Schema } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Bus } from "@opencode-ai/core/bus"
-import { Database } from "@opencode-ai/core/database/database"
-import { LocationServiceMap } from "@opencode-ai/core/location-services"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
-import { SdkPlugins } from "@opencode-ai/core/plugin/sdk"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Info } from "@opencode-ai/schema/config"
-import { Global } from "@opencode-ai/util/global"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { Npm } from "@opencode-ai/util/npm"
+import { Document, Info } from "@opencode-ai/schema/config"
+import { Config } from "../src/config"
 import { Formatter } from "../src/formatter"
 import { Location } from "../src/location"
-import { tempGlobalLayer } from "./fixture/global"
+import { location } from "./fixture/location"
 import { tmpdir } from "./fixture/tmpdir"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
-    [Global.node, tempGlobalLayer],
-  ]),
-)
+const it = testEffect(Layer.empty)
 type ConfigInput = typeof Info.Encoded
 
+function formatterLayer(directory: string, configured?: ConfigInput["formatter"]) {
+  const entries =
+    configured === undefined
+      ? []
+      : [
+          new Document({
+            type: "document",
+            info: Schema.decodeUnknownSync(Info)({ formatter: configured }),
+          }),
+        ]
+  return AppNodeBuilder.build(Formatter.node, [
+    [Config.node, Config.testLayer(entries)],
+    [
+      Location.node,
+      Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),
+    ],
+    [Npm.node, Layer.mock(Npm.Service, { which: () => Effect.succeed(undefined) })],
+  ])
+}
+
 function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>) {
   return Effect.acquireUseRelease(
     Effect.promise(() => tmpdir()),
@@ -33,166 +44,122 @@ function withTemp<A, E, R>(body: (directory: string) => Effect.Effect<A, E, R>)
   )
 }
 
-function withFormatter<A, E, R>(
-  configured: ConfigInput["formatter"],
-  body: (formatter: Formatter.Interface, directory: string) => Effect.Effect<A, E, R>,
-) {
-  return withTemp((directory) =>
-    Effect.promise(() =>
-      fs.writeFile(path.join(directory, "opencode.json"), JSON.stringify({ formatter: configured })),
-    ).pipe(
-      Effect.andThen(
-        Effect.gen(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.flush
-          return yield* body(yield* Formatter.Service, directory)
-        }).pipe(
-          Effect.scoped,
-          Effect.provide(
-            LocationServiceMap.Service.get(Location.Ref.make({ directory: AbsolutePath.make(directory) })),
-          ),
+describe("Formatter", () => {
+  it.live("does not run formatters marked as disabled in config", () =>
+    withTemp((directory) =>
+      Effect.gen(function* () {
+        const file = path.join(directory, "test.disabled")
+        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(false)
+      }).pipe(
+        Effect.provide(
+          formatterLayer(directory, {
+            disabled: {
+              disabled: true,
+              command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
+              extensions: [".disabled"],
+            },
+          }),
         ),
       ),
     ),
   )
-}
-
-describe("Formatter", () => {
-  it.live("does not run formatters marked as disabled in config", () =>
-    withFormatter(
-      {
-        disabled: {
-          disabled: true,
-          command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
-          extensions: [".disabled"],
-        },
-      },
-      (formatter, directory) =>
-        Effect.gen(function* () {
-          const file = path.join(directory, "test.disabled")
-          expect(yield* formatter.file(file)).toBe(false)
-        }),
-    ),
-  )
 
   it.live("file() returns false when no formatter runs", () =>
-    withFormatter(false, (formatter, directory) =>
+    withTemp((directory) =>
       Effect.gen(function* () {
         const file = path.join(directory, "test.txt")
         yield* Effect.promise(() => fs.writeFile(file, "x"))
-        expect(yield* formatter.file(file)).toBe(false)
-      }),
+        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(false)
+      }).pipe(Effect.provide(formatterLayer(directory, false))),
     ),
   )
 
   it.live("loads formatter state per directory", () =>
-    withFormatter(false, (disabledFormatter, off) =>
-      withFormatter(
-        {
-          isolated: {
-            command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
-            extensions: [".isolated"],
-          },
-        },
-        (enabledFormatter, on) =>
-          Effect.gen(function* () {
-            const offFile = path.join(off, "test.isolated")
-            const onFile = path.join(on, "test.isolated")
-            const disabled = yield* disabledFormatter.file(offFile)
-            const enabled = yield* enabledFormatter.file(onFile)
-            expect(disabled).toBe(false)
-            expect(enabled).toBe(true)
-          }),
+    withTemp((off) =>
+      withTemp((on) =>
+        Effect.gen(function* () {
+          const offFile = path.join(off, "test.isolated")
+          const onFile = path.join(on, "test.isolated")
+          const disabled = yield* Formatter.Service.use((formatter) => formatter.file(offFile)).pipe(
+            Effect.provide(formatterLayer(off, false)),
+          )
+          const enabled = yield* Formatter.Service.use((formatter) => formatter.file(onFile)).pipe(
+            Effect.provide(
+              formatterLayer(on, {
+                isolated: {
+                  command: [process.execPath, "-e", "process.exit(0)", "$FILE"],
+                  extensions: [".isolated"],
+                },
+              }),
+            ),
+          )
+          expect(disabled).toBe(false)
+          expect(enabled).toBe(true)
+        }),
       ),
     ),
   )
 
   it.live("stops after the first matching formatter succeeds", () =>
-    withFormatter(
-      {
-        first: {
-          command: [
-            process.execPath,
-            "-e",
-            "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'A')",
-            "$FILE",
-          ],
-          extensions: [".seq"],
-        },
-        second: {
-          command: [
-            process.execPath,
-            "-e",
-            "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
-            "$FILE",
-          ],
-          extensions: [".seq"],
-        },
-      },
-      (formatter, directory) =>
-        Effect.gen(function* () {
-          const file = path.join(directory, "test.seq")
-          yield* Effect.promise(() => fs.writeFile(file, "x"))
-          expect(yield* formatter.file(file)).toBe(true)
-          expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xA")
-        }),
+    withTemp((directory) =>
+      Effect.gen(function* () {
+        const file = path.join(directory, "test.seq")
+        yield* Effect.promise(() => fs.writeFile(file, "x"))
+        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(true)
+        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xA")
+      }).pipe(
+        Effect.provide(
+          formatterLayer(directory, {
+            first: {
+              command: [
+                process.execPath,
+                "-e",
+                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'A')",
+                "$FILE",
+              ],
+              extensions: [".seq"],
+            },
+            second: {
+              command: [
+                process.execPath,
+                "-e",
+                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
+                "$FILE",
+              ],
+              extensions: [".seq"],
+            },
+          }),
+        ),
+      ),
     ),
   )
 
   it.live("tries the next matching formatter when the first fails", () =>
-    withFormatter(
-      {
-        first: {
-          command: [process.execPath, "-e", "process.exit(1)", "$FILE"],
-          extensions: [".fallback"],
-        },
-        second: {
-          command: [
-            process.execPath,
-            "-e",
-            "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
-            "$FILE",
-          ],
-          extensions: [".fallback"],
-        },
-      },
-      (formatter, directory) =>
-        Effect.gen(function* () {
-          const file = path.join(directory, "test.fallback")
-          yield* Effect.promise(() => fs.writeFile(file, "x"))
-          expect(yield* formatter.file(file)).toBe(true)
-          expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xB")
-        }),
-    ),
-  )
-
-  it.live("rebuilds formatter state and clears resolved commands", () =>
-    withFormatter(false, (formatter, directory) =>
+    withTemp((directory) =>
       Effect.gen(function* () {
-        const command = { suffix: "A" }
-        yield* formatter.transform((draft) => {
-          const suffix = command.suffix
-          draft.set({
-            name: "reload",
-            extensions: [".reload"],
-            enabled: Effect.succeed([
-              process.execPath,
-              "-e",
-              `const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, '${suffix}')`,
-              "$FILE",
-            ]),
-          })
-        })
-        const file = path.join(directory, "test.reload")
+        const file = path.join(directory, "test.fallback")
         yield* Effect.promise(() => fs.writeFile(file, "x"))
-        expect(yield* formatter.file(file)).toBe(true)
-
-        command.suffix = "B"
-        yield* formatter.reload()
-
-        expect(yield* formatter.file(file)).toBe(true)
-        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xAB")
-      }),
+        expect(yield* Formatter.Service.use((formatter) => formatter.file(file))).toBe(true)
+        expect(yield* Effect.promise(() => fs.readFile(file, "utf8"))).toBe("xB")
+      }).pipe(
+        Effect.provide(
+          formatterLayer(directory, {
+            first: {
+              command: [process.execPath, "-e", "process.exit(1)", "$FILE"],
+              extensions: [".fallback"],
+            },
+            second: {
+              command: [
+                process.execPath,
+                "-e",
+                "const fs = require('fs'); const file = process.argv.at(-1); fs.appendFileSync(file, 'B')",
+                "$FILE",
+              ],
+              extensions: [".fallback"],
+            },
+          }),
+        ),
+      ),
     ),
   )
 })

packages/core/test/instructions/builtins.test.ts

@@ -51,7 +51,7 @@ describe("InstructionBuiltIns", () => {
           `  Workspace root folder: ${projectDirectory}`,
           "  Is directory a git repo: yes",
           `  Platform: ${process.platform}`,
-          `  Prefer ${temporary} over generic system temporary directories such as /tmp; it is pre-created and approved for external access.`,
+          `  Use ${temporary} for temporary work outside the workspace; it already exists and is pre-approved for external directory access.`,
           "</env>",
           "",
           `Today's date: ${localDate(timestamp)}`,

packages/core/test/session-error.test.ts

@@ -61,6 +61,24 @@ describe("toSessionError", () => {
       ).type,
     ).toBe("provider.no-route")
     expect(toSessionError(llm(new UnknownProviderReason({ message: "unknown" }))).type).toBe("provider.unknown")
+    expect(toSessionError(llm(new InvalidProviderOutputReason({ message: "malformed", raw: "not-json" })))).toEqual({
+      type: "provider.invalid-output",
+      message: "malformed",
+      data: "not-json",
+    })
+  })
+
+  test("preserves provider error data", () => {
+    const data = {
+      type: "error",
+      sequence_number: 2,
+      error: { type: "server_error", code: null, message: null },
+    }
+    expect(toSessionError(llm(new UnknownProviderReason({ message: "stream error", data })))).toEqual({
+      type: "provider.unknown",
+      message: "stream error",
+      data,
+    })
   })
 
   test("preserves the permission rejection type without exposing internal fields", () => {

packages/core/test/session-runner.test.ts

@@ -925,7 +925,7 @@ describe("SessionRunnerLLM", () => {
       yield* admit(session, "Second prompt")
       const titleFailed = yield* Deferred.make<void>()
       yield* TestLLM.push(
-        Stream.make(LLMEvent.providerError({ message: "Title provider unavailable" })).pipe(
+        Stream.make(LLMEvent.providerError({ message: "Title provider unavailable", data: {} })).pipe(
           Stream.ensuring(Deferred.succeed(titleFailed, undefined)),
         ),
         TestLLM.text("Recovered", "text-recovered"),
@@ -2179,7 +2179,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push(TestLLM.text("Earlier answer", "text-manual-provider-history"))
       yield* runPrompt(session, "Earlier question")
 
-      yield* TestLLM.push([LLMEvent.providerError({ message: "summary unavailable" })])
+      yield* TestLLM.push([LLMEvent.providerError({ message: "summary unavailable", data: {} })])
       const compaction = yield* session.compact({ sessionID })
       yield* session.resume(sessionID)
 
@@ -2337,7 +2337,7 @@ describe("SessionRunnerLLM", () => {
       currentModel = compactModel
       requests.length = 0
       yield* TestLLM.push(
-        [LLMEvent.providerError({ message: "Unsupported parameter: max_output_tokens" })],
+        [LLMEvent.providerError({ message: "Unsupported parameter: max_output_tokens", data: {} })],
         TestLLM.text("Must not run", "text-after-failed-compaction"),
       )
       yield* admit(session, "Recent exact request ".repeat(180))
@@ -2362,7 +2362,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push(
         [
           LLMEvent.stepStart({ index: 0 }),
-          LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" }),
+          LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" }),
         ],
         TestLLM.text("## Objective\n- Recover overflow", "text-summary"),
         TestLLM.text("Recovered", "text-final"),
@@ -2389,7 +2389,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setupOverflowRecovery
       currentModel = model
       yield* TestLLM.push(
-        [LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" })],
+        [LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" })],
         TestLLM.text("## Objective\n- Recover unknown limit", "text-summary-unknown-limit"),
         TestLLM.text("Recovered", "text-final-unknown-limit"),
       )
@@ -2408,7 +2408,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setupOverflowRecovery
       currentModel = undersizedContextModel
       yield* TestLLM.push(
-        [LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" })],
+        [LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" })],
         TestLLM.text("## Objective\n- Recover undersized limit", "text-summary-undersized-limit"),
         TestLLM.text("Recovered", "text-final-undersized-limit"),
       )
@@ -2427,7 +2427,7 @@ describe("SessionRunnerLLM", () => {
       const session = yield* setupOverflowRecovery
       const overflow = () => [
         LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" }),
+        LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" }),
       ]
       yield* TestLLM.push(overflow(), TestLLM.text("## Objective\n- Recover once", "text-summary"), overflow())
       yield* admit(session, "Continue")
@@ -2474,8 +2474,8 @@ describe("SessionRunnerLLM", () => {
     Effect.gen(function* () {
       const session = yield* setupOverflowRecovery
       yield* TestLLM.push(
-        [LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" })],
-        [LLMEvent.providerError({ message: "summary unavailable" })],
+        [LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" })],
+        [LLMEvent.providerError({ message: "summary unavailable", data: {} })],
       )
       yield* admit(session, "Continue")
       expect((yield* session.resume(sessionID).pipe(Effect.flip)).message).toBe("prompt too long")
@@ -2502,7 +2502,7 @@ describe("SessionRunnerLLM", () => {
     Effect.gen(function* () {
       const session = yield* setupOverflowRecovery
       yield* TestLLM.push(
-        [LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" })],
+        [LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" })],
         TestLLM.text("## Objective\n- Interrupted", "text-summary"),
       )
       const first = yield* TestLLM.gate
@@ -4078,9 +4078,10 @@ describe("SessionRunnerLLM", () => {
   it.effect("projects provider errors as terminal assistant step failures", () =>
     Effect.gen(function* () {
       const session = yield* setup
+      const data = { type: "error", error: { type: "server_error" } }
       yield* TestLLM.push([
         LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
+        LLMEvent.providerError({ message: "Provider unavailable", data }),
       ])
 
       expect((yield* runPrompt(session, "Fail durably").pipe(Effect.flip)).message).toBe("Provider unavailable")
@@ -4088,7 +4089,11 @@ describe("SessionRunnerLLM", () => {
       expect(requests).toHaveLength(1)
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Fail durably" },
-        { type: "assistant", finish: "error", error: { type: "provider.unknown", message: "Provider unavailable" } },
+        {
+          type: "assistant",
+          finish: "error",
+          error: { type: "provider.unknown", message: "Provider unavailable", data },
+        },
       ])
     }),
   )
@@ -4096,7 +4101,7 @@ describe("SessionRunnerLLM", () => {
   it.effect("projects provider errors emitted before assistant step start", () =>
     Effect.gen(function* () {
       const session = yield* setup
-      yield* TestLLM.push([LLMEvent.providerError({ message: "Provider unavailable" })])
+      yield* TestLLM.push([LLMEvent.providerError({ message: "Provider unavailable", data: {} })])
 
       expect((yield* runPrompt(session, "Fail before step").pipe(Effect.flip)).message).toBe("Provider unavailable")
 
@@ -4183,7 +4188,7 @@ describe("SessionRunnerLLM", () => {
         LLMEvent.textStart({ id: "text-partial" }),
         LLMEvent.textDelta({ id: "text-partial", text: "Partial" }),
         LLMEvent.textEnd({ id: "text-partial" }),
-        LLMEvent.providerError({ message: "prompt too long", classification: "context-overflow" }),
+        LLMEvent.providerError({ message: "prompt too long", data: {}, classification: "context-overflow" }),
       ])
       expect((yield* runPrompt(session, "Fail after output").pipe(Effect.flip)).message).toBe("prompt too long")
 
@@ -4958,7 +4963,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push([
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.toolCall({ id: "call-before-provider-error", name: "echo", input: { text: "settled" } }),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
+        LLMEvent.providerError({ message: "Provider unavailable", data: {} }),
       ])
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
@@ -4985,7 +4990,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push([
         LLMEvent.stepStart({ index: 0 }),
         hostedCall("call-hosted-provider-error", "effect"),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
+        LLMEvent.providerError({ message: "Provider unavailable", data: {} }),
       ])
 
       expect((yield* runPrompt(session, "Fail hosted tool durably").pipe(Effect.flip)).message).toBe(
@@ -5017,7 +5022,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push([
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.toolCall({ id: "call-defect-provider-error", name: "defect", input: {} }),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
+        LLMEvent.providerError({ message: "Provider unavailable", data: {} }),
       ])
 
       expect((yield* runPrompt(session, "Defect while provider fails").pipe(Effect.flip)).message).toBe(
@@ -5044,7 +5049,7 @@ describe("SessionRunnerLLM", () => {
       yield* TestLLM.push([
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.toolCall({ id: "call-store-provider-error", name: "storefail", input: {} }),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
+        LLMEvent.providerError({ message: "Provider unavailable", data: {} }),
       ])
 
       expect(yield* session.resume(sessionID).pipe(Effect.exit)).toMatchObject({

packages/core/test/session-title.test.ts

@@ -310,7 +310,7 @@ it.effect("retries after a failed title request", () =>
     yield* insertSession(sessionID)
     yield* prompt(sessionID, "Retry this title")
     const title = yield* SessionTitle.Service
-    titleStream = () => Stream.make(LLMEvent.providerError({ message: "Provider unavailable" }))
+    titleStream = () => Stream.make(LLMEvent.providerError({ message: "Provider unavailable", data: {} }))
 
     yield* title.generateForFirstPrompt(sessionID)
     titleStream = successfulTitle

packages/core/test/tool-shell.test.ts

@@ -782,40 +782,6 @@ describe("ShellTool", () => {
     ),
   )
 
-  if (!isWindows) {
-    it.live("settles a shell terminated by an external signal", () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const shell = yield* Shell.Service
-              const settled = yield* executeTool(
-                registry,
-                call({ command: idleCommand, background: true }, "call-external-signal"),
-              )
-              const shellID = settled.metadata?.shellID
-              expect(typeof shellID).toBe("string")
-              if (typeof shellID !== "string") return
-              const id = ShellSchema.ID.make(shellID)
-              const info = yield* shell.get(id)
-              expect(typeof info.pid).toBe("number")
-              if (info.pid === undefined) return
-
-              process.kill(-info.pid, "SIGTERM")
-              const result = yield* shell.wait(id).pipe(Effect.timeoutOption(Duration.seconds(1)))
-              expect(result._tag).toBe("Some")
-              if (result._tag === "Some") expect(result.value.status).toBe("exited")
-              expect((yield* shell.list()).map((item) => item.id)).not.toContain(id)
-            }),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    )
-  }
-
   it.live("backgrounds a foreground command when the session is signaled", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

packages/schema/src/session-error.ts

@@ -8,4 +8,5 @@ export const Error = Schema.Struct({
   type: Schema.String,
   message: Schema.String,
   status: Schema.Int.check(Schema.isBetween({ minimum: 100, maximum: 599 })).pipe(optional),
+  data: Schema.Json.pipe(optional),
 }).annotate({ identifier: "Session.StructuredError" })

packages/schema/test/session-error.test.ts

@@ -12,6 +12,11 @@ describe("SessionError", () => {
     const values: SessionError.Error[] = [
       { type: "provider.rate-limit", message: "Slow down" },
       { type: "provider.auth", message: "Authentication failed" },
+      {
+        type: "provider.unknown",
+        message: "Stream error",
+        data: { type: "error", error: { type: "server_error" } },
+      },
       { type: "provider.future-condition", message: "A future provider failure" },
       { type: "unknown", message: "Unexpected" },
     ]

packages/tui/src/component/prompt/index.tsx

@@ -452,6 +452,7 @@ export function Prompt(props: PromptProps) {
         title: "Queue prompt",
         name: "prompt.queue",
         category: "Prompt",
+        palette: undefined,
         run: async (_input: string | undefined, event?: KeyEvent) => {
           event?.preventDefault()
           event?.stopPropagation()

packages/tui/src/config/keybind.ts

@@ -178,7 +178,7 @@ export const Definitions = {
   "session.toggle.thinking": keybind("none", "Toggle thinking blocks visibility"),
 
   "prompt.submit": keybind("none", "Submit prompt"),
-  "prompt.queue": keybind("<leader>return", "Queue prompt"),
+  "prompt.queue": keybind("alt+return", "Queue prompt"),
   "prompt.editor_context.clear": keybind("none", "Clear editor context"),
   "prompt.images.view": keybind("<leader>i", "View image attachments"),
   "prompt.skills": keybind("none", "Open skill selector"),

packages/tui/src/config/v1/keybind.ts

@@ -163,7 +163,7 @@ export const Definitions = {
   display_thinking: keybind("none", "Toggle thinking blocks visibility"),
 
   prompt_submit: keybind("none", "Submit prompt"),
-  prompt_queue: keybind("<leader>return", "Queue prompt"),
+  prompt_queue: keybind("alt+return", "Queue prompt"),
   prompt_editor_context_clear: keybind("none", "Clear editor context"),
   prompt_images_view: keybind("<leader>i", "View image attachments"),
   prompt_skills: keybind("none", "Open skill selector"),

packages/tui/src/mini/footer.prompt.tsx

@@ -1050,7 +1050,6 @@ export function createPromptState(input: PromptInput): PromptState {
         id: "prompt.queue",
         title: "Queue prompt",
         group: "Prompt",
-        palette: true,
         run() {
           syncDraft()
           submitPrompt(promptCopy(draft), "queue")

packages/tui/src/mini/footer.view.tsx

@@ -595,7 +595,7 @@ export function RunFooterView(props: RunFooterViewProps) {
       {
         id: "session.queued_prompts",
         title: "View queued prompts",
-        group: "Prompt",
+        group: "Session",
         run: openQueuedMenu,
       },
     ],

packages/tui/src/routes/session/index.tsx

@@ -1062,7 +1062,7 @@ export function Session(props: { verticalTabsWidth: number }) {
     {
       title: "View queued prompts",
       id: "session.queued_prompts",
-      group: "Prompt",
+      group: "Session",
       enabled: queuedPrompts().length > 0,
       run: openQueuedPrompts,
     },

packages/tui/test/config-v2.test.tsx

@@ -107,7 +107,6 @@ test("preserves migrated v1 keybind defaults", () => {
   const pairs = [
     ["app.exit", "app_exit"],
     ["prompt.paste", "input_paste"],
-    ["prompt.queue", "prompt_queue"],
     ["session.delete", "session_delete"],
     ["session.list", "session_list"],
     ["agent.list", "agent_list"],

packages/tui/test/mini/footer.view.test.tsx

@@ -981,8 +981,7 @@ test("direct footer steers the oldest queued prompt from an empty composer", asy
 
   try {
     await app.renderOnce()
-    app.mockInput.pressKey("x", { ctrl: true })
-    app.mockInput.pressEnter()
+    app.mockInput.pressEnter({ meta: true })
     await Bun.sleep(0)
     expect(steered).toEqual([])
     app.mockInput.pressEnter()
@@ -1035,8 +1034,7 @@ test("direct footer rejects local commands submitted with the queue shortcut", a
   try {
     await app.renderOnce()
     await app.mockInput.typeText("/settings ")
-    app.mockInput.pressKey("x", { ctrl: true })
-    app.mockInput.pressEnter()
+    app.mockInput.pressEnter({ meta: true })
     await Bun.sleep(0)
     expect(submitted).toEqual([])
     expect(statuses).toContain("this prompt cannot be queued")

packages/tui/test/mini/runtime.boot.test.ts

@@ -22,7 +22,7 @@ describe("run runtime boot", () => {
     expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
     expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
     expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,ctrl+j")
-    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("<leader>return")
+    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("alt+return")
   })
 
   test("preserves shared config while resolving independent Mini defaults", async () => {