feat(tui): add tab status icons experiment

Persist background Job ownership and terminal results across server restarts. Resume existing subagent Sessions, admit shell cancellation notices without waking idle parents, and preserve explicit cancellation.

bun.lock

@@ -125,7 +125,7 @@
         "@effect/platform-node": "catalog:",
         "@opencode-ai/client": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.8",
+        "@opencode-ai/pty": "0.1.10",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/server": "workspace:*",
         "@opencode-ai/tui": "workspace:*",
@@ -350,7 +350,6 @@
         "@ai-sdk/cohere": "3.0.27",
         "@ai-sdk/gateway": "3.0.104",
         "@ai-sdk/google-vertex": "4.0.128",
-        "@ai-sdk/groq": "3.0.31",
         "@ai-sdk/mistral": "3.0.51",
         "@ai-sdk/openai-compatible": "2.0.41",
         "@ai-sdk/perplexity": "3.0.26",
@@ -365,7 +364,7 @@
         "@opencode-ai/ai": "workspace:*",
         "@opencode-ai/codemode": "workspace:*",
         "@opencode-ai/plugin": "workspace:*",
-        "@opencode-ai/pty": "0.1.8",
+        "@opencode-ai/pty": "0.1.10",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/util": "workspace:*",
         "@parcel/watcher": "2.5.1",
@@ -2157,19 +2156,19 @@
 
     "@opencode-ai/protocol": ["@opencode-ai/protocol@workspace:packages/protocol"],
 
-    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.8", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.8", "@opencode-ai/pty-darwin-x64": "0.1.8", "@opencode-ai/pty-linux-arm64-gnu": "0.1.8", "@opencode-ai/pty-linux-arm64-musl": "0.1.8", "@opencode-ai/pty-linux-x64-gnu": "0.1.8", "@opencode-ai/pty-linux-x64-musl": "0.1.8" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-+OHAANB6xgtO4zVMK5Q3l50Iot2fYcHL003rNpvxxCXLkpdO90UnnRCL9jrll1SWkWoDZKaUDlR/Scw6TUTN4A=="],
+    "@opencode-ai/pty": ["@opencode-ai/pty@0.1.10", "", { "optionalDependencies": { "@opencode-ai/pty-darwin-arm64": "0.1.10", "@opencode-ai/pty-darwin-x64": "0.1.10", "@opencode-ai/pty-linux-arm64-gnu": "0.1.10", "@opencode-ai/pty-linux-arm64-musl": "0.1.10", "@opencode-ai/pty-linux-x64-gnu": "0.1.10", "@opencode-ai/pty-linux-x64-musl": "0.1.10" }, "bin": { "opencode-pty": "bin/opencode-pty.js" } }, "sha512-cEJT1ADtmnb+df2wrlUcsGny6Q7pTe9Sa7keISzCO0xN1FrL1aS6+eleBPpDimHjgM/sXqvLwJv0UiAeiAvgxQ=="],
 
-    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-5DqVcCfa9P5zpM0QpvXD/QqZXFdXvtIoaBHVHjYnTt8oqlnmMWqG4OVowzPNQg07NudW6apwX1Jop1wuERgWGw=="],
+    "@opencode-ai/pty-darwin-arm64": ["@opencode-ai/pty-darwin-arm64@0.1.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-j7aszDFRwCIazGUT9eIy4PZwh4rltjvRmoicPRTK3kONN3v0MMflstkmAFDYYpqDPTNh3qJ6xkQmB+DugEbhAg=="],
 
-    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-keEDxfpy0mFJYmsTqea9IUbpLKpbe9yL4ISU8tYA0daWiKuR8ZlfLTlLGltaFNO7l7q6mURMeI4cZzwySOX/Kw=="],
+    "@opencode-ai/pty-darwin-x64": ["@opencode-ai/pty-darwin-x64@0.1.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-UAMP/E4lo9RGQF7xrfIwpW2ZEemj308rCogJy14ruKYJt5MwHeGNTynGiHE/1JlDLRy+21wV50jpugADgT71ag=="],
 
-    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-NVJvlVtPbYRyjABwLkm1iboijpSZMXv4lfg4qda7UCzAgiDZ0cWauXeW5wtd9bbnUbHw4rdNVU6YweuwASgZXw=="],
+    "@opencode-ai/pty-linux-arm64-gnu": ["@opencode-ai/pty-linux-arm64-gnu@0.1.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-lTPlZNQ66koFHZqoPmvvq0SetlepKVQYgnLryhlVfYtcryWDJM7gV4+P66V12RwqWQTjt2u8j12mtg3axSKg2w=="],
 
-    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-GAhnCs7b7B8Hqa7AEN7k5ra4IqybFYePgbCSOHn3Y4mofp/5NjDlkOG/VFM7rHAy05iEmRi5WtOPRv0Mkca8zA=="],
+    "@opencode-ai/pty-linux-arm64-musl": ["@opencode-ai/pty-linux-arm64-musl@0.1.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-IDmWHRylMR/ZfMw9/AAktO/Edi4TITPC+Tq7Xx3JZHsDgSba3QdyE11uNL0zM1myTGdk6Yrt4rpdAzaItPnDjw=="],
 
-    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-vSbty1L0BuOQlK7DmukuhdxNKv2vzqyxOjHmh+TULptMDbDZwE1EybASoXB7dYog9as85adFCz8ZTF7Boyfxjg=="],
+    "@opencode-ai/pty-linux-x64-gnu": ["@opencode-ai/pty-linux-x64-gnu@0.1.10", "", { "os": "linux", "cpu": "x64" }, "sha512-Q1yob0/8X2JoJZzFmNKUc32XDRAe0avKQ8PLKkpJr30qWXSrGmhltgcDmn94Q70zW9Ght9on84T7cmge9brvdQ=="],
 
-    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-2GhmJLl+Ly/JjzMS2Eqvk7SgeuHIB0cQ4Wrmnj4WKhr2V7lS+pdUEApN6S0SG/FK0TYJlWeHeOIpNZgDqzEPPg=="],
+    "@opencode-ai/pty-linux-x64-musl": ["@opencode-ai/pty-linux-x64-musl@0.1.10", "", { "os": "linux", "cpu": "x64" }, "sha512-7RLHWQxX/wfUKJJP2ZMMtkXaPsrgoMNKzE6PL/LbnYbMBtkqfld9EDcMv1RFZ0CqjNFgI0Hg4eRk6x+ZNc/wyQ=="],
 
     "@opencode-ai/schema": ["@opencode-ai/schema@workspace:packages/schema"],
 

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-6Fc26RulNnJZtMUxeryWYqCt/7xIs1E+cOQSddAC9LA=",
-    "aarch64-linux": "sha256-p7cyVH12IGAo6HyaoSgO1fBx5fNTCZGTpvbqzIpe+A8=",
-    "aarch64-darwin": "sha256-U90pWWqe7DRiUpY5KUUp4exQpa/ddb/bQ5Ldxe46LfQ=",
-    "x86_64-darwin": "sha256-Ak6omOq2BBRLQEMxPydiQY9ajaJGQR61P6az4+xxZVM="
+    "x86_64-linux": "sha256-QWLIdvu985FH5I9cZJOAuoeFeXU+4Jx9RzBB9RPoeeQ=",
+    "aarch64-linux": "sha256-SSzGD5hMj2vFvyw+dUPR9g/ZH6qhs0ZyZ/DnltZt3N8=",
+    "aarch64-darwin": "sha256-CeFUxiV+e8pKho+YcSclC3soQBogoxNMxwyIMztAExU=",
+    "x86_64-darwin": "sha256-FYwcACzU72y0+KtOpFfU7ndak8vMasqMgd5NLS6+XtY="
   }
 }

packages/ai/src/cache-policy.ts

@@ -36,7 +36,12 @@ const resolve = (policy: CachePolicy | undefined): CachePolicyObject => {
 // Protocols whose wire format ignores inline cache markers (OpenAI's implicit
 // prefix caching, Gemini's implicit + out-of-band CachedContent). Skip the
 // whole policy pass for these — emitting hints would be harmless but pointless.
-const RESPECTS_INLINE_HINTS = new Set(["anthropic-messages", "google-vertex-messages", "bedrock-converse", "openrouter"])
+const RESPECTS_INLINE_HINTS = new Set([
+  "anthropic-messages",
+  "google-vertex-messages",
+  "bedrock-converse",
+  "openrouter",
+])
 
 const makeHint = (ttlSeconds: number | undefined): CacheHint =>
   ttlSeconds !== undefined ? new CacheHint({ type: "ephemeral", ttlSeconds }) : new CacheHint({ type: "ephemeral" })

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

@@ -69,14 +69,22 @@ export interface OptionsInput {
   // SDK Metadata:2649 {user_id?: string | null}
   readonly metadata?: { readonly user_id?: string | null }
   // SDK MessageCreateParamsContainer:2596 ContainerParams|string
-  readonly container?: string | { readonly id?: string | null; readonly skills?: ReadonlyArray<Record<string, unknown>> | null }
+  readonly container?:
+    | string
+    | { readonly id?: string | null; readonly skills?: ReadonlyArray<Record<string, unknown>> | null }
   readonly inference_geo?: string | null
   readonly inferenceGeo?: string | null
   readonly cache_control?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" }
   readonly cacheControl?: { readonly type: "ephemeral"; readonly ttl?: "5m" | "1h" }
   // SDK OutputConfig:2684 {effort, format: JSONOutputFormat}
-  readonly output_config?: { readonly effort?: string | null; readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null }
-  readonly outputConfig?: { readonly effort?: string | null; readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null }
+  readonly output_config?: {
+    readonly effort?: string | null
+    readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null
+  }
+  readonly outputConfig?: {
+    readonly effort?: string | null
+    readonly format?: { readonly type: "json_schema"; readonly schema: Record<string, unknown> } | null
+  }
 }
 
 export type ProviderOptionsInput = OptionsInput
@@ -259,7 +267,11 @@ const AnthropicToolChoice = Schema.Union([
     type: Schema.Literals(["auto", "any", "none"]),
     disable_parallel_tool_use: Schema.optional(Schema.Boolean),
   }),
-  Schema.Struct({ type: Schema.tag("tool"), name: Schema.String, disable_parallel_tool_use: Schema.optional(Schema.Boolean) }),
+  Schema.Struct({
+    type: Schema.tag("tool"),
+    name: Schema.String,
+    disable_parallel_tool_use: Schema.optional(Schema.Boolean),
+  }),
 ])
 
 const AnthropicThinking = Schema.Union([
@@ -506,7 +518,11 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
   // Prefer the provider-owned replay payload; fall back to the result value for
   // histories constructed directly from provider events.
   const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value
-  return { type: wireType, tool_use_id: scrubToolCallID(part.id), content: payload } satisfies AnthropicServerToolResultBlock
+  return {
+    type: wireType,
+    tool_use_id: scrubToolCallID(part.id),
+    content: payload,
+  } satisfies AnthropicServerToolResultBlock
 })
 
 const fileIdFromMetadata = (metadata: MediaPart["metadata"]): string | undefined => {
@@ -554,9 +570,7 @@ const documentContextFromMetadata = (metadata: MediaPart["metadata"]): string |
   return undefined
 }
 
-const citationsFromMetadata = (
-  metadata: MediaPart["metadata"],
-): AnthropicDocumentBlock["citations"] | undefined => {
+const citationsFromMetadata = (metadata: MediaPart["metadata"]): AnthropicDocumentBlock["citations"] | undefined => {
   if (!ProviderShared.isRecord(metadata)) return undefined
   const raw = ProviderShared.isRecord(metadata.anthropic)
     ? (metadata.anthropic.citations ?? metadata.citations)
@@ -706,8 +720,7 @@ const lowerToolResultContent = Effect.fnUntraced(function* (part: ToolResultPart
 })
 
 const requireThinkingSignature = (request: LLMRequest) => {
-  if (request.model.compatibility?.requireSignature !== undefined)
-    return request.model.compatibility.requireSignature
+  if (request.model.compatibility?.requireSignature !== undefined) return request.model.compatibility.requireSignature
   const provider = request.model.provider.toLowerCase()
   const model = request.model.id.toLowerCase()
   const baseURL = (request.model.route.endpoint.baseURL ?? "").toLowerCase()
@@ -900,21 +913,24 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
 
 const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request: LLMRequest) {
   const input = request.providerOptions as Record<string, unknown> | undefined
-  const rawServiceTier = (input as Record<string, unknown> | undefined)?.service_tier ?? (input as Record<string, unknown> | undefined)?.serviceTier
+  const rawServiceTier =
+    (input as Record<string, unknown> | undefined)?.service_tier ??
+    (input as Record<string, unknown> | undefined)?.serviceTier
   const service_tier =
     rawServiceTier === "auto" || rawServiceTier === "standard_only"
       ? (rawServiceTier as "auto" | "standard_only")
       : undefined
   const rawMetadata = (input as Record<string, unknown> | undefined)?.metadata
   const metadata =
-    ProviderShared.isRecord(rawMetadata) &&
-    (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null)
+    ProviderShared.isRecord(rawMetadata) && (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null)
       ? { user_id: rawMetadata.user_id as string | null }
       : undefined
   const container =
     typeof (input as Record<string, unknown> | undefined)?.container === "string" ||
     ProviderShared.isRecord((input as Record<string, unknown> | undefined)?.container)
-      ? ((input as Record<string, unknown>).container as string | { id?: string | null; skills?: ReadonlyArray<Record<string, unknown>> | null })
+      ? ((input as Record<string, unknown>).container as
+          | string
+          | { id?: string | null; skills?: ReadonlyArray<Record<string, unknown>> | null })
       : undefined
   const rawInferenceGeo =
     (input as Record<string, unknown> | undefined)?.inference_geo ??
@@ -965,8 +981,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
     input.display === "summarized" || input.display === "omitted"
       ? (input.display as "summarized" | "omitted")
       : undefined
-  if (input.type === "adaptive")
-    return { type: "adaptive" as const, ...(display === undefined ? {} : { display }) }
+  if (input.type === "adaptive") return { type: "adaptive" as const, ...(display === undefined ? {} : { display }) }
   if (input.type === "disabled") return { type: "disabled" as const }
   if (input.type !== "enabled") return undefined
   const budget =
@@ -1418,9 +1433,7 @@ const step = (state: ParserState, event: AnthropicEvent) => {
       if (event.index === undefined)
         return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic ${block.type} missing index`))
       if (!block.id)
-        return Effect.fail(
-          ProviderShared.eventError(ADAPTER, `Anthropic tool_use missing id at index ${event.index}`),
-        )
+        return Effect.fail(ProviderShared.eventError(ADAPTER, `Anthropic tool_use missing id at index ${event.index}`))
     }
     return Effect.succeed(onContentBlockStart(state, { ...event, content_block: block }))
   }
@@ -1473,10 +1486,9 @@ export const route = Route.make({
   provider: "anthropic",
   providerMetadataKey: "anthropic",
   protocol,
-  endpoint: Endpoint.path(
-    (input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH),
-    { baseURL: DEFAULT_BASE_URL },
-  ),
+  endpoint: Endpoint.path((input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH), {
+    baseURL: DEFAULT_BASE_URL,
+  }),
   auth: Auth.none,
   framing,
   headers: () => ({ "anthropic-version": "2023-06-01" }),

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

@@ -652,7 +652,9 @@ const step = (state: ParserState, event: BedrockEvent) =>
         method: "stream",
         reason: classifyProviderFailure({
           message:
-            event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error",
+            event.exception.details.message ??
+            event.exception.details.originalMessage ??
+            "Bedrock Converse stream error",
           code: event.exception.type,
         }),
       })

packages/ai/src/protocols/bedrock-event-stream.ts

@@ -82,7 +82,9 @@ const consumeFrames = (route: string) => (state: FrameBufferState, chunk: Uint8A
         "Failed to parse Bedrock Converse event-stream payload",
       )) as Record<string, unknown>
       delete parsed.p
-      out.push(messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed })
+      out.push(
+        messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed },
+      )
     }
     return [cursor, out] as const
   })

packages/ai/src/protocols/gemini.ts

@@ -570,7 +570,12 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> => {
       googleMetadata({ thoughtSignature: state.reasoningSignature }),
     )
   if (state.textSignature !== undefined)
-    lifecycle = Lifecycle.textEnd(lifecycle, events, "text-0", googleMetadata({ thoughtSignature: state.textSignature }))
+    lifecycle = Lifecycle.textEnd(
+      lifecycle,
+      events,
+      "text-0",
+      googleMetadata({ thoughtSignature: state.textSignature }),
+    )
   Lifecycle.finish(lifecycle, events, {
     reason: {
       normalized:
@@ -675,8 +680,9 @@ const step = (state: ParserState, event: GeminiEvent) => {
           id,
           name: part.functionCall.name,
           input,
-          providerMetadata:
-            part.thoughtSignature ? googleMetadata({ thoughtSignature: part.thoughtSignature }) : undefined,
+          providerMetadata: part.thoughtSignature
+            ? googleMetadata({ thoughtSignature: part.thoughtSignature })
+            : undefined,
         }),
       )
       hasToolCalls = true

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

@@ -346,7 +346,8 @@ export const Event = Schema.StructWithRest(
     item_id: Schema.optional(Schema.String),
     output_index: Schema.optional(Schema.Number),
     summary_index: Schema.optional(Schema.Number),
-    item: Schema.optional(StreamItem),
+    // OutputItemAdded/Done permit a null item in the Open Responses OpenAPI schema.
+    item: optionalNull(StreamItem),
     response: Schema.optional(
       Schema.StructWithRest(
         Schema.Struct({
@@ -812,7 +813,7 @@ export const providerMetadata = (state: ParserState, metadata: Record<string, un
 })
 
 const isReasoningItem = (item: StreamItem): item is StreamItem & { type: "reasoning"; id: string } =>
-  item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0
+  item.type === "reasoning" && typeof item.id === "string"
 
 export type StepResult = readonly [ParserState, ReadonlyArray<LLMEvent>]
 
@@ -891,7 +892,7 @@ const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }
 // best-effort, not guaranteed.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
-  if (item?.type === "message" && item.id) {
+  if (item?.type === "message" && item.id !== undefined) {
     const phase = messagePhase(item.phase)
     return [
       {
@@ -922,7 +923,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   }
   if (item?.type !== "function_call" || !item.call_id) return [state, NO_EVENTS]
   const id = item.id ?? item.call_id
-  const metadata = item.id ? providerMetadata(state, { itemId: item.id }) : undefined
+  const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
   return [
@@ -941,7 +942,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 }
 
 const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
-  if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
+  if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
   if (!item) return [state, NO_EVENTS]
   if (event.summary_index === 0) return [state, NO_EVENTS]
@@ -988,7 +989,7 @@ const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResu
 }
 
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
-  if (!event.item_id || event.summary_index === undefined) return [state, NO_EVENTS]
+  if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
   if (!item) return [state, NO_EVENTS]
   return [
@@ -1013,7 +1014,7 @@ const onFunctionCallArgumentsDelta = Effect.fn("OpenResponses.onFunctionCallArgu
   state: ParserState,
   event: Event,
 ) {
-  if (!event.item_id) return [state, NO_EVENTS] satisfies StepResult
+  if (event.item_id === undefined) return [state, NO_EVENTS] satisfies StepResult
   const tool = state.tools[event.item_id]
   if (!tool) return [state, NO_EVENTS] satisfies StepResult
   const final = event.type === "response.function_call_arguments.done" ? event.arguments : undefined
@@ -1044,7 +1045,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
   const item = event.item
   if (!item) return [state, NO_EVENTS] satisfies StepResult
 
-  if (item.type === "message" && item.id) {
+  if (item.type === "message" && item.id !== undefined) {
     const itemPhase = messagePhase(item.phase)
     const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
     const events: LLMEvent[] = []
@@ -1075,7 +1076,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
       : ToolStream.start(state.tools, id, {
           id: item.call_id,
           name: item.name,
-          providerMetadata: item.id ? providerMetadata(state, { itemId: item.id }) : undefined,
+          providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
         })
     const result =
       item.arguments === undefined
@@ -1136,7 +1137,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
           ([current, events], item) => {
             const id = item.id ?? (item.type === "function_call" ? item.call_id : undefined)
             if (
-              !id ||
+              id === undefined ||
               ((item.type !== "function_call" || !current.tools[id]) &&
                 (item.type !== "reasoning" || !current.reasoningItems[id]))
             )
@@ -1219,12 +1220,13 @@ export const providerFailure = (id: string, event: Event, fallback: string) => {
 const providerError = (state: ParserState, event: Event, fallback: string) => providerFailure(state.id, event, fallback)
 
 export const step = (state: ParserState, input: Event) => {
+  // The OpenAPI requires string IDs but imposes no minLength; empty is not missing.
   const event =
-    input.item_id && outputItemID(state, input) !== input.item_id
+    input.item_id !== undefined && outputItemID(state, input) !== input.item_id
       ? { ...input, item_id: outputItemID(state, input) }
       : input
   if (event.type === "response.output_text.delta" || event.type === "response.output_text.done") {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(
       event.type === "response.output_text.delta"
         ? onOutputTextDelta(state, event, event.item_id)
@@ -1233,7 +1235,7 @@ export const step = (state: ParserState, input: Event) => {
   }
   if (event.type === "response.refusal.delta" || event.type === "response.refusal.done") {
     const value = event.type === "response.refusal.delta" ? event.delta : event.refusal
-    if (!event.item_id || typeof value !== "string")
+    if (event.item_id === undefined || typeof value !== "string")
       return ProviderShared.eventError(state.id, `${event.type} is malformed`)
     return Effect.succeed(
       event.type === "response.refusal.delta"
@@ -1242,7 +1244,7 @@ export const step = (state: ParserState, input: Event) => {
     )
   }
   if (event.type === "response.reasoning.delta" || event.type === "response.reasoning_summary_text.delta") {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(onReasoningDelta(state, event, event.item_id))
   }
   if (
@@ -1250,24 +1252,24 @@ export const step = (state: ParserState, input: Event) => {
     event.type === "response.reasoning_summary_text.done" ||
     event.type === "response.reasoning_text.done"
   ) {
-    if (!event.item_id) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
+    if (event.item_id === undefined) return ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
     return Effect.succeed(onReasoningDone(state, event, event.item_id))
   }
   if (event.type === "response.reasoning_summary_part.added")
-    return event.item_id
+    return event.item_id !== undefined
       ? Effect.succeed(onReasoningSummaryPartAdded(state, event))
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
   if (event.type === "response.reasoning_summary_part.done")
-    return event.item_id
+    return event.item_id !== undefined
       ? Effect.succeed(onReasoningSummaryPartDone(state, event))
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
   if (event.type === "response.output_item.added") {
-    if (event.item?.type === "message" && !event.item.id)
+    if (event.item?.type === "message" && event.item.id === undefined)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
     return Effect.succeed(
       onOutputItemAdded(
-        event.output_index !== undefined && id
+        event.output_index !== undefined && id !== undefined
           ? { ...state, outputItems: { ...state.outputItems, [event.output_index]: id } }
           : state,
         event,
@@ -1275,11 +1277,11 @@ export const step = (state: ParserState, input: Event) => {
     )
   }
   if (event.type === "response.function_call_arguments.delta" || event.type === "response.function_call_arguments.done")
-    return event.item_id
+    return event.item_id !== undefined
       ? onFunctionCallArgumentsDelta(state, event)
       : ProviderShared.eventError(state.id, `${event.type} is missing item_id`)
   if (event.type === "response.output_item.done") {
-    if (event.item?.type === "message" && !event.item.id)
+    if (event.item?.type === "message" && event.item.id === undefined)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
     return onOutputItemDone(state, event)
   }

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

@@ -496,7 +496,11 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
   const lowering = {
     ...options,
     toolCallID: (id: string) => {
-      if (mistral) return id.replace(/[^a-zA-Z0-9]/g, "").slice(0, 9).padEnd(9, "0")
+      if (mistral)
+        return id
+          .replace(/[^a-zA-Z0-9]/g, "")
+          .slice(0, 9)
+          .padEnd(9, "0")
       if (modelID.includes("claude")) return id.replace(/[^a-zA-Z0-9_-]/g, "_")
       if (request.model.provider === "openai" || request.model.provider === "azure" || modelID.startsWith("openai/"))
         return id.slice(0, 40)
@@ -505,7 +509,8 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
   }
   const requireAssistantAfterTool = request.model.compatibility?.requireAssistantAfterTool ?? mistral
   const bridgeTools = () => {
-    if (requireAssistantAfterTool && messages.at(-1)?.role === "tool") messages.push({ role: "assistant", content: "Done." })
+    if (requireAssistantAfterTool && messages.at(-1)?.role === "tool")
+      messages.push({ role: "assistant", content: "Done." })
   }
   const pendingImages: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
   const flushImages = () => {
@@ -557,7 +562,10 @@ const lowerMessages = Effect.fn("OpenAIChat.lowerMessages")(function* (request:
         )
       continue
     }
-    if (message.role === "assistant" && message.content.every((part) => part.type === "text" && part.text.trim() === ""))
+    if (
+      message.role === "assistant" &&
+      message.content.every((part) => part.type === "text" && part.text.trim() === "")
+    )
       continue
     if (message.role === "tool") {
       const lowered = yield* lowerToolMessages(message, lowering)
@@ -588,7 +596,10 @@ const hasToolHistory = (messages: ReadonlyArray<LLMRequest["messages"][number]>)
 // models.dev provider naming: DeepSeek, Moonshot AI, Together AI, ZAI
 // (Zhipu + Coding Plan variants), Nvidia, Cerebras, Chutes, etc. still
 // require `max_tokens`.
-const detectMaxTokensField = (provider: string, baseURL: string | undefined): "max_tokens" | "max_completion_tokens" => {
+const detectMaxTokensField = (
+  provider: string,
+  baseURL: string | undefined,
+): "max_tokens" | "max_completion_tokens" => {
   const p = provider.toLowerCase()
   const url = (baseURL ?? "").toLowerCase()
   if (
@@ -638,7 +649,8 @@ const detectSupportsStore = (provider: string, baseURL: string | undefined): boo
   const isChutes = p === "chutes" || url.includes("chutes.ai")
   const isCloudflareWorkersAI = p === "cloudflare-workers-ai" || url.includes("api.cloudflare.com")
   const isCloudflareAiGateway = p === "cloudflare-ai-gateway" || url.includes("gateway.ai.cloudflare.com")
-  const isVercelAiGateway = p === "vercel-ai-gateway" || url.includes("ai-gateway.vercel.sh") || url.includes("vercel.sh")
+  const isVercelAiGateway =
+    p === "vercel-ai-gateway" || url.includes("ai-gateway.vercel.sh") || url.includes("vercel.sh")
   const isAntLing = p === "ant-ling" || url.includes("api.ant-ling.com")
   const isOpencode = p === "opencode" || url.includes("opencode.ai")
   const isNonStandard =
@@ -670,11 +682,7 @@ const detectSupportsStrictMode = (provider: string, baseURL: string | undefined)
   return !isMoonshot && !isTogether && !isCloudflareAiGateway && !isNvidia
 }
 
-const detectZaiToolStream = (
-  provider: string,
-  baseURL: string | undefined,
-  modelID: string,
-): boolean => {
+const detectZaiToolStream = (provider: string, baseURL: string | undefined, modelID: string): boolean => {
   const p = provider.toLowerCase()
   const url = (baseURL ?? "").toLowerCase()
   const isZai =
@@ -724,10 +732,10 @@ export const fromRequest = Effect.fn("OpenAIChat.fromRequest")(function* (
   const supportsStore = request.model.compatibility?.supportsStore ?? detectSupportsStore(provider, baseURL)
   const supportsUsageInStreaming =
     request.model.compatibility?.supportsUsageInStreaming ?? detectSupportsUsageInStreaming()
-  const supportsStrictMode = request.model.compatibility?.supportsStrictMode ?? detectSupportsStrictMode(provider, baseURL)
+  const supportsStrictMode =
+    request.model.compatibility?.supportsStrictMode ?? detectSupportsStrictMode(provider, baseURL)
   const zaiToolStream =
-    request.model.compatibility?.zaiToolStream ??
-    detectZaiToolStream(provider, baseURL, request.model.id)
+    request.model.compatibility?.zaiToolStream ?? detectZaiToolStream(provider, baseURL, request.model.id)
   const hasHistory = hasToolHistory(request.messages)
   const hasActiveTools = request.tools.length > 0
   return {
@@ -816,11 +824,10 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
   if (!usage) return undefined
   const input = usage.prompt_tokens ?? undefined
   const output = usage.completion_tokens ?? undefined
-  const cached =
-    (usage.prompt_tokens_details?.cached_tokens ??
-      (usage as { prompt_cache_hit_tokens?: number | null }).prompt_cache_hit_tokens ??
-      (usage as { cached_tokens?: number | null }).cached_tokens ??
-      undefined) as number | undefined
+  const cached = (usage.prompt_tokens_details?.cached_tokens ??
+    (usage as { prompt_cache_hit_tokens?: number | null }).prompt_cache_hit_tokens ??
+    (usage as { cached_tokens?: number | null }).cached_tokens ??
+    undefined) as number | undefined
   const cacheWrite = usage.prompt_tokens_details?.cache_write_tokens ?? undefined
   const reasoning = usage.completion_tokens_details?.reasoning_tokens ?? undefined
   const nonCached = ProviderShared.subtractTokens(input, ProviderShared.sumTokens(cached, cacheWrite))
@@ -936,13 +943,12 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
     const choiceUsage = (choice as unknown as { usage?: OpenAIChatEvent["usage"] })?.usage
     const usage = mapUsage(event.usage) ?? (choiceUsage ? mapUsage(choiceUsage) : undefined) ?? state.usage
     const rawFinishReason = choice?.finish_reason
-    const finishReason =
-      rawFinishReason
-        ? {
-            normalized: yield* mapFinishReason(event, rawFinishReason),
-            raw: choice?.native_finish_reason ?? rawFinishReason,
-          }
-        : state.finishReason
+    const finishReason = rawFinishReason
+      ? {
+          normalized: yield* mapFinishReason(event, rawFinishReason),
+          raw: choice?.native_finish_reason ?? rawFinishReason,
+        }
+      : state.finishReason
     const delta = choice?.delta
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools

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

@@ -184,7 +184,7 @@ const HOSTED_TOOLS = {
 
 const step = (state: OpenResponses.ParserState, event: OpenResponses.Event) => {
   if (event.type === "response.reasoning_text.delta")
-    return event.item_id
+    return event.item_id !== undefined
       ? Effect.succeed(
           OpenResponses.onReasoningDelta(state, event, OpenResponses.outputItemID(state, event) ?? event.item_id),
         )

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

@@ -29,10 +29,9 @@ export type ResponseIncludable = (typeof ResponseIncludables)[number] | (string
 
 export const ServiceTiers = ["auto", "default", "flex", "priority"] as const
 export type ServiceTier = (typeof ServiceTiers)[number] | (string & {})
-export const ServiceTier = Schema.declare<ServiceTier>(
-  (value): value is ServiceTier => typeof value === "string",
-  { title: "ServiceTier" },
-)
+export const ServiceTier = Schema.declare<ServiceTier>((value): value is ServiceTier => typeof value === "string", {
+  title: "ServiceTier",
+})
 
 export const Truncations = ["auto", "disabled"] as const
 export type Truncation = (typeof Truncations)[number]

packages/ai/src/protocols/utils/responses-hosted-tools.ts

@@ -34,37 +34,35 @@ export const onDone: (
   state: OpenResponses.ParserState,
   item: Item,
   tools: Definitions,
-) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(function* (
-  state,
-  item,
-  tools,
-) {
-  const tool = tools[item.type]
-  if (!tool) return [state, []] satisfies OpenResponses.StepResult
-  const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
-  const events: LLMEvent[] = []
-  const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
-  events.push(
-    LLMEvent.toolCall({
-      id: item.id,
-      name: tool.name,
-      input: tool.input(item),
-      providerExecuted: true,
-      providerMetadata,
-    }),
-    LLMEvent.toolResult({
-      id: item.id,
-      name: tool.name,
-      result: tool.result
-        ? yield* tool.result(item)
-        : item.error !== undefined && item.error !== null
-          ? { type: "error", value: item.error }
-          : { type: "json", value: item },
-      providerExecuted: true,
-      providerMetadata,
-    }),
-  )
-  return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
-})
+) => Effect.Effect<OpenResponses.StepResult, AIError> = Effect.fn("ResponsesHostedTools.onDone")(
+  function* (state, item, tools) {
+    const tool = tools[item.type]
+    if (!tool) return [state, []] satisfies OpenResponses.StepResult
+    const providerMetadata = OpenResponses.providerMetadata(state, { itemId: item.id })
+    const events: LLMEvent[] = []
+    const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
+    events.push(
+      LLMEvent.toolCall({
+        id: item.id,
+        name: tool.name,
+        input: tool.input(item),
+        providerExecuted: true,
+        providerMetadata,
+      }),
+      LLMEvent.toolResult({
+        id: item.id,
+        name: tool.name,
+        result: tool.result
+          ? yield* tool.result(item)
+          : item.error !== undefined && item.error !== null
+            ? { type: "error", value: item.error }
+            : { type: "json", value: item },
+        providerExecuted: true,
+        providerMetadata,
+      }),
+    )
+    return [{ ...state, lifecycle }, events] satisfies OpenResponses.StepResult
+  },
+)
 
 export * as ResponsesHostedTools from "./responses-hosted-tools.js"

packages/ai/src/providers/groq.ts

@@ -0,0 +1,116 @@
+import { Effect, Schema } from "effect"
+import type { ProviderPackage } from "../provider-package.js"
+import { OpenAIChat } from "../protocols/openai-chat.js"
+import { ProviderShared } from "../protocols/shared.js"
+import { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
+import { Route, type RouteDefaultsInput } from "../route/client.js"
+import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
+import { Protocol } from "../route/protocol.js"
+import { ProviderID, type ModelID, type LLMRequest } from "../schema/index.js"
+import { profiles } from "./openai-compatible-profile.js"
+import type { OpenAIProviderOptionsInput } from "./openai-options.js"
+
+export const id = ProviderID.make("groq")
+
+export type ProviderOptions = Pick<OpenAIProviderOptionsInput, "reasoningEffort"> & {
+  /** Controls visible reasoning on GPT-OSS; other models always use parsed reasoning. */
+  readonly includeReasoning?: boolean
+  readonly parallelToolCalls?: boolean
+  readonly serviceTier?: "on_demand" | "flex" | "auto" | "performance" | (string & {})
+  readonly user?: string
+}
+
+export type LanguageModelOptions = Omit<RouteDefaultsInput, "providerOptions"> &
+  ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string
+    readonly providerOptions?: ProviderOptions
+  }
+
+export interface Settings extends ProviderPackage.Settings {
+  readonly apiKey?: string
+  readonly baseURL?: string
+  readonly providerOptions?: ProviderOptions
+}
+
+const Options = Schema.Struct({
+  includeReasoning: Schema.optional(Schema.Boolean),
+  parallelToolCalls: Schema.optional(Schema.Boolean),
+  serviceTier: Schema.optional(Schema.String),
+  user: Schema.optional(Schema.String),
+})
+
+export const protocol = Protocol.make({
+  id: "groq-chat",
+  body: {
+    schema: Schema.Struct({
+      ...OpenAIChat.bodyFields,
+      reasoning_format: Schema.optional(Schema.Literal("parsed")),
+      include_reasoning: Schema.optional(Schema.Boolean),
+      parallel_tool_calls: Schema.optional(Schema.Boolean),
+      service_tier: Schema.optional(Schema.String),
+      user: Schema.optional(Schema.String),
+    }),
+    from: Effect.fn("Groq.fromRequest")(function* (request: LLMRequest) {
+      const options = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Options))(
+        request.providerOptions ?? {},
+      )
+      const gptOSS = request.model.id.startsWith("openai/gpt-oss-")
+      return {
+        ...(yield* OpenAIChat.fromRequest(request)),
+        reasoning_format: gptOSS ? undefined : ("parsed" as const),
+        include_reasoning: gptOSS ? options.includeReasoning : undefined,
+        parallel_tool_calls: options.parallelToolCalls,
+        service_tier: options.serviceTier,
+        user: options.user,
+      }
+    }),
+  },
+  stream: OpenAIChat.protocol.stream,
+})
+
+export const route = Route.make({
+  id: "groq-chat",
+  provider: id,
+  providerMetadataKey: "openai",
+  protocol,
+  endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
+  framing: Framing.sse,
+})
+
+export const configure = (input: LanguageModelOptions = {}) => {
+  const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input
+  const configured = route.with({
+    ...defaults,
+    endpoint: { baseURL: baseURL ?? profiles.groq.baseURL },
+    auth: AuthOptions.bearer(input, "GROQ_API_KEY"),
+  })
+  return {
+    id,
+    model: (modelID: string | ModelID) =>
+      configured.model<ProviderOptions>({
+        id: modelID,
+        compatibility: {
+          maxTokensField: "max_completion_tokens",
+          reasoningField: "reasoning",
+          requireReasoning: false,
+          supportsStore: false,
+          supportsStrictMode: false,
+        },
+      }),
+    configure,
+  }
+}
+
+export const provider = configure()
+
+export const model: ProviderPackage.Definition<Settings, ProviderOptions>["model"] = (modelID, settings) =>
+  configure({
+    apiKey: settings.apiKey,
+    baseURL: settings.baseURL,
+    headers: settings.headers === undefined ? undefined : { ...settings.headers },
+    http: settings.body === undefined ? undefined : { body: { ...settings.body } },
+    providerOptions: settings.providerOptions,
+  }).model(modelID)
+
+export * as Groq from "./groq.js"

packages/ai/src/providers/index.ts

@@ -12,6 +12,7 @@ export * as GoogleVertex from "./google-vertex.js"
 export * as GoogleVertexChat from "./google-vertex-chat.js"
 export * as GoogleVertexMessages from "./google-vertex-messages.js"
 export * as GoogleVertexResponses from "./google-vertex-responses.js"
+export * as Groq from "./groq.js"
 export * as OpenAI from "./openai.js"
 export * as OpenAICompatible from "./openai-compatible.js"
 export * as OpenAICompatibleResponses from "./openai-compatible-responses.js"

packages/ai/src/route/client.ts

@@ -339,9 +339,7 @@ function makeFromTransport<Body, Prepared, Frame, Event, State>(
                 return onHalt
                   ? parsed.pipe(
                       Stream.concat(
-                        Stream.suspend(() =>
-                          Stream.unwrap(onHalt(state).pipe(Effect.map(Stream.fromIterable))),
-                        ),
+                        Stream.suspend(() => Stream.unwrap(onHalt(state).pipe(Effect.map(Stream.fromIterable)))),
                       ),
                     )
                   : parsed

packages/ai/test/fixtures/recordings/azure/chat-streams-text.json

@@ -1,10 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:azure",
-      "provider:azure"
-    ],
+    "tags": ["prefix:azure", "provider:azure"],
     "name": "azure/chat-streams-text",
     "recordedAt": "2026-08-23T17:21:53.198Z"
   },

packages/ai/test/fixtures/recordings/azure/responses-calls-a-tool.json

@@ -1,10 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:azure",
-      "provider:azure"
-    ],
+    "tags": ["prefix:azure", "provider:azure"],
     "name": "azure/responses-calls-a-tool",
     "recordedAt": "2026-08-23T17:21:55.170Z"
   },

packages/ai/test/fixtures/recordings/azure/responses-continues-after-a-tool-result.json

@@ -1,10 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:azure",
-      "provider:azure"
-    ],
+    "tags": ["prefix:azure", "provider:azure"],
     "name": "azure/responses-continues-after-a-tool-result",
     "recordedAt": "2026-08-23T17:21:56.397Z"
   },

packages/ai/test/fixtures/recordings/azure/responses-streams-text.json

@@ -1,10 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:azure",
-      "provider:azure"
-    ],
+    "tags": ["prefix:azure", "provider:azure"],
     "name": "azure/responses-streams-text",
     "recordedAt": "2026-08-23T17:21:54.158Z"
   },

packages/ai/test/fixtures/recordings/bedrock-mantle/streams-text.json

@@ -2,11 +2,7 @@
   "version": 1,
   "metadata": {
     "model": "openai.gpt-oss-120b",
-    "tags": [
-      "prefix:bedrock-mantle",
-      "provider:amazon-bedrock",
-      "protocol:openai-responses"
-    ],
+    "tags": ["prefix:bedrock-mantle", "provider:amazon-bedrock", "protocol:openai-responses"],
     "name": "bedrock-mantle/streams-text",
     "recordedAt": "2026-08-25T03:29:02.968Z"
   },

packages/ai/test/fixtures/recordings/cloudflare-workers-ai/cloudflare-workers-ai-gpt-oss-20b-tools-tool-call.json

@@ -7,13 +7,7 @@
     "route": "cloudflare-workers-ai",
     "transport": "http",
     "model": "@cf/openai/gpt-oss-20b",
-    "tags": [
-      "prefix:cloudflare-workers-ai",
-      "provider:cloudflare-workers-ai",
-      "tool",
-      "tool-call",
-      "golden"
-    ]
+    "tags": ["prefix:cloudflare-workers-ai", "provider:cloudflare-workers-ai", "tool", "tool-call", "golden"]
   },
   "interactions": [
     {
@@ -35,4 +29,4 @@
       }
     }
   ]
-}
+}

packages/ai/test/fixtures/recordings/google-vertex/calls-a-tool.json

@@ -1,11 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
+    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
     "name": "google-vertex/calls-a-tool",
     "recordedAt": "2026-08-23T17:21:51.036Z"
   },

packages/ai/test/fixtures/recordings/google-vertex/continues-after-a-tool-result.json

@@ -1,11 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
+    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
     "name": "google-vertex/continues-after-a-tool-result",
     "recordedAt": "2026-08-23T17:21:51.853Z"
   },

packages/ai/test/fixtures/recordings/google-vertex/streams-text.json

@@ -1,11 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:google-vertex",
-      "provider:google-vertex",
-      "protocol:gemini"
-    ],
+    "tags": ["prefix:google-vertex", "provider:google-vertex", "protocol:gemini"],
     "name": "google-vertex/streams-text",
     "recordedAt": "2026-08-23T17:21:50.112Z"
   },

packages/ai/test/fixtures/recordings/groq-chat/streams-text-with-usage.json

@@ -0,0 +1,29 @@
+{
+  "version": 1,
+  "metadata": {
+    "model": "openai/gpt-oss-20b",
+    "tags": ["prefix:groq-chat", "provider:groq", "protocol:groq-chat", "text", "usage"],
+    "name": "groq-chat/streams-text-with-usage",
+    "recordedAt": "2026-08-26T14:40:09.833Z"
+  },
+  "interactions": [
+    {
+      "transport": "http",
+      "request": {
+        "method": "POST",
+        "url": "https://api.groq.com/openai/v1/chat/completions",
+        "headers": {
+          "content-type": "application/json"
+        },
+        "body": "{\"model\":\"openai/gpt-oss-20b\",\"messages\":[{\"role\":\"user\",\"content\":\"Reply with exactly one word: hello\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning_effort\":\"low\",\"max_completion_tokens\":512,\"include_reasoning\":false,\"service_tier\":\"on_demand\",\"user\":\"recorded-test\"}"
+      },
+      "response": {
+        "status": 200,
+        "headers": {
+          "content-type": "text/event-stream"
+        },
+        "body": "data: {\"id\":\"chatcmpl-660048b0-3c99-4215-a582-e116b77eb881\",\"object\":\"chat.completion.chunk\",\"created\":1787755209,\"model\":\"openai/gpt-oss-20b\",\"system_fingerprint\":\"fp_66891002f6\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"logprobs\":null,\"finish_reason\":null}],\"x_groq\":{\"id\":\"req_01m0z87915eep9bpf10gg7331e\",\"seed\":94036161}}\n\ndata: {\"id\":\"chatcmpl-660048b0-3c99-4215-a582-e116b77eb881\",\"object\":\"chat.completion.chunk\",\"created\":1787755209,\"model\":\"openai/gpt-oss-20b\",\"system_fingerprint\":\"fp_66891002f6\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\"},\"logprobs\":null,\"finish_reason\":null}]}\n\ndata: {\"id\":\"chatcmpl-660048b0-3c99-4215-a582-e116b77eb881\",\"object\":\"chat.completion.chunk\",\"created\":1787755209,\"model\":\"openai/gpt-oss-20b\",\"system_fingerprint\":\"fp_66891002f6\",\"choices\":[{\"index\":0,\"delta\":{},\"logprobs\":null,\"finish_reason\":\"stop\"}],\"x_groq\":{\"id\":\"req_01m0z87915eep9bpf10gg7331e\",\"usage\":{\"queue_time\":0.10886435,\"prompt_tokens\":78,\"prompt_time\":0.003693734,\"completion_tokens\":20,\"completion_time\":0.020459983,\"total_tokens\":98,\"total_time\":0.024153717,\"completion_tokens_details\":{\"reasoning_tokens\":10}}},\"usage\":{\"queue_time\":0.10886435,\"prompt_tokens\":78,\"prompt_time\":0.003693734,\"completion_tokens\":20,\"completion_time\":0.020459983,\"total_tokens\":98,\"total_time\":0.024153717,\"completion_tokens_details\":{\"reasoning_tokens\":10}}}\n\ndata: {\"id\":\"chatcmpl-660048b0-3c99-4215-a582-e116b77eb881\",\"object\":\"chat.completion.chunk\",\"created\":1787755209,\"model\":\"openai/gpt-oss-20b\",\"system_fingerprint\":\"fp_66891002f6\",\"choices\":[],\"usage\":{\"queue_time\":0.10886435,\"prompt_tokens\":78,\"prompt_time\":0.003693734,\"completion_tokens\":20,\"completion_time\":0.020459983,\"total_tokens\":98,\"total_time\":0.024153717,\"completion_tokens_details\":{\"reasoning_tokens\":10}},\"service_tier\":\"on_demand\"}\n\ndata: [DONE]\n\n"
+      }
+    }
+  ]
+}

packages/ai/test/fixtures/recordings/openai-responses-cache/reports-cached-tokens-on-identical-second-call.json

@@ -1,12 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:openai-responses-cache",
-      "provider:openai",
-      "protocol:openai-responses",
-      "cache"
-    ],
+    "tags": ["prefix:openai-responses-cache", "provider:openai", "protocol:openai-responses", "cache"],
     "name": "openai-responses-cache/reports-cached-tokens-on-identical-second-call",
     "recordedAt": "2026-08-25T03:29:25.124Z"
   },

packages/ai/test/fixtures/recordings/openai-responses/openai-responses-gpt-5-5-tool-loop.json

@@ -5,14 +5,7 @@
     "route": "openai-responses",
     "transport": "http",
     "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses",
-      "provider:openai",
-      "flagship",
-      "tool",
-      "tool-loop",
-      "golden"
-    ],
+    "tags": ["prefix:openai-responses", "provider:openai", "flagship", "tool", "tool-loop", "golden"],
     "name": "openai-responses/openai-responses-gpt-5-5-tool-loop",
     "recordedAt": "2026-08-20T06:30:22.262Z"
   },

packages/ai/test/fixtures/recordings/pdf/openai-tool-result.json

@@ -1,14 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:openai",
-      "protocol:openai-responses",
-      "tool",
-      "tool-result"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:openai", "protocol:openai-responses", "tool", "tool-result"],
     "name": "pdf/openai-tool-result",
     "recordedAt": "2026-08-25T03:29:08.297Z"
   },

packages/ai/test/fixtures/recordings/pdf/openai-user-input.json

@@ -1,13 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:openai",
-      "protocol:openai-responses",
-      "user-input"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:openai", "protocol:openai-responses", "user-input"],
     "name": "pdf/openai-user-input",
     "recordedAt": "2026-08-25T03:29:05.645Z"
   },

packages/ai/test/fixtures/recordings/pdf/xai-tool-result.json

@@ -1,14 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:xai",
-      "protocol:xai-responses",
-      "tool",
-      "tool-result"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:xai", "protocol:xai-responses", "tool", "tool-result"],
     "name": "pdf/xai-tool-result",
     "recordedAt": "2026-08-25T03:29:11.774Z"
   },

packages/ai/test/fixtures/recordings/pdf/xai-user-input.json

@@ -1,13 +1,7 @@
 {
   "version": 1,
   "metadata": {
-    "tags": [
-      "prefix:pdf",
-      "pdf",
-      "provider:xai",
-      "protocol:xai-responses",
-      "user-input"
-    ],
+    "tags": ["prefix:pdf", "pdf", "provider:xai", "protocol:xai-responses", "user-input"],
     "name": "pdf/xai-user-input",
     "recordedAt": "2026-08-25T03:29:10.612Z"
   },

packages/ai/test/fixtures/recordings/vercel-ai-gateway-reasoning-tool-loop.json

@@ -52,4 +52,4 @@
       }
     }
   ]
-}
+}

packages/ai/test/fixtures/recordings/vercel-ai-gateway-reasoning.json

@@ -2,12 +2,7 @@
   "version": 1,
   "metadata": {
     "model": "anthropic/claude-sonnet-4.6",
-    "tags": [
-      "prefix:openai-compatible-chat",
-      "provider:vercel-ai-gateway",
-      "protocol:openai-chat",
-      "reasoning"
-    ],
+    "tags": ["prefix:openai-compatible-chat", "provider:vercel-ai-gateway", "protocol:openai-chat", "reasoning"],
     "name": "vercel-ai-gateway-reasoning",
     "recordedAt": "2026-07-18T11:28:42.077Z"
   },
@@ -31,4 +26,4 @@
       }
     }
   ]
-}
+}

packages/ai/test/provider-error.test.ts

@@ -89,9 +89,7 @@ describe("provider error classification", () => {
 
   test("classifies network error text as provider internal", () => {
     expect(
-      ["network error", "network-error", "network_error"].map(
-        (message) => classifyProviderFailure({ message })._tag,
-      ),
+      ["network error", "network-error", "network_error"].map((message) => classifyProviderFailure({ message })._tag),
     ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
   })
 

packages/ai/test/provider-package.test.ts

@@ -29,6 +29,7 @@ describe("provider package entrypoints", () => {
       import("@opencode-ai/ai/providers/togetherai"),
       import("@opencode-ai/ai/providers/cerebras"),
       import("@opencode-ai/ai/providers/deepinfra"),
+      import("@opencode-ai/ai/providers/groq"),
     ])
 
     for (const module of modules) expect(module.model).toBeFunction()

packages/ai/test/provider/gemini.test.ts

@@ -515,7 +515,10 @@ describe("Gemini route", () => {
         {
           role: "model",
           parts: [
-            { functionCall: { id: "call_image", name: "read", args: { path: "pixel.png" } }, thoughtSignature: "sig_1" },
+            {
+              functionCall: { id: "call_image", name: "read", args: { path: "pixel.png" } },
+              thoughtSignature: "sig_1",
+            },
           ],
         },
         {
@@ -606,10 +609,7 @@ describe("Gemini route", () => {
       expect(prepared.body.contents).toEqual([
         {
           role: "model",
-          parts: [
-            { functionCall: { name: "shot", args: {} } },
-            { functionCall: { name: "shot", args: {} } },
-          ],
+          parts: [{ functionCall: { name: "shot", args: {} } }, { functionCall: { name: "shot", args: {} } }],
         },
         {
           role: "user",
@@ -1071,7 +1071,9 @@ describe("Gemini route", () => {
       const prepared = yield* compileRequest(
         LLM.request({
           model,
-          messages: [Message.assistant([{ type: "text", text: "All done.", providerMetadata: delta?.providerMetadata }])],
+          messages: [
+            Message.assistant([{ type: "text", text: "All done.", providerMetadata: delta?.providerMetadata }]),
+          ],
         }),
       )
       expect(prepared.body.contents).toEqual([
@@ -1572,9 +1574,7 @@ describe("Gemini route", () => {
               { candidates: [{ content: { role: "model", parts: null } }] },
               { candidates: [{ content: null, finishReason: null }] },
               {
-                candidates: [
-                  { content: { role: "model", parts: [{ text: "Hello" }] }, finishReason: "STOP" as const },
-                ],
+                candidates: [{ content: { role: "model", parts: [{ text: "Hello" }] }, finishReason: "STOP" as const }],
               },
             ),
           ),

packages/ai/test/provider/google-vertex.recorded.test.ts

@@ -26,9 +26,7 @@ const recorded = recordedTests({
 describe("Google Vertex Gemini recorded", () => {
   recorded.effect("streams text", () =>
     Effect.gen(function* () {
-      const response = yield* LLMClient.generate(
-        LLM.request({ model, prompt: "Reply with exactly one word: hello" }),
-      )
+      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Reply with exactly one word: hello" }))
 
       expect(response.text.toLowerCase()).toContain("hello")
     }),

packages/ai/test/provider/groq.recorded.test.ts

@@ -0,0 +1,185 @@
+import { configure } from "@opencode-ai/ai/providers/groq"
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { LLM, LLMEvent, LLMRequest, LLMResponse, Message, ToolChoice, ToolDefinition } from "../../src/index.js"
+import { LLMClient } from "../../src/route.js"
+import { compileRequest } from "../../src/route/client.js"
+import { recordedTests } from "../recorded-test.js"
+
+const apiKey = process.env.GROQ_API_KEY ?? "fixture"
+const recorded = recordedTests({
+  prefix: "groq-chat",
+  provider: "groq",
+  protocol: "groq-chat",
+  requires: ["GROQ_API_KEY"],
+})
+
+const weather = ToolDefinition.make({
+  name: "lookup_weather",
+  description: "Look up the current weather for a city",
+  inputSchema: {
+    type: "object",
+    properties: { city: { type: "string", enum: ["Paris", "London"] } },
+    required: ["city"],
+    additionalProperties: false,
+  },
+})
+
+describe("Groq recorded", () => {
+  recorded.effect.with(
+    "streams text with usage",
+    { tags: ["text", "usage"], metadata: { model: "openai/gpt-oss-20b" } },
+    () =>
+      Effect.gen(function* () {
+        const request = LLM.request({
+          model: configure({
+            apiKey,
+            providerOptions: {
+              includeReasoning: false,
+              reasoningEffort: "low",
+              serviceTier: "on_demand",
+              user: "recorded-test",
+            },
+          }).model("openai/gpt-oss-20b"),
+          prompt: "Reply with exactly one word: hello",
+          generation: { maxTokens: 512 },
+        })
+        const compiled = yield* compileRequest(request)
+        expect(compiled.body).toMatchObject({
+          max_completion_tokens: 512,
+          stream_options: { include_usage: true },
+          include_reasoning: false,
+          service_tier: "on_demand",
+          user: "recorded-test",
+        })
+        expect(compiled.body.max_tokens).toBeUndefined()
+        expect(compiled.body.store).toBeUndefined()
+        expect(compiled.body.reasoning_format).toBeUndefined()
+
+        const response = yield* LLMClient.generate(request)
+        expect(response.text.toLowerCase().trim()).toBe("hello")
+        expect(response.reasoning).toBe("")
+        expect(response.events.some(LLMEvent.is.textDelta)).toBe(true)
+        expectUsage(response)
+      }),
+    60_000,
+  )
+
+  for (const item of [
+    {
+      name: "continues Qwen parallel tool calls",
+      model: configure({ apiKey, providerOptions: { parallelToolCalls: true, reasoningEffort: "none" } }).model(
+        "qwen/qwen3.6-27b",
+      ),
+      cities: ["Paris", "London"],
+      reasoning: false,
+    },
+    {
+      name: "replays GPT OSS reasoning through a tool loop",
+      model: configure({ apiKey, providerOptions: { includeReasoning: true, reasoningEffort: "low" } }).model(
+        "openai/gpt-oss-20b",
+      ),
+      cities: ["Paris"],
+      reasoning: true,
+    },
+  ]) {
+    recorded.effect.with(
+      item.name,
+      {
+        tags: ["tool", "tool-loop", "usage", item.reasoning ? "reasoning" : "parallel"],
+        metadata: { model: item.model.id },
+      },
+      () =>
+        Effect.gen(function* () {
+          const request = LLM.request({
+            model: item.model,
+            prompt: `Look up the current weather in ${item.cities.join(" and ")}. Call lookup_weather once for each city in the same response before answering. After receiving all results, report each city's weather in one short sentence.`,
+            tools: [weather],
+            toolChoice: "required",
+            generation: { maxTokens: 1536 },
+          })
+          const compiled = yield* compileRequest(request)
+          expect(compiled.body.stream_options).toEqual({ include_usage: true })
+          expect(compiled.body.store).toBeUndefined()
+          expect(compiled.body.reasoning_format).toBe(item.reasoning ? undefined : "parsed")
+          expect(compiled.body.tools[0].function.strict).toBeUndefined()
+          if (!item.reasoning) expect(compiled.body.parallel_tool_calls).toBe(true)
+
+          const first = yield* LLMClient.generate(request)
+          expect(first.finishReason.normalized).toBe("tool-calls")
+          expect(first.toolCalls).toHaveLength(item.cities.length)
+          expect(new Set(first.toolCalls.map((call) => call.id)).size).toBe(item.cities.length)
+          expect(first.toolCalls.map((call) => call.input)).toEqual(
+            expect.arrayContaining(item.cities.map((city) => ({ city }))),
+          )
+          expect(first.toolCalls.every((call) => call.name === "lookup_weather")).toBe(true)
+          expectUsage(first)
+          if (item.reasoning) {
+            expect(first.reasoning.length).toBeGreaterThan(0)
+            expect(first.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
+          }
+
+          const followUp = LLMRequest.update(request, {
+            toolChoice: ToolChoice.make("none"),
+            messages: [
+              ...request.messages,
+              first.message,
+              ...first.toolCalls.map((call) =>
+                Message.tool({ id: call.id, name: call.name, result: { condition: "sunny", temperature: "18C" } }),
+              ),
+            ],
+          })
+          const replay = yield* compileRequest(followUp)
+          if (item.reasoning) {
+            expect(replay.body.messages).toEqual(
+              expect.arrayContaining([expect.objectContaining({ role: "assistant", reasoning: first.reasoning })]),
+            )
+          }
+          expect(replay.body.reasoning_format).toBe(item.reasoning ? undefined : "parsed")
+
+          const second = yield* LLMClient.generate(followUp)
+          expect(second.finishReason.normalized).toBe("stop")
+          expect(second.toolCalls).toHaveLength(0)
+          expect(second.text.toLowerCase()).toContain("sunny")
+          item.cities.forEach((city) => expect(second.text).toContain(city))
+          expectUsage(second)
+        }),
+      60_000,
+    )
+  }
+
+  recorded.effect.with(
+    "streams Qwen parsed reasoning",
+    { tags: ["reasoning", "usage"], metadata: { model: "qwen/qwen3.6-27b" } },
+    () =>
+      Effect.gen(function* () {
+        const request = LLM.request({
+          model: configure({
+            apiKey,
+            providerOptions: { reasoningEffort: "default" },
+          }).model("qwen/qwen3.6-27b"),
+          prompt:
+            "What is 173 multiplied by 219? Think through the arithmetic, then reply with only the final integer.",
+          generation: { maxTokens: 2048 },
+        })
+        const compiled = yield* compileRequest(request)
+        expect(compiled.body).toMatchObject({ reasoning_format: "parsed", reasoning_effort: "default" })
+        expect(compiled.body.include_reasoning).toBeUndefined()
+
+        const response = yield* LLMClient.generate(request)
+        expect(response.text.replaceAll(",", "").trim()).toBe("37887")
+        expect(response.text).not.toContain("<think>")
+        expect(response.reasoning.length).toBeGreaterThan(0)
+        expect(response.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
+        expectUsage(response)
+      }),
+    60_000,
+  )
+})
+
+function expectUsage(response: LLMResponse) {
+  expect(response.usage).toBeDefined()
+  expect(response.usage?.inputTokens).toBeGreaterThan(0)
+  expect(response.usage?.outputTokens).toBeGreaterThan(0)
+  expect(response.events.filter(LLMEvent.is.finish)).toHaveLength(1)
+}

packages/ai/test/provider/groq.test.ts

@@ -0,0 +1,112 @@
+import { expect } from "bun:test"
+import { Effect } from "effect"
+import { LanguageModel, LLM, Message } from "../../src/index.js"
+import { OpenAIChat } from "../../src/protocols/openai-chat.js"
+import { Groq } from "../../src/providers/groq.js"
+import { compileRequest } from "../../src/route/client.js"
+import { it } from "../lib/effect.js"
+import { weatherTool } from "../recorded-scenarios.js"
+
+it.effect("Groq reuses Chat streaming and defaults to parsed reasoning", () =>
+  Effect.gen(function* () {
+    expect(Groq.protocol.stream).toBe(OpenAIChat.protocol.stream)
+    const model = Groq.configure({ apiKey: "fixture" }).model("llama-3.3-70b-versatile")
+    expect(model.route.endpoint.baseURL).toBe("https://api.groq.com/openai/v1")
+    const compiled = yield* compileRequest(
+      LLM.request({ model, prompt: "Hello", tools: [weatherTool], generation: { maxTokens: 64 } }),
+    )
+    expect(compiled.body).toMatchObject({
+      max_completion_tokens: 64,
+      stream_options: { include_usage: true },
+      reasoning_format: "parsed",
+    })
+    for (const key of ["store", "max_tokens", "include_reasoning", "parallel_tool_calls", "service_tier", "user"])
+      expect(compiled.body[key]).toBeUndefined()
+    expect(compiled.body.tools?.[0]?.function).not.toHaveProperty("strict")
+  }),
+)
+
+it.effect("Groq lowers its own options for custom catalog identities and endpoints", () =>
+  Effect.gen(function* () {
+    const model = LanguageModel.update(
+      Groq.model("qwen/qwen3.6-27b", {
+        apiKey: "fixture",
+        baseURL: "https://gateway.example/v1",
+        headers: { "x-client": "test" },
+        body: { custom: "value" },
+        providerOptions: {
+          reasoningEffort: "default",
+          parallelToolCalls: true,
+          serviceTier: "flex",
+          user: "test-user",
+        },
+      }),
+      { provider: "custom-groq" },
+    )
+    const compiled = yield* compileRequest(
+      LLM.request({ model, prompt: "Hello", providerOptions: { parallelToolCalls: false, includeReasoning: false } }),
+    )
+    expect(model.route.endpoint.baseURL).toBe("https://gateway.example/v1")
+    expect(model.route.defaults.headers).toEqual({ "x-client": "test" })
+    expect(model.route.defaults.http?.body).toEqual({ custom: "value" })
+    expect(compiled.body).toMatchObject({
+      reasoning_effort: "default",
+      reasoning_format: "parsed",
+      parallel_tool_calls: false,
+      service_tier: "flex",
+      user: "test-user",
+    })
+    expect(compiled.body.include_reasoning).toBeUndefined()
+    for (const key of ["reasoningFormat", "reasoningEffort", "parallelToolCalls", "serviceTier"])
+      expect(compiled.body).not.toHaveProperty(key)
+  }),
+)
+
+it.effect("Groq replays reasoning only when present and preserves explicit reasoning exclusion", () =>
+  Effect.gen(function* () {
+    const compiled = yield* compileRequest(
+      LLM.request({
+        model: Groq.configure({ apiKey: "fixture" }).model("openai/gpt-oss-20b"),
+        messages: [
+          Message.user("Think"),
+          Message.assistant([
+            { type: "reasoning", text: "Thinking" },
+            { type: "text", text: "Answer" },
+          ]),
+          Message.user("Again"),
+          Message.assistant("Answer only"),
+          Message.user("Continue"),
+        ],
+        providerOptions: { reasoningEffort: "low", includeReasoning: false },
+      }),
+    )
+    expect(compiled.body).toMatchObject({ reasoning_effort: "low", include_reasoning: false })
+    expect(compiled.body.reasoning_format).toBeUndefined()
+    expect(compiled.body.messages[1]).toMatchObject({ reasoning: "Thinking", content: "Answer" })
+    expect(compiled.body.messages[1]).not.toHaveProperty("reasoning_content")
+    expect(compiled.body.messages[3]).not.toHaveProperty("reasoning")
+  }),
+)
+
+it.effect("Groq omits reasoning_format for the GPT-OSS family by default", () =>
+  Effect.gen(function* () {
+    for (const id of ["openai/gpt-oss-20b", "openai/gpt-oss-120b", "openai/gpt-oss-safeguard-20b"]) {
+      const compiled = yield* compileRequest(
+        LLM.request({ model: Groq.configure({ apiKey: "fixture" }).model(id), prompt: "Hello" }),
+      )
+      expect(compiled.body.reasoning_format).toBeUndefined()
+      expect(compiled.body.include_reasoning).toBeUndefined()
+    }
+  }),
+)
+
+it.effect("Groq validates option types", () =>
+  Effect.gen(function* () {
+    for (const providerOptions of [{ includeReasoning: "false" }, { parallelToolCalls: "false" }]) {
+      const error = yield* compileRequest(
+        LLM.request({ model: Groq.configure({ apiKey: "fixture" }).model("qwen"), prompt: "Hello", providerOptions }),
+      ).pipe(Effect.flip)
+      expect(error.reason._tag).toBe("InvalidRequest")
+    }
+  }),
+)

packages/ai/test/provider/native-providers.test.ts

@@ -2,7 +2,7 @@ import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect } from "effect"
 import { HttpClientRequest } from "effect/unstable/http"
 import { LLM, Message, ToolDefinition } from "../../src/index.js"
-import { Cerebras, DeepInfra, TogetherAI } from "../../src/providers/index.js"
+import { Cerebras, DeepInfra, Groq, TogetherAI } from "../../src/providers/index.js"
 import { compileRequest } from "../../src/route/client.js"
 import { it } from "../lib/effect.js"
 import { dynamicResponse } from "../lib/http.js"
@@ -155,6 +155,12 @@ describe("native OpenAI-compatible providers", () => {
           token: "deepinfra-secret",
           url: "https://api.deepinfra.com/v1/openai/chat/completions",
         },
+        {
+          model: Groq.configure().model("llama"),
+          env: { GROQ_API_KEY: "groq-secret" },
+          token: "groq-secret",
+          url: "https://api.groq.com/openai/v1/chat/completions",
+        },
       ]
 
       yield* Effect.forEach(scenarios, (scenario) =>

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

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

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

@@ -2229,6 +2229,35 @@ describe("OpenAI Responses route", () => {
     }),
   )
 
+  it.effect("accepts empty IDs for native reasoning text deltas", () =>
+    Effect.gen(function* () {
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(
+            sseEvents(
+              { type: "response.output_item.added", output_index: 1, item: { type: "reasoning", id: "" } },
+              { type: "response.reasoning_text.delta", output_index: 1, item_id: "", delta: "Raw" },
+              {
+                type: "response.output_item.done",
+                output_index: 1,
+                item: { type: "reasoning", id: "", encrypted_content: "state" },
+              },
+              { type: "response.completed", response: { id: "resp_1" } },
+            ),
+          ),
+        ),
+      )
+
+      expect(response.message.content).toEqual([
+        {
+          type: "reasoning",
+          text: "Raw",
+          providerMetadata: { openai: { itemId: "", reasoningEncryptedContent: "state" } },
+        },
+      ])
+    }),
+  )
+
   it.effect("falls back to item ids when an output index was not registered", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(

packages/ai/test/provider/zai-images.test.ts

@@ -80,7 +80,9 @@ describe("Z.ai Images", () => {
 
   it.effect("sanitizes unpaired surrogates in outbound image requests", () =>
     Image.generate({
-      model: ZAI.configure({ apiKey: "test", http: { body: { metadata: { source: "default\uDC00" } } } }).image("model"),
+      model: ZAI.configure({ apiKey: "test", http: { body: { metadata: { source: "default\uDC00" } } } }).image(
+        "model",
+      ),
       prompt: "A red circle \uD800 on a white background \u{1F600}",
     }).pipe(
       Effect.provide(

packages/app/e2e/service-worker/cache.spec.ts

@@ -0,0 +1,137 @@
+import { expect, test } from "@playwright/test"
+import { readFile } from "node:fs/promises"
+import { createServer } from "node:http"
+import { once } from "node:events"
+
+const legacy = `
+self.addEventListener("install", event => event.waitUntil(
+  caches.open("workbox-precache-v2-" + self.registration.scope).then(cache =>
+    cache.addAll(["/index.html", "/assets/app-old.js", "/assets/lazy-old.js"])
+  )
+))
+self.addEventListener("fetch", event => {
+  if (event.request.mode === "navigate") {
+    event.respondWith(caches.match("/index.html"))
+    return
+  }
+  event.respondWith(caches.match(event.request).then(response => response || fetch(event.request)))
+})
+`
+
+const fixture = test.extend<{ site: { url: string; upgrade: () => void; repair: () => void } }>({
+  site: async ({}, use) => {
+    const worker = await readFile(new URL("../../dist/sw.js", import.meta.url), "utf8")
+    const state = { version: "old", repaired: false }
+    const server = createServer((request, response) => {
+      const pathname = new URL(request.url ?? "/", "http://localhost").pathname
+      const prefix = state.version === "old" ? "/assets" : "/_assets"
+      response.setHeader("cache-control", "no-store")
+      if (pathname === "/sw.js") {
+        response.setHeader("content-type", "text/javascript")
+        response.end(state.version === "old" ? legacy : worker)
+        return
+      }
+      if (pathname === `${prefix}/app-${state.version}.js`) {
+        response.setHeader("content-type", "text/javascript")
+        response.end(`import "${prefix}/startup-${state.version}.js"`)
+        return
+      }
+      if (pathname === `${prefix}/startup-${state.version}.js`) {
+        response.setHeader("content-type", "text/javascript")
+        response.end(`
+          document.getElementById("root").innerHTML = '<h1>${state.version}</h1><label>Draft<input></label><button>Load older chunk</button><output></output>'
+          document.querySelector("button").onclick = () => import("/assets/lazy-old.js")
+        `)
+        return
+      }
+      if (
+        (pathname === "/assets/lazy-old.js" && state.version === "old") ||
+        (pathname === "/_assets/retry.js" && state.repaired)
+      ) {
+        response.setHeader("content-type", "text/javascript")
+        response.end('document.querySelector("output").textContent = "Older chunk loaded"')
+        return
+      }
+      // Deliberately retain the old server's fallback so the worker must reject HTML asset responses itself.
+      response.setHeader("content-type", "text/html")
+      response.end(`<div id="root"></div><script type="module" src="${prefix}/app-${state.version}.js"></script>`)
+    })
+    server.listen(0, "127.0.0.1")
+    await once(server, "listening")
+    const address = server.address()
+    if (!address || typeof address === "string") throw new Error("Expected a TCP address")
+    try {
+      await use({
+        url: `http://127.0.0.1:${address.port}`,
+        upgrade: () => (state.version = "new"),
+        repair: () => (state.repaired = true),
+      })
+    } finally {
+      server.closeAllConnections()
+      await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())))
+    }
+  },
+})
+
+fixture("updates a legacy worker without reloading drafts or deleting old chunks", async ({ page, site }) => {
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("old")
+  await page.evaluate(async () => {
+    await navigator.serviceWorker.register("/sw.js")
+    await navigator.serviceWorker.ready
+  })
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("old")
+  await page.getByLabel("Draft").fill("Keep this unsent prompt")
+
+  site.upgrade()
+  await page.evaluate(async () => {
+    const cache = await caches.open("opencode-assets")
+    await cache.put(
+      "/_assets/startup-new.js",
+      new Response("<html>stale fallback</html>", {
+        headers: { "content-type": "text/html" },
+      }),
+    )
+    const changed = new Promise<void>((resolve) =>
+      navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true }),
+    )
+    const registration = await navigator.serviceWorker.getRegistration()
+    if (!registration) throw new Error("Missing legacy worker")
+    await registration.update()
+    await changed
+  })
+
+  await expect(page.getByLabel("Draft")).toHaveValue("Keep this unsent prompt")
+  await page.getByRole("button", { name: "Load older chunk" }).click()
+  await expect(page.getByRole("status")).toHaveText("Older chunk loaded")
+
+  await page.goto(`${site.url}/workspace/example`)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  await expect
+    .poll(() =>
+      page.evaluate(async () =>
+        (await (await caches.open("opencode-assets")).match("/_assets/startup-new.js"))?.headers.get("content-type"),
+      ),
+    )
+    .toBe("text/javascript")
+})
+
+fixture("does not cache HTML responses under asset URLs", async ({ page, site }) => {
+  site.upgrade()
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  await page.evaluate(async () => {
+    await navigator.serviceWorker.register("/sw.js")
+    await navigator.serviceWorker.ready
+  })
+  await page.goto(site.url)
+  await expect(page.getByRole("heading")).toHaveText("new")
+  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
+    "text/html",
+  )
+  site.repair()
+  expect(await page.evaluate(async () => (await fetch("/_assets/retry.js")).headers.get("content-type"))).toBe(
+    "text/javascript",
+  )
+})

packages/app/e2e/service-worker/playwright.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "@playwright/test"
+
+export default defineConfig({
+  testDir: ".",
+  testMatch: "*.spec.ts",
+  outputDir: "../test-results/service-worker",
+  timeout: 30_000,
+  use: { browserName: "chromium" },
+})

packages/app/package.json

@@ -28,6 +28,7 @@
     "test:e2e:local": "playwright test",
     "test:e2e:ui": "playwright test --ui",
     "test:e2e:report": "playwright show-report e2e/playwright-report",
+    "test:service-worker": "bun run build && playwright test --config e2e/service-worker/playwright.config.ts",
     "test:stability": "bun test ./e2e/performance/unit/visual-stability.test.ts && playwright test --config e2e/performance/timeline-stability/playwright.config.ts",
     "test:bench": "bun test ./e2e/performance/unit && playwright test --config e2e/performance/playwright.config.ts",
     "test:bench:devex": "bun test ./e2e/performance/unit/desktop-startup.test.ts && playwright test --config e2e/performance/devex/playwright.config.ts"

packages/app/playwright.config.ts

@@ -9,7 +9,10 @@ const reuse = !process.env.CI
 const workers = Number(process.env.PLAYWRIGHT_WORKERS ?? (process.env.CI ? 5 : 0)) || undefined
 export default defineConfig({
   testDir: "./e2e",
-  testIgnore: process.env.OPENCODE_PERFORMANCE === "1" ? "performance/**/*.test.ts" : "performance/**",
+  testIgnore: [
+    "service-worker/**",
+    process.env.OPENCODE_PERFORMANCE === "1" ? "performance/**/*.test.ts" : "performance/**",
+  ],
   outputDir: "./e2e/test-results",
   timeout: 60_000,
   expect: {

packages/app/public/_headers

@@ -1,10 +1,10 @@
-/assets/*.js
+/_assets/*.js
   Content-Type: application/javascript
 
-/assets/*.mjs
+/_assets/*.mjs
   Content-Type: application/javascript
 
-/assets/*.css
+/_assets/*.css
   Content-Type: text/css
 
 /*.js

packages/app/src/workspaces/files/model.tsx

@@ -212,7 +212,7 @@ export const { use: useFile, provider: FileProvider } = createSimpleContext({
           {
             location: { directory: sdk().directory },
             query,
-            type: dirs === "true" ? "directory" : "file",
+            type: dirs === "true" ? undefined : "file",
             limit: options?.limit,
           },
           { signal: options?.signal },

packages/app/vite.config.ts

@@ -29,33 +29,44 @@ export default defineConfig({
       injectRegister: false,
       manifest: false,
       workbox: {
-        cleanupOutdatedCaches: true,
         clientsClaim: false,
-        skipWaiting: false,
+        skipWaiting: true,
         inlineWorkboxRuntime: true,
-        navigateFallback: "/index.html",
-        navigateFallbackDenylist: [/^\/api(?:\/|$)/],
-        globPatterns: [
-          "index.html",
-          "site.webmanifest",
-          "favicon*",
-          "apple-touch-icon*",
-          "web-app-manifest*",
-          "assets/index-*.{js,css}",
-          "assets/session-*.js",
-          "assets/IBMPlexMono-Text-*.woff2",
-          "assets/Inter.ttf",
-          "assets/JetBrainsMonoNerdFontMono-Regular.woff2",
-        ],
+        // Always fetch the current HTML. Precaching a partial build can strand it without its chunks after an upgrade.
+        navigateFallback: null,
+        globPatterns: [],
         runtimeCaching: [
           {
-            urlPattern: ({ url }) => url.origin === self.location.origin && url.pathname.startsWith("/assets/"),
+            urlPattern: ({ url }) =>
+              url.origin === self.location.origin &&
+              (url.pathname.startsWith("/_assets/") || url.pathname.startsWith("/assets/")),
             handler: "CacheFirst",
             options: {
               cacheName: "opencode-assets",
-              cacheableResponse: {
-                statuses: [200],
-              },
+              plugins: [
+                {
+                  cachedResponseWillBeUsed: async ({ request, cachedResponse }) => {
+                    if (
+                      cachedResponse?.status === 200 &&
+                      !/^(text\/html|application\/xhtml\+xml)\b/i.test(cachedResponse.headers.get("content-type") ?? "")
+                    )
+                      return cachedResponse
+                    // Keep old tabs' precached chunks usable without retaining their stale HTML navigation handler.
+                    const response = await caches.match(request, {
+                      cacheName: `workbox-precache-v2-${self.location.origin}/`,
+                    })
+                    return response?.status === 200 &&
+                      !/^(text\/html|application\/xhtml\+xml)\b/i.test(response.headers.get("content-type") ?? "")
+                      ? response
+                      : null
+                  },
+                  cacheWillUpdate: async ({ response }) =>
+                    response.status === 200 &&
+                    !/^(text\/html|application\/xhtml\+xml)\b/i.test(response.headers.get("content-type") ?? "")
+                      ? response
+                      : null,
+                },
+              ],
               expiration: {
                 maxEntries: 1000,
               },
@@ -72,6 +83,7 @@ export default defineConfig({
     port: 3000,
   },
   build: {
+    assetsDir: "_assets",
     target: "esnext",
     sourcemap: true,
   },

packages/cli/package.json

@@ -27,7 +27,7 @@
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/pty": "0.1.8",
+    "@opencode-ai/pty": "0.1.10",
     "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/server": "workspace:*",
     "@opencode-ai/tui": "workspace:*",

packages/cli/src/services/web-ui.ts

@@ -26,6 +26,8 @@ export const handler = Effect.fn("cli.web-ui.handler")(function* (options?: { re
 
 function serveUI(request: HttpServerRequest.HttpServerRequest, url: URL, assets: AssetMap) {
   const key = url.pathname.replace(/^\//, "")
+  if (key.startsWith("_assets/") && assets[key] === undefined)
+    return Effect.succeed(HttpServerResponse.empty({ status: 404, headers: { "cache-control": "no-store" } }))
   const name = assets[key] !== undefined ? key : "index.html"
   const file = assets[name]
   if (!file) return Effect.succeed(HttpServerResponse.empty({ status: 404 }))

packages/cli/test/web-ui.test.ts

@@ -19,7 +19,7 @@ describe("web UI", () => {
     await writeFile(asset, "console.log('embedded')")
     const assets = {
       "index.html": await Bun.file(index).text(),
-      "app.js": await Bun.file(asset).text(),
+      "_assets/app.js": await Bun.file(asset).text(),
       "sw.js": "service worker",
       "registerSW.js": "registration",
       "font.woff2": new Uint8Array([0, 1, 2, 255]),
@@ -53,7 +53,16 @@ describe("web UI", () => {
           expect(missing.status).toBe(404)
           expect(yield* Effect.promise(() => missing.text())).toBe("")
 
-          const script = yield* Effect.promise(() => fetch(`${origin}/app.js`))
+          yield* Effect.forEach(["/_assets/old.js", "/_assets/old.css", "/_assets/missing"], (pathname) =>
+            Effect.gen(function* () {
+              const missing = yield* Effect.promise(() => fetch(`${origin}${pathname}`))
+              expect(missing.status).toBe(404)
+              expect(missing.headers.get("cache-control")).toBe("no-store")
+              expect(yield* Effect.promise(() => missing.text())).toBe("")
+            }),
+          )
+
+          const script = yield* Effect.promise(() => fetch(`${origin}/_assets/app.js`))
           expect(yield* Effect.promise(() => script.text())).toBe("console.log('embedded')")
           expect(script.headers.get("content-type")).toContain("javascript")
           expect(script.headers.get("cache-control")).toBe("public, max-age=31536000, immutable")
@@ -74,6 +83,14 @@ describe("web UI", () => {
           expect(yield* Effect.promise(() => fallback.text())).toContain("embedded")
           expect(fallback.headers.get("content-security-policy")).toContain("default-src 'self'")
           expect(fallback.headers.get("content-security-policy")).toContain("connect-src * data: blob:")
+
+          const dotted = yield* Effect.promise(() => fetch(`${origin}/workspace/example.js`))
+          expect(dotted.status).toBe(200)
+          expect(yield* Effect.promise(() => dotted.text())).toContain("embedded")
+
+          const legacy = yield* Effect.promise(() => fetch(`${origin}/assets/missing.js`))
+          expect(legacy.status).toBe(200)
+          expect(yield* Effect.promise(() => legacy.text())).toContain("embedded")
         }),
       ).pipe(Effect.provide(NodeFileSystem.layer)),
     )

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

@@ -663,6 +663,15 @@ export type SessionLogOutput =
             readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined
           }
         }
+      | {
+          readonly id: Event.ID
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.step.streamed"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: { readonly sessionID: Session.ID; readonly assistantMessageID: SessionMessage.ID }
+        }
       | {
           readonly id: Event.ID
           readonly created: number
@@ -974,6 +983,19 @@ export type SessionLogOutput =
           readonly location?: Location.Ref | undefined
           readonly data: { readonly sessionID: Session.ID; readonly to: SessionMessage.ID }
         }
+      | {
+          readonly id: Event.ID
+          readonly created: number
+          readonly metadata?: { readonly [x: string]: unknown } | undefined
+          readonly type: "session.message.content.updated"
+          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
+          readonly location?: Location.Ref | undefined
+          readonly data: {
+            readonly sessionID: Session.ID
+            readonly messageID: SessionMessage.ID
+            readonly content: ReadonlyArray<SessionMessage.AssistantContentEncoded>
+          }
+        }
       | {
           readonly id: Event.ID
           readonly created: number
@@ -1013,6 +1035,18 @@ export type SessionMessageInput = { readonly sessionID: Session.ID; readonly mes
 export type SessionMessageOutput = SessionMessage.Info
 export type SessionMessageOperation<E = never> = (input: SessionMessageInput) => Effect.Effect<SessionMessageOutput, E>
 
+export type SessionMessageUpdateInput = {
+  readonly sessionID: Session.ID
+  readonly messageID: SessionMessage.ID
+  readonly content: ReadonlyArray<
+    SessionMessage.AssistantText | SessionMessage.AssistantReasoning | SessionMessage.AssistantTool
+  >
+}
+export type SessionMessageUpdateOutput = SessionMessage.Assistant
+export type SessionMessageUpdateOperation<E = never> = (
+  input: SessionMessageUpdateInput,
+) => Effect.Effect<SessionMessageUpdateOutput, E>
+
 export type SessionEnvironmentInput = {
   readonly sessionID: Session.ID
   readonly variables: { readonly [x: string]: string }
@@ -1071,6 +1105,7 @@ export interface SessionApi<E = never> {
   readonly interrupt: SessionInterruptOperation<E>
   readonly background: SessionBackgroundOperation<E>
   readonly message: SessionMessageOperation<E>
+  readonly messageUpdate: SessionMessageUpdateOperation<E>
   readonly environment: SessionEnvironmentOperation<E>
   readonly view: SessionViewOperation<E>
 }

packages/client/src/effect/generated/client.ts

@@ -86,6 +86,8 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
+  SessionMessageUpdateInput,
+  SessionMessageUpdateOutput,
   SessionEnvironmentInput,
   SessionEnvironmentOutput,
   SessionViewInput,
@@ -651,6 +653,17 @@ const EndpointSessionMessage = (raw: RawClient["server.session"]) => (input: Ses
     ),
   )
 
+const EndpointSessionMessageUpdate = (raw: RawClient["server.session"]) => (input: SessionMessageUpdateInput) =>
+  preserveEffect<SessionMessageUpdateOutput>()(
+    raw["session.messageUpdate"]({
+      params: { sessionID: input["sessionID"], messageID: input["messageID"] },
+      payload: { content: input["content"] },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
 const EndpointSessionEnvironment = (raw: RawClient["server.session"]) => (input: SessionEnvironmentInput) =>
   preserveEffect<SessionEnvironmentOutput>()(
     raw["session.environment"]({
@@ -711,6 +724,7 @@ const adaptGroupSession = (raw: RawClient["server.session"]) => ({
   interrupt: EndpointSessionInterrupt(raw),
   background: EndpointSessionBackground(raw),
   message: EndpointSessionMessage(raw),
+  messageUpdate: EndpointSessionMessageUpdate(raw),
   environment: EndpointSessionEnvironment(raw),
   view: EndpointSessionView(raw),
 })

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

@@ -80,6 +80,8 @@ import type {
   SessionBackgroundOutput,
   SessionMessageInput,
   SessionMessageOutput,
+  SessionMessageUpdateInput,
+  SessionMessageUpdateOutput,
   SessionEnvironmentInput,
   SessionEnvironmentOutput,
   SessionViewInput,
@@ -929,6 +931,18 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
+      messageUpdate: (input: SessionMessageUpdateInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: SessionMessageUpdateOutput }>(
+          {
+            method: "PATCH",
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+            body: { content: input["content"] },
+            successStatus: 200,
+            declaredStatuses: [404, 400, 409, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
       environment: (input: SessionEnvironmentInput, requestOptions?: RequestOptions) =>
         request<SessionEnvironmentOutput>(
           {

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

@@ -174,6 +174,12 @@ export type SessionMessageProviderState1 = { [x: string]: any }
 
 export type ToolFileContent1 = { type: "file"; uri: string; mime: string; name?: string | undefined }
 
+export type SessionMessageToolStateRunning1 = {
+  status: "running"
+  input: { [x: string]: any }
+  metadata: { [x: string]: JsonValue }
+}
+
 export type EventLogSynced = { type: "log.synced"; aggregateID: string; seq?: number }
 
 export type SessionInterruptResponse = { interrupted: boolean }
@@ -714,6 +720,16 @@ export type SessionStepStarted = {
   data: { sessionID: string; assistantMessageID: string; agent: string; model: ModelRef; snapshot?: string }
 }
 
+export type SessionStepStreamed = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.step.streamed"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; assistantMessageID: string }
+}
+
 export type SessionTextStarted = {
   id: string
   created: number
@@ -1315,6 +1331,15 @@ export type SessionToolCalled = {
   }
 }
 
+export type SessionMessageAssistantText1 = { type: "text"; text: string; state?: SessionMessageProviderState1 }
+
+export type SessionMessageAssistantReasoning1 = {
+  type: "reasoning"
+  text: string
+  state?: SessionMessageProviderState1
+  time?: { created: number; completed?: number }
+}
+
 export type ToolContent1 = ToolTextContent | ToolFileContent1
 
 export type ModelCompatibility = {
@@ -1743,6 +1768,21 @@ export type SessionToolFailed = {
   }
 }
 
+export type SessionMessageToolStateCompleted1 = {
+  status: "completed"
+  input: { [x: string]: any }
+  content: [ToolContent1, ...Array<ToolContent1>]
+  metadata?: { [x: string]: JsonValue }
+}
+
+export type SessionMessageToolStateError1 = {
+  status: "error"
+  input: { [x: string]: any }
+  error: SessionStructuredError
+  content?: [ToolContent1, ...Array<ToolContent1>]
+  metadata?: { [x: string]: JsonValue }
+}
+
 export type ModelInfo = {
   id: string
   modelID: string
@@ -2009,6 +2049,21 @@ export type SessionMessageAssistantTool = {
   time: { created: number; ran?: number; completed?: number }
 }
 
+export type SessionMessageAssistantTool1 = {
+  type: "tool"
+  id: string
+  name: string
+  executed?: boolean
+  providerState?: SessionMessageProviderState1
+  providerResultState?: SessionMessageProviderState1
+  state:
+    | SessionMessageToolStateStreaming
+    | SessionMessageToolStateRunning1
+    | SessionMessageToolStateCompleted1
+    | SessionMessageToolStateError1
+  time: { created: number; ran?: number; completed?: number }
+}
+
 export type FormFields = [FormField, ...Array<FormField>]
 
 export type FormFields2 = [FormField1, ...Array<FormField1>]
@@ -2028,7 +2083,7 @@ export type SessionInboxEnqueued = {
 export type SessionMessageAssistant = {
   id: string
   metadata?: { [x: string]: JsonValue }
-  time: { created: number; completed?: number }
+  time: { created: number; streamed?: number; completed?: number }
   type: "assistant"
   agent: string
   model: ModelRef
@@ -2043,6 +2098,11 @@ export type SessionMessageAssistant = {
   retry?: SessionMessageAssistantRetry
 }
 
+export type SessionMessageAssistantContentEncoded =
+  | SessionMessageAssistantText1
+  | SessionMessageAssistantReasoning1
+  | SessionMessageAssistantTool1
+
 export type IntegrationOAuthMethod = { id: string; type: "oauth"; label: string; form?: FormFields }
 
 export type IntegrationKeyMethod = { type: "key"; label?: string; form?: FormFields }
@@ -2051,6 +2111,50 @@ export type FormInfo = { id: string; sessionID: string; title: string; metadata?
 
 export type FormInfo1 = { id: string; sessionID: string; title: string; metadata?: FormMetadata1; fields: FormFields2 }
 
+export type SessionMessageInfo =
+  | SessionMessageAgentSelected
+  | SessionMessageModelSelected
+  | SessionMessageLocationSwitched
+  | SessionMessageUser
+  | SessionMessageSynthetic
+  | SessionMessageSystem
+  | SessionMessageSkill
+  | SessionMessageShell
+  | SessionMessageAssistant
+  | SessionMessageCompaction
+
+export type SessionMessageContentUpdated = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "session.message.content.updated"
+  durable: { aggregateID: string; seq: number; version: 1 }
+  location?: LocationRef
+  data: { sessionID: string; messageID: string; content: Array<SessionMessageAssistantContentEncoded> }
+}
+
+export type IntegrationMethod =
+  | IntegrationOAuthMethod
+  | IntegrationCommandMethod
+  | IntegrationKeyMethod
+  | IntegrationEnvMethod
+
+export type FormCreated = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "form.created"
+  location?: LocationRef
+  data: { form: FormInfo1 }
+}
+
+export type SessionTransferData = { info: SessionInfo; messages: Array<SessionMessageInfo> }
+
+export type SessionMessagesResponse = {
+  data: Array<SessionMessageInfo>
+  cursor: { previous?: string | null; next?: string | null }
+}
+
 export type SessionEventDurable =
   | SessionCreated
   | SessionAgentSelected
@@ -2074,6 +2178,7 @@ export type SessionEventDurable =
   | SessionShellStarted
   | SessionShellEnded
   | SessionStepStarted
+  | SessionStepStreamed
   | SessionStepEnded
   | SessionStepFailed
   | SessionTextStarted
@@ -2092,44 +2197,9 @@ export type SessionEventDurable =
   | SessionRevertStaged
   | SessionRevertCleared
   | SessionRevertCommitted
+  | SessionMessageContentUpdated
   | SessionUsageRecorded
 
-export type SessionMessageInfo =
-  | SessionMessageAgentSelected
-  | SessionMessageModelSelected
-  | SessionMessageLocationSwitched
-  | SessionMessageUser
-  | SessionMessageSynthetic
-  | SessionMessageSystem
-  | SessionMessageSkill
-  | SessionMessageShell
-  | SessionMessageAssistant
-  | SessionMessageCompaction
-
-export type IntegrationMethod =
-  | IntegrationOAuthMethod
-  | IntegrationCommandMethod
-  | IntegrationKeyMethod
-  | IntegrationEnvMethod
-
-export type FormCreated = {
-  id: string
-  created: number
-  metadata?: { [x: string]: any }
-  type: "form.created"
-  location?: LocationRef
-  data: { form: FormInfo1 }
-}
-
-export type SessionLogItem = SessionEventDurable | EventLogSynced
-
-export type SessionTransferData = { info: SessionInfo; messages: Array<SessionMessageInfo> }
-
-export type SessionMessagesResponse = {
-  data: Array<SessionMessageInfo>
-  cursor: { previous?: string | null; next?: string | null }
-}
-
 export type IntegrationInfo = {
   id: string
   name: string
@@ -2168,6 +2238,7 @@ export type V2Event =
   | SessionShellStarted
   | SessionShellEnded
   | SessionStepStarted
+  | SessionStepStreamed
   | SessionStepEnded
   | SessionStepFailed
   | SessionTextStarted
@@ -2191,6 +2262,7 @@ export type V2Event =
   | SessionRevertStaged
   | SessionRevertCleared
   | SessionRevertCommitted
+  | SessionMessageContentUpdated
   | FilesystemChanged
   | ReferenceUpdated
   | PermissionAsked
@@ -2229,6 +2301,8 @@ export type V2Event =
   | McpResourcesChanged
   | V2EventServerConnected
 
+export type SessionLogItem = SessionEventDurable | EventLogSynced
+
 export type UnauthorizedError = { readonly _tag: "UnauthorizedError"; readonly message: string }
 export const isUnauthorizedError = (value: unknown): value is UnauthorizedError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnauthorizedError"
@@ -2789,7 +2863,7 @@ export type SessionImportInput = {
       | {
           readonly id: string
           readonly metadata?: { readonly [x: string]: JsonValue }
-          readonly time: { readonly created: number; readonly completed?: number }
+          readonly time: { readonly created: number; readonly streamed?: number; readonly completed?: number }
           readonly type: "assistant"
           readonly agent: string
           readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
@@ -3065,7 +3139,7 @@ export type SessionImportInput = {
       | {
           readonly id: string
           readonly metadata?: { readonly [x: string]: JsonValue }
-          readonly time: { readonly created: number; readonly completed?: number }
+          readonly time: { readonly created: number; readonly streamed?: number; readonly completed?: number }
           readonly type: "assistant"
           readonly agent: string
           readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
@@ -3341,7 +3415,7 @@ export type SessionImportInput = {
       | {
           readonly id: string
           readonly metadata?: { readonly [x: string]: JsonValue }
-          readonly time: { readonly created: number; readonly completed?: number }
+          readonly time: { readonly created: number; readonly streamed?: number; readonly completed?: number }
           readonly type: "assistant"
           readonly agent: string
           readonly model: { readonly id: string; readonly providerID: string; readonly variant?: string }
@@ -4036,6 +4110,91 @@ export type SessionMessageInput = {
 
 export type SessionMessageOutput = { data: SessionMessageInfo }["data"]
 
+export type SessionMessageUpdateInput = {
+  readonly sessionID: { readonly sessionID: string; readonly messageID: string }["sessionID"]
+  readonly messageID: { readonly sessionID: string; readonly messageID: string }["messageID"]
+  readonly content: {
+    readonly content: ReadonlyArray<
+      | { readonly type: "text"; readonly text: string; readonly state?: { readonly [x: string]: JsonValue } }
+      | {
+          readonly type: "reasoning"
+          readonly text: string
+          readonly state?: { readonly [x: string]: JsonValue }
+          readonly time?: { readonly created: number; readonly completed?: number }
+        }
+      | {
+          readonly type: "tool"
+          readonly id: string
+          readonly name: string
+          readonly executed?: boolean
+          readonly providerState?: { readonly [x: string]: JsonValue }
+          readonly providerResultState?: { readonly [x: string]: JsonValue }
+          readonly state:
+            | { readonly status: "streaming"; readonly input: string }
+            | {
+                readonly status: "running"
+                readonly input: { readonly [x: string]: JsonValue }
+                readonly metadata: { readonly [x: string]: JsonValue }
+              }
+            | {
+                readonly status: "completed"
+                readonly input: { readonly [x: string]: JsonValue }
+                readonly content: readonly [
+                  (
+                    | { readonly type: "text"; readonly text: string }
+                    | {
+                        readonly type: "file"
+                        readonly uri: string
+                        readonly mime: string
+                        readonly name?: string | null
+                      }
+                  ),
+                  ...Array<
+                    | { readonly type: "text"; readonly text: string }
+                    | {
+                        readonly type: "file"
+                        readonly uri: string
+                        readonly mime: string
+                        readonly name?: string | null
+                      }
+                  >,
+                ]
+                readonly metadata?: { readonly [x: string]: JsonValue }
+              }
+            | {
+                readonly status: "error"
+                readonly input: { readonly [x: string]: JsonValue }
+                readonly error: { readonly type: string; readonly message: string; readonly status?: number }
+                readonly content?: readonly [
+                  (
+                    | { readonly type: "text"; readonly text: string }
+                    | {
+                        readonly type: "file"
+                        readonly uri: string
+                        readonly mime: string
+                        readonly name?: string | null
+                      }
+                  ),
+                  ...Array<
+                    | { readonly type: "text"; readonly text: string }
+                    | {
+                        readonly type: "file"
+                        readonly uri: string
+                        readonly mime: string
+                        readonly name?: string | null
+                      }
+                  >,
+                ]
+                readonly metadata?: { readonly [x: string]: JsonValue }
+              }
+          readonly time: { readonly created: number; readonly ran?: number; readonly completed?: number }
+        }
+    >
+  }["content"]
+}
+
+export type SessionMessageUpdateOutput = { data: SessionMessageAssistant }["data"]
+
 export type SessionEnvironmentInput = {
   readonly sessionID: { readonly sessionID: string }["sessionID"]
   readonly variables: { readonly variables: { readonly [x: string]: string } }["variables"]

packages/client/src/solid/data.ts

@@ -167,6 +167,10 @@ function createSync() {
     has(key: string) {
       return state.has(key)
     },
+    pending(key: string) {
+      const active = state.get(key)
+      return active !== undefined && active !== true
+    },
     invalidate(key?: string) {
       if (key) {
         const active = state.get(key)
@@ -723,6 +727,17 @@ export function createData(config: CreateDataInput) {
           match.time.completed = event.created
         })
         return
+      case "session.message.content.updated": {
+        if (store.session.message[event.data.sessionID])
+          message.update(event.data.sessionID, (draft, index) => {
+            const assistant = message.assistant(draft, index, event.data.messageID)
+            if (assistant) assistant.content = [...event.data.content]
+          })
+        if (!sync.pending(`session.message:${event.data.sessionID}`)) return
+        result.session.message.invalidate(event.data.sessionID)
+        void result.session.message.sync(event.data.sessionID)
+        return
+      }
       case "session.step.started":
         message.update(event.data.sessionID, (draft, index) => {
           const position = index.get(event.data.assistantMessageID)
@@ -735,6 +750,7 @@ export function createData(config: CreateDataInput) {
             existing.finish = undefined
             existing.rawFinish = undefined
             existing.providerState = undefined
+            existing.time.streamed = undefined
             existing.time.completed = undefined
             if (event.data.snapshot) existing.snapshot = { ...existing.snapshot, start: event.data.snapshot }
             return
@@ -756,6 +772,12 @@ export function createData(config: CreateDataInput) {
           })
         })
         return
+      case "session.step.streamed":
+        message.update(event.data.sessionID, (draft, index) => {
+          const currentAssistant = message.assistant(draft, index, event.data.assistantMessageID)
+          if (currentAssistant) currentAssistant.time.streamed = event.created
+        })
+        return
       case "session.step.ended": {
         message.update(event.data.sessionID, (draft, index) => {
           const currentAssistant = message.assistant(draft, index, event.data.assistantMessageID)

packages/client/src/solid/pty.ts

@@ -1,4 +1,4 @@
-import type { OpenCodeClient, PtyConnectTokenInput } from "../promise"
+import type { ExperimentalPersistentPtyConnectTokenInput, OpenCodeClient, PtyConnectTokenInput } from "../promise"
 
 export type PtyClientOptions = {
   readonly url: string
@@ -11,6 +11,13 @@ export type PtyConnectInput = {
   readonly cursor?: number
 }
 
+export type PersistentPtyConnectInput = {
+  readonly ptyID: ExperimentalPersistentPtyConnectTokenInput["ptyID"]
+  readonly cursor: number
+  readonly attachmentID: string
+  readonly takeover?: boolean
+}
+
 export function createPtyClient(api: OpenCodeClient, options: PtyClientOptions) {
   return {
     async connect(input: PtyConnectInput) {
@@ -32,3 +39,25 @@ export function createPtyClient(api: OpenCodeClient, options: PtyClientOptions)
     },
   }
 }
+
+export function createPersistentPtyClient(api: OpenCodeClient, options: PtyClientOptions) {
+  return {
+    async connect(input: PersistentPtyConnectInput) {
+      const token = await api.experimental.persistentPty.connectToken({
+        ptyID: input.ptyID,
+        "x-opencode-ticket": "1",
+      })
+      const url = new URL(`/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect`, options.url)
+      url.searchParams.set("ticket", token.ticket)
+      url.searchParams.set("cursor", String(input.cursor))
+      url.searchParams.set("attachment_id", input.attachmentID)
+      url.searchParams.set("takeover", String(input.takeover ?? false))
+      url.searchParams.set("input_protocol", "1")
+      url.protocol = url.protocol === "https:" ? "wss:" : "ws:"
+
+      const socket = options.openSocket?.(url) ?? new WebSocket(url)
+      socket.binaryType = "arraybuffer"
+      return socket
+    },
+  }
+}

packages/client/test/solid-data.test.ts

@@ -414,6 +414,77 @@ test("loads bounded message pages", async () => {
   }
 })
 
+test("preserves assistant content replacement events across an active message read", async () => {
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  const release = Promise.withResolvers<void>()
+  let requests = 0
+  const content = [
+    { type: "text" as const, text: "replacement" },
+    { type: "reasoning" as const, text: "reasoning", time: { created: 3 } },
+  ]
+  const api = OpenCode.make({
+    baseUrl: "http://opencode.local",
+    fetch: async () => {
+      const current = ++requests
+      if (current === 2) await release.promise
+      return Response.json({
+        data: [
+          {
+            id: "msg_assistant",
+            type: "assistant",
+            agent: "build",
+            model: { id: "model", providerID: "provider" },
+            content: current === 3 ? content : [{ type: "text", text: "original" }],
+            time: { created: 1, completed: 2 },
+          },
+        ],
+        cursor: {},
+      })
+    },
+  })
+  const setup = createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/project",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    dispose,
+  }))
+
+  try {
+    await setup.data.session.message.sync("ses_refresh")
+    setup.data.session.message.invalidate("ses_refresh")
+    const stale = setup.data.session.message.sync("ses_refresh")
+    await wait(() => requests === 2)
+    const updated: OpenCodeEvent = {
+      id: "evt_message_updated",
+      created: 3,
+      type: "session.message.content.updated",
+      durable: { aggregateID: "ses_refresh", seq: 3, version: 1 },
+      data: {
+        sessionID: "ses_refresh",
+        messageID: "msg_assistant",
+        content,
+      },
+    }
+    listeners.forEach((listener) => listener({ name: updated.type, details: updated }))
+
+    expect(setup.data.session.message.list("ses_refresh")[0]).toMatchObject({ content })
+    release.resolve()
+    await stale
+    await wait(() => requests === 3)
+    expect(setup.data.session.message.list("ses_refresh")[0]).toMatchObject({ content })
+  } finally {
+    setup.dispose()
+  }
+})
+
 async function wait(check: () => boolean) {
   const started = Date.now()
   while (!check()) {

packages/client/test/solid-pty.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { OpenCode } from "../src/promise"
-import { createPtyClient } from "../src/solid"
+import { createPersistentPtyClient, createPtyClient } from "../src/solid"
 
 describe("createPtyClient", () => {
   test("mints an authenticated ticket before opening the terminal socket", async () => {
@@ -66,3 +66,36 @@ describe("createPtyClient", () => {
     expect(opened).toBe(false)
   })
 })
+
+describe("createPersistentPtyClient", () => {
+  test("mints an authenticated ticket before opening the persistent terminal socket", async () => {
+    let request: Request | undefined
+    let socketURL: URL | undefined
+    const socket = { binaryType: "blob" } as unknown as WebSocket
+    const api = OpenCode.make({
+      baseUrl: "https://server.example/base",
+      headers: { Authorization: "Basic credential" },
+      fetch: async (input, init) => {
+        request = input instanceof Request ? input : new Request(input, init)
+        return Response.json({ data: { ticket: "persistent-ticket", expires_in: 60 } })
+      },
+    })
+    const pty = createPersistentPtyClient(api, {
+      url: "https://server.example/base",
+      openSocket(url) {
+        socketURL = url
+        return socket
+      },
+    })
+
+    expect(await pty.connect({ ptyID: "pty_1", cursor: 42, attachmentID: "attachment_1", takeover: true })).toBe(socket)
+    expect(request?.method).toBe("POST")
+    expect(request?.url).toBe("https://server.example/api/experimental/persistent-pty/pty_1/connect-token")
+    expect(request?.headers.get("authorization")).toBe("Basic credential")
+    expect(request?.headers.get("x-opencode-ticket")).toBe("1")
+    expect(socketURL?.toString()).toBe(
+      "wss://server.example/api/experimental/persistent-pty/pty_1/connect?ticket=persistent-ticket&cursor=42&attachment_id=attachment_1&takeover=true&input_protocol=1",
+    )
+    expect(socket.binaryType).toBe("arraybuffer")
+  })
+})

packages/core/package.json

@@ -105,7 +105,6 @@
     "@ai-sdk/cohere": "3.0.27",
     "@ai-sdk/gateway": "3.0.104",
     "@ai-sdk/google-vertex": "4.0.128",
-    "@ai-sdk/groq": "3.0.31",
     "@ai-sdk/mistral": "3.0.51",
     "@ai-sdk/openai-compatible": "2.0.41",
     "@ai-sdk/perplexity": "3.0.26",
@@ -119,7 +118,7 @@
     "@ff-labs/fff-node": "0.10.5",
     "@opencode-ai/codemode": "workspace:*",
     "@opencode-ai/ai": "workspace:*",
-    "@opencode-ai/pty": "0.1.8",
+    "@opencode-ai/pty": "0.1.10",
     "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/util": "workspace:*",

packages/core/src/aisdk-native.ts

@@ -55,6 +55,7 @@ export function map(input: MapInput): Mapping | undefined {
       }
     case "@ai-sdk/cerebras":
     case "@ai-sdk/deepinfra":
+    case "@ai-sdk/groq":
     case "@ai-sdk/togetherai":
       return {
         package: `@opencode-ai/ai/providers/${input.packageName.slice("@ai-sdk/".length)}`,

packages/core/src/job.ts

@@ -1,11 +1,41 @@
 export * as Job from "./job.js"
 
-import { Cause, Clock, Context, Deferred, Effect, Exit, Layer, Scope, SynchronizedRef } from "effect"
+import { Array, Cause, Clock, Context, Deferred, Effect, Exit, Layer, Schema, Scope, SynchronizedRef } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Identifier } from "./id/id.js"
+import { KV } from "./kv.js"
+import { SessionMessage } from "./session/message.js"
 import { SessionSchema } from "./session/schema.js"
 
-export type Status = "running" | "completed" | "error" | "cancelled"
+const Background = Schema.Struct({
+  id: Schema.String,
+  notificationID: SessionMessage.ID,
+  recovery: Schema.Union([
+    Schema.Struct({
+      kind: Schema.Literal("shell"),
+      sessionID: SessionSchema.ID,
+      shellID: Schema.String,
+      command: Schema.String,
+    }),
+    Schema.Struct({
+      kind: Schema.Literal("subagent"),
+      parentSessionID: SessionSchema.ID,
+      childSessionID: SessionSchema.ID,
+      agent: Schema.String,
+      description: Schema.String,
+    }),
+  ]),
+  status: Schema.Literals(["running", "completed", "error", "cancelled"]),
+  output: Schema.optionalKey(Schema.String),
+  error: Schema.optionalKey(Schema.String),
+})
+
+export type Background = typeof Background.Type
+export type Recovery = Background["recovery"]
+export type Status = Background["status"]
+
+const decodeBackground = Schema.decodeUnknownResult(Background)
+const backgroundPrefix = "job.background/"
 
 export type Info = {
   id: string
@@ -17,6 +47,7 @@ export type Info = {
   output?: string
   error?: string
   metadata?: Record<string, unknown>
+  notificationID?: SessionMessage.ID
 }
 
 type Active = {
@@ -27,6 +58,7 @@ type Active = {
   token: object
   blockingSessions: Map<SessionSchema.ID, number>
   isBackgrounded: boolean
+  recovery?: Recovery
 }
 
 type State = {
@@ -63,6 +95,8 @@ export type StartInput = {
   type: string
   title?: string
   metadata?: Record<string, unknown>
+  recovery?: Recovery
+  notificationID?: SessionMessage.ID
   run: Effect.Effect<string, unknown>
 }
 
@@ -96,6 +130,8 @@ export interface Interface {
   readonly background: (id: string) => Effect.Effect<Info | undefined>
   readonly backgroundAll: (input: BackgroundAllInput) => Effect.Effect<Info[]>
   readonly cancel: (id: string) => Effect.Effect<Info | undefined>
+  readonly pendingBackground: Effect.Effect<readonly Background[]>
+  readonly completeBackground: (notificationID: SessionMessage.ID) => Effect.Effect<void>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Job") {}
@@ -126,43 +162,57 @@ function decrementSession(input: Map<SessionSchema.ID, number>, sessionID: Sessi
 }
 
 /**
- * Makes one scoped, process-local registry. Entries are intentionally not
- * durable: process restart or owner-scope closure loses status and interrupts
- * live work. Persisted observation, restart recovery, and remote workers need a
- * separate durable ownership slice rather than pretending this registry has
- * those semantics.
+ * Makes one scoped, process-local registry. Explicitly recoverable background
+ * work also owns a durable notification marker until its notification is admitted.
  */
 export const make = Effect.gen(function* () {
+  const kv = yield* KV.Service
   const state: State = {
     jobs: yield* SynchronizedRef.make(new Map()),
     scope: yield* Scope.Scope,
   }
 
+  const persistBackground = Effect.fnUntraced(function* (job: Active) {
+    if (!job.recovery || !job.info.notificationID) return
+    yield* kv.set(`${backgroundPrefix}${job.info.notificationID}`, {
+      id: job.info.id,
+      notificationID: job.info.notificationID,
+      recovery: job.recovery,
+      status: job.info.status,
+      ...(job.info.output !== undefined ? { output: job.info.output } : {}),
+      ...(job.info.error !== undefined ? { error: job.info.error } : {}),
+    })
+  })
+
   const settle = Effect.fnUntraced(function* (id: string, token: object, exit: Exit.Exit<string, unknown>) {
     const completed_at = yield* Clock.currentTimeMillis
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
-      const job = jobs.get(id)
-      if (!job) return [{}, jobs]
-      if (job.token !== token) return [{}, jobs]
-      if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
-      const status: Exclude<Status, "running"> = Exit.isSuccess(exit)
-        ? "completed"
-        : Cause.hasInterruptsOnly(exit.cause)
-          ? "cancelled"
-          : "error"
-      const next = {
-        ...job,
-        blockingSessions: new Map<SessionSchema.ID, number>(),
-        info: {
-          ...job.info,
-          status,
-          completed_at,
-          ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
-          ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
-        },
-      }
-      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
-    })
+    const result = yield* SynchronizedRef.modifyEffect(
+      state.jobs,
+      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [FinishResult, Map<string, Active>]> {
+        const job = jobs.get(id)
+        if (!job) return [{}, jobs]
+        if (job.token !== token) return [{}, jobs]
+        if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
+        const status: Exclude<Status, "running"> = Exit.isSuccess(exit)
+          ? "completed"
+          : Cause.hasInterruptsOnly(exit.cause)
+            ? "cancelled"
+            : "error"
+        const next = {
+          ...job,
+          blockingSessions: new Map<SessionSchema.ID, number>(),
+          info: {
+            ...job.info,
+            status,
+            completed_at,
+            ...(Exit.isSuccess(exit) ? { output: exit.value } : {}),
+            ...(Exit.isFailure(exit) ? { error: errorText(Cause.squash(exit.cause)) } : {}),
+          },
+        }
+        if (status !== "cancelled") yield* persistBackground(next)
+        return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+      }),
+    )
     if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
     if (result.scope) {
       yield* Scope.close(result.scope, Exit.void).pipe(Effect.forkIn(state.scope, { startImmediately: true }))
@@ -170,22 +220,6 @@ export const make = Effect.gen(function* () {
     return result.info
   })
 
-  const fork = Effect.fnUntraced(function* (
-    scope: Scope.Scope,
-    id: string,
-    token: object,
-    run: Effect.Effect<string, unknown>,
-  ) {
-    return yield* run.pipe(
-      Effect.matchCauseEffect({
-        onSuccess: (output) => settle(id, token, Exit.succeed(output)),
-        onFailure: (cause) => settle(id, token, Exit.failCause(cause)),
-      }),
-      Effect.asVoid,
-      Effect.forkIn(scope, { startImmediately: true }),
-    )
-  })
-
   const get: Interface["get"] = Effect.fn("Job.get")(function* (id) {
     const job = (yield* SynchronizedRef.get(state.jobs)).get(id)
     if (!job) return undefined
@@ -201,10 +235,10 @@ export const make = Effect.gen(function* () {
         const backgrounded = yield* Deferred.make<Info>()
         const result = yield* SynchronizedRef.modifyEffect(
           state.jobs,
-          Effect.fnUntraced(function* (jobs) {
+          Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [StartResult, Map<string, Active>]> {
             const existing = jobs.get(id)
             if (existing?.info.status === "running") {
-              return [{ info: snapshot(existing) }, jobs] as readonly [StartResult, Map<string, Active>]
+              return [{ info: snapshot(existing) }, jobs]
             }
             const scope = yield* Scope.fork(state.scope, "parallel")
             const token = {}
@@ -216,6 +250,7 @@ export const make = Effect.gen(function* () {
                 status: "running" as const,
                 started_at,
                 metadata: input.metadata,
+                ...(input.notificationID ? { notificationID: input.notificationID } : {}),
               },
               done,
               backgrounded,
@@ -223,14 +258,18 @@ export const make = Effect.gen(function* () {
               token,
               blockingSessions: new Map<SessionSchema.ID, number>(),
               isBackgrounded: false,
+              recovery: input.recovery,
             }
-            return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)] as readonly [
-              StartResult,
-              Map<string, Active>,
-            ]
+            return [{ info: snapshot(job), scope, token }, new Map(jobs).set(id, job)]
           }),
         )
-        if ("scope" in result) yield* fork(result.scope, id, result.token, restore(input.run))
+        if ("scope" in result)
+          yield* restore(input.run).pipe(
+            Effect.exit,
+            Effect.flatMap((exit) => settle(id, result.token, exit)),
+            Effect.asVoid,
+            Effect.forkIn(result.scope, { startImmediately: true }),
+          )
         return result.info
       }),
     )
@@ -281,20 +320,31 @@ export const make = Effect.gen(function* () {
     ).pipe(Effect.ensuring(removeBlock(input)))
   })
 
-  const background: Interface["background"] = Effect.fn("Job.background")(function* (id) {
-    const result = yield* SynchronizedRef.modify(
-      state.jobs,
-      (jobs): readonly [BackgroundResult, Map<string, Active>] => {
-        const job = jobs.get(id)
-        if (!job || job.info.status !== "running") return [{}, jobs]
-        if (job.isBackgrounded) return [{ info: snapshot(job) }, jobs]
-        const next = {
-          ...job,
-          isBackgrounded: true,
-          blockingSessions: new Map<SessionSchema.ID, number>(),
-        }
-        return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)]
+  const markBackground = Effect.fnUntraced(function* (job: Active) {
+    const next = {
+      ...job,
+      isBackgrounded: true,
+      blockingSessions: new Map<SessionSchema.ID, number>(),
+      info: {
+        ...job.info,
+        ...(job.recovery ? { notificationID: job.info.notificationID ?? SessionMessage.ID.create() } : {}),
       },
+    }
+    yield* persistBackground(next)
+    return next
+  })
+
+  const background: Interface["background"] = Effect.fn("Job.background")(function* (id) {
+    const result = yield* SynchronizedRef.modifyEffect(
+      state.jobs,
+      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [BackgroundResult, Map<string, Active>]> {
+        const job = jobs.get(id)
+        // Recoverable work may finish before the caller backgrounds it.
+        if (!job || (job.info.status !== "running" && !job.recovery)) return [{}, jobs]
+        if (job.isBackgrounded) return [{ info: snapshot(job) }, jobs]
+        const next = yield* markBackground(job)
+        return [{ info: snapshot(next), backgrounded: job.backgrounded }, new Map(jobs).set(id, next)]
+      }),
     )
     if (result.info && result.backgrounded)
       yield* Deferred.succeed(result.backgrounded, result.info).pipe(Effect.ignore)
@@ -302,60 +352,83 @@ export const make = Effect.gen(function* () {
   })
 
   const backgroundAll: Interface["backgroundAll"] = Effect.fn("Job.backgroundAll")(function* (input) {
-    const result = yield* SynchronizedRef.modify(
+    const result = yield* SynchronizedRef.modifyEffect(
       state.jobs,
-      (jobs): readonly [BackgroundResult[], Map<string, Active>] => {
-        const results: BackgroundResult[] = []
+      Effect.fnUntraced(function* (jobs): Effect.fn.Return<
+        readonly [Required<BackgroundResult>[], Map<string, Active>]
+      > {
+        const results: Required<BackgroundResult>[] = []
         const next = new Map(jobs)
         for (const [id, job] of jobs) {
           if (job.info.status !== "running") continue
           if (job.isBackgrounded) continue
           if (input.type !== undefined && job.info.type !== input.type) continue
           if (!job.blockingSessions.has(input.sessionID)) continue
-          const updated = {
-            ...job,
-            isBackgrounded: true,
-            blockingSessions: new Map<SessionSchema.ID, number>(),
-          }
+          const updated = yield* markBackground(job)
           results.push({ info: snapshot(updated), backgrounded: job.backgrounded })
           next.set(id, updated)
         }
         return [results, next]
-      },
+      }),
     )
-    yield* Effect.forEach(
-      result,
-      (item) => (item.info && item.backgrounded ? Deferred.succeed(item.backgrounded, item.info) : Effect.void),
-      { discard: true },
-    )
-    return result.flatMap((item) => (item.info ? [item.info] : []))
+    yield* Effect.forEach(result, (item) => Deferred.succeed(item.backgrounded, item.info), { discard: true })
+    return result.map((item) => item.info)
   })
 
   const cancel: Interface["cancel"] = Effect.fn("Job.cancel")(function* (id) {
     const completed_at = yield* Clock.currentTimeMillis
-    const result = yield* SynchronizedRef.modify(state.jobs, (jobs): readonly [FinishResult, Map<string, Active>] => {
-      const job = jobs.get(id)
-      if (!job) return [{}, jobs]
-      if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
-      const next = {
-        ...job,
-        blockingSessions: new Map<SessionSchema.ID, number>(),
-        info: {
-          ...job.info,
-          status: "cancelled" as const,
-          completed_at,
-        },
-      }
-      return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
-    })
+    const result = yield* SynchronizedRef.modifyEffect(
+      state.jobs,
+      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [FinishResult, Map<string, Active>]> {
+        const job = jobs.get(id)
+        if (!job) return [{}, jobs]
+        if (job.info.status !== "running") return [{ info: snapshot(job) }, jobs]
+        const next = {
+          ...job,
+          blockingSessions: new Map<SessionSchema.ID, number>(),
+          info: {
+            ...job.info,
+            status: "cancelled" as const,
+            completed_at,
+          },
+        }
+        yield* persistBackground(next)
+        return [{ info: snapshot(next), done: job.done, scope: job.scope }, new Map(jobs).set(id, next)]
+      }),
+    )
     if (result.info && result.done) yield* Deferred.succeed(result.done, result.info).pipe(Effect.ignore)
     if (result.scope) yield* Scope.close(result.scope, Exit.void)
     return result.info
   })
 
-  return Service.of({ get, start, wait, block, background, backgroundAll, cancel })
+  const pendingBackground: Interface["pendingBackground"] = Effect.gen(function* () {
+    const recovered: Background[] = []
+    let after: string | undefined
+    do {
+      const page = yield* kv.scan({ prefix: backgroundPrefix, after })
+      recovered.push(...Array.filterMap(page.entries, (entry) => decodeBackground(entry.value)))
+      after = page.next
+    } while (after)
+    return recovered
+  }).pipe(Effect.withSpan("Job.pendingBackground"))
+
+  const completeBackground: Interface["completeBackground"] = Effect.fn("Job.completeBackground")((notificationID) =>
+    kv.remove(`${backgroundPrefix}${notificationID}`),
+  )
+
+  return Service.of({
+    get,
+    start,
+    wait,
+    block,
+    background,
+    backgroundAll,
+    cancel,
+    pendingBackground,
+    completeBackground,
+  })
 })
 
 const layer = Layer.effect(Service, make)
 
-export const node = makeGlobalNode({ service: Service, layer, deps: [] })
+export const node = makeGlobalNode({ service: Service, layer, deps: [KV.node] })

packages/core/src/model-resolver.ts

@@ -337,6 +337,7 @@ function usesAPIKeyAuth(packageName: string | undefined) {
     name === "@ai-sdk/deepinfra" ||
     name === "@ai-sdk/openai-compatible" ||
     name === "@ai-sdk/google" ||
+    name === "@ai-sdk/groq" ||
     name === "@ai-sdk/togetherai" ||
     name === "@ai-sdk/xai" ||
     name === "@openrouter/ai-sdk-provider" ||
@@ -349,6 +350,7 @@ function usesAPIKeyAuth(packageName: string | undefined) {
     name === "@opencode-ai/ai/providers/deepinfra" ||
     name === "@opencode-ai/ai/providers/openai-compatible" ||
     name === "@opencode-ai/ai/providers/google" ||
+    name === "@opencode-ai/ai/providers/groq" ||
     name === "@opencode-ai/ai/providers/togetherai" ||
     name === "@opencode-ai/ai/providers/xai" ||
     name === "@opencode-ai/ai/providers/openrouter" ||

packages/core/src/plugin.ts

@@ -161,7 +161,7 @@ const layer = Layer.effect(
     yield* Effect.addFinalizer((exit) =>
       Effect.gen(function* () {
         active.clear()
-        yield* State.batch(Scope.close(scope, exit))
+        yield* State.batch(Scope.close(scope, exit), { flush: false })
       }),
     )
 

packages/core/src/plugin/provider.ts

@@ -11,7 +11,6 @@ import { GatewayPlugin } from "./provider/gateway.js"
 import { GithubCopilotPlugin } from "./provider/github-copilot.js"
 import { GitLabPlugin } from "./provider/gitlab.js"
 import { GoogleVertexPlugin } from "./provider/google-vertex.js"
-import { GroqPlugin } from "./provider/groq.js"
 import { KiloPlugin } from "./provider/kilo.js"
 import { LLMGatewayPlugin } from "./provider/llmgateway.js"
 import { LMStudioPlugin } from "./provider/lmstudio.js"
@@ -45,7 +44,6 @@ export const ProviderPlugins: PluginInternal.InternalPlugin[] = [
   GithubCopilotPlugin,
   GitLabPlugin,
   GoogleVertexPlugin,
-  GroqPlugin,
   KiloPlugin,
   LLMGatewayPlugin,
   LMStudioPlugin,

packages/core/src/plugin/provider/groq.ts

@@ -1,10 +0,0 @@
-import { createProviderPlugin } from "./factory.js"
-
-export const GroqPlugin = createProviderPlugin({
-  id: "opencode.provider.groq",
-  package: "@ai-sdk/groq",
-  load: async (options) => {
-    const { createGroq } = await import("@ai-sdk/groq")
-    return createGroq(options)
-  },
-})

packages/core/src/plugin/runtime.ts

@@ -29,7 +29,7 @@ export interface Interface {
     | "wait"
     | "context"
   >
-  readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel">
+  readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel" | "completeBackground">
   readonly location: {
     readonly agent: {
       readonly list: (
@@ -92,6 +92,8 @@ export const layerWithCell = (cell: Cell) =>
         block: (input) => require(cell, (runtime) => runtime.job.block(input)),
         background: (id) => require(cell, (runtime) => runtime.job.background(id)),
         cancel: (id) => require(cell, (runtime) => runtime.job.cancel(id)),
+        completeBackground: (notificationID) =>
+          require(cell, (runtime) => runtime.job.completeBackground(notificationID)),
       },
       location: {
         agent: {

packages/core/src/provider.ts

@@ -62,6 +62,7 @@ const builtins = new Map<string, () => Promise<unknown>>([
     "@opencode-ai/ai/providers/google-vertex/messages",
     () => import("@opencode-ai/ai/providers/google-vertex/messages"),
   ],
+  ["@opencode-ai/ai/providers/groq", () => import("@opencode-ai/ai/providers/groq")],
   ["@opencode-ai/ai/providers/openai", () => import("@opencode-ai/ai/providers/openai")],
   ["@opencode-ai/ai/providers/openai/chat", () => import("@opencode-ai/ai/providers/openai/chat")],
   ["@opencode-ai/ai/providers/openai/responses", () => import("@opencode-ai/ai/providers/openai/responses")],

packages/core/src/session.ts

@@ -139,6 +139,27 @@ export class CompactionConflictError extends Schema.TaggedError<CompactionConfli
 export class BusyError extends Schema.TaggedError<BusyError>()("Session.BusyError", {
   sessionID: SessionSchema.ID,
 }) {}
+export class MessageNotAssistantError extends Schema.TaggedError<MessageNotAssistantError>()(
+  "Session.MessageNotAssistantError",
+  {
+    sessionID: SessionSchema.ID,
+    messageID: SessionMessage.ID,
+  },
+) {}
+export class MessageIncompleteError extends Schema.TaggedError<MessageIncompleteError>()(
+  "Session.MessageIncompleteError",
+  {
+    sessionID: SessionSchema.ID,
+    messageID: SessionMessage.ID,
+  },
+) {}
+export class MessageToolIncompleteError extends Schema.TaggedError<MessageToolIncompleteError>()(
+  "Session.MessageToolIncompleteError",
+  {
+    sessionID: SessionSchema.ID,
+    messageID: SessionMessage.ID,
+  },
+) {}
 export class InboxConflictError extends Schema.TaggedError<InboxConflictError>()("Session.InboxConflictError", {
   sessionID: SessionSchema.ID,
   inboxID: SessionMessage.ID,
@@ -193,6 +214,19 @@ export interface Interface {
     sessionID: SessionSchema.ID
     messageID: SessionMessage.ID
   }) => Effect.Effect<SessionMessage.Info | undefined>
+  readonly updateMessage: (input: {
+    readonly sessionID: SessionSchema.ID
+    readonly messageID: SessionMessage.ID
+    readonly content: readonly SessionMessage.AssistantContent[]
+  }) => Effect.Effect<
+    SessionMessage.Assistant,
+    | NotFoundError
+    | MessageNotFoundError
+    | BusyError
+    | MessageNotAssistantError
+    | MessageIncompleteError
+    | MessageToolIncompleteError
+  >
   readonly context: (
     sessionID: SessionSchema.ID,
   ) => Effect.Effect<SessionMessage.Info[], NotFoundError | MessageDecodeError>
@@ -560,6 +594,29 @@ const layer = Layer.effect(
         const stored = yield* store.message(input.messageID)
         return stored?.sessionID === input.sessionID ? stored.message : undefined
       }),
+      updateMessage: Effect.fn("Session.updateMessage")(function* (input) {
+        const ref = { sessionID: input.sessionID, messageID: input.messageID }
+        yield* result.get(ref.sessionID)
+        if ((yield* execution.active).has(ref.sessionID)) return yield* new BusyError({ sessionID: ref.sessionID })
+        const message = yield* result.message(ref)
+        if (!message) return yield* new MessageNotFoundError(ref)
+        if (message.type !== "assistant") return yield* new MessageNotAssistantError(ref)
+        if (!message.time.completed) return yield* new MessageIncompleteError(ref)
+        if (
+          input.content.some(
+            (content) =>
+              content.type === "tool" && (content.state.status === "streaming" || content.state.status === "running"),
+          )
+        )
+          return yield* new MessageToolIncompleteError(ref)
+        yield* bus.publish(SessionEvent.MessageContentUpdated, {
+          ...ref,
+          content: Schema.encodeSync(Schema.Array(SessionMessage.AssistantContent))(input.content),
+        })
+        const updated = yield* result.message(ref)
+        if (updated?.type !== "assistant") return yield* new MessageNotFoundError(ref)
+        return updated
+      }),
       context: Effect.fn("Session.context")(function* (sessionID) {
         yield* result.get(sessionID)
         return yield* store.context(sessionID)

packages/core/src/session/execution.ts

@@ -3,6 +3,7 @@ export * as SessionExecution from "./execution.js"
 import { Cause, Context, Effect, Exit, Layer } from "effect"
 import { Bus } from "../bus.js"
 import { Database } from "../database/database.js"
+import { Job } from "../job.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { SessionEvent } from "./event.js"
@@ -52,6 +53,7 @@ export const layer = Layer.effect(
     const store = yield* SessionStore.Service
     const locations = yield* LocationServiceMap.Service
     const bus = yield* Bus.Service
+    const jobs = yield* Job.Service
     const db = (yield* Database.Service).db
     const reportLifecycle = <A>(sessionID: SessionSchema.ID, effect: Effect.Effect<A>) =>
       effect.pipe(
@@ -94,7 +96,7 @@ export const layer = Layer.effect(
               : Effect.logError("Failed to drain Session", cause).pipe(Effect.annotateLogs({ sessionID })),
           ),
         )
-        if (result.type === "complete") return
+        if (result._tag === "Complete") return
         return yield* drain(sessionID, false, result.continuation, promotable)
       })
     }
@@ -118,6 +120,7 @@ export const layer = Layer.effect(
             if (outcome.type === "interrupted") {
               // A user cancel releases the claim: the turn must not resurrect at the next
               // boot. Shutdown interruption keeps it for restart continuity.
+              if (outcome.reason === "user") yield* jobs.cancel(sessionID)
               yield* bus.publish(
                 SessionEvent.Execution.Interrupted,
                 { sessionID, reason: outcome.reason },
@@ -167,7 +170,7 @@ export const layer = Layer.effect(
 export const node = makeGlobalNode({
   service: Service,
   layer,
-  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node],
+  deps: [SessionStore.node, LocationServiceMap.node, Bus.node, Database.node, Job.node],
 })
 
 /** Low-level compatibility layer for callers that only need durable Session recording. */

packages/core/src/session/execution/restart.ts

@@ -3,6 +3,8 @@ export * as SessionRestart from "./restart.js"
 import { Context, Effect, Layer } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "../../bus.js"
+import { Job } from "../../job.js"
+import { Session } from "../../session.js"
 import { SessionEvent } from "../event.js"
 import { SessionExecution } from "../execution.js"
 import { SessionSchema } from "../schema.js"
@@ -45,6 +47,9 @@ export interface Interface {
  * process: crash, SIGKILL, isolate eviction, and graceful restart all leave
  * the same durable signature.
  *
+ * Recovery is at-least-once: local coordination prevents concurrent drains,
+ * not repeated external side effects after a crash.
+ *
  * The sweep assumes every orphaned claim's owner is dead. The managed-server
  * protocol guarantees this: a successor is only spawned after the previous
  * process is confirmed dead (client service `kill`/`evict` poll the PID), the
@@ -62,14 +67,16 @@ export const layer = (options?: Options) =>
       const store = yield* SessionStore.Service
       const execution = yield* SessionExecution.Service
       const bus = yield* Bus.Service
+      const jobs = yield* Job.Service
+      const sessions = yield* Session.Service
       const scope = yield* Effect.scope
       const maxAttempts = options?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS
 
-      const resumeOne = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
+      const prepareResume = Effect.fnUntraced(function* (sessionID: SessionSchema.ID) {
         // Durable before the resume runs, so a crash inside the resumed turn is
         // counted by the next sweep and the budget cannot be dodged.
         const attempts = yield* store.countResume(sessionID)
-        if (attempts === undefined) return // the Session was deleted since listing
+        if (attempts === undefined) return false
         if (attempts > maxAttempts) {
           // Terminalize instead: the release hook clears the claim and resets the
           // counter atomically with the terminal event.
@@ -78,31 +85,166 @@ export const layer = (options?: Options) =>
             { sessionID, error: RESUME_EXHAUSTED },
             { commit: () => store.release(sessionID) },
           )
-          return
+          return false
         }
         yield* bus.publish(SessionEvent.Synthetic, {
           sessionID,
           text: CONTINUE_AFTER_SERVER_RESTART,
           description: "Continuing after restart",
         })
-        // Forked into the service scope so boot never waits on resumed turns;
-        // resuming an already-live Session joins its execution. Drain failures
-        // are logged and durably recorded by the execution layer.
-        yield* execution.resume(sessionID).pipe(Effect.ignore, Effect.forkIn(scope))
+        return true
+      })
+
+      const recoverShell = Effect.fnUntraced(function* (
+        background: Job.Background,
+        recovery: Extract<Job.Recovery, { kind: "shell" }>,
+      ) {
+        const state = background.status === "running" ? "cancelled" : background.status
+        const text =
+          background.status === "running"
+            ? "Command cancelled because the server restarted"
+            : state === "completed"
+              ? (background.output ?? "Command completed")
+              : state === "error"
+                ? (background.error ?? "Command failed")
+                : "Command cancelled"
+
+        yield* sessions
+          .synthetic({
+            id: background.notificationID,
+            sessionID: recovery.sessionID,
+            description: recovery.command,
+            text: `<shell id="${background.id}" state="${state}" command="${recovery.command}">\n${text}\n</shell>`,
+            metadata: {
+              source: "shell",
+              jobID: background.id,
+              shellID: recovery.shellID,
+              state,
+            },
+            resume: false,
+          })
+          .pipe(
+            Effect.catchTag("Session.NotFoundError", () => Effect.void),
+            Effect.orDie,
+          )
+        yield* jobs.completeBackground(background.notificationID)
+      })
+
+      const recoverSubagent = Effect.fnUntraced(function* (
+        background: Job.Background,
+        recovery: Extract<Job.Recovery, { kind: "subagent" }>,
+        suspended: ReadonlySet<SessionSchema.ID>,
+      ) {
+        const child = yield* store.get(recovery.childSessionID)
+        if (!child || child.parentID !== recovery.parentSessionID || !(yield* store.get(recovery.parentSessionID))) {
+          yield* jobs.completeBackground(background.notificationID)
+          return
+        }
+
+        const notify = Effect.fnUntraced(function* (result: Pick<Job.Background, "status" | "output" | "error">) {
+          if (result.status === "running") return
+          const text =
+            result.status === "completed"
+              ? (result.output ?? "Subagent completed without a text response.")
+              : result.status === "error"
+                ? (result.error ?? "Subagent failed")
+                : "Subagent cancelled"
+          yield* sessions
+            .synthetic({
+              id: background.notificationID,
+              sessionID: recovery.parentSessionID,
+              ...(suspended.has(recovery.parentSessionID) ? { resume: false } : {}),
+              description: recovery.description,
+              text: `<subagent sessionID="${recovery.childSessionID}" state="${result.status}" description="${recovery.description}">\n${text}\n</subagent>`,
+              metadata: {
+                source: "subagent",
+                childID: recovery.childSessionID,
+                agent: recovery.agent,
+                state: result.status,
+              },
+            })
+            .pipe(Effect.orDie)
+          yield* jobs.completeBackground(background.notificationID)
+        })
+
+        if (background.status !== "running") {
+          yield* notify(background)
+          return
+        }
+        if ((yield* execution.active).has(recovery.childSessionID)) return
+        if (!(yield* prepareResume(recovery.childSessionID))) {
+          yield* notify({ status: "error", error: RESUME_EXHAUSTED.message })
+          return
+        }
+
+        yield* jobs.start({
+          id: background.id,
+          type: "subagent",
+          title: recovery.description,
+          notificationID: background.notificationID,
+          recovery,
+          run: execution.resume(recovery.childSessionID).pipe(
+            Effect.andThen(store.context(recovery.childSessionID)),
+            Effect.map((messages) => {
+              const assistant = messages.findLast(
+                (message) =>
+                  message.type === "assistant" && message.time.completed !== undefined && message.error === undefined,
+              )
+              if (assistant?.type !== "assistant") return "Subagent completed without a text response."
+              return (
+                assistant.content
+                  .filter((part) => part.type === "text")
+                  .map((part) => part.text)
+                  .join("") || "Subagent completed without a text response."
+              )
+            }),
+          ),
+        })
+        yield* jobs.background(background.id)
+        yield* jobs.wait({ id: background.id }).pipe(
+          Effect.flatMap((result) => (result.info ? notify(result.info) : Effect.void)),
+          Effect.ignore,
+          Effect.forkIn(scope),
+        )
       })
 
       return Service.of({
         resumeSuspendedSessions: Effect.gen(function* () {
-          // Child claims never drive recovery (children are not resumed), so a
-          // dead child's claim is noise no terminal will ever release. Clearing
-          // is safe even against a live child: claims are recovery markers, not
-          // locks, and children are excluded from that recovery.
-          yield* store.releaseChildClaims
           const active = yield* execution.active
-          // Sessions already draining in this process keep their claim; resuming
-          // them would only inject a stray continuation into a live turn.
-          const orphaned = (yield* store.listSuspended()).filter((sessionID) => !active.has(sessionID))
-          yield* Effect.forEach(orphaned, resumeOne, { concurrency: "unbounded", discard: true })
+          // Early notices wait for root recovery's accounting, including roots that exhaust their budget.
+          const suspended = new Set((yield* store.listSuspended()).filter((sessionID) => !active.has(sessionID)))
+          const pending = yield* jobs.pendingBackground
+          yield* store.releaseChildClaims(
+            pending.flatMap((background) =>
+              background.status === "running" && background.recovery.kind === "subagent"
+                ? [background.recovery.childSessionID]
+                : [],
+            ),
+          )
+          yield* Effect.forEach(
+            pending,
+            Effect.fnUntraced(function* (background) {
+              if ((yield* jobs.get(background.id))?.status === "running") return
+              const recovery = background.recovery
+              yield* recovery.kind === "shell"
+                ? recoverShell(background, recovery)
+                : recoverSubagent(background, recovery, suspended)
+            }),
+            { discard: true },
+          )
+
+          // Background completion can wake a parent, so inspect local ownership only after recovery.
+          const resumed = yield* execution.active
+          yield* Effect.forEach(
+            (yield* store.listSuspended()).filter((sessionID) => !resumed.has(sessionID)),
+            (sessionID) =>
+              execution
+                .resume(sessionID)
+                .pipe(Effect.ignore, Effect.forkIn(scope), Effect.when(prepareResume(sessionID))),
+            { concurrency: "unbounded", discard: true },
+          )
+          // Async observers consult this set at delivery; later completions wake parents normally.
+          suspended.clear()
         }),
       })
     }),
@@ -111,5 +253,5 @@ export const layer = (options?: Options) =>
 export const node = makeGlobalNode({
   service: Service,
   layer: layer(),
-  deps: [SessionStore.node, SessionExecution.node, Bus.node],
+  deps: [SessionStore.node, SessionExecution.node, Bus.node, Job.node, Session.node],
 })

packages/core/src/session/message-updater.ts

@@ -1,5 +1,5 @@
 import { castDraft, produce, type WritableDraft } from "immer"
-import { DateTime, Effect, Match, pipe } from "effect"
+import { DateTime, Effect, Match, pipe, Schema } from "effect"
 import { SessionEvent } from "./event.js"
 import { SessionMessage } from "./message.js"
 
@@ -71,6 +71,12 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
     Match.discriminatorsExhaustive("type")({
       "session.created": () => Effect.void,
       "session.viewed": () => Effect.void,
+      "session.message.content.updated": (event) =>
+        updateOwnedAssistant(event.data.messageID, (draft) => {
+          draft.content = castDraft(
+            Schema.decodeUnknownSync(Schema.Array(SessionMessage.AssistantContent))(event.data.content),
+          )
+        }),
       "session.usage.recorded": () => Effect.void,
       "session.agent.selected": (event) =>
         Effect.gen(function* () {
@@ -204,6 +210,7 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
                 draft.finish = undefined
                 draft.rawFinish = undefined
                 draft.providerState = undefined
+                draft.time.streamed = undefined
                 draft.time.completed = undefined
                 if (event.data.snapshot) draft.snapshot = { ...draft.snapshot, start: event.data.snapshot }
               }),
@@ -232,6 +239,11 @@ export function update(adapter: Adapter, event: SessionEvent.DurableEvent) {
             }),
           )
         }),
+      "session.step.streamed": (event) => {
+        return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
+          draft.time.streamed = created
+        })
+      },
       "session.step.ended": (event) => {
         return updateOwnedAssistant(event.data.assistantMessageID, (draft) => {
           draft.time.completed = created

packages/core/src/session/model-request.ts

@@ -45,7 +45,7 @@ const declineDefect = (cause: Cause.Cause<Tool.Error>) => {
   return decline ? Result.succeed(decline) : Result.fail(cause)
 }
 
-interface Prepared {
+export interface Prepared {
   readonly request: LLMRequest
   readonly options: StreamOptions
   /**

packages/core/src/session/projector.ts

@@ -581,6 +581,7 @@ const layer = Layer.effectDiscard(
         .run()
         .pipe(Effect.orDie)
     })
+    yield* bus.project(SessionEvent.MessageContentUpdated, (event) => run(db, event))
     yield* bus.project(SessionEvent.UsageRecorded, (event) => applyUsage(db, event.data.sessionID, event.data))
     yield* bus.project(SessionEvent.Forked, (event) => projectFork(db, event))
     yield* bus.project(SessionEvent.InboxDelivered, (event) =>
@@ -659,6 +660,7 @@ const layer = Layer.effectDiscard(
     yield* bus.project(SessionEvent.Shell.Started, (event) => run(db, event))
     yield* bus.project(SessionEvent.Shell.Ended, (event) => run(db, event))
     yield* bus.project(SessionEvent.Step.Started, (event) => run(db, event))
+    yield* bus.project(SessionEvent.Step.Streamed, (event) => run(db, event))
     yield* bus.project(SessionEvent.Step.Ended, (event) =>
       Effect.gen(function* () {
         yield* run(db, event)

packages/core/src/session/runner/index.ts

@@ -1,7 +1,7 @@
 export * as SessionRunner from "./index.js"
 
 import type { AIError } from "@opencode-ai/ai"
-import { Context, Effect } from "effect"
+import { Context, Data, Effect } from "effect"
 import { SessionSchema } from "../schema.js"
 import type { Promotable } from "../inbox.js"
 import type { AgentNotFoundError, MessageDecodeError, StepFailedError, UserInterruptedError } from "../error.js"
@@ -19,9 +19,11 @@ export type RunError =
 
 export type Continuation = { readonly step: number }
 
-export type DrainResult =
-  | { readonly type: "complete" }
-  | { readonly type: "moved"; readonly continuation?: Continuation }
+export type DrainResult = Data.TaggedEnum<{
+  Complete: {}
+  Moved: { readonly continuation?: Continuation }
+}>
+export const DrainResult = Data.taggedEnum<DrainResult>()
 
 /** Runs one local continuation from already-recorded Session history. */
 export interface Interface {

packages/core/src/session/runner/llm.ts

@@ -1,20 +1,9 @@
 export * as SessionRunnerLLM from "./llm.js"
 
-import {
-  LLMClient,
-  AIError,
-  InvalidProviderOutputReason,
-  LLMEvent,
-  Message,
-  isContextOverflowFailure,
-  type ProviderErrorEvent,
-  type ToolCall,
-} from "@opencode-ai/ai"
-import { Cause, Config, Data, Effect, Exit, Fiber, FiberMap, Layer, Option, Pull, Schedule, Stream } from "effect"
+import { Message } from "@opencode-ai/ai"
+import { Cause, Config, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect"
 import { Database } from "../../database/database.js"
 import { Bus } from "../../bus.js"
-import { Permission } from "../../permission.js"
-import { QuestionTool } from "../../tool/plugin/question.js"
 import { InstructionState } from "../instruction-state.js"
 import { SessionCompaction } from "../compaction.js"
 import { SessionContext } from "../context.js"
@@ -26,100 +15,18 @@ import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 import { SessionStore } from "../store.js"
 import { SessionTitle } from "../title.js"
-import { Service, type Continuation } from "./index.js"
-import { createLLMEventPublisher, type StepRecord } from "./publish-llm-event.js"
+import { DrainResult, Service, type Continuation } from "./index.js"
 import { Snapshot } from "../../snapshot.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../../effect/app-node-platform.js"
 import { StepFailedError } from "../error.js"
-import { toSessionError } from "../to-session-error.js"
 import { SessionRunnerRetry } from "./retry.js"
-import { SessionUsage } from "../usage.js"
+import { SessionStep } from "./step.js"
 import { ToolOutput } from "../../tool-output.js"
 import { PluginSupervisor } from "../../plugin/supervisor.js"
-import { Tool } from "../../tool.js"
 import { PromptCacheDiagnostics } from "../prompt-cache-diagnostics.js"
 import { MAX_STEPS_PROMPT } from "./max-steps.js"
 
-/** How one model call ended: settled, awaiting retry/recovery, or restarted by compaction. */
-type CallOutcome = Data.TaggedEnum<{
-  Completed: { readonly needsContinuation: boolean; readonly step: number }
-  Retry: { readonly step: number }
-  Continue: {
-    readonly cause: AIError
-    readonly error: SessionRunnerRetry.RetryableFailure["error"]
-    readonly step: number
-  }
-  RecoverFull: { readonly step: number }
-  Restart: { readonly step: number; readonly recoveredOverflow: boolean }
-}>
-const CallOutcome = Data.taggedEnum<CallOutcome>()
-
-// Declining an interactive prompt halts the drain instead of becoming model-facing tool output.
-const isDecline = (
-  error: SessionModelRequest.ExecuteError,
-): error is Permission.DeclinedError | QuestionTool.CancelledError =>
-  error._tag === "Permission.DeclinedError" || error._tag === "QuestionTool.CancelledError"
-
-const isInterruptedStream = (failure: AIError) => {
-  if (failure.reason._tag === "InvalidProviderOutput")
-    return failure.reason.classification === "incomplete-stream"
-  if (failure.reason._tag === "Transport") return failure.reason.operation === "read"
-  return false
-}
-
-/**
- * Classifies how the owned tool fibers ended. Interrupts abort the step; a user decline
- * settles its own call and then aborts the step; a defect from a tool implementation
- * becomes a failed tool call the model can read; a typed infrastructure failure must
- * fail the assistant and then the drain.
- */
-const classifyToolExits = (
-  settled: Exit.Exit<Array<Exit.Exit<void, SessionModelRequest.ExecuteError>>, never>,
-  calls: ReadonlyArray<ToolCall>,
-) => {
-  // Exits align with calls by construction: one owned fiber per accepted local call.
-  const exits = settled._tag === "Success" ? settled.value : []
-  const declines = exits.flatMap((exit, index) =>
-    exit._tag === "Failure"
-      ? exit.cause.reasons.flatMap((reason) =>
-          Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : [],
-        )
-      : [],
-  )
-  const causes =
-    settled._tag === "Failure"
-      ? [settled.cause]
-      : exits.flatMap((exit) => (exit._tag === "Failure" ? [exit.cause] : []))
-  // The first non-interrupt, non-decline failure, rebuilt without decline reasons so the
-  // drain's error channel never carries a decline.
-  const failure = causes
-    .flatMap((cause) => {
-      if (Cause.hasInterrupts(cause)) return []
-      const reasons = cause.reasons.flatMap(
-        (reason): Array<Cause.Reason<never>> =>
-          Cause.isFailReason(reason)
-            ? isDecline(reason.error)
-              ? []
-              : // A typed failure here broke the ExecuteError contract (the per-fiber
-                // `catchTag("Tool.Error")` consumes honest ones). Surfacing it as a defect
-                // keeps it from being dropped, which would leave its call unsettled forever.
-                [Cause.makeDieReason(reason.error)]
-            : [reason],
-      )
-      return reasons.length > 0 ? [Cause.fromReasons(reasons)] : []
-    })
-    .at(0)
-  return {
-    interrupted: causes.some(Cause.hasInterrupts),
-    declines,
-    failure,
-  }
-}
-
-const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
-const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
-const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
 const CONTINUE_AFTER_INCOMPLETE_STREAM =
   "The previous response was interrupted. Continue from where you left off without repeating completed content."
 
@@ -127,17 +34,15 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
-    const llm = yield* LLMClient.Service
     const store = yield* SessionStore.Service
     const context = yield* SessionContext.Service
     const modelRequests = yield* SessionModelRequest.Service
     const modelTransport = yield* SessionModelTransport.Service
-    const snapshots = yield* Snapshot.Service
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const plugins = yield* PluginSupervisor.Service
     const title = yield* SessionTitle.Service
-    const toolOutput = yield* ToolOutput.Service
+    const steps = yield* SessionStep.make
     const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(
       Config.withDefault(false),
       Effect.orDie,
@@ -166,10 +71,7 @@ const layer = Layer.effect(
     })
     // Title generation starts once input is visible and must not delay model execution.
     const titles = yield* FiberMap.make<SessionSchema.ID, void, never>()
-    /**
-     * Drains eligible manual compaction and user input until the Session becomes idle.
-     * Execution lifecycle is published per busy period by SessionExecution, not here.
-     */
+
     const drain = Effect.fn("SessionRunner.drain")(function* (input: {
       readonly sessionID: SessionSchema.ID
       readonly force: boolean
@@ -179,30 +81,25 @@ const layer = Layer.effect(
       let force = input.force
       let continuation = input.continuation
       const promotable = input.promotable ?? "input"
-      if (!force && !continuation && !(yield* eligible(input.sessionID, promotable)))
-        return { type: "complete" as const }
+      if (!force && !continuation && !(yield* eligible(input.sessionID, promotable))) return DrainResult.Complete()
       yield* plugins.flush
       yield* settleStaleToolCalls(input.sessionID)
       while (true) {
-        // Between-turn control items run under any drain scope: scope gates which user
-        // input may promote, not whether admitted housekeeping runs. Steered control
-        // items go ahead of any queued input; only a queue-delivered control item
-        // parked behind a queued prompt is not the next eligible item.
+        // Scope gates input promotion, not a between-step control that is next in line.
         if (yield* runPendingCompaction(input.sessionID, "input")) {
           force = false
           continue
         }
-        if (yield* runPendingMove(input.sessionID, "input")) return { type: "moved" as const }
+        if (yield* runPendingMove(input.sessionID, "input")) return DrainResult.Moved({})
         if (!force && !continuation && !(yield* SessionInbox.has(db, input.sessionID, promotable)))
-          return { type: "complete" as const }
+          return DrainResult.Complete()
         const result = yield* runSteps(input.sessionID, continuation, promotable)
-        if (result.type === "moved") return result
+        if (result._tag === "Moved") return result
         force = false
         continuation = undefined
       }
     })
 
-    /** Work this drain may perform: scoped input, or a between-turn control item next in line. */
     const eligible = Effect.fnUntraced(function* (sessionID: SessionSchema.ID, promotable: SessionInbox.Promotable) {
       if (yield* SessionInbox.has(db, sessionID, promotable)) return true
       if (promotable === "input") return false
@@ -210,31 +107,20 @@ const layer = Layer.effect(
       return next?.type === "compaction" || next?.type === "move"
     })
 
-    /**
-     * Runs logical steps until no tool result or newly admitted steer requires another
-     * model call. Queued inputs remain pending until the current model work reaches idle.
-     */
+    /** Queued inputs wait until the current model work reaches idle; later Steps absorb only steers. */
     const runSteps = Effect.fn("SessionRunner.runSteps")(function* (
       sessionID: SessionSchema.ID,
       continuation: Continuation | undefined,
       drainPromotable: SessionInbox.Promotable,
     ) {
-      // Fresh work may promote queued input; resumed turns and later steps absorb steers only.
       let promotable: SessionInbox.Promotable = continuation ? "steer" : drainPromotable
       let step = continuation?.step ?? 1
       let next = continuation
-      // The drain admitted this work, so the first step always runs — even after a
-      // control item consumed at this boundary (unlike drain's one-shot force).
       let first = true
-      // Every boundary has the same shape: control items first, then one exit decision,
-      // then the model. The turn continues only while the first step, a continuation, or
-      // steer input is owed. Deciding after control items means consuming the last
-      // steered compaction ends the turn instead of issuing an input-free model call.
       while (true) {
         if (yield* runPendingCompaction(sessionID, "steer")) continue
-        if (yield* runPendingMove(sessionID, "steer")) return { type: "moved" as const, continuation: next }
-        if (!first && !next && !(yield* SessionInbox.has(db, sessionID, "steer")))
-          return { type: "complete" as const }
+        if (yield* runPendingMove(sessionID, "steer")) return DrainResult.Moved({ continuation: next })
+        if (!first && !next && !(yield* SessionInbox.has(db, sessionID, "steer"))) return DrainResult.Complete()
         const result = yield* runStep(sessionID, promotable, step)
         first = false
         promotable = "steer"
@@ -243,390 +129,100 @@ const layer = Layer.effect(
       }
     })
 
-    /** Completes one logical model step, transparently retrying or rebuilding after compaction. */
-    const runStep = Effect.fnUntraced(function* (
+    /** Owns logical Step policy; each attempt owns its streaming, tools, and durable settlement. */
+    const runStep = Effect.fn("SessionRunner.runStep")(function* (
       sessionID: SessionSchema.ID,
       promotable: SessionInbox.Promotable,
       step: number,
     ) {
-      // Minting message identity before any attempt lets retries resume the same durable
-      // message. A compaction restart re-mints: the old message is stranded behind the new
-      // compaction boundary, so the rebuilt step needs identity inside the new epoch.
       let assistantMessageID = SessionMessage.ID.create()
-      const retry = yield* Schedule.toStepWithSleep(
-        SessionRunnerRetry.schedule(bus, sessionID, () => assistantMessageID),
-      )
-      /**
-       * Consumes one retry allowance: sleeps the scheduled backoff, or publishes
-       * Step.Failed and fails once attempts are exhausted. The step loop performs
-       * the retry itself on the next iteration.
-       */
-      const waitForRetry = (failure: SessionRunnerRetry.RetryableFailure) =>
-        retry(failure).pipe(
-          Effect.as(CallOutcome.Retry({ step: failure.step })),
-          Pull.catchDone(() =>
-            bus
-              .publish(SessionEvent.Step.Failed, {
-                sessionID,
-                assistantMessageID,
-                error: failure.error,
-              })
-              .pipe(Effect.andThen(Effect.fail(failure.cause))),
-          ),
-        )
+      const retry = yield* Schedule.toStepWithSleep(SessionRunnerRetry.schedule(bus, sessionID))
       let currentPromotable: SessionInbox.Promotable | undefined = promotable
       let currentStep = step
-      // Overflow recovery is one-shot: a call after recovery must not recover another overflow.
       let recoverOverflow = true
-      // Continuation rejection permits one immediate full-context Physical Attempt without generic backoff.
       let recoverContinuation = true
       while (true) {
-        const outcome = yield* callModel(
-          sessionID,
-          currentPromotable,
-          currentStep,
-          recoverOverflow,
-          recoverContinuation,
-          assistantMessageID,
-        ).pipe(Effect.catchTag("SessionRunner.RetryableFailure", waitForRetry))
-        if (outcome._tag === "Completed") return { needsContinuation: outcome.needsContinuation, step: outcome.step }
-        if (outcome._tag === "Continue") {
-          yield* retry(
-            new SessionRunnerRetry.RetryableFailure({
-              cause: outcome.cause,
-              error: outcome.error,
-              step: outcome.step,
-            }),
-          ).pipe(Pull.catchDone(() => Effect.fail(outcome.cause)))
-          yield* bus.publish(SessionEvent.Synthetic, {
-            sessionID,
-            text: CONTINUE_AFTER_INCOMPLETE_STREAM,
+        const selected = yield* context.select(sessionID)
+        // A blocked initial instruction baseline must leave admitted input pending.
+        yield* InstructionState.prepare(db, bus, selected.instructions, selected.session.id)
+        const promoted = currentPromotable
+          ? yield* SessionInbox.promote(db, bus, selected.session.id, currentPromotable)
+          : 0
+        if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
+          yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
+            onlyIfMissing: true,
           })
-          assistantMessageID = SessionMessage.ID.create()
-        }
-        if (outcome._tag === "Restart") {
-          if (outcome.recoveredOverflow) recoverOverflow = false
-          assistantMessageID = SessionMessage.ID.create()
-        }
-        if (outcome._tag === "RecoverFull") recoverContinuation = false
-        // Neither a retry nor a compaction restart re-promotes input.
+        currentStep = promoted > 0 ? 1 : currentStep
         currentPromotable = undefined
-        currentStep = outcome.step
+        const loaded = yield* context.load(selected)
+        const compactionInput = { session: loaded.session, messages: loaded.messages, resolved: loaded.model }
+        if (compaction.required(compactionInput)) {
+          const compacted = yield* compaction.compact(compactionInput)
+          if (compacted.status !== "completed") return yield* new StepFailedError({ error: compacted.error })
+          assistantMessageID = SessionMessage.ID.create()
+          continue
+        }
+        const stepLimitReached = loaded.agent.info.steps !== undefined && currentStep >= loaded.agent.info.steps
+        const transcript = SessionModelRequest.baseTranscript({
+          agent: loaded.agent.info,
+          model: loaded.model,
+          tools: loaded.tools,
+          initial: loaded.initial,
+          messages: loaded.messages,
+        })
+        const prepared = yield* modelRequests.prepare({
+          scope: { session: loaded.session, agentID: loaded.agent.id, model: loaded.model, tools: loaded.tools },
+          transcript: {
+            system: transcript.system,
+            messages: stepLimitReached
+              ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
+              : transcript.messages,
+          },
+          // Keep tool definitions on the final Step to preserve the provider's cached prefix.
+          toolChoice: stepLimitReached ? "none" : undefined,
+          webSocket: "session",
+        })
+        yield* diagnosePromptCache(sessionID, prepared.request)
+        const outcome = yield* steps.attempt({
+          sessionID,
+          assistantMessageID,
+          agent: loaded.agent.id,
+          model: loaded.model,
+          prepared,
+          toolsDisabled: stepLimitReached,
+          recoverContinuation,
+          recoverOverflow: Effect.suspend(() =>
+            recoverOverflow && compaction.enabled()
+              ? compaction.compact(compactionInput).pipe(Effect.map((result) => result.status === "completed"))
+              : Effect.succeed(false),
+          ),
+        })
+        if (outcome._tag === "Completed") return { needsContinuation: outcome.needsContinuation, step: currentStep }
+        if (outcome._tag === "Retry" || outcome._tag === "Continue") {
+          yield* retry({ cause: outcome.cause, error: outcome.error, assistantMessageID }).pipe(
+            Pull.catchDone(() =>
+              Effect.gen(function* () {
+                if (outcome._tag === "Retry")
+                  yield* bus.publish(SessionEvent.Step.Failed, { sessionID, assistantMessageID, error: outcome.error })
+                return yield* outcome.cause
+              }),
+            ),
+          )
+          if (outcome._tag === "Continue") {
+            yield* bus.publish(SessionEvent.Synthetic, { sessionID, text: CONTINUE_AFTER_INCOMPLETE_STREAM })
+            assistantMessageID = SessionMessage.ID.create()
+          }
+          continue
+        }
+        if (outcome._tag === "Compacted") {
+          recoverOverflow = false
+          assistantMessageID = SessionMessage.ID.create()
+          continue
+        }
+        recoverContinuation = false
       }
     })
 
-    /**
-     * Prepares and runs at most one model call, executes its local tools, and durably
-     * settles the step. Compaction may instead request that the logical step restart.
-     */
-    const callModel = Effect.fn("SessionRunner.callModel")(function* (
-      sessionID: SessionSchema.ID,
-      promotable: SessionInbox.Promotable | undefined,
-      step: number,
-      recoverOverflow: boolean,
-      recoverContinuation: boolean,
-      assistantMessageID: SessionMessage.ID,
-    ) {
-      const selected = yield* context.select(sessionID)
-      // Establish what the model knows before admitting what the user said, so
-      // a blocked first step leaves pending inputs untouched.
-      yield* InstructionState.prepare(db, bus, selected.instructions, selected.session.id)
-      const promoted = promotable ? yield* SessionInbox.promote(db, bus, selected.session.id, promotable) : 0
-      if (promoted > 0 && !selected.session.parentID && SessionTitle.isUntitled(selected.session))
-        yield* FiberMap.run(titles, sessionID, title.generate(sessionID).pipe(Effect.ignore), {
-          onlyIfMissing: true,
-        })
-      // Promoted input opens a fresh step allowance.
-      const currentStep = promoted > 0 ? 1 : step
-      const loaded = yield* context.load(selected)
-      const { session, agent } = loaded
-      const resolved = loaded.model
-      // Make room: history must fit the context window before the call. A pending manual
-      // compaction owns this instead; the runner executes it between steps.
-      const compactionInput = { session, messages: loaded.messages, resolved }
-      if (compaction.required(compactionInput)) {
-        const compacted = yield* compaction.compact(compactionInput)
-        if (compacted.status === "completed")
-          return CallOutcome.Restart({ step: currentStep, recoveredOverflow: false })
-        return yield* new StepFailedError({ error: compacted.error })
-      }
-      const stepLimitReached = agent.info.steps !== undefined && currentStep >= agent.info.steps
-      const transcript = SessionModelRequest.baseTranscript({
-        agent: agent.info,
-        model: resolved,
-        tools: loaded.tools,
-        initial: loaded.initial,
-        messages: loaded.messages,
-      })
-      const prepared = yield* modelRequests.prepare({
-        scope: { session, agentID: agent.id, model: resolved, tools: loaded.tools },
-        transcript: {
-          system: transcript.system,
-          messages: stepLimitReached
-            ? [...transcript.messages, Message.assistant(MAX_STEPS_PROMPT)]
-            : transcript.messages,
-        },
-        // The final Step keeps definitions available to protocols with native "none",
-        // preserving their prompt cache prefix. Calls are still rejected at execution.
-        toolChoice: stepLimitReached ? "none" : undefined,
-        webSocket: "session",
-      })
-      yield* diagnosePromptCache(session.id, prepared.request)
-      const executeTool = (input: Parameters<typeof prepared.executeTool>[0]) => {
-        if (stepLimitReached) return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
-        return prepared.executeTool(input)
-      }
-      // Every local tool call forked here is owned until it reaches one durable settlement.
-      const toolRuns: Array<{
-        readonly call: ToolCall
-        readonly fiber: Fiber.Fiber<void, SessionModelRequest.ExecuteError>
-      }> = []
-      const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
-      const startSnapshot = yield* snapshots.capture()
-      const publisher = createLLMEventPublisher(bus, {
-        sessionID: session.id,
-        agent: agent.id,
-        // The selected catalog identity, not model.id: route-level ids are provider API
-        // model ids (for example gpt-5.5-fast resolves to api id gpt-5.5).
-        model: resolved.ref,
-        providerMetadataKey: transcript.providerMetadataKey,
-        snapshot: startSnapshot,
-        assistantMessageID,
-      })
-      const stepUsage = (finish: NonNullable<StepRecord["finish"]>) => ({
-        cost: SessionUsage.calculateCost(resolved.cost, finish.tokens),
-        tokens: finish.tokens,
-      })
-
-      const captureStepEnd = Effect.fnUntraced(function* () {
-        const snapshot = yield* snapshots.capture()
-        const files =
-          startSnapshot && snapshot
-            ? startSnapshot === snapshot
-              ? []
-              : yield* snapshots
-                  .files({ from: startSnapshot, to: snapshot })
-                  .pipe(Effect.orElseSucceed(() => undefined))
-            : undefined
-        return { snapshot, files }
-      })
-
-      const publishStepEnd = (finish: NonNullable<StepRecord["finish"]>) =>
-        Effect.gen(function* () {
-          const end = yield* captureStepEnd()
-          yield* bus.publish(SessionEvent.Step.Ended, {
-            sessionID: session.id,
-            assistantMessageID: yield* publisher.startAssistant(),
-            finish: finish.finish,
-            rawFinish: finish.rawFinish,
-            providerState: finish.providerState,
-            ...stepUsage(finish),
-            ...end,
-          })
-        })
-
-      // Concurrent writers, no lock: the provider loop and each tool fiber publish
-      // durable events unserialized. This is safe because every publisher method commits
-      // its state marks synchronously before its first await (see publish-llm-event.ts),
-      // every required event order is per-source (each source is one sequential fiber),
-      // and a fiber's events are causally after its own Tool.Called: the fork happens
-      // below that publish. Cross-source order is unconstrained; either interleaving is
-      // a truthful history of concurrent work.
-      //
-      // The stream is defined here but runs inside the settlement mask below: publish each
-      // event durably, fork one fiber per local tool call, and hold back a virgin
-      // context-overflow provider error so settlement may recover it via compaction.
-      let overflowFailure: ProviderErrorEvent | undefined
-      const providerStream = llm.stream(prepared.request, prepared.options).pipe(
-        Stream.runForEach((event) =>
-          Effect.gen(function* () {
-            if (overflowFailure || publisher.hasProviderError()) return
-            if (
-              LLMEvent.is.providerError(event) &&
-              isContextOverflowFailure(event) &&
-              !publisher.record().outputStarted
-            ) {
-              overflowFailure = event
-              return
-            }
-            yield* publisher.publish(event)
-            if (event.type !== "tool-call" || event.providerExecuted) return
-            const assistantMessageID = yield* publisher.assistantMessageID(event.id)
-            toolRuns.push({
-              call: event,
-              fiber: yield* Effect.uninterruptibleMask((restore) =>
-                restore(
-                  executeTool({
-                    sessionID: session.id,
-                    agent: agent.id,
-                    messageID: assistantMessageID,
-                    call: event,
-                    // Progress is ephemeral, not durable history: nothing to order.
-                    progress: (update) => publisher.progress(event.id, update),
-                  }),
-                ).pipe(
-                  // The fiber owns its call: it publishes its own completion, masked so a
-                  // finished execution always reaches its durable settlement.
-                  Effect.flatMap(toolOutput.truncate),
-                  Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
-                  Effect.catchTag("Tool.Error", (error) =>
-                    publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid),
-                  ),
-                ),
-              ).pipe(Effect.forkScoped),
-            })
-          }),
-        ),
-        Effect.ensuring(publisher.flush()),
-      )
-
-      // Settle: only the stream and the fiber joins are interruptible (restore); every
-      // other line is protected so a started call always reaches one durable outcome.
-      return yield* Effect.uninterruptibleMask((restore) =>
-        Effect.gen(function* () {
-          const stream = yield* restore(providerStream).pipe(Effect.exit)
-          const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream))
-          // Note: Exit.hasInterrupts is a type guard whose false branch unsoundly narrows
-          // away non-interrupt failures, so both interrupt checks stay Cause-based.
-          const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
-
-          // Join every owned tool run first: await all exits, not just the first failure.
-          // Afterwards no fiber is alive, settlement is the only writer, and the record
-          // is final. A failed join means the waiting itself was interrupted, so the runs
-          // we abandoned are interrupted before settlement closes them out.
-          if (streamInterrupted) yield* interruptTools
-          const joined = yield* restore(
-            Effect.forEach(toolRuns, (run) => Fiber.await(run.fiber), { concurrency: "unbounded" }),
-          ).pipe(Effect.exit)
-          if (joined._tag === "Failure") yield* interruptTools
-          const tools = classifyToolExits(
-            joined,
-            toolRuns.map((run) => run.call),
-          )
-
-          // A context overflow before any assistant output is recoverable: compact and
-          // restart the step instead of surfacing the provider error.
-          if (
-            recoverOverflow &&
-            compaction.enabled() &&
-            !publisher.record().outputStarted &&
-            isContextOverflowFailure(overflowFailure ?? streamFailure) &&
-            (yield* restore(compaction.compact(compactionInput))).status === "completed"
-          )
-            return CallOutcome.Restart({ step: currentStep, recoveredOverflow: true })
-
-          // An unrecovered held-back overflow becomes the step's durable provider error.
-          if (overflowFailure) yield* publisher.publish(overflowFailure)
-          // A thrown LLM failure not already recorded as the provider error either
-          // escapes as a scheduled retry or fails the assistant durably.
-          const unknownFinish =
-            stream._tag === "Success" && publisher.record().finish?.finish === "unknown"
-              ? new AIError({
-                  module: "session",
-                  method: "stream",
-                  reason: new InvalidProviderOutputReason({
-                    classification: "incomplete-stream",
-                    message: "The provider response ended with an unknown finish reason.",
-                  }),
-                })
-              : undefined
-          const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish
-          const llmError = llmFailure && !publisher.record().providerFailed ? toSessionError(llmFailure) : undefined
-          if (
-            recoverContinuation &&
-            llmFailure?.reason._tag === "Transport" &&
-            (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") &&
-            !publisher.record().outputStarted
-          )
-            return CallOutcome.RecoverFull({ step: currentStep })
-          if (
-            llmFailure &&
-            llmError &&
-            SessionRunnerRetry.isRetryable(llmFailure) &&
-            !publisher.record().outputStarted
-          ) {
-            // RetryScheduled and Step.Failed fold onto an existing assistant message, so
-            // Step.Started must be durable before the failure escapes.
-            yield* publisher.startAssistant()
-            return yield* new SessionRunnerRetry.RetryableFailure({
-              cause: llmFailure,
-              error: llmError,
-              step: currentStep,
-            })
-          }
-          if (llmError) yield* publisher.failAssistant(llmError)
-
-          // Close every unsettled call with the reason it could not settle truthfully,
-          // and fail the assistant when the step itself cannot complete. A declined call
-          // settles with its own reason before the generic sweeps.
-          for (const decline of tools.declines)
-            yield* publisher.failTool(decline.call.id, {
-              type: "aborted",
-              message:
-                decline.reason._tag === "QuestionTool.CancelledError"
-                  ? decline.reason.message
-                  : "The user declined this tool call",
-            })
-          if (tools.declines.length > 0 || streamInterrupted || tools.interrupted) {
-            yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
-            yield* publisher.failAssistant(STEP_INTERRUPTED)
-          }
-          if (tools.failure !== undefined) {
-            const error = toSessionError(Cause.squash(tools.failure))
-            yield* publisher.failUnsettledTools(error)
-          }
-          // Local calls have joined, so the remaining sweeps only close hosted calls the
-          // provider promised but never resolved.
-          if (publisher.record().providerFailed) yield* publisher.failUnsettledTools(TOOLS_INTERRUPTED)
-          if (llmError) yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
-          // A clean stream that still left hosted calls unresolved fails the step itself.
-          if (stream._tag === "Success" && !publisher.record().providerFailed) {
-            const hostedResultMissing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
-            if (hostedResultMissing && !publisher.record().finish) yield* publisher.failAssistant(RESULT_MISSING)
-          }
-
-          // One terminal event: Step.Ended on a clean finish, Step.Failed otherwise.
-          const record = publisher.record()
-          if (record.finish && !record.failure) yield* publishStepEnd(record.finish)
-          if (record.failure) {
-            const end = yield* captureStepEnd()
-            yield* publisher.publishStepFailure({
-              ...(record.finish ? stepUsage(record.finish) : {}),
-              ...end,
-            })
-          }
-
-          if (
-            llmFailure &&
-            llmError &&
-            isInterruptedStream(llmFailure) &&
-            record.outputStarted &&
-            tools.declines.length === 0 &&
-            !tools.interrupted
-          )
-            return CallOutcome.Continue({
-              cause: llmFailure,
-              error: llmError,
-              step: currentStep,
-            })
-
-          if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
-          if (tools.declines.length > 0) return yield* Effect.interrupt
-          if (tools.interrupted && tools.failure) return yield* Effect.failCause(tools.failure)
-          if (tools.interrupted && joined._tag === "Failure") return yield* Effect.failCause(joined.cause)
-          if (record.failure) return yield* new StepFailedError({ error: record.failure })
-          return CallOutcome.Completed({
-            // A local call or malformed tool input requires another model step, unless
-            // this step already exhausted the agent's allowance.
-            needsContinuation:
-              !stepLimitReached && record.calls.some((call) => !call.providerExecuted && (call.called || call.settled)),
-            step: currentStep,
-          })
-        }),
-      )
-    }, Effect.scoped)
-
-    /** Executes a previously admitted manual compaction request, if one is pending. */
     const runPendingCompaction = Effect.fn("SessionRunner.runPendingCompaction")(function* (
       sessionID: SessionSchema.ID,
       promotable: SessionInbox.Promotable,
@@ -698,7 +294,6 @@ const layer = Layer.effect(
       )
     })
 
-    /** Closes stale tool calls left active by an earlier interrupted drain. */
     const settleStaleToolCalls = Effect.fn("SessionRunner.settleStaleToolCalls")(function* (
       sessionID: SessionSchema.ID,
     ) {
@@ -706,11 +301,18 @@ const layer = Layer.effect(
         if (message.type !== "assistant") continue
         for (const tool of message.content) {
           if (tool.type !== "tool" || (tool.state.status !== "streaming" && tool.state.status !== "running")) continue
+          const metadata = tool.state.status === "running" ? tool.state.metadata : undefined
+          const childID =
+            tool.name === "subagent" && typeof metadata?.sessionID === "string" ? metadata.sessionID : undefined
           yield* bus.publish(SessionEvent.Tool.Failed, {
             sessionID,
             assistantMessageID: message.id,
             id: tool.id,
-            error: { type: "aborted", message: `Tool execution interrupted: ${tool.name}` },
+            error: {
+              type: "aborted",
+              message: `Tool execution interrupted: ${tool.name}${childID ? ` (sessionID: ${childID})` : ""}`,
+            },
+            ...(metadata && Object.keys(metadata).length > 0 ? { metadata } : {}),
             executed: tool.executed === true,
           })
         }

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

@@ -1,5 +1,5 @@
 import { type LLMEvent, type ProviderMetadata, type ToolResultValue } from "@opencode-ai/ai"
-import { Clock, Effect } from "effect"
+import { Clock, Effect, Iterable } from "effect"
 import { Bus } from "../../bus.js"
 import { Model } from "../../model.js"
 import { SessionEvent } from "../event.js"
@@ -39,13 +39,7 @@ export interface StepRecord {
     readonly providerState?: SessionMessage.ProviderState
     readonly tokens: ReturnType<typeof SessionUsage.tokens>
   }
-  readonly calls: ReadonlyArray<{
-    readonly id: string
-    readonly name: string
-    readonly called: boolean
-    readonly settled: boolean
-    readonly providerExecuted: boolean
-  }>
+  readonly needsContinuation: boolean
 }
 
 /** Derives canonical model content from a provider-hosted tool result. */
@@ -85,7 +79,6 @@ const hostedContent = (result: ToolResultValue): NonEmptyContent => {
 export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, input: Input) => {
   const deltaBatchInterval = 100
   type ToolState = {
-    readonly assistantMessageID: SessionMessage.ID
     readonly name: string
     called: boolean
     settled: boolean
@@ -103,6 +96,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
   let stepFailed = false
   let providerFailed = false
   let outputStarted = false
+  let stepStreamed = false
   let stepFailure: SessionError.Error | undefined
   let stepSettlement: StepRecord["finish"]
 
@@ -120,6 +114,14 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
   })
   const currentAssistantMessageID = () =>
     stepStarted ? Effect.succeed(assistantMessageID) : Effect.die(new Error("Tool event before assistant step start"))
+  const streamed = Effect.fnUntraced(function* () {
+    if (stepStreamed) return
+    stepStreamed = true
+    yield* bus.publish(SessionEvent.Step.Streamed, {
+      sessionID: input.sessionID,
+      assistantMessageID: yield* startAssistant(),
+    })
+  })
   const providerState = (metadata: ProviderMetadata | undefined) => metadata?.[input.providerMetadataKey]
   const fragments = (
     name: string,
@@ -241,7 +243,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
       if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${id}`))
       yield* bus.publish(SessionEvent.Tool.Input.Ended, {
         sessionID: input.sessionID,
-        assistantMessageID: tool.assistantMessageID,
+        assistantMessageID,
         id,
         text: value,
       })
@@ -260,9 +262,8 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     readonly providerExecuted?: boolean
   }) {
     if (tools.has(event.id)) return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`))
-    const assistantMessageID = yield* startAssistant()
+    yield* startAssistant()
     const tool: ToolState = {
-      assistantMessageID,
       name: event.name,
       called: false,
       settled: false,
@@ -305,7 +306,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     tool.settled = true
     yield* bus.publish(SessionEvent.Tool.Failed, {
       sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
+      assistantMessageID,
       id: event.id,
       error: {
         type: "tool.input-json",
@@ -324,9 +325,12 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     tool.settled = true
     yield* bus.publish(SessionEvent.Tool.Failed, {
       sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
+      assistantMessageID,
       id,
-      error,
+      error:
+        tool.name === "subagent" && error.type === "aborted" && typeof tool.progress?.sessionID === "string"
+          ? { ...error, message: `${error.message} (sessionID: ${tool.progress.sessionID})` }
+          : error,
       ...failureSnapshot(tool, metadata),
       executed: tool.providerExecuted,
     })
@@ -374,11 +378,6 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     (error: SessionError.Error, scope: "hosted" | "all" = "all") => failTools(error, scope),
   )
 
-  const assistantMessageIDForTool = (id: string) => {
-    const tool = tools.get(id)
-    return tool ? Effect.succeed(tool.assistantMessageID) : Effect.die(new Error(`Unknown tool call: ${id}`))
-  }
-
   const publish = Effect.fn("SessionRunner.publishLLMEvent")(function* (event: LLMEvent) {
     switch (event.type) {
       case "step-start":
@@ -446,7 +445,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         tool.providerExecuted = event.providerExecuted === true
         yield* bus.publish(SessionEvent.Tool.Called, {
           sessionID: input.sessionID,
-          assistantMessageID: tool.assistantMessageID,
+          assistantMessageID,
           id: event.id,
           input: asRecord(event.input),
           executed: tool.providerExecuted,
@@ -472,7 +471,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         if (event.result.type === "error") {
           yield* bus.publish(SessionEvent.Tool.Failed, {
             sessionID: input.sessionID,
-            assistantMessageID: tool.assistantMessageID,
+            assistantMessageID,
             id: event.id,
             error: { type: "tool.execution", message: stringify(event.result.value) },
             ...failureSnapshot(tool),
@@ -483,7 +482,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         }
         yield* bus.publish(SessionEvent.Tool.Success, {
           sessionID: input.sessionID,
-          assistantMessageID: tool.assistantMessageID,
+          assistantMessageID,
           id: event.id,
           content: hostedContent(event.result),
           executed,
@@ -500,7 +499,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         tool.settled = true
         yield* bus.publish(SessionEvent.Tool.Failed, {
           sessionID: input.sessionID,
-          assistantMessageID: tool.assistantMessageID,
+          assistantMessageID,
           id: event.id,
           error:
             event.message === `Unknown tool: ${event.name}`
@@ -542,7 +541,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     tool.progress = update
     yield* bus.publish(SessionEvent.Tool.Progress, {
       sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
+      assistantMessageID,
       id,
       metadata: update,
     })
@@ -565,7 +564,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     if (content.length === 0) return yield* Effect.die(new Error(`Tool execution has no content: ${id}`))
     yield* bus.publish(SessionEvent.Tool.Success, {
       sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
+      assistantMessageID,
       id,
       content: [content[0], ...content.slice(1)],
       ...(result.metadata === undefined ? {} : { metadata: result.metadata }),
@@ -583,21 +582,19 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
     publishStepFailure,
     failUnsettledTools,
     hasProviderError: () => providerFailed,
+    hasStarted: () => stepStarted,
     /** Immutable snapshot of everything recorded for this step so far. */
     record: (): StepRecord => ({
       outputStarted,
       providerFailed,
       failure: stepFailure,
       finish: stepSettlement,
-      calls: Array.from(tools, ([id, tool]) => ({
-        id,
-        name: tool.name,
-        called: tool.called,
-        settled: tool.settled,
-        providerExecuted: tool.providerExecuted,
-      })),
+      needsContinuation: Iterable.some(
+        tools.values(),
+        (tool) => !tool.providerExecuted && (tool.called || tool.settled),
+      ),
     }),
     startAssistant,
-    assistantMessageID: assistantMessageIDForTool,
+    streamed,
   }
 }

packages/core/src/session/runner/retry.ts

@@ -2,17 +2,17 @@ export * as SessionRunnerRetry from "./retry.js"
 
 import { AIError } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
-import { Data, Duration, Effect, Schedule } from "effect"
+import { Duration, Effect, Schedule } from "effect"
 import { Bus } from "../../bus.js"
 import { SessionEvent } from "../event.js"
 import { SessionMessage } from "../message.js"
 import { SessionSchema } from "../schema.js"
 
-export class RetryableFailure extends Data.TaggedError("SessionRunner.RetryableFailure")<{
+export interface Input {
   readonly cause: AIError
   readonly error: SessionError.Error
-  readonly step: number
-}> {}
+  readonly assistantMessageID: SessionMessage.ID
+}
 
 export function isRetryable(error: AIError) {
   const override = "http" in error.reason ? error.reason.http?.response?.headers["x-should-retry"] : undefined
@@ -40,29 +40,25 @@ export function isRetryable(error: AIError) {
   }
 }
 
-const retryAfter = (failure: RetryableFailure) => {
-  if (failure.cause.reason._tag === "RateLimit" || failure.cause.reason._tag === "ProviderInternal")
-    return failure.cause.reason.retryAfterMs
+const retryAfter = (input: Input) => {
+  if (input.cause.reason._tag === "RateLimit" || input.cause.reason._tag === "ProviderInternal")
+    return input.cause.reason.retryAfterMs
   return undefined
 }
 
-export const schedule = (
-  bus: Bus.Interface,
-  sessionID: SessionSchema.ID,
-  assistantMessageID: () => SessionMessage.ID,
-) =>
+export const schedule = (bus: Bus.Interface, sessionID: SessionSchema.ID) =>
   Schedule.max([Schedule.exponential("2 seconds"), Schedule.recurs(4)]).pipe(
     Schedule.jittered,
-    Schedule.setInputType<RetryableFailure>(),
-    Schedule.modifyDelay(({ input: failure, duration: delay }) => {
-      const minimum = retryAfter(failure)
+    Schedule.setInputType<Input>(),
+    Schedule.modifyDelay(({ input, duration: delay }) => {
+      const minimum = retryAfter(input)
       const duration = minimum === undefined ? delay : Duration.max(delay, Duration.millis(minimum))
       return Effect.succeed(Duration.millis(Math.ceil(Duration.toMillis(duration))))
     }),
     Schedule.tap((metadata) =>
       bus.publish(SessionEvent.RetryScheduled, {
         sessionID,
-        assistantMessageID: assistantMessageID(),
+        assistantMessageID: metadata.input.assistantMessageID,
         attempt: metadata.attempt + 1,
         at: metadata.now + Duration.toMillis(metadata.duration),
         error: metadata.input.error,

packages/core/src/session/runner/step.ts

@@ -0,0 +1,293 @@
+export * as SessionStep from "./step.js"
+
+import {
+  AIError,
+  InvalidProviderOutputReason,
+  LLMClient,
+  LLMEvent,
+  isContextOverflowFailure,
+  type ProviderErrorEvent,
+  type ToolCall,
+} from "@opencode-ai/ai"
+import { Cause, Data, Effect, Exit, Fiber, Option, Stream } from "effect"
+import { SessionError } from "@opencode-ai/schema/session-error"
+import { Agent } from "../../agent.js"
+import { Bus } from "../../bus.js"
+import { Permission } from "../../permission.js"
+import { Snapshot } from "../../snapshot.js"
+import { Tool } from "../../tool.js"
+import { ToolOutput } from "../../tool-output.js"
+import { QuestionTool } from "../../tool/plugin/question.js"
+import { StepFailedError } from "../error.js"
+import { SessionEvent } from "../event.js"
+import { SessionMessage } from "../message.js"
+import { SessionModelRequest } from "../model-request.js"
+import { SessionSchema } from "../schema.js"
+import { toSessionError } from "../to-session-error.js"
+import { SessionUsage } from "../usage.js"
+import { SessionRunnerModel } from "./model.js"
+import { createLLMEventPublisher } from "./publish-llm-event.js"
+import { SessionRunnerRetry } from "./retry.js"
+
+export type Outcome = Data.TaggedEnum<{
+  Completed: { readonly needsContinuation: boolean }
+  Retry: { readonly cause: AIError; readonly error: SessionError.Error }
+  Continue: { readonly cause: AIError; readonly error: SessionError.Error }
+  RecoverFull: {}
+  Compacted: {}
+}>
+const Outcome = Data.taggedEnum<Outcome>()
+
+interface Input {
+  readonly sessionID: SessionSchema.ID
+  readonly assistantMessageID: SessionMessage.ID
+  readonly agent: Agent.ID
+  readonly model: SessionRunnerModel.Resolved
+  readonly prepared: SessionModelRequest.Prepared
+  readonly toolsDisabled: boolean
+  readonly recoverContinuation: boolean
+  /** The runner owns compaction policy; the attempt invokes it only before durable output. */
+  readonly recoverOverflow: Effect.Effect<boolean>
+}
+
+const TOOLS_INTERRUPTED = { type: "aborted", message: "Tool execution interrupted" } as const
+const STEP_INTERRUPTED = { type: "aborted", message: "Step interrupted" } as const
+const RESULT_MISSING = { type: "tool.result-missing", message: "Provider did not return a tool result" } as const
+
+/** Captures Location-scoped dependencies without introducing another service or execution loop. */
+export const make = Effect.gen(function* () {
+  const bus = yield* Bus.Service
+  const llm = yield* LLMClient.Service
+  const snapshots = yield* Snapshot.Service
+  const toolOutput = yield* ToolOutput.Service
+
+  const attempt = Effect.fn("SessionStep.attempt")(function* (input: Input) {
+    const startSnapshot = yield* snapshots.capture()
+    const publisher = createLLMEventPublisher(bus, {
+      sessionID: input.sessionID,
+      assistantMessageID: input.assistantMessageID,
+      agent: input.agent,
+      model: input.model.ref,
+      providerMetadataKey: input.model.model.route.providerMetadataKey ?? input.model.model.provider,
+      snapshot: startSnapshot,
+    })
+    const toolRuns: Array<{
+      readonly call: ToolCall
+      readonly fiber: Fiber.Fiber<void, SessionModelRequest.ExecuteError>
+    }> = []
+    const interruptTools = Effect.suspend(() => Fiber.interruptAll(toolRuns.map((run) => run.fiber)))
+    const executeTool = (call: ToolCall) => {
+      if (input.toolsDisabled) return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
+      return input.prepared.executeTool({
+        sessionID: input.sessionID,
+        agent: input.agent,
+        messageID: input.assistantMessageID,
+        call,
+        progress: (update) => publisher.progress(call.id, update),
+      })
+    }
+
+    // Provider and tool fibers retain per-source order without a shared writer queue.
+    // A local execution starts only after its Tool.Called publication completes.
+    let overflowFailure: ProviderErrorEvent | undefined
+    // Read to the end, not just the finish event, so the next request can reuse this response.
+    const providerStream = llm.stream(input.prepared.request, input.prepared.options).pipe(
+      Stream.runForEach((event) =>
+        Effect.gen(function* () {
+          if (overflowFailure || publisher.hasProviderError()) return
+          if (
+            LLMEvent.is.providerError(event) &&
+            isContextOverflowFailure(event) &&
+            !publisher.record().outputStarted
+          ) {
+            overflowFailure = event
+            return
+          }
+          yield* publisher.publish(event)
+          if (event.type !== "tool-call" || event.providerExecuted) return
+          toolRuns.push({
+            call: event,
+            fiber: yield* Effect.uninterruptibleMask((restore) =>
+              restore(executeTool(event)).pipe(
+                Effect.flatMap(toolOutput.truncate),
+                Effect.flatMap((outcome) => publisher.toolExecution(event.id, event.name, outcome)),
+                Effect.catchTag("Tool.Error", (error) =>
+                  publisher.failTool(event.id, toSessionError(error), error.metadata).pipe(Effect.asVoid),
+                ),
+              ),
+            ).pipe(Effect.forkScoped),
+          })
+        }),
+      ),
+      Effect.ensuring(publisher.flush()),
+    )
+
+    // Keep the final tool and Step events uninterruptible, even when the work itself is cancelled.
+    return yield* Effect.uninterruptibleMask((restore) =>
+      Effect.gen(function* () {
+        const stream = yield* restore(providerStream).pipe(Effect.exit)
+        const streamFailure = Option.getOrUndefined(Exit.findErrorOption(stream))
+        const streamInterrupted = stream._tag === "Failure" && Cause.hasInterrupts(stream.cause)
+        if (!overflowFailure && publisher.hasStarted()) yield* publisher.streamed()
+        if (streamInterrupted) yield* interruptTools
+        const joined = yield* restore(Fiber.awaitAll(toolRuns.map((run) => run.fiber))).pipe(Effect.exit)
+        if (joined._tag === "Failure") yield* interruptTools
+        const tools = classifyToolExits(
+          joined,
+          toolRuns.map((run) => run.call),
+        )
+
+        if (
+          !publisher.record().outputStarted &&
+          isContextOverflowFailure(overflowFailure ?? streamFailure) &&
+          (yield* restore(input.recoverOverflow))
+        )
+          return Outcome.Compacted()
+
+        if (overflowFailure) yield* publisher.publish(overflowFailure)
+        const recorded = publisher.record()
+        const unknownFinish =
+          stream._tag === "Success" && recorded.finish?.finish === "unknown"
+            ? new AIError({
+                module: "session",
+                method: "stream",
+                reason: new InvalidProviderOutputReason({
+                  classification: "incomplete-stream",
+                  message: "The provider response ended with an unknown finish reason.",
+                }),
+              })
+            : undefined
+        const llmFailure = streamFailure instanceof AIError ? streamFailure : unknownFinish
+        const llmError = llmFailure && !recorded.providerFailed ? toSessionError(llmFailure) : undefined
+        if (
+          input.recoverContinuation &&
+          llmFailure?.reason._tag === "Transport" &&
+          (llmFailure.reason.recovery === "retry-full" || llmFailure.reason.recovery === "rotate-and-retry-full") &&
+          !recorded.outputStarted
+        )
+          return Outcome.RecoverFull()
+        if (llmFailure && llmError && SessionRunnerRetry.isRetryable(llmFailure) && !recorded.outputStarted) {
+          // Retry state projects onto the existing assistant, even before it has produced output.
+          yield* publisher.startAssistant()
+          return Outcome.Retry({ cause: llmFailure, error: llmError })
+        }
+        if (llmError) yield* publisher.failAssistant(llmError)
+
+        for (const decline of tools.declines)
+          yield* publisher.failTool(decline.call.id, {
+            type: "aborted",
+            message:
+              decline.reason._tag === "QuestionTool.CancelledError"
+                ? decline.reason.message
+                : "The user declined this tool call",
+          })
+        const interrupted = tools.declines.length > 0 || streamInterrupted || tools.interrupted
+        const toolFailure = interrupted
+          ? TOOLS_INTERRUPTED
+          : tools.failure !== undefined
+            ? toSessionError(Cause.squash(tools.failure))
+            : recorded.providerFailed
+              ? TOOLS_INTERRUPTED
+              : undefined
+        if (toolFailure) yield* publisher.failUnsettledTools(toolFailure)
+        if (interrupted) yield* publisher.failAssistant(STEP_INTERRUPTED)
+
+        // All local fibers have joined; only provider-hosted results can still be missing.
+        if (llmError || (stream._tag === "Success" && !recorded.providerFailed)) {
+          const missing = yield* publisher.failUnsettledTools(RESULT_MISSING, "hosted")
+          if (missing && !llmError && !recorded.finish) yield* publisher.failAssistant(RESULT_MISSING)
+        }
+
+        const record = publisher.record()
+        if (record.finish || record.failure) {
+          const snapshot = yield* snapshots.capture()
+          const files =
+            startSnapshot && snapshot
+              ? startSnapshot === snapshot
+                ? []
+                : yield* snapshots
+                    .files({ from: startSnapshot, to: snapshot })
+                    .pipe(Effect.orElseSucceed(() => undefined))
+              : undefined
+          const usage = record.finish
+            ? { cost: SessionUsage.calculateCost(input.model.cost, record.finish.tokens), tokens: record.finish.tokens }
+            : undefined
+          if (record.failure) yield* publisher.publishStepFailure({ ...usage, snapshot, files })
+          if (record.finish && usage && !record.failure)
+            yield* bus.publish(SessionEvent.Step.Ended, {
+              sessionID: input.sessionID,
+              assistantMessageID: yield* publisher.startAssistant(),
+              finish: record.finish.finish,
+              rawFinish: record.finish.rawFinish,
+              providerState: record.finish.providerState,
+              ...usage,
+              snapshot,
+              files,
+            })
+        }
+
+        if (
+          llmFailure &&
+          llmError &&
+          isInterruptedStream(llmFailure) &&
+          record.outputStarted &&
+          tools.declines.length === 0 &&
+          !tools.interrupted
+        )
+          return Outcome.Continue({ cause: llmFailure, error: llmError })
+
+        if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
+        if (tools.declines.length > 0) return yield* Effect.interrupt
+        if (tools.interrupted && tools.failure) return yield* Effect.failCause(tools.failure)
+        if (tools.interrupted && joined._tag === "Failure") return yield* Effect.failCause(joined.cause)
+        if (record.failure) return yield* new StepFailedError({ error: record.failure })
+        return Outcome.Completed({
+          needsContinuation: !input.toolsDisabled && record.needsContinuation,
+        })
+      }),
+    )
+  }, Effect.scoped)
+
+  return { attempt }
+})
+
+const isDecline = (
+  error: SessionModelRequest.ExecuteError,
+): error is Permission.DeclinedError | QuestionTool.CancelledError =>
+  error._tag === "Permission.DeclinedError" || error._tag === "QuestionTool.CancelledError"
+
+const isInterruptedStream = (failure: AIError) => {
+  if (failure.reason._tag === "InvalidProviderOutput") return failure.reason.classification === "incomplete-stream"
+  if (failure.reason._tag === "Transport") return failure.reason.operation === "read"
+  return false
+}
+
+/** Keep every joined exit associated with its call; a decline is not an infrastructure failure. */
+const classifyToolExits = (
+  settled: Exit.Exit<Array<Exit.Exit<void, SessionModelRequest.ExecuteError>>>,
+  calls: ReadonlyArray<ToolCall>,
+) => {
+  const exits = settled._tag === "Success" ? settled.value : []
+  const declines = exits.flatMap((exit, index) =>
+    exit._tag === "Failure"
+      ? exit.cause.reasons.flatMap((reason) =>
+          Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : [],
+        )
+      : [],
+  )
+  const causes =
+    settled._tag === "Failure"
+      ? [settled.cause]
+      : exits.flatMap((exit) => (exit._tag === "Failure" ? [exit.cause] : []))
+  const failure = causes
+    .flatMap((cause) => {
+      if (Cause.hasInterrupts(cause)) return []
+      const reasons = cause.reasons.flatMap(
+        (reason): Array<Cause.Reason<never>> =>
+          Cause.isFailReason(reason) ? (isDecline(reason.error) ? [] : [Cause.makeDieReason(reason.error)]) : [reason],
+      )
+      return reasons.length > 0 ? [Cause.fromReasons(reasons)] : []
+    })
+    .at(0)
+  return { interrupted: causes.some(Cause.hasInterrupts), declines, failure }
+}

packages/core/src/session/store.ts

@@ -1,6 +1,6 @@
 export * as SessionStore from "./store.js"
 
-import { and, eq, isNotNull, isNull, sql } from "drizzle-orm"
+import { and, eq, isNotNull, isNull, notInArray, sql } from "drizzle-orm"
 import { Context, Effect, Layer } from "effect"
 import { Database } from "../database/database.js"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
@@ -18,9 +18,8 @@ export interface Interface {
     messageID: SessionMessage.ID,
   ) => Effect.Effect<{ readonly sessionID: Session.ID; readonly message: SessionMessage.Info } | undefined>
   /**
-   * Top-level Sessions holding an execution claim. Child (subagent) Sessions
-   * are excluded: a resumed parent re-runs its tool call and spawns fresh
-   * children, so resuming orphaned children would duplicate their work.
+   * Top-level Sessions holding an execution claim. Recoverable background
+   * children are resumed separately through their durable Job records.
    */
   readonly listSuspended: () => Effect.Effect<ReadonlyArray<Session.ID>>
   /**
@@ -33,11 +32,10 @@ export interface Interface {
   /** Releases the claim and resets resume accounting. Terminal events call this on commit. */
   readonly release: (sessionID: Session.ID) => Effect.Effect<void>
   /**
-   * Clears orphaned child (subagent) claims. Children are never resumed
-   * independently, so a dead child's claim is noise no terminal will ever
-   * release.
+   * Clears orphaned child claims except children owned by recoverable
+   * background subagent jobs.
    */
-  readonly releaseChildClaims: Effect.Effect<void>
+  readonly releaseChildClaims: (recoverable: ReadonlyArray<Session.ID>) => Effect.Effect<void>
   /**
    * Durably counts one more resume of an orphaned claim, returning the new
    * total — or undefined when the Session no longer exists.
@@ -103,12 +101,20 @@ const layer = Layer.effect(
           .run()
           .pipe(Effect.orDie)
       }),
-      releaseChildClaims: db
-        .update(SessionTable)
-        .set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` })
-        .where(and(isNotNull(SessionTable.time_suspended), isNotNull(SessionTable.parent_id)))
-        .run()
-        .pipe(Effect.orDie, Effect.asVoid, Effect.withSpan("SessionStore.releaseChildClaims")),
+      releaseChildClaims: Effect.fn("SessionStore.releaseChildClaims")((recoverable) =>
+        db
+          .update(SessionTable)
+          .set({ time_suspended: null, resume_attempts: 0, time_updated: sql`${SessionTable.time_updated}` })
+          .where(
+            and(
+              isNotNull(SessionTable.time_suspended),
+              isNotNull(SessionTable.parent_id),
+              recoverable.length > 0 ? notInArray(SessionTable.id, Array.from(recoverable)) : undefined,
+            ),
+          )
+          .run()
+          .pipe(Effect.orDie, Effect.asVoid),
+      ),
       countResume: Effect.fn("SessionStore.countResume")(function* (sessionID) {
         const row = yield* db
           .update(SessionTable)

packages/core/src/shell.ts

@@ -134,8 +134,8 @@ const layer = () =>
         Effect.gen(function* () {
           for (const session of sessions.values()) {
             if (session.timeoutFiber) yield* Fiber.interrupt(session.timeoutFiber)
-            // Unblock waiters still pending at teardown; succeed is a no-op once already resolved.
-            yield* Deferred.fail(session.done, new NotFoundError({ id: Shell.ID.make(session.info.id) }))
+            // Teardown interrupts pending commands; it is not a terminal command failure.
+            yield* Deferred.interrupt(session.done)
           }
           sessions.clear()
           exitOrder.length = 0

packages/core/src/state.ts

@@ -32,6 +32,7 @@ export interface Transformable<DraftApi> {
 
 type Batch = {
   active: boolean
+  readonly flush: boolean
   readonly reloads: Set<Reload>
 }
 
@@ -40,14 +41,15 @@ const CurrentBatch = Context.Reference<Batch | undefined>("@opencode/State/Curre
 })
 const reloadDebounce = 500
 
-export function batch<A, E, R>(effect: Effect.Effect<A, E, R>) {
+/** flush: false is terminal teardown: states whose transforms are removed stop rebuilding, including pending reloads. */
+export function batch<A, E, R>(effect: Effect.Effect<A, E, R>, options: { readonly flush?: boolean } = {}) {
   return Effect.gen(function* () {
     const current = yield* CurrentBatch
-    if (current?.active) return yield* effect
-    const batch: Batch = { active: true, reloads: new Set() }
+    if (current?.active && options.flush !== false) return yield* effect
+    const batch: Batch = { active: true, flush: options.flush !== false, reloads: new Set() }
     const exit = yield* effect.pipe(Effect.provideService(CurrentBatch, batch), Effect.exit)
     batch.active = false
-    yield* Effect.forEach(batch.reloads, (reload) => reload(), { discard: true })
+    if (batch.flush) yield* Effect.forEach(batch.reloads, (reload) => reload(), { discard: true })
     return yield* exit
   })
 }
@@ -81,6 +83,7 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
   let generation = 0
   let requestedAt = 0
   let running = false
+  let closed = false
   let waiters: { generation: number; done: Deferred.Deferred<void> }[] = []
   const semaphore = Semaphore.makeUnsafe(1)
 
@@ -90,6 +93,7 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
   })
 
   const materialize = Effect.fnUntraced(function* () {
+    if (closed) return
     const next = options.initial()
     const api = options.draft(next)
     for (const transform of transforms) {
@@ -122,6 +126,7 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
     })
 
   const reload = Effect.fnUntraced(function* () {
+    if (closed) return
     const done = Deferred.makeUnsafe<void>()
     const clock = yield* Clock.Clock
     generation++
@@ -131,7 +136,7 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
       running = true
       yield* rebuild().pipe(Effect.forkDetach)
     }
-    return yield* Deferred.await(done)
+    yield* Deferred.await(done)
   })
 
   return {
@@ -152,6 +157,11 @@ export function create<State, DraftApi>(options: Options<State, DraftApi>): Inte
                 return Effect.gen(function* () {
                   const batch = yield* CurrentBatch
                   if (batch?.active) {
+                    // Detached debounced reloads must also stay quiet after teardown.
+                    if (!batch.flush) {
+                      closed = true
+                      return
+                    }
                     batch.reloads.add(materializeReload)
                     return
                   }

packages/core/src/tool.ts

@@ -271,12 +271,12 @@ function schemaMakeError(error: unknown) {
 }
 
 const validateName = (name: string) =>
-  /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(name)
+  /^[A-Za-z0-9_-]{1,64}$/.test(name)
     ? Effect.void
     : Effect.fail(new RegistrationError({ name, message: `Invalid tool name: ${name}` }))
 
 const validateNamespace = (namespace: string) =>
-  namespace.split(".").every((segment) => /^[A-Za-z][A-Za-z0-9_-]{0,63}$/.test(segment))
+  namespace.split(".").every((segment) => /^[A-Za-z0-9_-]{1,64}$/.test(segment))
     ? Effect.void
     : Effect.fail(
         new RegistrationError({

packages/core/src/tool/plugin/shell.ts

@@ -115,56 +115,45 @@ export const Plugin = {
     const permission = yield* Permission.Service
     const config = yield* Config.Service
 
-    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
-      sessionID: SessionSchema.ID,
-      id: string,
-      shellID: string,
-      command: string,
-      settled: Deferred.Deferred<Output>,
-    ) {
-      yield* runtime.job.wait({ id: id }).pipe(
-        Effect.flatMap((result) =>
-          Effect.gen(function* () {
-            const info = result.info
-            if (!info) return
-            const state =
-              info.status === "completed"
-                ? "completed"
-                : info.status === "error"
-                  ? "error"
-                  : info.status === "cancelled"
-                    ? "cancelled"
-                    : undefined
-            if (state === undefined) return
-            const output = state === "completed" ? yield* Deferred.await(settled) : undefined
-            const text = output
-              ? resultMessages(output).join("\n\n")
-              : state === "error"
-                ? (info.error ?? "Command failed")
-                : "Command cancelled"
-            yield* runtime.session.synthetic({
-              sessionID,
-              text: `<shell id="${id}" state="${state}" command="${command}">\n${text}\n</shell>`,
-              description: command,
-              metadata: {
-                source: "shell",
-                jobID: id,
-                shellID,
-                state,
-                ...(output
-                  ? {
-                      truncated: output.truncated,
-                      ...(output.exit !== undefined ? { exit: output.exit } : {}),
-                      ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
-                    }
-                  : {}),
-              },
-            })
-          }),
-        ),
-        Effect.forkIn(scope, { startImmediately: true }),
-      )
-    })
+    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(
+      function* (
+        sessionID: SessionSchema.ID,
+        id: string,
+        shellID: string,
+        command: string,
+        settled: Deferred.Deferred<Output>,
+      ) {
+        const info = (yield* runtime.job.wait({ id })).info
+        if (!info || info.status === "running") return
+        const output = info.status === "completed" ? yield* Deferred.await(settled) : undefined
+        const text = output
+          ? resultMessages(output).join("\n\n")
+          : info.status === "error"
+            ? (info.error ?? "Command failed")
+            : "Command cancelled"
+        yield* runtime.session.synthetic({
+          ...(info.notificationID ? { id: info.notificationID } : {}),
+          sessionID,
+          text: `<shell id="${id}" state="${info.status}" command="${command}">\n${text}\n</shell>`,
+          description: command,
+          metadata: {
+            source: "shell",
+            jobID: id,
+            shellID,
+            state: info.status,
+            ...(output
+              ? {
+                  truncated: output.truncated,
+                  ...(output.exit !== undefined ? { exit: output.exit } : {}),
+                  ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
+                }
+              : {}),
+          },
+        })
+        if (info.notificationID) yield* runtime.job.completeBackground(info.notificationID)
+      },
+      Effect.forkIn(scope, { startImmediately: true }),
+    )
 
     yield* ctx.tool
       .transform((draft) =>
@@ -286,7 +275,7 @@ export const Plugin = {
               const settled = yield* Deferred.make<Output>()
               const run = settleShell().pipe(
                 Effect.tap((output) => Deferred.succeed(settled, output)),
-                Effect.map((output) => output.output),
+                Effect.map((output) => resultMessages(output).join("\n\n")),
                 Effect.onInterrupt(() => shell.remove(info.id).pipe(Effect.ignore)),
               )
               const job = yield* runtime.job.start({
@@ -294,6 +283,12 @@ export const Plugin = {
                 type: name,
                 title: info.command,
                 metadata: { sessionID: context.sessionID, shellID: info.id },
+                recovery: {
+                  kind: "shell",
+                  sessionID: context.sessionID,
+                  shellID: info.id,
+                  command: info.command,
+                },
                 run,
               })
 

packages/core/src/tool/plugin/subagent.ts

@@ -78,22 +78,6 @@ export const Plugin = {
       return text.length > 0 ? text : NO_TEXT
     })
 
-    const injectCompletion = Effect.fn("SubagentTool.injectCompletion")(function* (
-      parentID: SessionSchema.ID,
-      childID: SessionSchema.ID,
-      agent: string,
-      description: string,
-      state: "completed" | "error" | "cancelled",
-      text: string,
-    ) {
-      yield* runtime.session.synthetic({
-        sessionID: parentID,
-        text: `<subagent sessionID="${childID}" state="${state}" description="${description}">\n${text}\n</subagent>`,
-        description,
-        metadata: { source: "subagent", childID, agent, state },
-      })
-    })
-
     const notifyWhenDone = Effect.fn("SubagentTool.notifyWhenDone")(function* (
       parentID: SessionSchema.ID,
       childID: SessionSchema.ID,
@@ -104,23 +88,24 @@ export const Plugin = {
       const key = `${childID}:${startedAt}`
       if (notifications.has(key)) return
       notifications.add(key)
-      yield* runtime.job.wait({ id: childID }).pipe(
-        Effect.flatMap((result) => {
-          if (result.info?.status === "completed")
-            return injectCompletion(parentID, childID, agent, description, "completed", result.info.output ?? NO_TEXT)
-          if (result.info?.status === "error")
-            return injectCompletion(
-              parentID,
-              childID,
-              agent,
-              description,
-              "error",
-              result.info.error ?? "Subagent failed",
-            )
-          if (result.info?.status === "cancelled")
-            return injectCompletion(parentID, childID, agent, description, "cancelled", "Subagent cancelled")
-          return Effect.void
-        }),
+      yield* Effect.gen(function* () {
+        const info = (yield* runtime.job.wait({ id: childID })).info
+        if (!info || info.status === "running") return
+        const text =
+          info.status === "completed"
+            ? (info.output ?? NO_TEXT)
+            : info.status === "error"
+              ? (info.error ?? "Subagent failed")
+              : "Subagent cancelled"
+        yield* runtime.session.synthetic({
+          ...(info.notificationID ? { id: info.notificationID } : {}),
+          sessionID: parentID,
+          text: `<subagent sessionID="${childID}" state="${info.status}" description="${description}">\n${text}\n</subagent>`,
+          description,
+          metadata: { source: "subagent", childID, agent, state: info.status },
+        })
+        if (info.notificationID) yield* runtime.job.completeBackground(info.notificationID)
+      }).pipe(
         Effect.ensuring(Effect.sync(() => notifications.delete(key))),
         Effect.forkIn(scope, { startImmediately: true }),
       )
@@ -239,6 +224,7 @@ export const Plugin = {
                     existing === undefined
                       ? ["You are a subagent spawned by another session.", input.prompt].join("\n")
                       : input.prompt,
+                  ...(background && existing === undefined ? { resume: false } : {}),
                 })
                 .pipe(
                   Effect.mapError(
@@ -246,17 +232,19 @@ export const Plugin = {
                   ),
                 )
 
-              const run = Effect.gen(function* () {
-                yield* runtime.session.resume(child.id)
-                return yield* latestAssistantText(child.id)
-              }).pipe(Effect.onInterrupt(() => runtime.session.interrupt(child.id)))
-
               const info = yield* runtime.job.start({
                 id: child.id,
                 type: name,
                 title: input.description,
                 metadata: {},
-                run,
+                recovery: {
+                  kind: "subagent",
+                  parentSessionID: context.sessionID,
+                  childSessionID: child.id,
+                  agent: agent.name,
+                  description: input.description,
+                },
+                run: runtime.session.resume(child.id).pipe(Effect.andThen(latestAssistantText(child.id))),
               })
 
               if (background) {

packages/core/test/aisdk-native.test.ts

@@ -61,8 +61,8 @@ describe("AISDKNative", () => {
     })
   })
 
-  test("maps Cerebras, DeepInfra, and Together AI settings, headers, and reasoning options to native providers", () => {
-    for (const name of ["cerebras", "deepinfra", "togetherai"]) {
+  test("maps Cerebras, DeepInfra, Groq, and Together AI settings, headers, and reasoning options to native providers", () => {
+    for (const name of ["cerebras", "deepinfra", "groq", "togetherai"]) {
       expect(
         map(`@ai-sdk/${name}`, {
           apiKey: "secret",

packages/core/test/job.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect } from "bun:test"
 import { Job } from "@opencode-ai/core/job"
+import { KV } from "@opencode-ai/core/kv"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Deferred, Effect, Exit, Fiber, Scope } from "effect"
 import { SessionSchema } from "@opencode-ai/core/session/schema"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(AppNodeBuilder.build(Job.node))
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([Job.node, KV.node])))
 
 describe("Job", () => {
   it.live("tracks process-local work through explicit observation", () =>
@@ -145,6 +147,177 @@ describe("Job", () => {
     }),
   )
 
+  it.live("retains background ownership and terminal output until notification acknowledgment", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const latch = yield* Deferred.make<void>()
+      const recovery = {
+        kind: "shell" as const,
+        sessionID: SessionSchema.ID.make("ses_background_shell"),
+        shellID: "shell_background",
+        command: "echo done",
+      }
+      const job = yield* jobs.start({ type: "shell", recovery, run: Deferred.await(latch).pipe(Effect.as("done")) })
+
+      expect((yield* jobs.pendingBackground).find((item) => item.id === job.id)).toBeUndefined()
+      const background = yield* jobs.background(job.id)
+
+      const running = (yield* jobs.pendingBackground).find((item) => item.id === job.id)
+      expect(running).toMatchObject({ id: job.id, recovery, status: "running" })
+      expect(running?.notificationID).toStartWith("msg_")
+      expect(background?.notificationID).toBe(running?.notificationID)
+
+      yield* Deferred.succeed(latch, undefined)
+      yield* jobs.wait({ id: job.id })
+
+      const completed = (yield* jobs.pendingBackground).find((item) => item.id === job.id)
+      expect(completed).toMatchObject({
+        id: job.id,
+        notificationID: running?.notificationID,
+        recovery,
+        status: "completed",
+        output: "done",
+      })
+      if (!completed) return yield* Effect.die("background marker missing")
+
+      yield* jobs.completeBackground(completed.notificationID)
+      expect((yield* jobs.pendingBackground).find((item) => item.id === job.id)).toBeUndefined()
+    }),
+  )
+
+  it.live("persists backgroundAll ownership before releasing a blocked subagent", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const parentSessionID = SessionSchema.ID.make("ses_background_parent")
+      const latch = yield* Deferred.make<void>()
+      const recovery = {
+        kind: "subagent" as const,
+        parentSessionID,
+        childSessionID: SessionSchema.ID.make("ses_background_child"),
+        agent: "explore",
+        description: "Explore background recovery",
+      }
+      const job = yield* jobs.start({ type: "subagent", recovery, run: Deferred.await(latch).pipe(Effect.as("done")) })
+      const waiting = yield* jobs
+        .block({ id: job.id, sessionID: parentSessionID })
+        .pipe(Effect.forkIn(yield* Scope.Scope, { startImmediately: true }))
+
+      yield* jobs.backgroundAll({ sessionID: parentSessionID })
+      expect(yield* Fiber.join(waiting)).toMatchObject({ type: "backgrounded", info: { id: job.id } })
+
+      const marker = (yield* jobs.pendingBackground).find((item) => item.id === job.id)
+      expect(marker).toMatchObject({ id: job.id, recovery, status: "running" })
+      if (!marker) return yield* Effect.die("background marker missing")
+
+      yield* jobs.cancel(job.id)
+      expect((yield* jobs.pendingBackground).find((item) => item.id === job.id)).toMatchObject({
+        notificationID: marker.notificationID,
+        status: "cancelled",
+      })
+      yield* jobs.completeBackground(marker.notificationID)
+    }),
+  )
+
+  it.live("retains terminal errors for recovery until notification acknowledgment", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const latch = yield* Deferred.make<void>()
+      const job = yield* jobs.start({
+        type: "shell",
+        recovery: {
+          kind: "shell",
+          sessionID: SessionSchema.ID.make("ses_background_error"),
+          shellID: "shell_error",
+          command: "exit 1",
+        },
+        run: Deferred.await(latch).pipe(Effect.andThen(Effect.fail(new Error("shell failed")))),
+      })
+
+      yield* jobs.background(job.id)
+      yield* Deferred.succeed(latch, undefined)
+      yield* jobs.wait({ id: job.id })
+
+      const marker = (yield* jobs.pendingBackground).find((item) => item.id === job.id)
+      expect(marker).toMatchObject({ id: job.id, status: "error", error: "shell failed" })
+      if (!marker) return yield* Effect.die("background marker missing")
+      yield* jobs.completeBackground(marker.notificationID)
+    }),
+  )
+
+  it.live("durably backgrounds recoverable work that has already failed", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const job = yield* jobs.start({
+        type: "shell",
+        recovery: {
+          kind: "shell",
+          sessionID: SessionSchema.ID.make("ses_immediate_error"),
+          shellID: "shell_immediate_error",
+          command: "exit 1",
+        },
+        run: Effect.fail(new Error("shell failed")),
+      })
+      expect((yield* jobs.wait({ id: job.id })).info?.status).toBe("error")
+
+      const background = yield* jobs.background(job.id)
+      expect(background?.notificationID).toStartWith("msg_")
+      expect(yield* jobs.pendingBackground).toMatchObject([
+        { id: job.id, notificationID: background?.notificationID, status: "error", error: "shell failed" },
+      ])
+    }),
+  )
+
+  it.live("recovers a background marker after its process-local registry closes", () =>
+    Effect.gen(function* () {
+      const scope = yield* Scope.make()
+      const previous = yield* Job.make.pipe(Scope.provide(scope))
+      const job = yield* previous.start({
+        type: "shell",
+        recovery: {
+          kind: "shell",
+          sessionID: SessionSchema.ID.make("ses_background_restart"),
+          shellID: "shell_restart",
+          command: "sleep 60",
+        },
+        run: Effect.never,
+      })
+      yield* previous.background(job.id)
+      yield* Scope.close(scope, Exit.void)
+
+      const current = yield* Job.make
+      const marker = (yield* current.pendingBackground).find((item) => item.id === job.id)
+      expect(marker).toMatchObject({ id: job.id, status: "running" })
+      if (!marker) return yield* Effect.die("background marker missing")
+      yield* current.completeBackground(marker.notificationID)
+    }),
+  )
+
+  it.live("preserves running background ownership when its work is interrupted", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const interrupted = yield* Deferred.make<void>()
+      const job = yield* jobs.start({
+        type: "subagent",
+        recovery: {
+          kind: "subagent",
+          parentSessionID: SessionSchema.ID.make("ses_interrupted_parent"),
+          childSessionID: SessionSchema.ID.make("ses_interrupted_child"),
+          agent: "explore",
+          description: "Continue after shutdown",
+        },
+        run: Deferred.await(interrupted).pipe(Effect.andThen(Effect.interrupt)),
+      })
+      yield* jobs.background(job.id)
+      yield* Deferred.succeed(interrupted, undefined)
+      yield* jobs.wait({ id: job.id })
+
+      const marker = (yield* jobs.pendingBackground).find((item) => item.id === job.id)
+      expect(marker).toMatchObject({ id: job.id, status: "running" })
+      if (!marker) return yield* Effect.die("background marker missing")
+      yield* jobs.completeBackground(marker.notificationID)
+    }),
+  )
+
   it.live("interrupts live work without promising settlement after the owning process-local scope closes", () =>
     Effect.gen(function* () {
       const scope = yield* Scope.make()

packages/core/test/model-resolver.test.ts

@@ -915,6 +915,12 @@ describe("ModelResolver", () => {
           { reasoning: { effort: "high" } },
           { reasoning: { effort: "high" } },
         ],
+        [
+          "@ai-sdk/groq",
+          "@opencode-ai/ai/providers/groq",
+          { reasoningEffort: "high", parallelToolCalls: false },
+          { reasoningEffort: "high", parallelToolCalls: false },
+        ],
         [
           "@ai-sdk/togetherai",
           "@opencode-ai/ai/providers/togetherai",
@@ -973,6 +979,7 @@ describe("ModelResolver", () => {
         ["@ai-sdk/google", "@opencode-ai/ai/providers/google", "api-model"],
         ["@ai-sdk/google-vertex", "@opencode-ai/ai/providers/google-vertex", "api-model"],
         ["@ai-sdk/google-vertex/anthropic", "@opencode-ai/ai/providers/google-vertex/messages", "claude-sonnet-4-6"],
+        ["@ai-sdk/groq", "@opencode-ai/ai/providers/groq", "api-model"],
         ["@ai-sdk/openai", "@opencode-ai/ai/providers/openai", "api-model"],
         ["@ai-sdk/openai-compatible", "@opencode-ai/ai/providers/openai-compatible", "api-model"],
         ["@openrouter/ai-sdk-provider", "@opencode-ai/ai/providers/openrouter", "api-model"],
@@ -1102,6 +1109,11 @@ describe("ModelResolver", () => {
       const togetherai = yield* ModelResolver.fromCatalogModel(
         model(Provider.aisdk("@ai-sdk/togetherai"), { settings: { reasoningEffort: "high" } }),
       )
+      const groq = yield* ModelResolver.fromCatalogModel(
+        model(Provider.aisdk("@ai-sdk/groq"), {
+          settings: { reasoningEffort: "high", parallelToolCalls: false },
+        }),
+      )
       const xai = yield* ModelResolver.fromCatalogModel(
         model(Provider.aisdk("@ai-sdk/xai"), { settings: { reasoningEffort: "high" } }),
       )
@@ -1132,6 +1144,10 @@ describe("ModelResolver", () => {
       expect(togetherai.route.id).toBe("togetherai-chat")
       expect(togetherai.route.defaults.providerOptions).toEqual({ reasoningEffort: "high" })
       expect(String(togetherai.provider)).toBe("test-provider")
+      expect(groq.route.id).toBe("groq-chat")
+      expect(groq.route.protocol).toBe("groq-chat")
+      expect(groq.route.defaults.providerOptions).toEqual({ reasoningEffort: "high", parallelToolCalls: false })
+      expect(String(groq.provider)).toBe("test-provider")
       expect(xai.route.id).toBe("openai-responses")
       expect(xai.route.defaults.providerOptions).toEqual({
         reasoningEffort: "high",

packages/core/test/npm.test.ts

@@ -223,6 +223,7 @@ describe("Npm.add", () => {
     ).toBeTruthy()
   })
 
+  // Several real Git installs and refreshes exceed Bun's default timeout on Windows.
   test("refreshes mutable Git packages once per service lifetime and preserves pinned or cached installs", async () => {
     await using tmp = await tmpdir()
     const fixture = await createGitFixture(tmp.path)
@@ -262,7 +263,7 @@ describe("Npm.add", () => {
       return yield* npm.add(mutable, { refresh: true })
     }).pipe(Effect.scoped, Effect.provide(npmLayer(cache)), Effect.runPromise)
     expect(await Bun.file(path.join(offline.directory, "index.js")).text()).toContain('root: "second"')
-  })
+  }, 30_000)
 })
 
 describe("Npm.resolve", () => {

packages/core/test/plugin.test.ts

@@ -184,6 +184,39 @@ describe("Plugin", () => {
     }),
   )
 
+  it.effect("emits rebuilt state when disabling one plugin while another remains enabled", () =>
+    Effect.gen(function* () {
+      const plugins = yield* Plugin.Service
+      const agents = yield* Agent.Service
+      const bus = yield* Bus.Service
+      const definitions = ["first", "second"].map((id) =>
+        versioned(
+          EffectPlugin.define({
+            id,
+            effect: (ctx) => ctx.agent.transform((draft) => draft.update(id, () => {})),
+          }),
+        ),
+      )
+      yield* plugins.activate(definitions)
+
+      const observed: string[][] = []
+      const unsubscribe = yield* bus.listen((event) =>
+        event.type === Agent.Event.Updated.type
+          ? agents.list().pipe(
+              Effect.flatMap((items) => Effect.sync(() => observed.push(items.map((item) => item.id)))),
+              Effect.asVoid,
+            )
+          : Effect.void,
+      )
+      yield* Effect.addFinalizer(() => unsubscribe)
+
+      yield* plugins.activate(definitions.slice(1))
+      expect(yield* agents.get(Agent.ID.make("first"))).toBeUndefined()
+      expect(yield* agents.get(Agent.ID.make("second"))).toBeDefined()
+      expect(observed).toEqual([["second"]])
+    }),
+  )
+
   it.effect("rejects duplicate IDs before replacing active plugins", () =>
     Effect.gen(function* () {
       const plugins = yield* Plugin.Service

packages/core/test/plugin/provider-factory.test.ts

@@ -7,7 +7,6 @@ import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { AlibabaPlugin } from "@opencode-ai/core/plugin/provider/alibaba"
 import { CoherePlugin } from "@opencode-ai/core/plugin/provider/cohere"
 import { GatewayPlugin } from "@opencode-ai/core/plugin/provider/gateway"
-import { GroqPlugin } from "@opencode-ai/core/plugin/provider/groq"
 import { MistralPlugin } from "@opencode-ai/core/plugin/provider/mistral"
 import { PerplexityPlugin } from "@opencode-ai/core/plugin/provider/perplexity"
 import { VenicePlugin } from "@opencode-ai/core/plugin/provider/venice"
@@ -21,7 +20,6 @@ const providers = [
   { id: "alibaba", plugin: AlibabaPlugin, package: "@ai-sdk/alibaba", provider: "alibaba.chat" },
   { id: "cohere", plugin: CoherePlugin, package: "@ai-sdk/cohere", provider: "cohere.chat" },
   { id: "gateway", plugin: GatewayPlugin, package: "@ai-sdk/gateway", provider: "gateway" },
-  { id: "groq", plugin: GroqPlugin, package: "@ai-sdk/groq", provider: "groq.chat" },
   { id: "mistral", plugin: MistralPlugin, package: "@ai-sdk/mistral", provider: "mistral.chat" },
   { id: "perplexity", plugin: PerplexityPlugin, package: "@ai-sdk/perplexity", provider: "perplexity" },
   { id: "venice", plugin: VenicePlugin, package: "venice-ai-sdk-provider", provider: "custom-provider.chat" },

packages/core/test/provider.test.ts

@@ -12,6 +12,7 @@ describe("Provider", () => {
       "@opencode-ai/ai/providers/google-vertex/chat",
       "@opencode-ai/ai/providers/google-vertex/responses",
       "@opencode-ai/ai/providers/google-vertex/messages",
+      "@opencode-ai/ai/providers/groq",
       "@opencode-ai/ai/providers/togetherai",
     ]
 

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

@@ -4,6 +4,8 @@ import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
+import { Job } from "@opencode-ai/core/job"
+import { KV } from "@opencode-ai/core/kv"
 import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationServices } from "@opencode-ai/core/location-services"
 import { Project } from "@opencode-ai/core/project"
@@ -23,7 +25,9 @@ import { Context, Deferred, Effect, Exit, Fiber, Layer, LayerMap, Scope } from "
 import { eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionStore.node])))
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SessionStore.node, Job.node, KV.node, Session.node])),
+)
 
 describe("SessionExecution lifecycle", () => {
   test("classifies success and typed failure terminals", () => {
@@ -60,14 +64,13 @@ describe("SessionExecution lifecycle", () => {
       const idle = Session.ID.make("ses_recover_idle")
       yield* seedSessions(database, [parent], { time_suspended: Date.now() })
       yield* seedSessions(database, [idle])
-      // An orphaned child is never resumed: the resumed parent re-runs its
-      // tool call and spawns a fresh child instead.
+      // Children recover through background Job records, never through the root claim sweep.
       yield* seedSessions(database, [child], { time_suspended: Date.now(), parent_id: parent })
 
       expect(yield* store.listSuspended()).toEqual([parent])
 
       // The sweep clears orphaned child claims outright; parents keep theirs.
-      yield* store.releaseChildClaims
+      yield* store.releaseChildClaims([])
       expect(yield* claims(database)).toEqual({ [parent]: true, [child]: false, [idle]: false })
     }),
   )
@@ -147,6 +150,66 @@ describe("SessionExecution lifecycle", () => {
     }),
   )
 
+  it.effect("does not resume a user-cancelled background child whose notification was not admitted", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const parent = Session.ID.make("ses_cancelled_background_parent")
+      const child = Session.ID.make("ses_cancelled_background_child")
+      yield* seedSessions(database, [parent])
+      yield* seedSessions(database, [child], { parent_id: parent })
+
+      const running = yield* Deferred.make<void>()
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const jobs = yield* Job.make.pipe(Scope.provide(scope))
+      const context = yield* buildExecution(
+        scope,
+        () => Deferred.succeed(running, undefined).pipe(Effect.andThen(Effect.never)),
+        undefined,
+        jobs,
+      )
+      const execution = Context.get(context, SessionExecution.Service)
+      yield* jobs.start({
+        id: child,
+        type: "subagent",
+        recovery: {
+          kind: "subagent",
+          parentSessionID: parent,
+          childSessionID: child,
+          agent: "general",
+          description: "Cancelled inspection",
+        },
+        run: execution.resume(child).pipe(Effect.as("unused")),
+      })
+      yield* jobs.background(child)
+      yield* Deferred.await(running)
+      expect(yield* execution.interrupt(child)).toBeTrue()
+      yield* execution.awaitIdle(child)
+      expect((yield* jobs.wait({ id: child })).info?.status).toBe("cancelled")
+      expect(yield* jobs.pendingBackground).toMatchObject([{ id: child, status: "cancelled" }])
+      expect((yield* claims(database))[child]).toBe(false)
+      yield* Scope.close(scope, Exit.void)
+
+      const restartedScope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(restartedScope, Exit.void))
+      const restartedJobs = yield* Job.make.pipe(Scope.provide(restartedScope))
+      const drained: Session.ID[] = []
+      const restarted = yield* buildExecution(
+        restartedScope,
+        ({ sessionID }) => Effect.sync(() => void drained.push(sessionID)),
+        undefined,
+        restartedJobs,
+      )
+      yield* Context.get(restarted, SessionRestart.Service).resumeSuspendedSessions
+      yield* Context.get(restarted, SessionExecution.Service).awaitIdle(parent)
+      expect(drained).toEqual([parent])
+      expect(yield* SessionInbox.list(database.db, parent)).toMatchObject([
+        { payload: { text: expect.stringContaining("Subagent cancelled"), metadata: { state: "cancelled" } } },
+      ])
+      expect(yield* restartedJobs.pendingBackground).toEqual([])
+    }),
+  )
+
   it.effect("starts every claimed execution without waiting for earlier drains to finish", () =>
     Effect.gen(function* () {
       const database = yield* Database.Service
@@ -304,6 +367,518 @@ describe("SessionExecution lifecycle", () => {
   )
 })
 
+describe("SessionRestart background recovery", () => {
+  it.effect("admits orphaned shell notices without waking and delivers them once on the next run", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const store = yield* SessionStore.Service
+      const jobs = yield* Job.Service
+      const bus = yield* Bus.Service
+      const parent = Session.ID.make("ses_background_recovery_parent")
+      const child = Session.ID.make("ses_background_recovery_child")
+      yield* seedSessions(database, [parent])
+      yield* seedSessions(database, [child], { parent_id: parent, time_suspended: Date.now() })
+      yield* seedBackground(jobs, parent, [
+        { id: "call-background-shell", shellID: "sh_background_orphan", command: "sleep 60" },
+      ])
+      yield* seedBackground(jobs, child, [{ id: "call-child-shell", shellID: "sh_child_orphan", command: "sleep 30" }])
+
+      expect(yield* store.listSuspended()).toEqual([])
+      expect(yield* jobs.pendingBackground).toHaveLength(2)
+
+      const drained: Session.ID[] = []
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(
+        scope,
+        ({ sessionID }) =>
+          Effect.sync(() => void drained.push(sessionID)).pipe(
+            Effect.andThen(SessionInbox.promote(database.db, bus, sessionID, "steer")),
+            Effect.asVoid,
+          ),
+        undefined,
+        restarted,
+      )
+      const restart = Context.get(context, SessionRestart.Service)
+      yield* restart.resumeSuspendedSessions
+
+      expect((yield* store.context(parent)).filter((message) => message.type === "synthetic")).toEqual([])
+      expect(yield* SessionInbox.list(database.db, parent)).toMatchObject([
+        {
+          type: "synthetic",
+          payload: {
+            description: "sleep 60",
+            text: expect.stringContaining("server restarted"),
+            metadata: {
+              source: "shell",
+              jobID: "call-background-shell",
+              shellID: "sh_background_orphan",
+              state: "cancelled",
+            },
+          },
+        },
+      ])
+      expect(yield* SessionInbox.list(database.db, child)).toMatchObject([
+        {
+          type: "synthetic",
+          payload: {
+            metadata: {
+              source: "shell",
+              jobID: "call-child-shell",
+              shellID: "sh_child_orphan",
+              state: "cancelled",
+            },
+          },
+        },
+      ])
+      expect(drained).toEqual([])
+      expect(yield* claims(database)).toEqual({ [parent]: false, [child]: false })
+      expect(yield* restarted.pendingBackground).toEqual([])
+
+      yield* restart.resumeSuspendedSessions
+      expect(yield* SessionInbox.list(database.db, parent)).toHaveLength(1)
+      expect(drained).toEqual([])
+      const execution = Context.get(context, SessionExecution.Service)
+      yield* execution.resume(parent)
+      expect(yield* SessionInbox.list(database.db, parent)).toEqual([])
+      expect((yield* store.context(parent)).filter((message) => message.type === "synthetic")).toHaveLength(1)
+      yield* execution.resume(parent)
+      expect((yield* store.context(parent)).filter((message) => message.type === "synthetic")).toHaveLength(1)
+    }),
+  )
+
+  it.effect("preserves locally running background work", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const store = yield* SessionStore.Service
+      const jobs = yield* Job.Service
+      const parent = Session.ID.make("ses_background_existing_parent")
+      yield* seedSessions(database, [parent])
+      yield* seedBackground(jobs, parent, [{ id: "call-running-shell", shellID: "sh_running", command: "sleep 60" }])
+
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const context = yield* buildExecution(scope, () => Effect.void)
+      const restart = Context.get(context, SessionRestart.Service)
+      yield* restart.resumeSuspendedSessions
+
+      expect((yield* store.context(parent)).filter((message) => message.type === "synthetic")).toEqual([])
+      expect(yield* jobs.get("call-running-shell")).toMatchObject({ status: "running" })
+      expect(yield* jobs.pendingBackground).toHaveLength(1)
+    }),
+  )
+
+  it.effect("preserves a silent shell failure persisted before its completion notification", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const sessionID = Session.ID.make("ses_background_completed_shell")
+      yield* seedSessions(database, [sessionID])
+      const complete = yield* Deferred.make<string>()
+      yield* jobs.start({
+        id: "call-completed-shell",
+        type: "shell",
+        recovery: {
+          kind: "shell",
+          sessionID,
+          shellID: "sh_completed",
+          command: "exit 7",
+        },
+        run: Deferred.await(complete),
+      })
+      yield* jobs.background("call-completed-shell")
+      yield* Deferred.succeed(complete, "(no output)\n\nCommand exited with code 7.")
+      yield* jobs.wait({ id: "call-completed-shell" })
+
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(scope, () => Effect.void, undefined, restarted)
+      yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+
+      expect(yield* SessionInbox.list(database.db, sessionID)).toMatchObject([
+        {
+          type: "synthetic",
+          payload: {
+            text: expect.stringContaining("(no output)\n\nCommand exited with code 7."),
+            metadata: { source: "shell", shellID: "sh_completed", state: "completed" },
+          },
+        },
+      ])
+      expect(yield* restarted.pendingBackground).toEqual([])
+    }),
+  )
+
+  for (const delivered of [false, true]) {
+    it.effect(`does not duplicate a shell notification already ${delivered ? "delivered" : "admitted"}`, () =>
+      Effect.gen(function* () {
+        const database = yield* Database.Service
+        const bus = yield* Bus.Service
+        const jobs = yield* Job.Service
+        const sessions = yield* Session.Service
+        const sessionID = Session.ID.make("ses_shell_notification_retry")
+        yield* seedSessions(database, [sessionID])
+        yield* seedBackground(jobs, sessionID, [
+          { id: "call-shell-notified", shellID: "sh_notified", command: "echo done" },
+        ])
+        const background = (yield* jobs.pendingBackground)[0]
+        if (!background) return yield* Effect.die("background record missing")
+        yield* sessions.synthetic({
+          id: background.notificationID,
+          sessionID,
+          text: "Command already completed",
+          metadata: { source: "shell", shellID: "sh_notified", state: "completed" },
+          resume: false,
+        })
+        if (delivered) yield* SessionInbox.promote(database.db, bus, sessionID, "steer")
+
+        const scope = yield* Scope.make()
+        yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+        const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+        const context = yield* buildExecution(scope, () => Effect.void, undefined, restarted)
+        yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+
+        expect(yield* restarted.pendingBackground).toEqual([])
+        expect(yield* SessionInbox.list(database.db, sessionID)).toHaveLength(delivered ? 0 : 1)
+        yield* SessionInbox.promote(database.db, bus, sessionID, "steer")
+        expect(yield* sessions.messages({ sessionID })).toMatchObject([
+          {
+            id: background.notificationID,
+            type: "synthetic",
+            text: "Command already completed",
+            metadata: { state: "completed" },
+          },
+        ])
+        expect(yield* sessions.messages({ sessionID })).toHaveLength(1)
+      }),
+    )
+  }
+
+  it.effect("acknowledges recovery markers when their owning session is deleted", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const sessionID = Session.ID.make("ses_background_deleted")
+      yield* seedSessions(database, [sessionID])
+      yield* seedBackground(jobs, sessionID, [{ id: "call-deleted-shell", shellID: "sh_deleted", command: "sleep 60" }])
+      yield* database.db.delete(SessionTable).where(eq(SessionTable.id, sessionID)).run().pipe(Effect.orDie)
+
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(scope, () => Effect.void, undefined, restarted)
+      yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+
+      expect(yield* restarted.pendingBackground).toEqual([])
+    }),
+  )
+
+  it.effect("delivers cancellation at the resumed parent's next step", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const store = yield* SessionStore.Service
+      const bus = yield* Bus.Service
+      const parent = Session.ID.make("ses_background_claimed_parent")
+      yield* seedSessions(database, [parent], { time_suspended: Date.now() })
+      yield* seedBackground(jobs, parent, [{ id: "call-claimed-shell", shellID: "sh_claimed", command: "sleep 60" }])
+
+      const observed = yield* Deferred.make<string[]>()
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(
+        scope,
+        ({ sessionID }) =>
+          SessionInbox.promote(database.db, bus, sessionID, "steer").pipe(
+            Effect.andThen(store.context(sessionID)),
+            Effect.orDie,
+            Effect.flatMap((messages) =>
+              Deferred.succeed(
+                observed,
+                messages.filter((message) => message.type === "synthetic").map((message) => message.text),
+              ),
+            ),
+            Effect.asVoid,
+          ),
+        undefined,
+        restarted,
+      )
+      const execution = Context.get(context, SessionExecution.Service)
+      yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+      expect(yield* Deferred.await(observed)).toEqual([
+        "The server restarted while you were working. Continue from where you left off without repeating completed work.",
+        expect.stringContaining("Command cancelled because the server restarted"),
+      ])
+      yield* execution.awaitIdle(parent)
+      expect(yield* SessionInbox.list(database.db, parent)).toEqual([])
+      expect((yield* claims(database))[parent]).toBe(false)
+    }),
+  )
+
+  it.effect("resumes a background subagent and notifies its parent exactly once", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const parent = Session.ID.make("ses_subagent_recovery_parent")
+      const child = Session.ID.make("ses_subagent_recovery_child")
+      const unrelated = Session.ID.make("ses_subagent_unrelated_child")
+      yield* seedSessions(database, [parent], { time_suspended: Date.now(), resume_attempts: 1 })
+      yield* seedSessions(database, [child, unrelated], { parent_id: parent, time_suspended: Date.now() })
+      yield* jobs.start({
+        id: child,
+        type: "subagent",
+        recovery: {
+          kind: "subagent",
+          parentSessionID: parent,
+          childSessionID: child,
+          agent: "explore",
+          description: "Inspect recovery",
+        },
+        run: Effect.never,
+      })
+      yield* jobs.background(child)
+
+      const resumed = yield* Deferred.make<void>()
+      const release = yield* Deferred.make<void>()
+      const parentResumed = yield* Deferred.make<void>()
+      const parentWoken = yield* Deferred.make<void>()
+      const drained: Session.ID[] = []
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(
+        scope,
+        ({ sessionID }) =>
+          Effect.gen(function* () {
+            drained.push(sessionID)
+            if (sessionID === child) {
+              yield* Deferred.succeed(resumed, undefined)
+              yield* Deferred.await(release)
+              return
+            }
+            yield* Deferred.succeed(
+              drained.filter((id) => id === parent).length === 1 ? parentResumed : parentWoken,
+              undefined,
+            )
+          }),
+        undefined,
+        restarted,
+      )
+      const restart = Context.get(context, SessionRestart.Service)
+      const execution = Context.get(context, SessionExecution.Service)
+      yield* restart.resumeSuspendedSessions
+      yield* Deferred.await(resumed)
+      yield* Deferred.await(parentResumed)
+      yield* execution.awaitIdle(parent)
+
+      yield* restart.resumeSuspendedSessions
+      expect(drained.toSorted()).toEqual([child, parent].toSorted())
+      expect(yield* claims(database)).toEqual({ [parent]: false, [child]: true, [unrelated]: false })
+      expect(yield* attempts(database, child)).toBe(1)
+      expect(yield* restarted.get(child)).toMatchObject({ status: "running" })
+
+      yield* Deferred.succeed(release, undefined)
+      yield* Deferred.await(parentWoken)
+      expect(drained.filter((id) => id === child)).toHaveLength(1)
+      expect(drained.filter((id) => id === parent)).toHaveLength(2)
+      expect(yield* SessionInbox.list(database.db, parent)).toMatchObject([
+        {
+          payload: {
+            description: "Inspect recovery",
+            metadata: { source: "subagent", childID: child, agent: "explore", state: "completed" },
+          },
+        },
+      ])
+      expect(yield* restarted.pendingBackground).toEqual([])
+      yield* restart.resumeSuspendedSessions
+      expect(yield* SessionInbox.list(database.db, parent)).toHaveLength(1)
+    }),
+  )
+
+  it.effect("delivers a subagent result persisted before restart without rerunning the child", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const parent = Session.ID.make("ses_subagent_completed_parent")
+      const child = Session.ID.make("ses_subagent_completed_child")
+      yield* seedSessions(database, [parent])
+      yield* seedSessions(database, [child], { parent_id: parent })
+      const complete = yield* Deferred.make<string>()
+      yield* jobs.start({
+        id: child,
+        type: "subagent",
+        recovery: {
+          kind: "subagent",
+          parentSessionID: parent,
+          childSessionID: child,
+          agent: "explore",
+          description: "Completed inspection",
+        },
+        run: Deferred.await(complete),
+      })
+      yield* jobs.background(child)
+      yield* Deferred.succeed(complete, "Recovered result")
+      yield* jobs.wait({ id: child })
+
+      const parentWoken = yield* Deferred.make<void>()
+      const drained: Session.ID[] = []
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(
+        scope,
+        ({ sessionID }) =>
+          Effect.sync(() => void drained.push(sessionID)).pipe(
+            Effect.andThen(Deferred.succeed(parentWoken, undefined)),
+          ),
+        undefined,
+        restarted,
+      )
+      yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+      yield* Deferred.await(parentWoken)
+
+      expect(drained).toEqual([parent])
+      expect(yield* SessionInbox.list(database.db, parent)).toMatchObject([
+        { payload: { text: expect.stringContaining("Recovered result"), metadata: { state: "completed" } } },
+      ])
+      expect(yield* restarted.pendingBackground).toEqual([])
+    }),
+  )
+
+  for (const resumeAttempts of [1, 2]) {
+    it.effect(`honors a suspended parent's restart budget after ${resumeAttempts} attempts before notifying it`, () =>
+      Effect.gen(function* () {
+        const database = yield* Database.Service
+        const bus = yield* Bus.Service
+        const jobs = yield* Job.Service
+        const parent = Session.ID.make("ses_subagent_budget_parent")
+        const children = [
+          Session.ID.make("ses_subagent_budget_child_1"),
+          Session.ID.make("ses_subagent_budget_child_2"),
+        ]
+        yield* seedSessions(database, [parent], { time_suspended: Date.now(), resume_attempts: resumeAttempts })
+        yield* seedSessions(database, children, { parent_id: parent })
+        const complete = yield* Deferred.make<string>()
+        for (const child of children) {
+          yield* jobs.start({
+            id: child,
+            type: "subagent",
+            recovery: {
+              kind: "subagent",
+              parentSessionID: parent,
+              childSessionID: child,
+              agent: "explore",
+              description: "Completed inspection",
+            },
+            run: Deferred.await(complete),
+          })
+          yield* jobs.background(child)
+        }
+        yield* Deferred.succeed(complete, "Recovered result")
+        yield* Effect.forEach(children, (id) => jobs.wait({ id }), { discard: true })
+
+        const draining = yield* Deferred.make<number | undefined>()
+        const release = yield* Deferred.make<void>()
+        const drained: Session.ID[] = []
+        const continued: Session.ID[] = []
+        yield* bus.project(SessionEvent.Synthetic, (event) =>
+          Effect.sync(() => void continued.push(event.data.sessionID)),
+        )
+        const scope = yield* Scope.make()
+        yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+        const restarted = yield* Job.make.pipe(Scope.provide(scope))
+        const context = yield* buildExecution(
+          scope,
+          ({ sessionID }) =>
+            Effect.gen(function* () {
+              drained.push(sessionID)
+              yield* Deferred.succeed(draining, yield* attempts(database, sessionID))
+              yield* Deferred.await(release)
+            }),
+          { maxAttempts: 2 },
+          restarted,
+        )
+        const restart = Context.get(context, SessionRestart.Service)
+        const execution = Context.get(context, SessionExecution.Service)
+        yield* restart.resumeSuspendedSessions
+
+        if (resumeAttempts < 2) {
+          expect(yield* Deferred.await(draining)).toBe(2)
+          expect(drained).toEqual([parent])
+          expect(continued).toEqual([parent])
+          yield* Deferred.succeed(release, undefined)
+          yield* execution.awaitIdle(parent)
+        }
+        if (resumeAttempts === 2) {
+          expect(drained).toEqual([])
+          expect(continued).toEqual([])
+        }
+        expect((yield* claims(database))[parent]).toBe(false)
+        expect(yield* attempts(database, parent)).toBe(0)
+        expect(yield* SessionInbox.list(database.db, parent)).toHaveLength(2)
+        expect(yield* restarted.pendingBackground).toEqual([])
+        yield* restart.resumeSuspendedSessions
+        expect(drained).toHaveLength(resumeAttempts < 2 ? 1 : 0)
+      }),
+    )
+  }
+
+  it.effect("terminalizes a recovered subagent that exhausts its resume budget", () =>
+    Effect.gen(function* () {
+      const database = yield* Database.Service
+      const jobs = yield* Job.Service
+      const parent = Session.ID.make("ses_subagent_exhausted_parent")
+      const child = Session.ID.make("ses_subagent_exhausted_child")
+      yield* seedSessions(database, [parent])
+      yield* seedSessions(database, [child], { parent_id: parent, time_suspended: Date.now(), resume_attempts: 2 })
+      yield* jobs.start({
+        id: child,
+        type: "subagent",
+        recovery: {
+          kind: "subagent",
+          parentSessionID: parent,
+          childSessionID: child,
+          agent: "explore",
+          description: "Exhausted inspection",
+        },
+        run: Effect.never,
+      })
+      yield* jobs.background(child)
+
+      const parentWoken = yield* Deferred.make<void>()
+      const drained: Session.ID[] = []
+      const scope = yield* Scope.make()
+      yield* Effect.addFinalizer(() => Scope.close(scope, Exit.void))
+      const restarted = yield* Job.make.pipe(Effect.provideService(Scope.Scope, scope))
+      const context = yield* buildExecution(
+        scope,
+        ({ sessionID }) =>
+          Effect.sync(() => void drained.push(sessionID)).pipe(
+            Effect.andThen(Deferred.succeed(parentWoken, undefined)),
+          ),
+        { maxAttempts: 2 },
+        restarted,
+      )
+      yield* Context.get(context, SessionRestart.Service).resumeSuspendedSessions
+      yield* Deferred.await(parentWoken)
+
+      expect(drained).toEqual([parent])
+      expect((yield* claims(database))[child]).toBe(false)
+      expect(yield* SessionInbox.list(database.db, parent)).toMatchObject([
+        {
+          payload: {
+            text: expect.stringContaining("will not be resumed automatically"),
+            metadata: { source: "subagent", childID: child, state: "error" },
+          },
+        },
+      ])
+      expect(yield* restarted.pendingBackground).toEqual([])
+    }),
+  )
+})
+
 describe("SessionExecution interrupt continuation", () => {
   it.effect("resumes only steering input after an interrupt with continue", () =>
     Effect.gen(function* () {
@@ -446,6 +1021,27 @@ describe("SessionExecution interrupt continuation", () => {
   )
 })
 
+function seedBackground(
+  jobs: Job.Interface,
+  sessionID: Session.ID,
+  background: ReadonlyArray<{ readonly id: string; readonly shellID: string; readonly command: string }>,
+) {
+  return Effect.forEach(
+    background,
+    (job) =>
+      Effect.gen(function* () {
+        yield* jobs.start({
+          id: job.id,
+          type: "shell",
+          recovery: { kind: "shell", sessionID, shellID: job.shellID, command: job.command },
+          run: Effect.never,
+        })
+        yield* jobs.background(job.id)
+      }),
+    { discard: true },
+  )
+}
+
 /** Plain deliveries seed user prompts; objects seed control items. */
 function seedInbox(
   database: Database.Service["Service"],
@@ -531,14 +1127,32 @@ function buildExecution(
   scope: Scope.Closeable,
   drain: (input: Parameters<SessionRunner.Interface["drain"]>[0]) => Effect.Effect<void, SessionRunner.RunError>,
   options?: SessionRestart.Options,
+  overrideJobs?: Job.Interface,
 ) {
   return Effect.gen(function* () {
     const database = yield* Database.Service
     const bus = yield* Bus.Service
     const store = yield* SessionStore.Service
+    const jobs = overrideJobs ?? (yield* Job.Service)
+    const sessions = yield* Session.Service
+    const sessionLayer = Layer.effect(
+      Session.Service,
+      Effect.gen(function* () {
+        const execution = yield* SessionExecution.Service
+        return Session.Service.of({
+          ...sessions,
+          synthetic: (input) =>
+            sessions
+              .synthetic({ ...input, resume: false })
+              .pipe(Effect.tap(() => (input.resume === false ? Effect.void : execution.wake(input.sessionID)))),
+        })
+      }),
+    )
     const runner = Layer.succeed(
       SessionRunner.Service,
-      SessionRunner.Service.of({ drain: (input) => drain(input).pipe(Effect.as({ type: "complete" as const })) }),
+      SessionRunner.Service.of({
+        drain: (input) => drain(input).pipe(Effect.as(SessionRunner.DrainResult.Complete())),
+      }),
     )
     const locations = Layer.effect(
       LocationServiceMap.Service,
@@ -551,10 +1165,12 @@ function buildExecution(
     )
     return yield* Layer.buildWithScope(
       SessionRestart.layer(options).pipe(
-        Layer.provideMerge(SessionExecution.layer),
+        Layer.provideMerge(sessionLayer),
+        Layer.provideMerge(Layer.fresh(SessionExecution.layer)),
         Layer.provide(Layer.succeed(Database.Service, database)),
         Layer.provide(Layer.succeed(Bus.Service, bus)),
         Layer.provide(Layer.succeed(SessionStore.Service, store)),
+        Layer.provide(Layer.succeed(Job.Service, jobs)),
         Layer.provide(locations),
       ),
       scope,

packages/core/test/session-message-update.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect } from "bun:test"
+import path from "path"
+import { Effect, Layer, Stream } from "effect"
+import { asc, eq } from "drizzle-orm"
+import { Agent } from "@opencode-ai/core/agent"
+import { Bus } from "@opencode-ai/core/bus"
+import { Database } from "@opencode-ai/core/database/database"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { EventTable } from "@opencode-ai/core/event/sql"
+import { Location } from "@opencode-ai/core/location"
+import { Model } from "@opencode-ai/core/model"
+import { Project } from "@opencode-ai/core/project"
+import { ProjectTable } from "@opencode-ai/core/project/sql"
+import { Provider } from "@opencode-ai/core/provider"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { Session } from "@opencode-ai/core/session"
+import { SessionEvent } from "@opencode-ai/core/session/event"
+import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { SessionMessage } from "@opencode-ai/core/session/message"
+import { SessionProjector } from "@opencode-ai/core/session/projector"
+import { SessionStore } from "@opencode-ai/core/session/store"
+import { Money } from "@opencode-ai/schema/money"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { tmpdir } from "./fixture/tmpdir"
+import { testEffect } from "./lib/effect"
+import { globalProjectLayer } from "./lib/project"
+
+const active = new Set<Session.ID>()
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Session.node]),
+    [
+      [Bus.node, Bus.configured({ persist: true })],
+      [Project.node, globalProjectLayer],
+      [
+        SessionExecution.node,
+        Layer.succeed(
+          SessionExecution.Service,
+          SessionExecution.Service.of({
+            active: Effect.sync(() => active),
+            resume: () => Effect.void,
+            wake: () => Effect.void,
+            interrupt: () => Effect.succeed(false),
+            awaitIdle: () => Effect.void,
+          }),
+        ),
+      ],
+    ],
+  ),
+)
+const location = Location.Ref.make({ directory: AbsolutePath.make("/project") })
+const model = { id: Model.ID.make("model"), providerID: Provider.ID.make("provider") }
+
+const start = (bus: Bus.Interface, sessionID: Session.ID, messageID: SessionMessage.ID) =>
+  bus.publish(SessionEvent.Step.Started, {
+    sessionID,
+    assistantMessageID: messageID,
+    agent: Agent.defaultID,
+    model,
+  })
+
+const complete = (bus: Bus.Interface, sessionID: Session.ID, messageID: SessionMessage.ID) =>
+  bus.publish(SessionEvent.Step.Ended, {
+    sessionID,
+    assistantMessageID: messageID,
+    finish: "stop",
+    cost: Money.USD.make(0),
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  })
+
+describe("Session.updateMessage", () => {
+  it.effect("replaces assistant content through a durable projected event", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const db = (yield* Database.Service).db
+      const created = yield* session.create({ location })
+      const messageID = SessionMessage.ID.create()
+      yield* start(bus, created.id, messageID)
+      yield* complete(bus, created.id, messageID)
+
+      const content = [
+        SessionMessage.AssistantText.make({ type: "text", text: "replacement" }),
+        SessionMessage.AssistantReasoning.make({
+          type: "reasoning",
+          text: "updated reasoning",
+          time: { created: created.time.created },
+        }),
+      ]
+      const updated = yield* session.updateMessage({ sessionID: created.id, messageID, content })
+
+      expect(updated.content).toEqual(content)
+      expect(yield* session.message({ sessionID: created.id, messageID })).toMatchObject({ content })
+      expect((yield* session.messages({ sessionID: created.id }))[0]).toMatchObject({ id: messageID, content })
+
+      const events = Array.from(yield* Stream.runCollect(session.log({ sessionID: created.id })))
+      expect(events.at(-2)).toMatchObject({
+        type: "session.message.content.updated",
+        data: {
+          sessionID: created.id,
+          messageID,
+          content: [
+            { type: "text", text: "replacement" },
+            { type: "reasoning", text: "updated reasoning", time: { created: expect.any(Number) } },
+          ],
+        },
+      })
+      expect(
+        yield* db
+          .select()
+          .from(EventTable)
+          .where(eq(EventTable.type, Bus.versionedType(SessionEvent.MessageContentUpdated.type, 1)))
+          .get(),
+      ).toMatchObject({ aggregate_id: created.id, data: { messageID } })
+
+      expect((yield* session.updateMessage({ sessionID: created.id, messageID, content: [] })).content).toEqual([])
+    }),
+  )
+
+  it.effect("replays updated assistant content into a fresh projection", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const db = (yield* Database.Service).db
+      const created = yield* session.create({ location })
+      const messageID = SessionMessage.ID.create()
+      yield* start(bus, created.id, messageID)
+      yield* complete(bus, created.id, messageID)
+      const content = [
+        SessionMessage.AssistantReasoning.make({
+          type: "reasoning",
+          text: "replayed reasoning",
+          time: { created: created.time.created },
+        }),
+      ]
+      yield* session.updateMessage({ sessionID: created.id, messageID, content })
+
+      const serialized = (yield* db
+        .select()
+        .from(EventTable)
+        .where(eq(EventTable.aggregate_id, created.id))
+        .orderBy(asc(EventTable.seq))
+        .all()
+        .pipe(Effect.orDie)).map((event) => ({
+        id: event.id,
+        created: event.created,
+        aggregateID: event.aggregate_id,
+        seq: event.seq,
+        type: event.type,
+        data: event.data,
+      }))
+      const tmp = yield* Effect.acquireRelease(
+        Effect.promise(() => tmpdir()),
+        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+      )
+      const target = AppNodeBuilder.build(
+        LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node]),
+        [
+          [Database.node, Database.configured({ path: path.join(tmp.path, "target.sqlite") })],
+          [Bus.node, Bus.configured({ persist: true })],
+        ],
+      )
+
+      yield* Effect.gen(function* () {
+        const database = (yield* Database.Service).db
+        const replay = yield* Bus.Service
+        const store = yield* SessionStore.Service
+        yield* database
+          .insert(ProjectTable)
+          .values({ id: Project.ID.global, worktree: location.directory, sandboxes: [] })
+          .run()
+          .pipe(Effect.orDie)
+        yield* Effect.forEach(serialized, (event) => replay.replay(event), { discard: true })
+        expect((yield* store.message(messageID))?.message).toMatchObject({ content })
+      }).pipe(Effect.provide(Layer.fresh(target)))
+    }),
+  )
+
+  it.effect("rejects missing and cross-session messages", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const created = yield* session.create({ location })
+      const other = yield* session.create({ location })
+      const messageID = SessionMessage.ID.create()
+      yield* start(bus, created.id, messageID)
+      yield* complete(bus, created.id, messageID)
+
+      expect(yield* Effect.flip(session.updateMessage({ sessionID: other.id, messageID, content: [] }))).toEqual(
+        new Session.MessageNotFoundError({ sessionID: other.id, messageID }),
+      )
+      const missing = Session.ID.create()
+      expect(yield* Effect.flip(session.updateMessage({ sessionID: missing, messageID, content: [] }))).toEqual(
+        new Session.NotFoundError({ sessionID: missing }),
+      )
+    }),
+  )
+
+  it.effect("rejects non-assistant messages, incomplete assistants, and unfinished tools", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const created = yield* session.create({ location })
+      const synthetic = yield* bus.publish(SessionEvent.Synthetic, { sessionID: created.id, text: "synthetic" })
+      const syntheticID = SessionMessage.ID.fromEvent(synthetic.id)
+
+      expect(
+        yield* Effect.flip(session.updateMessage({ sessionID: created.id, messageID: syntheticID, content: [] })),
+      ).toEqual(new Session.MessageNotAssistantError({ sessionID: created.id, messageID: syntheticID }))
+
+      const messageID = SessionMessage.ID.create()
+      yield* start(bus, created.id, messageID)
+      expect(yield* Effect.flip(session.updateMessage({ sessionID: created.id, messageID, content: [] }))).toEqual(
+        new Session.MessageIncompleteError({ sessionID: created.id, messageID }),
+      )
+
+      yield* complete(bus, created.id, messageID)
+      const unfinished = SessionMessage.AssistantTool.make({
+        type: "tool",
+        id: "call_unfinished",
+        name: "read",
+        state: { status: "streaming", input: "" },
+        time: { created: created.time.created },
+      })
+      expect(
+        yield* Effect.flip(session.updateMessage({ sessionID: created.id, messageID, content: [unfinished] })),
+      ).toEqual(new Session.MessageToolIncompleteError({ sessionID: created.id, messageID }))
+    }),
+  )
+
+  it.effect("rejects a completed assistant while its session is active", () =>
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const bus = yield* Bus.Service
+      const created = yield* session.create({ location })
+      const messageID = SessionMessage.ID.create()
+      yield* start(bus, created.id, messageID)
+      yield* complete(bus, created.id, messageID)
+      active.add(created.id)
+      const failure = yield* Effect.flip(session.updateMessage({ sessionID: created.id, messageID, content: [] }))
+      active.delete(created.id)
+
+      expect(failure).toEqual(new Session.BusyError({ sessionID: created.id }))
+    }),
+  )
+})

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

@@ -784,6 +784,10 @@ describe("SessionProjector", () => {
         .pipe(Effect.orDie)
 
       const service = yield* Bus.Service
+      yield* service.publish(SessionEvent.Step.Streamed, {
+        sessionID,
+        assistantMessageID: endedID,
+      })
       yield* service.publish(SessionEvent.Step.Ended, {
         sessionID,
         assistantMessageID: endedID,
@@ -824,7 +828,7 @@ describe("SessionProjector", () => {
         cost: Money.USD.make(1),
         tokens: { input: 2, output: 3, reasoning: 4, cache: { read: 5, write: 6 } },
         snapshot: { end: "snap_ended", files: ["src/ended.ts"] },
-        time: { completed: created },
+        time: { streamed: created, completed: created },
       })
       expect(messages[1]).toMatchObject({
         type: "assistant",