refactor(core): extract config discovery engine

Merge session status changes received during activity hydration and ignore superseded reconnect responses. Cover terminal events, starts, deletion, and overlapping connections so idle sessions do not regain stale TUI spinners.

bun.lock

@@ -966,7 +966,6 @@
         "mime-types": "3.0.2",
         "minimatch": "10.2.5",
         "npm-package-arg": "13.0.2",
-        "pacote": "21.5.1",
         "resolve.exports": "catalog:",
       },
       "devDependencies": {
@@ -976,7 +975,6 @@
         "@types/node": "catalog:",
         "@types/npm-package-arg": "6.1.4",
         "@types/npmcli__arborist": "6.3.3",
-        "@types/pacote": "11.1.8",
         "@typescript/native-preview": "catalog:",
       },
     },
@@ -5814,7 +5812,7 @@
 
     "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
 
-    "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+    "yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
 
     "yaml": ["yaml@2.9.0", "", { "bin": { "yaml": "bin.mjs" } }, "sha512-2AvhNX3mb8zd6Zy7INTtSpl1F15HW6Wnqj0srWlkKLcpYl/gMIMJiyuGq2KeI2YFxUPjdlB+3Lc10seMLtL4cA=="],
 
@@ -6644,6 +6642,8 @@
 
     "svgo/commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="],
 
+    "tar/yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="],
+
     "temp/rimraf": ["rimraf@2.6.3", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "./bin.js" } }, "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA=="],
 
     "tempy/type-fest": ["type-fest@0.16.0", "", {}, "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg=="],
@@ -7450,12 +7450,6 @@
 
     "miniflare/sharp/@img/sharp-win32-x64": ["@img/sharp-win32-x64@0.33.5", "", { "os": "win32", "cpu": "x64" }, "sha512-MpY/o8/8kj+EcnxwvrP4aTJSWw/aZ7JIGR4aBeZkZw5B7/Jn+tY9/VNwtcoGmdT7GfggGIU4kygOMSbYnOrAbg=="],
 
-    "minipass-flush/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
-
-    "minipass-pipeline/minipass/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
-
-    "openid-client/lru-cache/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
-
     "p-locate/p-limit/yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
 
     "pkg-dir/find-up/locate-path": ["locate-path@5.0.0", "", { "dependencies": { "p-locate": "^4.1.0" } }, "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g=="],
@@ -8162,8 +8156,6 @@
 
     "app-builder-lib/@electron/get/fs-extra/universalify": ["universalify@0.1.2", "", {}, "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg=="],
 
-    "app-builder-lib/hosted-git-info/lru-cache/yallist": ["yallist@4.0.0", "", {}, "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="],
-
     "archiver-utils/glob/jackspeak/@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
 
     "archiver-utils/glob/minimatch/brace-expansion": ["brace-expansion@2.1.4", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-hGfVzPxthbf3+2yjg/RBs60cB0FhqBS/zvdV/4wn4/BmN0bNMMHPc4V/BbFieqf1TKAGGAHnY4eSjajCl0f2Xg=="],

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-Fmwqp/fjTMX7gQW01Zgta51reLHp1S53GSQgBcJePrY=",
-    "aarch64-linux": "sha256-KLI6OIbvycMePKxt66nNKeILYJSEkufOIaSawZ/gotc=",
-    "aarch64-darwin": "sha256-go1wmrsHfYfJ3ukUIR/fveobyVba4E9G/rdsB/J2cQQ=",
-    "x86_64-darwin": "sha256-UnVYMijlG12k4RLFkTwf4Or0yXqFSwe1Ji6QCGufjzg="
+    "x86_64-linux": "sha256-EtUp4pHl9TyPtRrLGvk/X7kd2LuIxNxCpUwF5aLtzN4=",
+    "aarch64-linux": "sha256-m0j/pMZCguclR3/T9JmzCfi11YzmIvBFyR2bVhIO37Y=",
+    "aarch64-darwin": "sha256-nqefk68ZTUfNU15q1WkXaGsFzPNwOjCtMHpp6WrpNqM=",
+    "x86_64-darwin": "sha256-syD7hX62E4yCDV/wux1QKw4q/zZr24f99Y2mmzMJo6o="
   }
 }

packages/ai/README.md

@@ -214,22 +214,40 @@ the requests sent by code under test:
 import { Effect } from "effect"
 import { TestLLM } from "@opencode-ai/ai/testing"
 
-const testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
 const programWithTestClient = Effect.gen(function* () {
+  const test = yield* TestLLM.Test
+  yield* test.push(TestLLM.text("Hello from the test model", "text-1"))
   const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
+  console.log(yield* test.requests())
   return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
+}).pipe(Effect.provide(TestLLM.testLayer()))
 ```
 
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
+`testLayer()` provides the same object under `LLMClient.Service` and `TestLLM.Test`. Production consumes the
+normal client; tests use the additional controls. Each layer build has fresh state.
+
+- `test.push(...)` queues one-shot responses in execution order. Each argument is one response.
+- `test.always(response)` installs a repeatable fallback. The layer's `fallback` option sets its initial value.
+- `test.serve(request => response)` installs a request-dependent fallback. `always` and `serve` replace each
+  other without changing queued replies; queued replies take precedence.
+- `test.requests()` returns an array snapshot. `transformRequest` changes only the recorded observation;
+  `serve` receives the original canonical request.
+- `test.wait(count)` waits for request arrivals, not output or completion, and supports concurrent waiters.
+- `test.gate()` returns a scoped gate with countable `started` notifications and a `release` Effect. Release
+  unblocks all requests captured by that gate; closing its scope also releases it. Effect-aware test runners
+  already provide Scope.
+
+Constructing `stream()` or `generate()` does not record a request, invoke a responder, or consume a script.
+Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
+future reply.
+
+Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
+it does not repair or truncate them.
+
+The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
+over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
+`testLayer`.
 
 ## Caching
 

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

@@ -496,6 +496,7 @@ const mapUsage = (usage: BedrockUsageSchema | undefined, providerMetadataKey: st
 interface ParserState {
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<number>
+  readonly finishedTools: ReadonlySet<number>
   // Bedrock splits the finish into `messageStop` (carries `stopReason`) and
   // `metadata` (carries usage). Hold the terminal event in state so `onHalt`
   // can emit exactly one finish after both chunks have had a chance to arrive.
@@ -574,6 +575,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
 
     if (event.contentBlockDelta?.delta?.toolUse) {
       const index = event.contentBlockDelta.contentBlockIndex
+      if (state.finishedTools.has(index)) return [state, []] as const
       const result = ToolStream.appendExisting(
         ADAPTER,
         state.tools,
@@ -612,6 +614,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
             state.hasToolCalls,
           lifecycle,
           tools: result.tools,
+          finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
           reasoningSignatures: Object.fromEntries(
             Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index)),
           ),
@@ -703,6 +706,7 @@ export const protocol = Protocol.make({
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
+      finishedTools: new Set<number>(),
       pendingFinish: undefined,
       hasToolCalls: false,
       lifecycle: Lifecycle.initial(),

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

@@ -391,17 +391,19 @@ export interface ParserState {
   readonly name: string
   readonly providerMetadataKey: string
   readonly tools: ToolStream.State<string>
+  // Call ids stay independent of item ids, which may be omitted or reused.
+  readonly completedTools: ReadonlySet<string>
   readonly hasFunctionCall: boolean
   readonly lifecycle: Lifecycle.State
   readonly outputItems: Readonly<Record<number, string>>
-  readonly messageItems: ReadonlySet<string>
-  readonly messagePhases: Readonly<Record<string, MessagePhase | null>>
+  readonly message: { readonly id: string; readonly phase: MessagePhase | null | undefined } | undefined
   readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>
 }
 
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded"
 
 interface ReasoningStreamItem {
+  readonly open: boolean
   readonly encryptedContent: string | null | undefined
   // Keyed by the wire protocol's numeric `summary_index`. JS object keys coerce to
   // strings, but typing the map as `Record<number, ...>` documents intent
@@ -826,16 +828,16 @@ const TERMINAL_TYPES = new Set(["error", "response.completed", "response.incompl
 export const terminal = (event: Event) => TERMINAL_TYPES.has(event.type)
 
 const onOutputTextDelta = (state: ParserState, event: Event, id: string): StepResult => {
-  if (!event.delta || !state.messageItems.has(id)) return [state, NO_EVENTS]
+  if (!event.delta || state.message?.id !== id) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
-  const phase = state.messagePhases[id]
+  const phase = state.message.phase
   const metadata = providerMetadata(state, { itemId: id, ...(phase === undefined ? {} : { phase }) })
   const lifecycle = Lifecycle.textStart(state.lifecycle, events, id, metadata)
   return [{ ...state, lifecycle: Lifecycle.textDelta(lifecycle, events, id, event.delta) }, events]
 }
 
 const onOutputTextDone = (state: ParserState, event: Event, id: string): StepResult => {
-  if (state.messageItems.has(id)) {
+  if (state.message?.id === id) {
     if (state.lifecycle.text.has(id) || event.text === undefined) return [state, NO_EVENTS]
     return onOutputTextDelta(state, { ...event, delta: event.text }, id)
   }
@@ -846,18 +848,62 @@ const onOutputTextDone = (state: ParserState, event: Event, id: string): StepRes
 export const outputItemID = (state: ParserState, event: Event) =>
   event.output_index === undefined ? event.item_id : (state.outputItems[event.output_index] ?? event.item_id)
 
-export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
+const startReasoningSummaryPart = (state: ParserState, itemID: string, index: number): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!event.delta || !item) return [state, NO_EVENTS]
-  const index = event.summary_index ?? 0
+  if (!item?.open || index === 0 || item.summaryParts[index] !== undefined) return [state, NO_EVENTS]
+
   const events: LLMEvent[] = []
+  const lifecycle = Object.entries(item.summaryParts)
+    .filter((entry) => entry[1] !== "concluded")
+    .reduce(
+      (lifecycle, entry) =>
+        Lifecycle.reasoningEnd(lifecycle, events, `${itemID}:${entry[0]}`, providerMetadata(state, { itemId: itemID })),
+      state.lifecycle,
+    )
   return [
     {
       ...state,
-      lifecycle: Lifecycle.reasoningDelta(state.lifecycle, events, `${itemID}:${index}`, event.delta),
+      lifecycle: Lifecycle.reasoningStart(
+        lifecycle,
+        events,
+        `${itemID}:${index}`,
+        providerMetadata(state, { itemId: itemID, reasoningEncryptedContent: item.encryptedContent ?? null }),
+      ),
       reasoningItems: {
         ...state.reasoningItems,
-        [itemID]: { ...item, deltaIndexes: new Set([...item.deltaIndexes, index]) },
+        [itemID]: {
+          ...item,
+          summaryParts: {
+            ...Object.fromEntries(
+              Object.entries(item.summaryParts).map((entry) =>
+                entry[1] === "concluded" ? entry : [entry[0], "concluded" as const],
+              ),
+            ),
+            [index]: "active",
+          },
+        },
+      },
+    },
+    events,
+  ]
+}
+
+export const onReasoningDelta = (state: ParserState, event: Event, itemID: string): StepResult => {
+  const item = state.reasoningItems[itemID]
+  if (!event.delta || !item?.open) return [state, NO_EVENTS]
+  const index = event.summary_index ?? 0
+  if (item.summaryParts[index] === "concluded") return [state, NO_EVENTS]
+  const [started, emitted] = startReasoningSummaryPart(state, itemID, index)
+  const current = started.reasoningItems[itemID]
+  if (!current) return [started, emitted]
+  const events: LLMEvent[] = [...emitted]
+  return [
+    {
+      ...started,
+      lifecycle: Lifecycle.reasoningDelta(started.lifecycle, events, `${itemID}:${index}`, event.delta),
+      reasoningItems: {
+        ...started.reasoningItems,
+        [itemID]: { ...current, deltaIndexes: new Set([...current.deltaIndexes, index]) },
       },
     },
     events,
@@ -869,7 +915,7 @@ export const onReasoningDelta = (state: ParserState, event: Event, itemID: strin
 // as a single delta unless that summary index already streamed one.
 export const onReasoningDone = (state: ParserState, event: Event, itemID: string): StepResult => {
   const item = state.reasoningItems[itemID]
-  if (!item || typeof event.text !== "string") return [state, NO_EVENTS]
+  if (!item?.open || typeof event.text !== "string") return [state, NO_EVENTS]
   const index = event.summary_index ?? 0
   if (item.deltaIndexes.has(index)) return [state, NO_EVENTS]
   return onReasoningDelta(state, { ...event, delta: event.text }, itemID)
@@ -878,32 +924,48 @@ export const onReasoningDone = (state: ParserState, event: Event, itemID: string
 const reasoningMetadata = (state: ParserState, item: StreamItem & { id: string }) =>
   providerMetadata(state, { itemId: item.id, reasoningEncryptedContent: item.encrypted_content ?? null })
 
-// Responses APIs stream reasoning items in a stable order:
+// Responses APIs normally stream reasoning items in this order:
 //   `output_item.added` (reasoning) →
 //     `reasoning_summary_part.added` (index=0) →
 //     `reasoning_summary_text.delta` →
 //     `reasoning_summary_part.done` (index=0) →
 //     (repeat for index>0) →
 //   `output_item.done` (reasoning).
-// The handlers below rely on this ordering: `onOutputItemAdded` seeds the
-// per-item entry, `onReasoningSummaryPartAdded` for `summary_index === 0`
-// short-circuits when the entry already exists, and higher-index handlers
-// fold against the same entry. Behaviour for out-of-order events is
-// best-effort, not guaranteed.
+// `onOutputItemAdded` seeds the per-item entry, while each later part start is
+// also an implicit boundary for the previous part. This keeps the common event
+// lifecycle ordered when a compatible provider omits or delays a part-done event.
 const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
   const item = event.item
   if (item?.type === "message" && item.id !== undefined) {
+    const itemID = item.id
     const phase = messagePhase(item.phase)
+    // A new message closes earlier messages, including ones that never streamed.
+    const events: LLMEvent[] = []
+    const lifecycle = [...state.lifecycle.text]
+      .filter((id) => id !== itemID)
+      .reduce((lifecycle, id) => {
+        const openPhase = state.message?.id === id ? state.message.phase : undefined
+        return Lifecycle.textEnd(
+          lifecycle,
+          events,
+          id,
+          providerMetadata(state, { itemId: id, ...(openPhase === undefined ? {} : { phase: openPhase }) }),
+        )
+      }, state.lifecycle)
     return [
       {
         ...state,
-        messageItems: new Set([...state.messageItems, item.id]),
-        messagePhases: phase === undefined ? state.messagePhases : { ...state.messagePhases, [item.id]: phase },
+        lifecycle,
+        message: {
+          id: itemID,
+          phase: phase === undefined && state.message?.id === itemID ? state.message.phase : phase,
+        },
       },
-      NO_EVENTS,
+      events,
     ]
   }
   if (item && isReasoningItem(item)) {
+    if (state.reasoningItems[item.id] !== undefined) return [state, NO_EVENTS]
     const events: LLMEvent[] = []
     return [
       {
@@ -912,6 +974,7 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
         reasoningItems: {
           ...state.reasoningItems,
           [item.id]: {
+            open: true,
             encryptedContent: item.encrypted_content,
             summaryParts: { 0: "active" },
             deltaIndexes: new Set(),
@@ -923,6 +986,8 @@ 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
+  if (Object.values(state.tools).some((tool) => tool?.id === item.call_id) || state.completedTools.has(item.call_id))
+    return [state, NO_EVENTS]
   const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
@@ -943,55 +1008,14 @@ const onOutputItemAdded = (state: ParserState, event: Event): StepResult => {
 
 const onReasoningSummaryPartAdded = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
-  const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
-  if (event.summary_index === 0) return [state, NO_EVENTS]
-
-  const events: LLMEvent[] = []
-  const closed = Object.entries(item.summaryParts)
-    .filter((entry) => entry[1] === "can-conclude")
-    .reduce(
-      (lifecycle, entry) =>
-        Lifecycle.reasoningEnd(
-          lifecycle,
-          events,
-          `${event.item_id}:${entry[0]}`,
-          providerMetadata(state, { itemId: event.item_id }),
-        ),
-      state.lifecycle,
-    )
-  return [
-    {
-      ...state,
-      lifecycle: Lifecycle.reasoningStart(
-        closed,
-        events,
-        `${event.item_id}:${event.summary_index}`,
-        providerMetadata(state, { itemId: event.item_id, reasoningEncryptedContent: item.encryptedContent ?? null }),
-      ),
-      reasoningItems: {
-        ...state.reasoningItems,
-        [event.item_id]: {
-          ...item,
-          summaryParts: {
-            ...Object.fromEntries(
-              Object.entries(item.summaryParts).map((entry) =>
-                entry[1] === "can-conclude" ? [entry[0], "concluded" as const] : entry,
-              ),
-            ),
-            [event.summary_index]: "active",
-          },
-        },
-      },
-    },
-    events,
-  ]
+  return startReasoningSummaryPart(state, event.item_id, event.summary_index)
 }
 
 const onReasoningSummaryPartDone = (state: ParserState, event: Event): StepResult => {
   if (event.item_id === undefined || event.summary_index === undefined) return [state, NO_EVENTS]
   const item = state.reasoningItems[event.item_id]
-  if (!item) return [state, NO_EVENTS]
+  if (!item?.open) return [state, NO_EVENTS]
+  if (item.summaryParts[event.summary_index] !== "active") return [state, NO_EVENTS]
   return [
     {
       ...state,
@@ -1047,11 +1071,8 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "message" && item.id !== undefined) {
     const itemPhase = messagePhase(item.phase)
-    const phase = itemPhase === undefined ? state.messagePhases[item.id] : itemPhase
+    const phase = itemPhase === undefined && state.message?.id === item.id ? state.message.phase : itemPhase
     const events: LLMEvent[] = []
-    const messageItems = new Set(state.messageItems)
-    messageItems.delete(item.id)
-    const { [item.id]: _phase, ...messagePhases } = state.messagePhases
     return [
       {
         ...state,
@@ -1061,8 +1082,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           item.id,
           providerMetadata(state, { itemId: item.id, ...(phase === undefined ? {} : { phase }) }),
         ),
-        messageItems,
-        messagePhases,
+        message: state.message?.id === item.id ? undefined : state.message,
       },
       events,
     ] satisfies StepResult
@@ -1070,20 +1090,36 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
 
   if (item.type === "function_call") {
     if (!item.call_id || !item.name) return [state, NO_EVENTS] satisfies StepResult
-    const id = item.id ?? item.call_id
-    const tools = state.tools[id]
-      ? state.tools
-      : ToolStream.start(state.tools, id, {
-          id: item.call_id,
-          name: item.name,
-          providerMetadata: item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined,
-        })
+    const callID = item.call_id
+    if (state.completedTools.has(callID)) return [state, NO_EVENTS] satisfies StepResult
+    const metadata = item.id !== undefined ? providerMetadata(state, { itemId: item.id }) : undefined
+    const fallback = item.id ?? callID
+    // Match the pending tool by call id so item events that disagree on
+    // whether `item.id` is present still resolve the same call.
+    const registered =
+      state.tools[fallback] !== undefined
+        ? fallback
+        : Object.keys(state.tools).find((key) => state.tools[key]?.id === callID)
+    const id = registered ?? fallback
+    const tools =
+      registered !== undefined
+        ? state.tools
+        : ToolStream.start(state.tools, id, {
+            id: callID,
+            name: item.name,
+            providerMetadata: metadata,
+          })
     const result =
       item.arguments === undefined
         ? yield* ToolStream.finish(state.id, tools, id)
         : yield* ToolStream.finishWithInput(state.id, tools, id, item.arguments)
     const events: LLMEvent[] = []
-    const resultEvents = result.events ?? []
+    const finished = result.events ?? []
+    // A done-only call never streamed a start event, so open its lifecycle here.
+    const resultEvents =
+      registered !== undefined || finished.length === 0
+        ? finished
+        : [LLMEvent.toolInputStart({ id: callID, name: item.name, providerMetadata: metadata }), ...finished]
     const lifecycle = resultEvents.length ? Lifecycle.stepStart(state.lifecycle, events) : state.lifecycle
     events.push(...resultEvents)
     return [
@@ -1094,6 +1130,7 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
           resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
           state.hasFunctionCall,
         tools: result.tools,
+        completedTools: new Set([...state.completedTools, callID]),
       },
       events,
     ] satisfies StepResult
@@ -1104,20 +1141,49 @@ const onOutputItemDone = Effect.fn("OpenResponses.onOutputItemDone")(function* (
     const metadata = reasoningMetadata(state, item)
     const reasoningItem = state.reasoningItems[item.id]
     if (reasoningItem) {
+      if (!reasoningItem.open) return [state, NO_EVENTS] satisfies StepResult
       const lifecycle = Object.entries(reasoningItem.summaryParts)
         .filter((entry) => entry[1] === "active" || entry[1] === "can-conclude")
         .reduce(
           (lifecycle, entry) => Lifecycle.reasoningEnd(lifecycle, events, `${item.id}:${entry[0]}`, metadata),
           state.lifecycle,
         )
-      const { [item.id]: _removed, ...reasoningItems } = state.reasoningItems
-      return [{ ...state, lifecycle, reasoningItems }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              ...reasoningItem,
+              open: false,
+              encryptedContent: item.encrypted_content ?? reasoningItem.encryptedContent,
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
     }
     if (!state.lifecycle.reasoning.has(item.id)) {
       const lifecycle = Lifecycle.stepStart(state.lifecycle, events)
       events.push(LLMEvent.reasoningStart({ id: item.id, providerMetadata: metadata }))
       events.push(LLMEvent.reasoningEnd({ id: item.id, providerMetadata: metadata }))
-      return [{ ...state, lifecycle }, events] satisfies StepResult
+      return [
+        {
+          ...state,
+          lifecycle,
+          reasoningItems: {
+            ...state.reasoningItems,
+            [item.id]: {
+              open: false,
+              encryptedContent: item.encrypted_content,
+              summaryParts: { 0: "concluded" },
+              deltaIndexes: new Set(),
+            },
+          },
+        },
+        events,
+      ] satisfies StepResult
     }
     return [
       { ...state, lifecycle: Lifecycle.reasoningEnd(state.lifecycle, events, item.id, metadata) },
@@ -1139,7 +1205,7 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
             if (
               id === undefined ||
               ((item.type !== "function_call" || !current.tools[id]) &&
-                (item.type !== "reasoning" || !current.reasoningItems[id]))
+                (item.type !== "reasoning" || !current.reasoningItems[id]?.open))
             )
               return Effect.succeed([current, events] satisfies StepResult)
             return onOutputItemDone(current, { type: "response.output_item.done", item }).pipe(
@@ -1256,6 +1322,13 @@ export const step = (state: ParserState, input: Event) => {
   if (event.type === "response.output_item.added") {
     if (event.item?.type === "message" && event.item.id === undefined)
       return ProviderShared.eventError(state.id, `${event.type} message is missing id`)
+    if (
+      event.item &&
+      isReasoningItem(event.item) &&
+      state.reasoningItems[event.item.id] === undefined &&
+      state.lifecycle.reasoning.size > 0
+    )
+      return ProviderShared.eventError(state.id, `${event.type} started reasoning before the previous item ended`)
     const id = event.item?.id ?? (event.item?.type === "function_call" ? event.item.call_id : undefined)
     return Effect.succeed(
       onOutputItemAdded(
@@ -1305,10 +1378,10 @@ export const initial = (request: LLMRequest, extension: Extension = BASE): Parse
   providerMetadataKey: request.model.route.providerMetadataKey ?? "openresponses",
   hasFunctionCall: false,
   tools: ToolStream.empty<string>(),
+  completedTools: new Set<string>(),
   lifecycle: Lifecycle.initial(),
   outputItems: {},
-  messageItems: new Set<string>(),
-  messagePhases: {},
+  message: undefined,
   reasoningItems: {},
 })
 

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

@@ -3,6 +3,7 @@ import { Tool } from "@opencode-ai/schema/tool"
 import { Route } from "../route/client.js"
 import { Auth } from "../route/auth.js"
 import { Endpoint } from "../route/endpoint.js"
+import { Framing } from "../route/framing.js"
 import { HttpTransport } from "../route/transport/index.js"
 import { Protocol } from "../route/protocol.js"
 import {
@@ -245,6 +246,8 @@ export const OpenAIChatEvent = Schema.StructWithRest(
   [Schema.Record(Schema.String, Schema.Unknown)],
 )
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
+const DONE = "[DONE]" as const
+const OpenAIChatStreamEvent = Schema.Union([Schema.Literal(DONE), Protocol.jsonEvent(OpenAIChatEvent)])
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]
 
 interface PendingToolDelta {
@@ -1166,7 +1169,7 @@ export const protocol = Protocol.make({
     from: fromRequest,
   },
   stream: {
-    event: Protocol.jsonEvent(OpenAIChatEvent),
+    event: OpenAIChatStreamEvent,
     initial: (request) => ({
       providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
       tools: ToolStream.empty<number>(),
@@ -1180,12 +1183,14 @@ export const protocol = Protocol.make({
       nextToolIndex: 0,
       requireFinishReason: request.model.compatibility?.requireFinishReason ?? true,
     }),
-    step,
+    step: (state: ParserState, event) => (event === DONE ? Effect.succeed([state, []] as const) : step(state, event)),
+    terminal: (event) => event === DONE,
     onHalt: finishEvents,
   },
 })
 
-export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>()
+export const framing = Framing.sseWithDone
+export const httpTransport = HttpTransport.sseJson.with<OpenAIChatBody>().with({ framing })
 
 export const route = Route.make({
   id: ADAPTER,

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

@@ -1,6 +1,5 @@
 import { Route, type RouteRoutedLanguageModelInput } from "../route/client.js"
 import { Endpoint } from "../route/endpoint.js"
-import { Framing } from "../route/framing.js"
 import * as OpenAIChat from "./openai-chat.js"
 
 const ADAPTER = "openai-compatible-chat"
@@ -19,7 +18,7 @@ export const route = Route.make({
   providerMetadataKey: "openai",
   protocol: OpenAIChat.protocol,
   endpoint: Endpoint.path("/chat/completions"),
-  framing: Framing.sse,
+  framing: OpenAIChat.framing,
 })
 
 export * as OpenAICompatibleChat from "./openai-compatible-chat.js"

packages/ai/src/protocols/shared.ts

@@ -207,15 +207,16 @@ export const errorText = (error: unknown) => {
 
 /**
  * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
- * decoder, optionally filters named events, and drops empty / `[DONE]`
- * keep-alive events so the protocol event schema sees one JSON string per
- * element. Retry control events are ignored without interrupting the stream.
+ * decoder, optionally filters named events, and drops empty events. `[DONE]`
+ * is dropped by default or retained for protocols that use it as their stream
+ * boundary. Retry control events are ignored without interrupting the stream.
  * Decoder failures become provider output errors so the public error channel
  * stays `AIError`.
  */
 export const sseFraming = (
   bytes: Stream.Stream<Uint8Array, AIError>,
   events?: ReadonlySet<string>,
+  includeDone = false,
 ): Stream.Stream<string, AIError> =>
   bytes.pipe(
     Stream.decodeText(),
@@ -240,7 +241,7 @@ export const sseFraming = (
       (event) =>
         (events === undefined || events.has(event.event)) &&
         event.data.length > 0 &&
-        (event.data !== "[DONE]" || (events !== undefined && event.event !== "message")),
+        (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message")),
     ),
     Stream.map((event) => event.data),
   )

packages/ai/src/protocols/utils/lifecycle.ts

@@ -62,22 +62,31 @@ export const reasoningEnd = (
   events: LLMEvent[],
   id: string,
   providerMetadata?: ProviderMetadata,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text?: string,
 ): State => {
   if (!state.reasoning.has(id)) return state
   const stepped = stepStart(state, events)
-  events.push(LLMEvent.reasoningEnd({ id, providerMetadata }))
+  events.push(LLMEvent.reasoningEnd({ id, text, providerMetadata }))
   const reasoning = new Set(stepped.reasoning)
   reasoning.delete(id)
   return { ...stepped, reasoning }
 }
 
-export const textEnd = (state: State, events: LLMEvent[], id: string, providerMetadata?: ProviderMetadata): State => {
+export const textEnd = (
+  state: State,
+  events: LLMEvent[],
+  id: string,
+  providerMetadata?: ProviderMetadata,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text?: string,
+): State => {
   if (!state.text.has(id)) return state
   const stepped = stepStart(state, events)
-  events.push(LLMEvent.textEnd({ id, providerMetadata }))
-  const text = new Set(stepped.text)
-  text.delete(id)
-  return { ...stepped, text }
+  events.push(LLMEvent.textEnd({ id, text, providerMetadata }))
+  const open = new Set(stepped.text)
+  open.delete(id)
+  return { ...stepped, text: open }
 }
 
 const closeOpenBlocks = (state: State, events: LLMEvent[]): State => {

packages/ai/src/provider-error.ts

@@ -37,6 +37,7 @@ const patterns = [
   /too large for model with \d+ maximum context length/i,
   /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
   /model_context_window_exceeded/i,
+  /range of input length should be/i,
   /too many tokens/i,
   /token limit exceeded/i,
   /request_too_large/i,
@@ -59,6 +60,7 @@ export const isContextOverflowFailure = (failure: unknown) =>
 
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown))
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"])
+const AUTH_CODES = new Set(["authentication_error", "permission_error"])
 const SERVER_CODES = new Set([
   "api_error",
   "internal_error",
@@ -74,7 +76,6 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i
-const NETWORK_ERROR_TEXT = /network[-_\s]error/i
 
 export interface ProviderFailure {
   readonly message: string
@@ -90,8 +91,12 @@ export interface ProviderFailure {
   readonly rateLimit?: HttpRateLimitDetails | undefined
 }
 
-// Keep HTTP failures and provider-reported stream failures on one typed path so
-// session retry policy never needs provider-specific string matching.
+// Classification records affirmative evidence about a failure. Deterministic
+// failures need positive identification (a 4xx status, quota/auth/policy
+// signals); anything unrecognized stays UnknownProvider, which the session
+// retry policy treats as retry-eligible because transient failures arrive in
+// unpredictable shapes while deterministic rejections almost always carry a
+// status or known code.
 export function classifyProviderFailure(input: ProviderFailure): AIError["reason"] {
   const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause }
   const body = input.rawBody ?? ""
@@ -116,46 +121,33 @@ export function classifyProviderFailure(input: ProviderFailure): AIError["reason
   if (CONTENT_POLICY_TEXT.test(text)) return new ContentPolicyError(details)
   if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
     return new QuotaExceededError(details)
-  if (input.status === 401) return new AuthenticationError({ ...details, kind: "invalid" })
-  if (input.status === 403) return new AuthenticationError({ ...details, kind: "insufficient-permissions" })
-  if (codes.includes("authentication_error")) return new AuthenticationError({ ...details, kind: "invalid" })
-  if (codes.includes("permission_error"))
-    return new AuthenticationError({ ...details, kind: "insufficient-permissions" })
+  if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
+    return new AuthenticationError(details)
   if (
-    codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception")
+    input.status === 429 ||
+    codes.some(
+      (code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception",
+    ) ||
+    RATE_LIMIT_TEXT.test(text)
   )
     return new RateLimitError({
       ...details,
       retryAfterMs: input.retryAfterMs,
       rateLimit: input.rateLimit,
     })
-  if (RATE_LIMIT_TEXT.test(text))
-    return new RateLimitError({
-      ...details,
-      retryAfterMs: input.retryAfterMs,
-      rateLimit: input.rateLimit,
-    })
-  if (NETWORK_ERROR_TEXT.test(text)) return new ProviderInternalError(details)
-  if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-    return new ProviderInternalError({
-      ...details,
-      retryAfterMs: input.retryAfterMs,
-    })
-  if (input.status === 429) {
-    return new RateLimitError({
-      ...details,
-      retryAfterMs: input.retryAfterMs,
-      rateLimit: input.rateLimit,
-    })
-  }
-  if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
+  if (
+    input.status === 408 ||
+    input.status === 409 ||
+    (input.status !== undefined && input.status >= 500) ||
+    codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable"))
+  )
     return new ProviderInternalError({
       ...details,
       retryAfterMs: input.retryAfterMs,
     })
   if (codes.some((code) => INVALID_REQUEST_CODES.has(code))) return new InvalidRequestError(details)
-  if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
-    return new InvalidRequestError(details)
+  // Any remaining 4xx is a deterministic rejection of this request.
+  if (input.status !== undefined && input.status >= 400 && input.status < 500) return new InvalidRequestError(details)
   return new UnknownProviderError(details)
 }
 

packages/ai/src/providers/groq.ts

@@ -5,7 +5,6 @@ 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"
@@ -75,7 +74,7 @@ export const route = Route.make({
   providerMetadataKey: "openai",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
-  framing: Framing.sse,
+  framing: OpenAIChat.framing,
 })
 
 export const configure = (input: LanguageModelOptions = {}) => {

packages/ai/src/providers/openrouter.ts

@@ -1,7 +1,6 @@
 import { Effect, Schema } from "effect"
 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 { AuthOptions, type ProviderAuthOption } from "../route/auth-options.js"
 import { ProviderID, type CacheHint, type ModelID } from "../schema/index.js"
@@ -167,7 +166,7 @@ export const route = Route.make({
   providerMetadataKey: "openrouter",
   protocol,
   endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
-  framing: Framing.sse,
+  framing: OpenAIChat.framing,
 })
 
 export const routes = [route]

packages/ai/src/route/auth.ts

@@ -139,7 +139,7 @@ const toAIError = (error: AuthError): AIError => {
     return new AIError({
       reason:
         error instanceof MissingCredentialError
-          ? new AuthenticationError({ message: error.message, cause: error, kind: "missing" })
+          ? new AuthenticationError({ message: error.message, cause: error })
           : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
     })
   }

packages/ai/src/route/framing.ts

@@ -8,8 +8,8 @@ import type { AIError } from "../schema/index.js"
  * `Framing` is the byte-stream-shaped seam between transport and protocol:
  *
  * - SSE (`Framing.sse`) — UTF-8 decode the body, run the SSE channel decoder,
- *   drop empty / `[DONE]` keep-alives. Each emitted frame is the JSON `data:`
- *   payload of one event.
+ *   and emit the `data:` payload of each non-empty event. The default drops
+ *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
@@ -26,6 +26,12 @@ export interface Definition<Frame> {
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse: Definition<string> = { id: "sse", frame: ProviderShared.sseFraming }
 
+/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
+export const sseWithDone: Definition<string> = {
+  id: "sse",
+  frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
+}
+
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events: ReadonlySet<string>): Definition<string> => ({
   id: "sse",

packages/ai/src/schema/errors.ts

@@ -44,10 +44,7 @@ export class NoRouteError extends Schema.TaggedError<NoRouteError>("AI.Error.NoR
 
 export class AuthenticationError extends Schema.TaggedError<AuthenticationError>("AI.Error.Authentication")(
   "Authentication",
-  {
-    ...ReasonFields,
-    kind: Schema.Literals(["missing", "invalid", "expired", "insufficient-permissions", "unknown"]),
-  },
+  ReasonFields,
 ) {}
 
 export class RateLimitError extends Schema.TaggedError<RateLimitError>("AI.Error.RateLimit")("RateLimit", {

packages/ai/src/schema/events.ts

@@ -112,6 +112,8 @@ export type TextDelta = Schema.Schema.Type<typeof TextDelta>
 export const TextEnd = Schema.Struct({
   type: Schema.tag("text-end"),
   id: ContentBlockID,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.TextEnd" })
 export type TextEnd = Schema.Schema.Type<typeof TextEnd>
@@ -134,6 +136,8 @@ export type ReasoningDelta = Schema.Schema.Type<typeof ReasoningDelta>
 export const ReasoningEnd = Schema.Struct({
   type: Schema.tag("reasoning-end"),
   id: ContentBlockID,
+  /** Authoritative complete value; replaces accumulated deltas when present. */
+  text: Schema.optional(Schema.String),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ReasoningEnd" })
 export type ReasoningEnd = Schema.Schema.Type<typeof ReasoningEnd>
@@ -328,17 +332,32 @@ export const LLMEvent = Object.assign(llmEventTagged, {
 })
 export type LLMEvent = Schema.Schema.Type<typeof llmEventTagged>
 
+/** Joins deltas per fragment, letting an authoritative end value replace that fragment's accumulated deltas. */
+const joinFragments = <Delta extends { id: string; text: string }, End extends { id: string; text?: string }>(
+  events: ReadonlyArray<LLMEvent>,
+  isDelta: (event: LLMEvent) => event is Extract<LLMEvent, Delta>,
+  isEnd: (event: LLMEvent) => event is Extract<LLMEvent, End>,
+) => {
+  const order: string[] = []
+  const parts = new Map<string, string>()
+  for (const event of events) {
+    if (isDelta(event)) {
+      if (!parts.has(event.id)) order.push(event.id)
+      parts.set(event.id, (parts.get(event.id) ?? "") + event.text)
+    }
+    if (isEnd(event) && event.text !== undefined) {
+      if (!parts.has(event.id)) order.push(event.id)
+      parts.set(event.id, event.text)
+    }
+  }
+  return order.map((id) => parts.get(id)).join("")
+}
+
 const responseText = (events: ReadonlyArray<LLMEvent>) =>
-  events
-    .filter(LLMEvent.is.textDelta)
-    .map((event) => event.text)
-    .join("")
+  joinFragments(events, LLMEvent.is.textDelta, LLMEvent.is.textEnd)
 
 const responseReasoning = (events: ReadonlyArray<LLMEvent>) =>
-  events
-    .filter(LLMEvent.is.reasoningDelta)
-    .map((event) => event.text)
-    .join("")
+  joinFragments(events, LLMEvent.is.reasoningDelta, LLMEvent.is.reasoningEnd)
 
 const responseUsage = (events: ReadonlyArray<LLMEvent>) =>
   events.reduce<Usage | undefined>(
@@ -445,10 +464,11 @@ const reduceTextDelta = (state: ResponseState, event: TextDelta): ResponseState
 const reduceTextEnd = (state: ResponseState, event: TextEnd): ResponseState => {
   const current = state.textParts[event.id]
   if (!current) return state
+  const text = event.text ?? current.text
   const providerMetadata = event.providerMetadata ?? current.providerMetadata
   return {
-    ...replaceContent(state, current.contentIndex, textContent(current.text, providerMetadata)),
-    textParts: { ...state.textParts, [event.id]: { ...current, providerMetadata } },
+    ...replaceContent(state, current.contentIndex, textContent(text, providerMetadata)),
+    textParts: { ...state.textParts, [event.id]: { ...current, text, providerMetadata } },
   }
 }
 
@@ -478,10 +498,11 @@ const reduceReasoningDelta = (state: ResponseState, event: ReasoningDelta): Resp
 const reduceReasoningEnd = (state: ResponseState, event: ReasoningEnd): ResponseState => {
   const current = state.reasoningParts[event.id]
   if (!current) return state
+  const text = event.text ?? current.text
   const providerMetadata = event.providerMetadata ?? current.providerMetadata
   return {
-    ...replaceContent(state, current.contentIndex, reasoningContent(current.text, providerMetadata)),
-    reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, providerMetadata } },
+    ...replaceContent(state, current.contentIndex, reasoningContent(text, providerMetadata)),
+    reasoningParts: { ...state.reasoningParts, [event.id]: { ...current, text, providerMetadata } },
   }
 }
 
@@ -579,12 +600,12 @@ export class LLMResponse extends Schema.Class<LLMResponse>("LLM.Response")({
   usage: Schema.optional(Usage),
   finishReason: FinishReasonDetails,
 }) {
-  /** Concatenated assistant text assembled from streamed `text-delta` events. */
+  /** Concatenated assistant text; each fragment's `text-end` value replaces its accumulated deltas when present. */
   get text() {
     return responseText(this.events)
   }
 
-  /** Concatenated reasoning text assembled from streamed `reasoning-delta` events. */
+  /** Concatenated reasoning text; each fragment's `reasoning-end` value replaces its accumulated deltas when present. */
   get reasoning() {
     return responseReasoning(this.events)
   }

packages/ai/src/testing.ts

@@ -1,6 +1,6 @@
 export * as TestLLM from "./testing.js"
 
-import { LLMClient, type Interface as LLMClientShape } from "./route/client.js"
+import { LLMClient } from "./route/client.js"
 import {
   LLMEvent,
   LLMResponse,
@@ -16,13 +16,33 @@ export type Response = readonly LLMEvent[] | Stream.Stream<LLMEvent, AIError>
 
 export type Gate = Readonly<{ started: Effect.Effect<void>; release: Effect.Effect<void> }>
 
+type ClientInterface = Context.Service.Shape<typeof LLMClient.Service>
+
+export type Responder = (request: LLMRequest) => Response
+
+export interface TestInterface extends ClientInterface {
+  /** Returns a snapshot of requests observed at execution time. */
+  readonly requests: () => Effect.Effect<readonly LLMRequest[]>
+  readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
+  /** Replaces the fallback without changing queued responses. */
+  readonly always: (response: Response) => Effect.Effect<void>
+  /** Answers requests after the one-shot queue is exhausted; receives the original request. */
+  readonly serve: (responder: Responder) => Effect.Effect<void>
+  /** Waits for request arrivals, not output or completion. */
+  readonly wait: (count: number) => Effect.Effect<void>
+  readonly gate: () => Effect.Effect<Gate, never, Scope.Scope>
+}
+
+export class Test extends Context.Service<Test, TestInterface>()("@opencode/ai/TestLLM/Test") {}
+
+/** @deprecated Use TestInterface through Test and testLayer. */
 export interface Interface {
   readonly requests: LLMRequest[]
   readonly push: (...responses: readonly Response[]) => Effect.Effect<void>
   readonly always: (response: Response) => Effect.Effect<void>
   readonly wait: (count: number) => Effect.Effect<void>
   readonly gate: Effect.Effect<Gate, never, Scope.Scope>
-  readonly client: LLMClientShape
+  readonly client: ClientInterface
 }
 
 export interface LayerOptions {
@@ -31,6 +51,7 @@ export interface LayerOptions {
   readonly fallback?: Response
 }
 
+/** @deprecated Use Test and testLayer for normal client methods and test controls. */
 export class Service extends Context.Service<Service, Interface>()("@opencode/ai/TestLLM") {}
 
 export const complete = (
@@ -80,59 +101,64 @@ export const hangAfter = (...events: readonly LLMEvent[]) => Stream.concat(Strea
 
 const toStream = (response: Response) => (Stream.isStream(response) ? response : Stream.fromIterable(response))
 
-export const layer = (options: LayerOptions = {}) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const requests: LLMRequest[] = []
-      const responses: Response[] = []
-      let started = Deferred.makeUnsafe<void>()
-      let fallback = options.fallback
-      let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
-      const wait = (count: number): Effect.Effect<void> =>
-        Effect.suspend(() =>
-          requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
-        )
+const make = (options: LayerOptions) =>
+  Effect.sync(() => {
+    const requests: LLMRequest[] = []
+    const responses: Response[] = []
+    let started = Deferred.makeUnsafe<void>()
+    let fallback: Response | Responder | undefined = options.fallback
+    let activeGate: { readonly started: Queue.Queue<void>; readonly release: Latch.Latch } | undefined
+    const wait = (count: number): Effect.Effect<void> =>
+      Effect.suspend(() =>
+        requests.length >= count ? Effect.void : Deferred.await(started).pipe(Effect.andThen(wait(count))),
+      )
 
-      const stream = ((request: LLMRequest) => {
-        requests.push(options.transformRequest?.(request) ?? request)
+    const stream: ClientInterface["stream"] = (request) =>
+      Stream.suspend(() => {
+        const count = requests.push(options.transformRequest?.(request) ?? request)
         const waiting = started
         started = Deferred.makeUnsafe()
-        Deferred.doneUnsafe(waiting, Effect.void)
-        const response = responses.shift() ?? fallback
-        if (!response) return Stream.die(new Error(`TestLLM has no response for request ${requests.length}`))
-        const streamed = toStream(response)
         const gate = activeGate
-        if (!gate) return streamed
-        return Stream.unwrap(
-          Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
-        )
-      }) as LLMClientShape["stream"]
-      const client = LLMClient.Service.of({
-        stream,
-        generate: (request) =>
-          stream(request).pipe(
-            Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
-            Effect.flatMap((state) => {
-              const response = LLMResponse.complete(state)
-              if (response) return Effect.succeed(response)
-              return Effect.die("TestLLM response ended without a terminal finish event")
-            }),
-          ),
+        try {
+          const response = responses.shift() ?? (typeof fallback === "function" ? fallback(request) : fallback)
+          if (!response) return Stream.die(new Error(`TestLLM has no response for request ${count}`))
+          const streamed = toStream(response)
+          if (!gate) return streamed
+          return Stream.unwrap(
+            Queue.offer(gate.started, undefined).pipe(Effect.andThen(gate.release.await), Effect.as(streamed)),
+          )
+        } finally {
+          // Waiters can resume synchronously; assign the reply and gate before notifying them.
+          Deferred.doneUnsafe(waiting, Effect.void)
+        }
       })
-
-      return Service.of({
-        requests,
-        push: (...input) =>
-          Effect.sync(() => {
-            responses.push(...input)
+    const test = Test.of({
+      stream,
+      generate: (request) =>
+        stream(request).pipe(
+          Stream.runFold(LLMResponse.empty, LLMResponse.reduce),
+          Effect.flatMap((state) => {
+            const response = LLMResponse.complete(state)
+            if (response) return Effect.succeed(response)
+            return Effect.die("TestLLM response ended without a terminal finish event")
           }),
-        always: (response) =>
-          Effect.sync(() => {
-            fallback = response
-          }),
-        wait,
-        gate: Effect.gen(function* () {
+        ),
+      requests: () => Effect.sync(() => [...requests]),
+      push: (...input) =>
+        Effect.sync(() => {
+          responses.push(...input)
+        }),
+      always: (response) =>
+        Effect.sync(() => {
+          fallback = response
+        }),
+      serve: (responder) =>
+        Effect.sync(() => {
+          fallback = responder
+        }),
+      wait,
+      gate: () =>
+        Effect.gen(function* () {
           const gate = {
             started: yield* Effect.acquireRelease(Queue.unbounded<void>(), Queue.shutdown),
             release: yield* Latch.make(),
@@ -147,11 +173,36 @@ export const layer = (options: LayerOptions = {}) =>
             release,
           }
         }),
-        client,
-      })
-    }),
+    })
+
+    return { test, requests }
+  })
+
+/** Provides one shared implementation under the normal client and test-control tags. */
+export const testLayer = (options: LayerOptions = {}) =>
+  Layer.effectContext(
+    Effect.map(make(options), (implementation) =>
+      Context.make(LLMClient.Service, implementation.test).pipe(Context.add(Test, implementation.test)),
+    ),
   )
 
+/** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
+export const layer = (options: LayerOptions = {}) =>
+  Layer.effect(
+    Service,
+    Effect.map(make(options), (implementation) =>
+      Service.of({
+        requests: implementation.requests,
+        push: implementation.test.push,
+        always: implementation.test.always,
+        wait: implementation.test.wait,
+        gate: implementation.test.gate(),
+        client: implementation.test,
+      }),
+    ),
+  )
+
+/** @deprecated testLayer provides LLMClient.Service directly. */
 export const clientLayer = Layer.effect(
   LLMClient.Service,
   Effect.map(Service, (service) => service.client),

packages/ai/test/executor.test.ts

@@ -574,6 +574,7 @@ describe("WebSocket channel execution", () => {
   const model = configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).responses("gpt-4.1-mini")
   const request = LLM.request({ model, prompt: "Say hello." })
   const frames = [
+    JSON.stringify({ type: "response.output_item.added", item: { type: "message", id: "msg_1" } }),
     JSON.stringify({ type: "response.output_text.delta", item_id: "msg_1", delta: "Hi" }),
     JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }),
   ]

packages/ai/test/exports.test.ts

@@ -32,6 +32,8 @@ describe("public exports", () => {
     expect(Provider.make).toBeFunction()
     expect(ProviderSubpath.make).toBe(Provider.make)
     expect(TestLLM.layer).toBeFunction()
+    expect(TestLLM.testLayer).toBeFunction()
+    expect(TestLLM.Test.of).toBeFunction()
   })
 
   test("route barrel exposes route-authoring APIs", () => {

packages/ai/test/fixtures/recordings/anthropic-messages-cache/keeps-a-long-tool-turn-inside-the-cache-lookback.json

@@ -10,7 +10,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"
@@ -29,7 +29,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

packages/ai/test/fixtures/recordings/anthropic-messages-cache/writes-then-reads-cache-control-on-identical-second-call.json

@@ -10,7 +10,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"
@@ -29,7 +29,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

packages/ai/test/fixtures/recordings/anthropic-messages/anthropic-opus-4-7-image-tool-result.json

@@ -24,7 +24,7 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "anthropic-version": "2023-06-01",
           "content-type": "application/json"

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

@@ -23,7 +23,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"reasoning\":{\"max_tokens\":1024}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
       },
       "response": {
         "status": 200,
@@ -41,7 +41,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"},{\"role\":\"assistant\",\"content\":\"Sure! Let me check the weather in Paris for you right now!\",\"tool_calls\":[{\"id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}],\"reasoning\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"format\":\"anthropic-claude-v1\",\"index\":0,\"signature\":\"ErkCCosBCA8YAipAjKnRKpxkZ4eHrMPJ63IWEOYPSzb+XSHyG+vLK+2ks2O9T4N9M37Xn2kausQSH1rfsrdmKxgUlBg6yUFRgMVR7DIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMNFb5O6pb4nX0HojdGgyL5h+CAIpsxpdM1QgiMGm/i3ST6F5mAhxB+Uez0Cm95ra9yvQkrzHaA/AmWoXpdmPlczSn1S1RDk2IqeA57Spbf7JT44jygtLQt6yZmGzoTBHn3VkwaNZsuuAtbdo4B5QJXooa/AoKKs54QZ2kfS640vsv5flQVCg7CoQCFuLKjIeLMO7MnxVyuskXJr1DgesTa7I0ScF53U9JGhgB\"}]},{\"role\":\"tool\",\"tool_call_id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"reasoning\":{\"max_tokens\":1024}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":\"What is the weather in Paris?\"},{\"role\":\"assistant\",\"content\":\"Sure! Let me check the weather in Paris for you right now!\",\"tool_calls\":[{\"id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}],\"reasoning\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"The user wants to know the weather in Paris. I'll use the get_weather tool.\",\"format\":\"anthropic-claude-v1\",\"index\":0,\"signature\":\"ErkCCosBCA8YAipAjKnRKpxkZ4eHrMPJ63IWEOYPSzb+XSHyG+vLK+2ks2O9T4N9M37Xn2kausQSH1rfsrdmKxgUlBg6yUFRgMVR7DIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMNFb5O6pb4nX0HojdGgyL5h+CAIpsxpdM1QgiMGm/i3ST6F5mAhxB+Uez0Cm95ra9yvQkrzHaA/AmWoXpdmPlczSn1S1RDk2IqeA57Spbf7JT44jygtLQt6yZmGzoTBHn3VkwaNZsuuAtbdo4B5QJXooa/AoKKs54QZ2kfS640vsv5flQVCg7CoQCFuLKjIeLMO7MnxVyuskXJr1DgesTa7I0ScF53U9JGhgB\"}]},{\"role\":\"tool\",\"tool_call_id\":\"toolu_01PaChhcyw3yu2P2bDS2bgAA\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"function\":{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
       },
       "response": {
         "status": 200,

packages/ai/test/fixtures/recordings/openrouter-reasoning.json

@@ -15,7 +15,7 @@
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"temperature\":0,\"reasoning\":{\"max_tokens\":1024}}"
+        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"temperature\":0,\"reasoning\":{\"max_tokens\":1024},\"max_completion_tokens\":1536,\"store\":false,\"usage\":{\"include\":true}}"
       },
       "response": {
         "status": 200,

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

@@ -10,11 +10,11 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
+        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"system\":[{\"type\":\"text\",\"text\":\"Read the PDF returned by the tool and follow the user's response format exactly.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_pdf_1\",\"name\":\"read_pdf\",\"input\":{}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_pdf_1\",\"content\":[{\"type\":\"text\",\"text\":\"PDF read successfully\"},{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},\"title\":\"verification.pdf\"}]}]}],\"tools\":[{\"name\":\"read_pdf\",\"description\":\"Read the attached PDF.\",\"input_schema\":{\"type\":\"object\",\"properties\":{},\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
       },
       "response": {
         "status": 200,

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

@@ -10,11 +10,11 @@
       "transport": "http",
       "request": {
         "method": "POST",
-        "url": "https://api.anthropic.com/v1/messages",
+        "url": "https://api.anthropic.com/v1/messages?beta=true",
         "headers": {
           "content-type": "application/json"
         },
-        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"}},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
+        "body": "{\"model\":\"claude-haiku-4-5-20251001\",\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"document\",\"source\":{\"type\":\"base64\",\"media_type\":\"application/pdf\",\"data\":\"JVBERi0xLjQKMSAwIG9iago8PCAvVHlwZSAvQ2F0YWxvZyAvUGFnZXMgMiAwIFIgPj4KZW5kb2JqCjIgMCBvYmoKPDwgL1R5cGUgL1BhZ2VzIC9LaWRzIFszIDAgUl0gL0NvdW50IDEgPj4KZW5kb2JqCjMgMCBvYmoKPDwgL1R5cGUgL1BhZ2UgL1BhcmVudCAyIDAgUiAvTWVkaWFCb3ggWzAgMCA2MTIgNzkyXSAvUmVzb3VyY2VzIDw8IC9Gb250IDw8IC9GMSA1IDAgUiA+PiA+PiAvQ29udGVudHMgNCAwIFIgPj4KZW5kb2JqCjQgMCBvYmoKPDwgL0xlbmd0aCA3NSA+PgpzdHJlYW0KQlQKL0YxIDE4IFRmCjcyIDcyMCBUZAooUERGIGNhc3NldHRlIHZlcmlmaWNhdGlvbiBjb2RlOiBPUkNISUQtNzM5MSkgVGoKRVQKZW5kc3RyZWFtCmVuZG9iago1IDAgb2JqCjw8IC9UeXBlIC9Gb250IC9TdWJ0eXBlIC9UeXBlMSAvQmFzZUZvbnQgL0hlbHZldGljYSA+PgplbmRvYmoKeHJlZgowIDYKMDAwMDAwMDAwMCA2NTUzNSBmIAowMDAwMDAwMDA5IDAwMDAwIG4gCjAwMDAwMDAwNTggMDAwMDAgbiAKMDAwMDAwMDExNSAwMDAwMCBuIAowMDAwMDAwMjQxIDAwMDAwIG4gCjAwMDAwMDAzNjUgMDAwMDAgbiAKdHJhaWxlcgo8PCAvU2l6ZSA2IC9Sb290IDEgMCBSID4+CnN0YXJ0eHJlZgo0MzUKJSVFT0YK\"},\"title\":\"verification.pdf\"},{\"type\":\"text\",\"text\":\"Return only the verification code from the PDF.\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
       },
       "response": {
         "status": 200,

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

@@ -11,6 +11,7 @@ describe("provider error classification", () => {
       "Input length 131393 exceeds the maximum allowed input length of 131040 tokens.",
       "The input (516368 tokens) is longer than the model's context length (262144 tokens).",
       "Prompt has 5,958,968 tokens, but the configured context size is 256,000 tokens",
+      "Range of input length should be [1, 129024]",
       "Too many tokens",
       "Token limit exceeded",
     ]
@@ -87,10 +88,12 @@ describe("provider error classification", () => {
     ])
   })
 
-  test("classifies network error text as provider internal", () => {
+  test("classifies any remaining 4xx status as an invalid request", () => {
     expect(
-      ["network error", "network-error", "network_error"].map((message) => classifyProviderFailure({ message })._tag),
-    ).toEqual(["ProviderInternal", "ProviderInternal", "ProviderInternal"])
+      [400, 402, 404, 418, 422, 451].map(
+        (status) => classifyProviderFailure({ message: `HTTP ${status}`, status })._tag,
+      ),
+    ).toEqual(Array(6).fill("InvalidRequest"))
   })
 
   test("classifies nested provider codes when a top-level code is also present", () => {
@@ -103,10 +106,12 @@ describe("provider error classification", () => {
     ).toEqual(["QuotaExceeded", "ProviderInternal", "InvalidRequest"])
   })
 
-  test("keeps unknown and malformed provider payloads non-retryable", () => {
+  test("leaves unrecognized failures unclassified for the retry default", () => {
     expect(classifyProviderFailure({ message: '{"error":{"message":"no_kv_space"}}' })._tag).toBe("UnknownProvider")
     expect(classifyProviderFailure({ message: '{"type":"error","error":{"code":123}}' })._tag).toBe("UnknownProvider")
     expect(classifyProviderFailure({ message: "not-json" })._tag).toBe("UnknownProvider")
+    expect(classifyProviderFailure({ message: "network error" })._tag).toBe("UnknownProvider")
+    expect(classifyProviderFailure({ message: "Provider returned error" })._tag).toBe("UnknownProvider")
   })
 })
 

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

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test"
 import { model } from "@opencode-ai/ai/providers/openai"
+import { LLM } from "../src/index.js"
+import { Endpoint } from "../src/route/endpoint.js"
 
 describe("provider package entrypoints", () => {
   test("semantic API aliases expose the same contract", async () => {
@@ -36,7 +38,8 @@ describe("provider package entrypoints", () => {
     expect(modules[0].model).toBe(modules[1].model)
     expect(modules[8].model).toBe(modules[9].model)
     expect(modules[12].model).toBe(modules[13].model)
-    expect(modules[19].model).toBe(modules[20].model)
+    expect(modules[19].model).toBe(modules[21].model)
+    expect(modules[19].model).not.toBe(modules[20].model)
   })
 
   test("maps DeepInfra package settings onto its native executable model", async () => {
@@ -139,8 +142,10 @@ describe("provider package entrypoints", () => {
     expect(selected.route.id).toBe("anthropic-messages")
     expect(selected.route.endpoint).toMatchObject({
       baseURL: "https://messages.example.test/v1",
-      path: "/messages",
     })
+    expect(
+      Endpoint.render(selected.route.endpoint, { request: LLM.request({ model: selected }), body: {} }).toString(),
+    ).toBe("https://messages.example.test/v1/messages")
     expect(selected.route.defaults.headers).toEqual({ "x-application": "opencode" })
     expect(selected.route.defaults.http?.body).toEqual({ metadata: { user_id: "user_1" } })
     expect(selected.route.defaults.providerOptions).toEqual({ effort: "low" })

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

@@ -491,6 +491,59 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
+  it.effect("ignores late tool deltas after contentBlockStop", () =>
+    Effect.gen(function* () {
+      const body = eventStreamBody(
+        [
+          "contentBlockStart",
+          {
+            contentBlockIndex: 0,
+            start: { toolUse: { toolUseId: "tool_1", name: "lookup" } },
+          },
+        ],
+        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"query":"weather"}' } } }],
+        ["contentBlockStop", { contentBlockIndex: 0 }],
+        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"late":true}' } } }],
+        ["messageStop", { stopReason: "tool_use" }],
+      )
+      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
+
+      expect(response.toolCalls).toEqual([
+        { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "weather" } },
+      ])
+      expect(response.events.filter((event) => event.type === "tool-input-delta")).toEqual([
+        {
+          type: "tool-input-delta",
+          id: "tool_1",
+          name: "lookup",
+          text: '{"query":"weather"}',
+          input: { query: "weather" },
+        },
+      ])
+    }),
+  )
+
+  it.effect("rejects tool deltas without contentBlockStart", () =>
+    Effect.gen(function* () {
+      const error = yield* LLMClient.generate(baseRequest).pipe(
+        Effect.provide(
+          fixedBytes(
+            eventStreamBody(
+              ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: "{}" } } }],
+              ["messageStop", { stopReason: "tool_use" }],
+            ),
+          ),
+        ),
+        Effect.flip,
+      )
+
+      expect(error).toMatchObject({
+        reason: { _tag: "InvalidProviderOutput" },
+        message: "Bedrock Converse tool delta is missing its tool call",
+      })
+    }),
+  )
+
   it.effect("recovers incomplete tool input at finalization", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(

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

@@ -52,7 +52,7 @@ describe("provider error retention", () => {
           Effect.flip,
         )
         expect(error.message).toContain("Slow down")
-        expect(error.reason._tag).toBe(entry.name === "Gemini" ? "ProviderInternal" : "RateLimit")
+        expect(error.reason._tag).toBe("RateLimit")
         expect(error.reason.body).toBe(body)
         expect(error.reason.http).toMatchObject({ status: 200, headers: { "x-provider-trace": "trace-1" } })
         expect(error.reason.http?.url).toStartWith("https://provider.test/")

packages/ai/test/provider/open-responses-lifecycle.test.ts

@@ -0,0 +1,467 @@
+import { describe, expect } from "bun:test"
+import { Effect, Stream } from "effect"
+import { LLM, LLMEvent } from "../../src/index.js"
+import { OpenResponses } from "../../src/protocols/open-responses.js"
+import { configure } from "../../src/providers/openai-compatible-responses.js"
+import { LLMClient } from "../../src/route.js"
+import { it } from "../lib/effect.js"
+import { fixedResponse } from "../lib/http.js"
+import { sseEvents } from "../lib/sse.js"
+
+const request = LLM.request({
+  model: configure({ apiKey: "test-key", baseURL: "https://responses.example.test/v1" }).model("example-model"),
+  prompt: "Respond.",
+})
+const completed = { type: "response.completed", response: { id: "resp_1" } }
+
+const collect = (...input: OpenResponses.Event[]) =>
+  Effect.gen(function* () {
+    const events = yield* LLMClient.stream(request).pipe(
+      Stream.runCollect,
+      Effect.provide(fixedResponse(sseEvents(...input))),
+    )
+    expectLifecycle(
+      events,
+      input.some((event) => event.type === "response.completed"),
+    )
+    return events
+  })
+
+// Deliberately local to these basic-item fixtures, not a general stream validator.
+function expectLifecycle(events: ReadonlyArray<LLMEvent>, completed: boolean) {
+  const active = { text: new Set<string>(), reasoning: new Set<string>() }
+  const tools = new Map<string, "started" | "ended" | "called">()
+  events.forEach((event) => {
+    if (event.type === "text-start" || event.type === "reasoning-start") {
+      const blocks = event.type === "text-start" ? active.text : active.reasoning
+      expect(blocks.size).toBe(0)
+      blocks.add(event.id)
+    }
+    if (event.type === "text-delta" || event.type === "reasoning-delta") {
+      expect((event.type === "text-delta" ? active.text : active.reasoning).has(event.id)).toBe(true)
+    }
+    if (event.type === "text-end" || event.type === "reasoning-end") {
+      expect((event.type === "text-end" ? active.text : active.reasoning).delete(event.id)).toBe(true)
+    }
+    if (event.type === "tool-input-start") {
+      expect(tools.has(event.id)).toBe(false)
+      tools.set(event.id, "started")
+    }
+    if (event.type === "tool-input-delta") expect(tools.get(event.id)).toBe("started")
+    if (event.type === "tool-input-end") {
+      expect(tools.get(event.id)).toBe("started")
+      tools.set(event.id, "ended")
+    }
+    if (event.type === "tool-call") {
+      expect(tools.get(event.id)).toBe("ended")
+      tools.set(event.id, "called")
+    }
+    // Incomplete responses may leave pending tool inputs without a call.
+    if (event.type === "finish" && completed) {
+      expect(active.text.size).toBe(0)
+      expect(active.reasoning.size).toBe(0)
+      expect([...tools.values()].every((status) => status === "called")).toBe(true)
+    }
+  })
+  expect(events.filter(LLMEvent.is.stepStart)).toHaveLength(1)
+  expect(events[0]?.type).toBe("step-start")
+  expect(events.filter(LLMEvent.is.stepFinish)).toHaveLength(1)
+  expect(events.filter(LLMEvent.is.finish)).toHaveLength(1)
+  expect(events.slice(-2).map((event) => event.type)).toEqual(["step-finish", "finish"])
+}
+
+describe("Open Responses basic-item lifecycles", () => {
+  it.effect("closes implicit summary boundaries and ignores late events for completed reasoning", () =>
+    Effect.gen(function* () {
+      const item = { type: "reasoning", id: "rs_1", encrypted_content: "encrypted-state" }
+      const events = yield* collect(
+        { type: "response.output_item.added", output_index: 0, item: { ...item, encrypted_content: null } },
+        { type: "response.output_item.added", item: { ...item, encrypted_content: null } },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 0, delta: "First" },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
+        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "Second" },
+        // The third part omits both explicit summary boundaries.
+        {
+          type: "response.reasoning_summary_text.delta",
+          output_index: 0,
+          item_id: "wrong",
+          summary_index: 2,
+          delta: "Third",
+        },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 3 },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", summary_index: 3, delta: "late" },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 2, text: "late final" },
+        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 3 },
+        completed,
+      )
+
+      expect(events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
+        {
+          type: "reasoning-start",
+          id: "rs_1:0",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:0", text: "First" },
+        { type: "reasoning-end", id: "rs_1:0", providerMetadata: { "openai-compatible": { itemId: "rs_1" } } },
+        {
+          type: "reasoning-start",
+          id: "rs_1:1",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:1", text: "Second" },
+        { type: "reasoning-end", id: "rs_1:1", providerMetadata: { "openai-compatible": { itemId: "rs_1" } } },
+        {
+          type: "reasoning-start",
+          id: "rs_1:2",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: null } },
+        },
+        { type: "reasoning-delta", id: "rs_1:2", text: "Third" },
+        {
+          type: "reasoning-end",
+          id: "rs_1:2",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
+      ])
+    }),
+  )
+
+  it.effect("preserves done-only encrypted reasoning without replaying its summary or late events", () =>
+    Effect.gen(function* () {
+      const item = {
+        type: "reasoning",
+        id: "rs_1",
+        encrypted_content: "encrypted-state",
+        summary: [{ type: "summary_text", text: "Not streamed" }],
+      }
+      const events = yield* collect(
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.done", item },
+        { type: "response.output_item.added", item },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "late" },
+        { type: "response.reasoning_summary_part.added", item_id: "rs_1", summary_index: 1 },
+        { type: "response.reasoning_summary_text.done", item_id: "rs_1", summary_index: 1, text: "late final" },
+        completed,
+        // Route termination must also prevent events after response completion.
+        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_after" } },
+      )
+      expect(events.filter((event) => event.type.startsWith("reasoning-"))).toEqual([
+        {
+          type: "reasoning-start",
+          id: "rs_1",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
+        {
+          type: "reasoning-end",
+          id: "rs_1",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
+        },
+      ])
+    }),
+  )
+
+  it.effect("forgets never-streamed messages at implicit boundaries and preserves refusal phases", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_empty" } },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.done", item_id: "msg_1", text: "Checking" },
+        { type: "response.output_text.done", item_id: "msg_1", text: "Duplicate" },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_2", phase: null } },
+        { type: "response.output_text.delta", item_id: "msg_empty", delta: "stale" },
+        { type: "response.output_text.done", item_id: "msg_empty", text: "stale final" },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "late" },
+        { type: "response.refusal.delta", item_id: "msg_2", delta: "Cannot help." },
+        { type: "response.refusal.done", item_id: "msg_2", refusal: "Cannot help." },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_2", phase: "final_answer" } },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_3", phase: null } },
+        { type: "response.refusal.done", item_id: "msg_3", refusal: "Done-only refusal." },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_3" } },
+        completed,
+      )
+      expect(events.filter((event) => event.type.startsWith("text-"))).toEqual([
+        {
+          type: "text-start",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+        { type: "text-delta", id: "msg_1", text: "Checking" },
+        {
+          type: "text-end",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+        {
+          type: "text-start",
+          id: "msg_2",
+          providerMetadata: { "openai-compatible": { itemId: "msg_2", phase: null } },
+        },
+        { type: "text-delta", id: "msg_2", text: "Cannot help." },
+        {
+          type: "text-end",
+          id: "msg_2",
+          providerMetadata: { "openai-compatible": { itemId: "msg_2", phase: "final_answer" } },
+        },
+        {
+          type: "text-start",
+          id: "msg_3",
+          providerMetadata: { "openai-compatible": { itemId: "msg_3", phase: null } },
+        },
+        { type: "text-delta", id: "msg_3", text: "Done-only refusal." },
+        { type: "text-end", id: "msg_3", providerMetadata: { "openai-compatible": { itemId: "msg_3", phase: null } } },
+      ])
+    }),
+  )
+  it.effect("allows a message to be registered again without inheriting its previous phase", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "commentary" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "First" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Second" },
+        { type: "response.output_item.done", item: { type: "message", id: "msg_1" } },
+        completed,
+      )
+      expect(events.filter(LLMEvent.is.textEnd)).toEqual([
+        {
+          type: "text-end",
+          id: "msg_1",
+          providerMetadata: { "openai-compatible": { itemId: "msg_1", phase: "commentary" } },
+        },
+        { type: "text-end", id: "msg_1", providerMetadata: { "openai-compatible": { itemId: "msg_1" } } },
+      ])
+      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["First", "Second"])
+    }),
+  )
+  ;[undefined, "fc_1"].forEach((id) => {
+    it.effect(`opens and closes a done-only tool ${id === undefined ? "without" : "with"} an item id`, () =>
+      Effect.gen(function* () {
+        const item = {
+          type: "function_call",
+          ...(id === undefined ? {} : { id }),
+          call_id: "call_1",
+          name: "lookup",
+          arguments: '{"query":"weather"}',
+        }
+        const events = yield* collect(
+          { type: "response.output_item.done", item },
+          { type: "response.output_item.done", item: { ...item, id: "fc_1" } },
+          { type: "response.output_item.added", item },
+          completed,
+        )
+        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
+        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
+          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
+        ])
+        expect(events.filter(LLMEvent.is.finish)).toEqual([
+          {
+            type: "finish",
+            reason: { normalized: "tool-calls", raw: undefined },
+            providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
+          },
+        ])
+      }),
+    )
+
+    it.effect(`deduplicates a pending call whose item id is ${id === undefined ? "introduced" : "omitted"} later`, () =>
+      Effect.gen(function* () {
+        const item = { type: "function_call", call_id: "call_1", name: "lookup" }
+        const first = { ...item, ...(id === undefined ? {} : { id }) }
+        const duplicate = { ...item, ...(id === undefined ? { id: "fc_1" } : {}) }
+        const events = yield* collect(
+          { type: "response.output_item.added", item: first },
+          { type: "response.function_call_arguments.delta", item_id: id ?? "call_1", delta: '{"query":"weather"}' },
+          { type: "response.output_item.added", item: duplicate },
+          { type: "response.output_item.done", item: duplicate },
+          { type: "response.output_item.done", item: first },
+          { type: "response.output_item.added", item: duplicate },
+          completed,
+        )
+        // Identity metadata comes from the first admission, not the duplicate.
+        const providerMetadata = id === undefined ? undefined : { "openai-compatible": { itemId: id } }
+        expect(events.filter((event) => event.type.startsWith("tool-"))).toEqual([
+          { type: "tool-input-start", id: "call_1", name: "lookup", providerMetadata },
+          {
+            type: "tool-input-delta",
+            id: "call_1",
+            name: "lookup",
+            text: '{"query":"weather"}',
+            input: { query: "weather" },
+          },
+          { type: "tool-input-end", id: "call_1", name: "lookup", providerMetadata },
+          { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" }, providerMetadata },
+        ])
+      }),
+    )
+  })
+
+  it.effect("recovers pending items in completed output order with terminal encrypted metadata", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        {
+          type: "response.output_item.added",
+          item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup" },
+        },
+        { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":"draft"}' },
+        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1", encrypted_content: null } },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "Thinking" },
+        { type: "response.reasoning_summary_part.done", item_id: "rs_1", summary_index: 0 },
+        {
+          type: "response.completed",
+          response: {
+            id: "resp_1",
+            output: [
+              { type: "reasoning", id: "rs_1", encrypted_content: "terminal-state" },
+              { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: '{"query":"final"}' },
+              { type: "function_call", id: "fc_unseen", call_id: "call_unseen", name: "lookup", arguments: "{}" },
+            ],
+          },
+        },
+      )
+      expect(events.slice(5, -2)).toEqual([
+        {
+          type: "reasoning-end",
+          id: "rs_1:0",
+          providerMetadata: { "openai-compatible": { itemId: "rs_1", reasoningEncryptedContent: "terminal-state" } },
+        },
+        {
+          type: "tool-input-end",
+          id: "call_1",
+          name: "lookup",
+          providerMetadata: { "openai-compatible": { itemId: "fc_1" } },
+        },
+        {
+          type: "tool-call",
+          id: "call_1",
+          name: "lookup",
+          input: { query: "final" },
+          providerMetadata: { "openai-compatible": { itemId: "fc_1" } },
+        },
+      ])
+    }),
+  )
+
+  it.effect("preserves call identity and pending order when an item id is reused", () =>
+    Effect.gen(function* () {
+      const first = { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup", arguments: "{}" }
+      const events = yield* collect(
+        { type: "response.output_item.added", item: first },
+        { type: "response.output_item.added", item: { ...first, id: "fc_2", call_id: "call_2" } },
+        { type: "response.output_item.done", item: first },
+        { type: "response.output_item.added", item: { ...first, call_id: "call_3" } },
+        { type: "response.output_item.done", item: first },
+        completed,
+      )
+      expect(events.filter(LLMEvent.is.toolCall).map((event) => event.id)).toEqual(["call_1", "call_2", "call_3"])
+    }),
+  )
+
+  it.effect("keeps text and reasoning identities separate even with empty item ids", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "reasoning", id: "" } },
+        { type: "response.output_item.added", item: { type: "message", id: "" } },
+        { type: "response.output_item.added", item: { type: "reasoning", id: "" } },
+        { type: "response.reasoning_summary_text.delta", item_id: "", delta: "Thinking" },
+        { type: "response.output_text.delta", item_id: "", delta: "Answer" },
+        { type: "response.output_item.done", item: { type: "reasoning", id: "", encrypted_content: "state" } },
+        { type: "response.output_item.done", item: { type: "message", id: "" } },
+        completed,
+      )
+      expect(events.filter(LLMEvent.is.reasoningDelta).map((event) => event.text)).toEqual(["Thinking"])
+      expect(events.filter(LLMEvent.is.textDelta).map((event) => event.text)).toEqual(["Answer"])
+      expect(events.filter(LLMEvent.is.reasoningEnd)).toEqual([
+        {
+          type: "reasoning-end",
+          id: ":0",
+          providerMetadata: { "openai-compatible": { itemId: "", reasoningEncryptedContent: "state" } },
+        },
+      ])
+    }),
+  )
+
+  it.effect("does not recover a completed tool from a tracked message with the same id", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "item_1" } },
+        { type: "response.output_text.delta", item_id: "item_1", delta: "Answer" },
+        {
+          type: "response.completed",
+          response: {
+            id: "resp_1",
+            output: [{ type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "{}" }],
+          },
+        },
+      )
+      expect(events.filter(LLMEvent.is.toolCall)).toEqual([])
+      expect(events.filter(LLMEvent.is.finish).map((event) => event.reason.normalized)).toEqual(["stop"])
+    }),
+  )
+
+  it.effect("flushes pending calls and open text when completed output is absent", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "message", id: "msg_1", phase: "final_answer" } },
+        { type: "response.output_text.delta", item_id: "msg_1", delta: "Answer" },
+        {
+          type: "response.output_item.added",
+          item: { type: "function_call", call_id: "call_1", name: "lookup", arguments: "{}" },
+        },
+        completed,
+      )
+      // Generic terminal closure does not repeat the message's phase metadata.
+      expect(events.slice(4, -2)).toEqual([
+        { type: "tool-input-end", id: "call_1", name: "lookup" },
+        { type: "tool-call", id: "call_1", name: "lookup", input: {} },
+        { type: "text-end", id: "msg_1" },
+      ])
+    }),
+  )
+
+  it.effect("does not reconcile pending calls or terminal reasoning metadata on incomplete responses", () =>
+    Effect.gen(function* () {
+      const events = yield* collect(
+        { type: "response.output_item.added", item: { type: "reasoning", id: "rs_1", encrypted_content: null } },
+        { type: "response.reasoning_summary_text.delta", item_id: "rs_1", delta: "Partial" },
+        {
+          type: "response.output_item.added",
+          item: { type: "function_call", id: "fc_1", call_id: "call_1", name: "lookup" },
+        },
+        { type: "response.function_call_arguments.delta", item_id: "fc_1", delta: '{"query":' },
+        {
+          type: "response.incomplete",
+          response: {
+            id: "resp_1",
+            incomplete_details: { reason: "max_output_tokens" },
+            output: [
+              { type: "reasoning", id: "rs_1", encrypted_content: "not-reconciled" },
+              {
+                type: "function_call",
+                id: "fc_1",
+                call_id: "call_1",
+                name: "lookup",
+                arguments: '{"query":"not-reconciled"}',
+              },
+            ],
+          },
+        },
+      )
+      expect(events.filter(LLMEvent.is.toolInputEnd)).toEqual([])
+      expect(events.filter(LLMEvent.is.toolCall)).toEqual([])
+      expect(events.filter(LLMEvent.is.reasoningEnd)).toEqual([{ type: "reasoning-end", id: "rs_1:0" }])
+      expect(events.filter(LLMEvent.is.finish)).toEqual([
+        {
+          type: "finish",
+          reason: { normalized: "length", raw: "max_output_tokens" },
+          providerMetadata: { "openai-compatible": { responseId: "resp_1", serviceTier: undefined } },
+        },
+      ])
+    }),
+  )
+})

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

@@ -807,6 +807,28 @@ describe("OpenAI Chat route", () => {
     }),
   )
 
+  it.effect("finishes at the done sentinel without waiting for response EOF", () =>
+    Effect.gen(function* () {
+      const stream = new ReadableStream<Uint8Array>({
+        start(controller) {
+          controller.enqueue(
+            new TextEncoder().encode(sseEvents(deltaChunk({ content: "Hello" }), deltaChunk({}, "stop"))),
+          )
+        },
+      })
+      const response = yield* LLMClient.generate(request).pipe(
+        Effect.provide(
+          fixedResponse(stream, {
+            headers: { "content-type": "text/event-stream" },
+          }),
+        ),
+      )
+
+      expect(response.text).toBe("Hello")
+      expect(response.events.at(-1)?.type).toBe("finish")
+    }),
+  )
+
   it.effect("preserves streamed refusals as ordinary assistant text", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(

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

@@ -405,6 +405,19 @@ describe("OpenAI-compatible Chat route", () => {
     }),
   )
 
+  it.effect("ignores events after the done sentinel", () =>
+    Effect.gen(function* () {
+      const body = `${sseEvents(
+        deltaChunk({ content: "Hello" }),
+        deltaChunk({}, "stop"),
+      )}data: ${JSON.stringify(deltaChunk({ content: " late" }))}\n\n`
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
+
+      expect(response.text).toBe("Hello")
+      expect(response.finishReason).toEqual({ normalized: "stop", raw: "stop" })
+    }),
+  )
+
   it.effect("accepts nullable usage and preserves provider fields", () =>
     Effect.gen(function* () {
       const response = yield* LLMClient.generate(request).pipe(

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

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

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

@@ -305,9 +305,11 @@ describe("OpenRouter", () => {
       expect(prepared.body.messages).toEqual([
         {
           role: "assistant",
-          content: null,
+          content: "",
           reasoning: "Thinking",
+          reasoning_content: undefined,
           reasoning_details: details,
+          reasoning_text: undefined,
         },
       ])
     }),
@@ -335,7 +337,14 @@ describe("OpenRouter", () => {
       )
 
       expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning: "Thinking", reasoning_details: details },
+        {
+          role: "assistant",
+          content: "",
+          reasoning: "Thinking",
+          reasoning_content: undefined,
+          reasoning_details: details,
+          reasoning_text: undefined,
+        },
       ])
     }),
   )
@@ -361,7 +370,14 @@ describe("OpenRouter", () => {
       )
 
       expect(prepared.body.messages).toEqual([
-        { role: "assistant", content: null, reasoning: "AB", reasoning_details: details },
+        {
+          role: "assistant",
+          content: "",
+          reasoning: "AB",
+          reasoning_content: undefined,
+          reasoning_details: details,
+          reasoning_text: undefined,
+        },
       ])
     }),
   )
@@ -376,7 +392,16 @@ describe("OpenRouter", () => {
         }),
       )
 
-      expect(prepared.body.messages).toEqual([{ role: "assistant", content: null }])
+      expect(prepared.body.messages).toEqual([
+        {
+          role: "assistant",
+          content: "",
+          reasoning: undefined,
+          reasoning_content: undefined,
+          reasoning_details: undefined,
+          reasoning_text: undefined,
+        },
+      ])
     }),
   )
 })

packages/ai/test/response.test.ts

@@ -104,6 +104,60 @@ describe("LLMResponse reducer", () => {
     ])
   })
 
+  test("authoritative text-end value replaces accumulated deltas", () => {
+    const response = LLMResponse.fromEvents([
+      LLMEvent.textStart({ id: "t1" }),
+      LLMEvent.textDelta({ id: "t1", text: "Hel" }),
+      LLMEvent.textEnd({ id: "t1", text: "Hello!" }),
+      LLMEvent.finish({ reason: { normalized: "stop" } }),
+    ])
+
+    expect(response?.message.content).toEqual([{ type: "text", text: "Hello!" }])
+    expect(response?.text).toBe("Hello!")
+  })
+
+  test("text-end without value keeps joined deltas", () => {
+    const response = LLMResponse.fromEvents([
+      LLMEvent.textStart({ id: "t1" }),
+      LLMEvent.textDelta({ id: "t1", text: "Hel" }),
+      LLMEvent.textDelta({ id: "t1", text: "lo" }),
+      LLMEvent.textEnd({ id: "t1" }),
+      LLMEvent.finish({ reason: { normalized: "stop" } }),
+    ])
+
+    expect(response?.message.content).toEqual([{ type: "text", text: "Hello" }])
+    expect(response?.text).toBe("Hello")
+  })
+
+  test("authoritative reasoning-end value replaces only its own fragment", () => {
+    const response = LLMResponse.fromEvents([
+      LLMEvent.reasoningStart({ id: "r1:0" }),
+      LLMEvent.reasoningDelta({ id: "r1:0", text: "First summ" }),
+      LLMEvent.reasoningEnd({ id: "r1:0", text: "First summary." }),
+      LLMEvent.reasoningStart({ id: "r1:1" }),
+      LLMEvent.reasoningDelta({ id: "r1:1", text: "Second summary." }),
+      LLMEvent.reasoningEnd({ id: "r1:1" }),
+      LLMEvent.finish({ reason: { normalized: "stop" } }),
+    ])
+
+    expect(response?.message.content).toEqual([
+      { type: "reasoning", text: "First summary." },
+      { type: "reasoning", text: "Second summary." },
+    ])
+    expect(response?.reasoning).toBe("First summary.Second summary.")
+  })
+
+  test("end value recovers a fragment that streamed no deltas", () => {
+    const response = LLMResponse.fromEvents([
+      LLMEvent.textStart({ id: "t1" }),
+      LLMEvent.textEnd({ id: "t1", text: "Hello!" }),
+      LLMEvent.finish({ reason: { normalized: "stop" } }),
+    ])
+
+    expect(response?.message.content).toEqual([{ type: "text", text: "Hello!" }])
+    expect(response?.text).toBe("Hello!")
+  })
+
   test("clears malformed tool input without appending an executable call", () => {
     const state = reduce([
       LLMEvent.toolInputStart({ id: "call_1", name: "lookup" }),

packages/ai/test/schema.test.ts

@@ -250,7 +250,7 @@ test("AI error reasons are tagged Errors with required messages", () => {
       provider: model.provider,
       model: model.id,
     }),
-    new AuthenticationError({ message: "Missing credentials", kind: "missing" }),
+    new AuthenticationError({ message: "Missing credentials" }),
     new RateLimitError({ message: "Rate limited" }),
     new QuotaExceededError({ message: "Quota exceeded" }),
     new ContentPolicyError({ message: "Content blocked" }),

packages/ai/test/testing.test.ts

@@ -0,0 +1,331 @@
+import { describe, expect } from "bun:test"
+import { AIError, LanguageModel, LLM, LLMClient, LLMEvent, LLMRequest, RateLimitError } from "../src/index.js"
+import { OpenAIChat } from "../src/protocols/openai-chat.js"
+import { TestLLM } from "../src/testing.js"
+import { Effect, Fiber, Latch, Stream } from "effect"
+import { testEffect } from "./lib/effect.js"
+
+const request = LLM.request({
+  model: LanguageModel.make({ id: "fictional-model", provider: "fixture", route: OpenAIChat.route }),
+  prompt: "Say hello",
+})
+const legacy = testEffect(TestLLM.layer())
+const it = testEffect(TestLLM.testLayer())
+
+describe("TestLLM legacy client", () => {
+  legacy.effect("does not observe requests or consume responses until execution", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Service
+      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
+
+      llm.client.stream(request)
+      llm.client.generate(request)
+      expect(llm.requests).toEqual([])
+
+      expect((yield* llm.client.generate(request)).text).toBe("first")
+      expect((yield* llm.client.generate(request)).text).toBe("second")
+      expect(llm.requests).toEqual([request, request])
+    }),
+  )
+
+  legacy.effect("assigns and records a fresh response for each execution", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Service
+      yield* llm.push(
+        TestLLM.text("first", "first"),
+        TestLLM.text("second", "second"),
+        TestLLM.text("third", "third"),
+        TestLLM.text("fourth", "fourth"),
+      )
+      const stream = llm.client.stream(request)
+      const generate = llm.client.generate(request)
+
+      expect(yield* Stream.runCollect(stream)).toEqual(TestLLM.text("first", "first"))
+      expect(yield* Stream.runCollect(stream)).toEqual(TestLLM.text("second", "second"))
+      expect((yield* generate).text).toBe("third")
+      expect((yield* generate).text).toBe("fourth")
+      expect(llm.requests).toEqual([request, request, request, request])
+    }),
+  )
+
+  legacy.effect("keeps module-level controls and clientLayer on the same backing state", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Service
+      const requests = llm.requests
+      yield* TestLLM.push(TestLLM.text("queued", "queued"))
+      yield* TestLLM.always(TestLLM.text("fallback", "fallback"))
+      expect((yield* LLMClient.generate(request).pipe(Effect.provide(TestLLM.clientLayer))).text).toBe("queued")
+      yield* TestLLM.wait(1)
+      expect(requests).toEqual([request])
+      requests.length = 0
+      expect((yield* llm.client.generate(request)).text).toBe("fallback")
+      expect(llm.requests).toBe(requests)
+      expect(requests).toEqual([request])
+    }),
+  )
+})
+
+describe("TestLLM first-class client", () => {
+  it.effect("provides the same object under normal and test tags with snapshot observations", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const client = yield* LLMClient.Service
+      expect(client).toBe(llm)
+      const before = yield* llm.requests()
+      yield* llm.push(TestLLM.text("hello", "answer"))
+      const generate = client.generate(request)
+      client.stream(request)
+      expect(yield* llm.requests()).toEqual([])
+
+      expect((yield* generate).text).toBe("hello")
+      expect(before).toEqual([])
+      expect(yield* llm.requests()).toEqual([request])
+      expect(yield* llm.requests()).not.toBe(yield* llm.requests())
+    }),
+  )
+
+  it.effect("prioritizes queued replies over request-dependent and constant fallbacks", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const served: LLMRequest[] = []
+      yield* llm.always(TestLLM.text("old fallback", "old"))
+      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
+      yield* llm.serve((request) => {
+        served.push(request)
+        return TestLLM.text(request.promptCacheKey ?? "default", "served")
+      })
+
+      expect((yield* LLMClient.generate(request)).text).toBe("first")
+      expect((yield* LLMClient.generate(request)).text).toBe("second")
+      expect(served).toEqual([])
+      const selected = LLMRequest.update(request, { promptCacheKey: "selected" })
+      expect((yield* LLMClient.generate(selected)).text).toBe("selected")
+      expect((yield* LLMClient.generate(request)).text).toBe("default")
+      expect(served).toEqual([selected, request])
+
+      yield* llm.push(TestLLM.text("queued again", "queued"))
+      yield* llm.always(TestLLM.text("constant", "constant"))
+      expect((yield* LLMClient.generate(request)).text).toBe("queued again")
+      expect((yield* LLMClient.generate(request)).text).toBe("constant")
+      expect((yield* LLMClient.generate(request)).text).toBe("constant")
+      expect(served).toEqual([selected, request])
+    }),
+  )
+
+  testEffect(
+    TestLLM.testLayer({
+      transformRequest: (request) => LLMRequest.update(request, { promptCacheKey: "observation" }),
+    }),
+  ).effect("transforms observations without changing the request passed to the responder", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.serve((input) => {
+        expect(input).toBe(request)
+        return TestLLM.text("original", "answer")
+      })
+      const generate = llm.generate(request)
+      expect(yield* llm.requests()).toEqual([])
+      expect((yield* generate).text).toBe("original")
+      expect(yield* llm.requests()).toEqual([LLMRequest.update(request, { promptCacheKey: "observation" })])
+    }),
+  )
+
+  it.effect("broadcasts request-arrival waits and satisfies waits registered afterward", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.always(TestLLM.stop())
+      const first = yield* llm.wait(2).pipe(Effect.forkChild({ startImmediately: true }))
+      const second = yield* llm.wait(2).pipe(Effect.forkChild({ startImmediately: true }))
+      yield* llm.generate(request)
+      expect(first.pollUnsafe()).toBeUndefined()
+      expect(second.pollUnsafe()).toBeUndefined()
+      yield* llm.generate(request)
+      yield* Fiber.join(first)
+      yield* Fiber.join(second)
+      yield* llm.wait(2)
+      expect(yield* llm.requests()).toHaveLength(2)
+    }),
+  )
+  ;(["queued", "served"] as const).forEach((mode) => {
+    it.effect(`assigns ${mode} replies before resuming request-arrival continuations`, () =>
+      Effect.gen(function* () {
+        const llm = yield* TestLLM.Test
+        const responses = [TestLLM.text("first", "first"), TestLLM.text("second", "second")]
+        yield* mode === "queued" ? llm.push(...responses) : llm.serve(() => responses.shift() ?? [])
+        const later = yield* llm
+          .wait(1)
+          .pipe(Effect.andThen(llm.generate(request)), Effect.forkChild({ startImmediately: true }))
+
+        expect((yield* llm.generate(request)).text).toBe("first")
+        expect((yield* Fiber.join(later)).text).toBe("second")
+        expect(yield* llm.requests()).toEqual([request, request])
+      }),
+    )
+  })
+
+  it.effect("notifies arrival waiters even when the responder defects", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const defect = new Error("Broken fixture responder")
+      yield* llm.serve(() => {
+        throw defect
+      })
+      const waiter = yield* llm.wait(1).pipe(Effect.forkChild({ startImmediately: true }))
+      expect(yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
+      yield* Fiber.join(waiter)
+    }),
+  )
+
+  it.effect("builds independent state even when the same layer is provided concurrently", () => {
+    const layer = TestLLM.testLayer()
+    const run = Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      expect(yield* llm.requests()).toEqual([])
+      yield* llm.push(TestLLM.text("one", "answer"))
+      expect((yield* LLMClient.generate(request)).text).toBe("one")
+      return yield* llm.requests()
+    }).pipe(Effect.provide(layer))
+    return Effect.gen(function* () {
+      expect(yield* Effect.all([run, run], { concurrency: "unbounded" })).toEqual([[request], [request]])
+    })
+  })
+
+  it.effect("counts concurrent starts on one gate without serializing their response assignment", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.push(TestLLM.text("first", "first"), TestLLM.text("second", "second"))
+      const generate = llm.generate(request)
+      const gate = yield* llm.gate()
+      const first = yield* generate.pipe(Effect.forkChild({ startImmediately: true }))
+      yield* gate.started
+      const second = yield* generate.pipe(Effect.forkChild({ startImmediately: true }))
+      yield* gate.started
+      yield* llm.wait(2)
+      expect(first.pollUnsafe()).toBeUndefined()
+      expect(second.pollUnsafe()).toBeUndefined()
+      yield* gate.release
+      expect((yield* Fiber.join(first)).text).toBe("first")
+      expect((yield* Fiber.join(second)).text).toBe("second")
+    }),
+  )
+
+  it.effect("does not clear a replacement gate when the previous gate is released", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.always(TestLLM.stop())
+      const previous = yield* llm.gate()
+      const first = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
+      yield* previous.started
+      const next = yield* llm.gate()
+      yield* previous.release
+      yield* Fiber.join(first)
+
+      const second = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
+      yield* next.started
+      expect(second.pollUnsafe()).toBeUndefined()
+      yield* next.release
+      yield* Fiber.join(second)
+    }),
+  )
+
+  it.effect("releases a gate when its deliberately narrower scope closes", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.always(TestLLM.stop())
+      // Only the gate is scoped here; its release must happen before the test ends.
+      const run = yield* Effect.scoped(
+        Effect.gen(function* () {
+          const gate = yield* llm.gate()
+          const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
+          yield* gate.started
+          return run
+        }),
+      )
+      yield* Fiber.join(run)
+      yield* llm.generate(request)
+      expect(yield* llm.requests()).toHaveLength(2)
+    }),
+  )
+
+  it.effect("keeps an executed response consumed after interruption and permits later requests", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      yield* llm.push(TestLLM.text("interrupted", "first"), TestLLM.text("next", "second"))
+      const gate = yield* llm.gate()
+      const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
+      yield* gate.started
+      yield* Fiber.interrupt(run)
+      yield* gate.release
+      expect((yield* llm.generate(request)).text).toBe("next")
+      expect(yield* llm.requests()).toHaveLength(2)
+    }),
+  )
+
+  it.effect("consumes a supplied stream's post-finish tail and runs its finalizer", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const tail = yield* Latch.make()
+      const release = yield* Latch.make()
+      const finalized = yield* Latch.make()
+      yield* llm.push(
+        Stream.unwrap(
+          Effect.gen(function* () {
+            yield* Effect.addFinalizer(() => finalized.open)
+            return Stream.fromIterable(TestLLM.text("complete", "answer")).pipe(
+              Stream.concat(Stream.fromEffect(tail.open.pipe(Effect.andThen(release.await))).pipe(Stream.drain)),
+            )
+          }),
+        ),
+      )
+      const run = yield* llm.generate(request).pipe(Effect.forkChild({ startImmediately: true }))
+      yield* tail.await
+      expect(run.pollUnsafe()).toBeUndefined()
+      yield* release.open
+      expect((yield* Fiber.join(run)).text).toBe("complete")
+      yield* finalized.await
+    }),
+  )
+
+  it.effect("preserves irregular events, ordinary EOF, typed failures, and responder defects", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const events = [LLMEvent.textDelta({ id: "without-start", text: "partial" })]
+      yield* llm.push(events, [])
+      expect(yield* Stream.runCollect(llm.stream(request))).toEqual(events)
+      expect(yield* Stream.runCollect(llm.stream(request))).toEqual([])
+
+      const failure = new AIError({ reason: new RateLimitError({ message: "Try later" }) })
+      const observed: LLMEvent[] = []
+      yield* llm.serve(() => TestLLM.failAfter(failure, ...events))
+      expect(
+        yield* llm.stream(request).pipe(
+          Stream.runForEach((event) => Effect.sync(() => observed.push(event))),
+          Effect.flip,
+        ),
+      ).toBe(failure)
+      expect(observed).toEqual(events)
+      expect(yield* llm.generate(request).pipe(Effect.flip)).toBe(failure)
+
+      const defect = new Error("Broken fixture responder")
+      yield* llm.serve(() => {
+        throw defect
+      })
+      expect(yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))).toBe(defect)
+      yield* llm.push(TestLLM.text("recovered", "answer"))
+      expect((yield* llm.generate(request)).text).toBe("recovered")
+    }),
+  )
+
+  it.effect("defects on unexpected requests instead of waiting for a late script", () =>
+    Effect.gen(function* () {
+      const llm = yield* TestLLM.Test
+      const defect = yield* llm.generate(request).pipe(Effect.catchDefect(Effect.succeed))
+      expect(defect).toBeInstanceOf(Error)
+      if (!(defect instanceof Error)) return
+      expect(defect.message).toBe("TestLLM has no response for request 1")
+      expect(yield* llm.requests()).toEqual([request])
+      yield* llm.push(TestLLM.stop())
+      yield* llm.generate(request)
+    }),
+  )
+})

packages/ai/tsconfig.types.json

@@ -5,5 +5,5 @@
     "noEmit": true,
     "rootDir": "."
   },
-  "include": ["test/**/*.types.ts"]
+  "include": ["test/**/*.types.ts", "test/testing.test.ts"]
 }

packages/cli/src/commands/handlers/default.ts

@@ -84,15 +84,12 @@ export default Runtime.handler(Commands, (input) =>
         update: (update) => runPromise(config.update(update)),
       },
       packages: {
-        resolve: (spec, install = true, revision) =>
+        resolve: (spec, install = true) =>
           runPromise(
-            install
-              ? npm.add(spec, { subpaths: ["tui"], revision })
-              : npm.resolve(spec, { subpaths: ["tui"], revision }),
+            (install ? npm.add(spec, { subpaths: ["tui"] }) : npm.resolve(spec, { subpaths: ["tui"] })).pipe(
+              Effect.map((result) => result.entrypoint),
+            ),
           ),
-        check: (spec) => runPromise(npm.check(spec)),
-        update: (spec) => runPromise(npm.update(spec, { subpaths: ["tui"] })),
-        reload: (spec, options) => runPromise(npm.reload(spec, { subpaths: ["tui"], ...options })),
       },
       environment: requestedServer === undefined ? Env.session() : undefined,
       terminalHandoff: () => preflight.finish(),

packages/cli/src/services/fixtures/updater.ts

@@ -1,58 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { Global } from "@opencode-ai/util/global"
-import { AppProcess } from "@opencode-ai/util/process"
-import { Effect, FileSystem, Layer, Stream } from "effect"
-import { ChildProcessSpawner } from "effect/unstable/process"
-import assert from "node:assert/strict"
-import path from "node:path"
-import { Updater } from "../updater"
-
-const latest = { version: "0.0.0-beta-17498" }
-const installs: string[] = []
-
-// This fixture runs in its own process; no real update requests or installs occur.
-globalThis.fetch = Object.assign(async () => Response.json(latest), { preconnect() {} })
-
-await Effect.runPromise(
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const directory = yield* fs.makeTempDirectoryScoped({ prefix: "opencode-updater-" })
-    const dependencies = Layer.mergeAll(
-      Layer.succeed(FileSystem.FileSystem, fs),
-      Layer.succeed(
-        Global.Service,
-        Global.make({ home: directory, config: directory, cache: path.join(directory, "cache") }),
-      ),
-      Layer.succeed(AppProcess.Service, {
-        ...ChildProcessSpawner.make(() => Effect.die("Unexpected process spawn")),
-        runStream: () => Stream.die("Unexpected streaming process"),
-        run: (command) => {
-          assert.equal(command._tag, "StandardCommand")
-          if (command.command === "npm" && command.args[0] === "install") {
-            assert.ok(command.args.includes("--global"))
-            installs.push(command.args.at(-1)!)
-          }
-          return Effect.succeed({
-            command: command.command,
-            exitCode: 0,
-            stdout: Buffer.from(command.command === "npm" ? "@opencode-ai/cli" : ""),
-            stderr: Buffer.alloc(0),
-            stdoutTruncated: false,
-            stderrTruncated: false,
-          })
-        },
-      }),
-    )
-    yield* Effect.gen(function* () {
-      const updater = yield* Updater.Service
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498"])
-      yield* updater.check()
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498"])
-      latest.version = "0.0.0-beta-17499"
-      yield* updater.check()
-      assert.deepEqual(installs, ["@opencode-ai/cli@0.0.0-beta-17498", "@opencode-ai/cli@0.0.0-beta-17499"])
-    }).pipe(Effect.provide(Updater.layer.pipe(Layer.provide(dependencies))))
-  }).pipe(Effect.scoped, Effect.provide(NodeFileSystem.layer)),
-)

packages/cli/src/services/updater-action.ts

@@ -5,9 +5,9 @@ const maximumComponent = "9007199254740991"
 const versionPattern =
   /^v?([0-9]+)\.([0-9]+)\.([0-9]+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/
 
-export function action(current: string, latest: string, policy: Policy, installed = current): Action {
+export function action(current: string, latest: string, policy: Policy): Action {
   if (policy === false) return "none"
-  const currentVersion = parseReleaseVersion(installed)
+  const currentVersion = parseReleaseVersion(current)
   const latestVersion = parseReleaseVersion(latest)
   if (!currentVersion || !latestVersion || sameRelease(currentVersion, latestVersion)) return "none"
   // Major upgrades are never installed automatically.

packages/cli/src/services/updater.test.ts

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

packages/cli/src/services/updater.ts

@@ -1,7 +1,7 @@
 import { Global } from "@opencode-ai/util/global"
 import { AppProcess } from "@opencode-ai/util/process"
 import { OPENCODE_CHANNEL, OPENCODE_LOCAL, OPENCODE_VERSION } from "../version"
-import { Context, Duration, Effect, FileSystem, Layer, Ref } from "effect"
+import { Context, Duration, Effect, FileSystem, Layer } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { parse, type ParseError } from "jsonc-parser"
 import path from "node:path"
@@ -38,7 +38,6 @@ export const layer = Layer.effect(
     const fs = yield* FileSystem.FileSystem
     const global = yield* Global.Service
     const appProcess = yield* AppProcess.Service
-    const installed = yield* Ref.make(OPENCODE_VERSION)
     const channel = OPENCODE_CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-")
 
     const readPolicy = Effect.fnUntraced(function* () {
@@ -113,20 +112,18 @@ export const layer = Layer.effect(
 
     const upgrade = Effect.fnUntraced(function* (method: Method, version: string) {
       const target = `${packageName}@${version}`
-      const commands: Record<Exclude<Method, "bun" | "curl" | "npm">, string[]> = {
+      const commands: Record<Exclude<Method, "bun" | "curl">, string[]> = {
+        npm: ["npm", "install", "--global", target],
         pnpm: ["pnpm", "add", "--global", `--allow-build=${packageName}`, target],
         yarn: ["yarn", "global", "add", target],
       }
       const result = yield* Effect.scoped(
         Effect.gen(function* () {
-          if (method === "bun" || method === "npm") {
+          if (method === "bun") {
+            // Bun does not prune old versions from its shared package cache.
             yield* fs.makeDirectory(global.cache, { recursive: true })
             const cache = yield* fs.makeTempDirectoryScoped({ directory: global.cache, prefix: "update-" })
-            const command =
-              method === "bun"
-                ? ["bun", "install", "--global", "--trust", "--cache-dir", cache, target]
-                : ["npm", "install", "--global", "--cache", cache, target]
-            return yield* run(command, "5 minutes")
+            return yield* run(["bun", "install", "--global", "--trust", "--cache-dir", cache, target], "5 minutes")
           }
           if (method === "curl") {
             yield* fs.makeDirectory(global.cache, { recursive: true })
@@ -159,19 +156,18 @@ export const layer = Layer.effect(
 
         return yield* Effect.gen(function* () {
           const version = yield* latest()
-          const current = yield* Ref.get(installed)
           yield* Effect.logInfo("update check", {
-            current,
+            current: OPENCODE_VERSION,
             latest: version,
           })
-          const next = action(OPENCODE_VERSION, version, policy, current)
+          const next = action(OPENCODE_VERSION, version, policy)
           if (next === "none") return yield* Effect.logInfo("update check done", { action: "up-to-date" })
-          if (next === "notify") return yield* Effect.logInfo("OpenCode update available", { current, latest: version })
+          if (next === "notify")
+            return yield* Effect.logInfo("OpenCode update available", { current: OPENCODE_VERSION, latest: version })
           const detected = yield* method()
           if (!detected) return yield* Effect.logWarning("automatic update skipped: installation method not found")
           yield* upgrade(detected, version)
-          yield* Ref.set(installed, version)
-          yield* Effect.logInfo("updated OpenCode", { from: current, to: version, method: detected })
+          yield* Effect.logInfo("updated OpenCode", { from: OPENCODE_VERSION, to: version, method: detected })
         })
       },
       Effect.catchCause((cause) => Effect.logWarning("automatic update failed", { cause })),

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

@@ -88,32 +88,8 @@ export type PluginListInput = {
 export type PluginListOutput = { readonly location: Location.Info; readonly data: ReadonlyArray<Plugin.Info> }
 export type PluginListOperation<E = never> = (input?: PluginListInput) => Effect.Effect<PluginListOutput, E>
 
-export type PluginCheckInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  readonly target: string
-}
-export type PluginCheckOutput = { readonly location: Location.Info; readonly data: Plugin.PackageStatus }
-export type PluginCheckOperation<E = never> = (input: PluginCheckInput) => Effect.Effect<PluginCheckOutput, E>
-
-export type PluginUpdateInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  readonly target: string
-}
-export type PluginUpdateOutput = { readonly location: Location.Info; readonly data: ReadonlyArray<Plugin.Info> }
-export type PluginUpdateOperation<E = never> = (input: PluginUpdateInput) => Effect.Effect<PluginUpdateOutput, E>
-
-export type PluginReloadInput = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  readonly target: string
-}
-export type PluginReloadOutput = { readonly location: Location.Info; readonly data: ReadonlyArray<Plugin.Info> }
-export type PluginReloadOperation<E = never> = (input: PluginReloadInput) => Effect.Effect<PluginReloadOutput, E>
-
 export interface PluginApi<E = never> {
   readonly list: PluginListOperation<E>
-  readonly check: PluginCheckOperation<E>
-  readonly update: PluginUpdateOperation<E>
-  readonly reload: PluginReloadOperation<E>
 }
 
 export type SessionListInput = {
@@ -1663,6 +1639,23 @@ export interface PtyApi<E = never> {
   readonly connect: { readonly token: PtyConnectTokenOperation<E> }
 }
 
+export type ExperimentalPersistentPtyReadInput = { readonly sessionID: Session.ID; readonly lines?: number | undefined }
+export type ExperimentalPersistentPtyReadOutput = {
+  readonly ptyID: Pty.ID
+  readonly title: string
+  readonly cwd: string
+  readonly foregroundProcess: string | null
+  readonly screen: {
+    readonly text: string
+    readonly cols: number
+    readonly rows: number
+    readonly cursor: { readonly x: number; readonly y: number }
+  }
+} | null
+export type ExperimentalPersistentPtyReadOperation<E = never> = (
+  input: ExperimentalPersistentPtyReadInput,
+) => Effect.Effect<ExperimentalPersistentPtyReadOutput, E>
+
 export type ExperimentalPersistentPtyListInput = { readonly sessionID: Session.ID }
 export type ExperimentalPersistentPtyListOutput = ReadonlyArray<{
   readonly id: Pty.ID
@@ -1811,6 +1804,7 @@ export type ExperimentalPersistentPtyConnectTokenOperation<E = never> = (
 
 export interface ExperimentalApi<E = never> {
   readonly persistentPty: {
+    readonly read: ExperimentalPersistentPtyReadOperation<E>
     readonly list: ExperimentalPersistentPtyListOperation<E>
     readonly create: ExperimentalPersistentPtyCreateOperation<E>
     readonly shutdown: ExperimentalPersistentPtyShutdownOperation<E>

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

@@ -15,12 +15,6 @@ import type {
   AgentGetOutput,
   PluginListInput,
   PluginListOutput,
-  PluginCheckInput,
-  PluginCheckOutput,
-  PluginUpdateInput,
-  PluginUpdateOutput,
-  PluginReloadInput,
-  PluginReloadOutput,
   SessionListInput,
   SessionListOutput,
   SessionStatsInput,
@@ -204,6 +198,8 @@ import type {
   PtyRemoveOutput,
   PtyConnectTokenInput,
   PtyConnectTokenOutput,
+  ExperimentalPersistentPtyReadInput,
+  ExperimentalPersistentPtyReadOutput,
   ExperimentalPersistentPtyListInput,
   ExperimentalPersistentPtyListOutput,
   ExperimentalPersistentPtyCreateInput,
@@ -322,33 +318,7 @@ const EndpointPluginList = (raw: RawClient["server.plugin"]) => (input?: PluginL
     raw["plugin.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const EndpointPluginCheck = (raw: RawClient["server.plugin"]) => (input: PluginCheckInput) =>
-  preserveEffect<PluginCheckOutput>()(
-    raw["plugin.check"]({ query: { location: input["location"] }, payload: { target: input["target"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const EndpointPluginUpdate = (raw: RawClient["server.plugin"]) => (input: PluginUpdateInput) =>
-  preserveEffect<PluginUpdateOutput>()(
-    raw["plugin.update"]({ query: { location: input["location"] }, payload: { target: input["target"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const EndpointPluginReload = (raw: RawClient["server.plugin"]) => (input: PluginReloadInput) =>
-  preserveEffect<PluginReloadOutput>()(
-    raw["plugin.reload"]({ query: { location: input["location"] }, payload: { target: input["target"] } }).pipe(
-      Effect.mapError(mapClientError),
-    ),
-  )
-
-const adaptGroupPlugin = (raw: RawClient["server.plugin"]) => ({
-  list: EndpointPluginList(raw),
-  check: EndpointPluginCheck(raw),
-  update: EndpointPluginUpdate(raw),
-  reload: EndpointPluginReload(raw),
-})
+const adaptGroupPlugin = (raw: RawClient["server.plugin"]) => ({ list: EndpointPluginList(raw) })
 
 const EndpointSessionList = (raw: RawClient["server.session"]) => (input?: SessionListInput) =>
   preserveEffect<SessionListOutput>()(
@@ -1266,6 +1236,15 @@ const adaptGroupPty = (raw: RawClient["server.pty"]) => ({
   connect: { token: EndpointPtyConnectToken(raw) },
 })
 
+const EndpointExperimentalPersistentPtyRead =
+  (raw: RawClient["server.experimental"]) => (input: ExperimentalPersistentPtyReadInput) =>
+    preserveEffect<ExperimentalPersistentPtyReadOutput>()(
+      raw["persistentPty.read"]({ params: { sessionID: input["sessionID"] }, query: { lines: input["lines"] } }).pipe(
+        Effect.mapError(mapClientError),
+        Effect.map((value) => value.data),
+      ),
+    )
+
 const EndpointExperimentalPersistentPtyList =
   (raw: RawClient["server.experimental"]) => (input: ExperimentalPersistentPtyListInput) =>
     preserveEffect<ExperimentalPersistentPtyListOutput>()(
@@ -1354,6 +1333,7 @@ const EndpointExperimentalPersistentPtyConnectToken =
 
 const adaptGroupExperimental = (raw: RawClient["server.experimental"]) => ({
   persistentPty: {
+    read: EndpointExperimentalPersistentPtyRead(raw),
     list: EndpointExperimentalPersistentPtyList(raw),
     create: EndpointExperimentalPersistentPtyCreate(raw),
     shutdown: EndpointExperimentalPersistentPtyShutdown(raw),

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

@@ -9,12 +9,6 @@ import type {
   AgentGetOutput,
   PluginListInput,
   PluginListOutput,
-  PluginCheckInput,
-  PluginCheckOutput,
-  PluginUpdateInput,
-  PluginUpdateOutput,
-  PluginReloadInput,
-  PluginReloadOutput,
   SessionListInput,
   SessionListOutput,
   SessionStatsInput,
@@ -200,6 +194,8 @@ import type {
   PtyRemoveOutput,
   PtyConnectTokenInput,
   PtyConnectTokenOutput,
+  ExperimentalPersistentPtyReadInput,
+  ExperimentalPersistentPtyReadOutput,
   ExperimentalPersistentPtyListInput,
   ExperimentalPersistentPtyListOutput,
   ExperimentalPersistentPtyCreateInput,
@@ -466,45 +462,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      check: (input: PluginCheckInput, requestOptions?: RequestOptions) =>
-        request<PluginCheckOutput>(
-          {
-            method: "POST",
-            path: `/api/plugin/check`,
-            query: { location: input["location"] },
-            body: { target: input["target"] },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      update: (input: PluginUpdateInput, requestOptions?: RequestOptions) =>
-        request<PluginUpdateOutput>(
-          {
-            method: "POST",
-            path: `/api/plugin/update`,
-            query: { location: input["location"] },
-            body: { target: input["target"] },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      reload: (input: PluginReloadInput, requestOptions?: RequestOptions) =>
-        request<PluginReloadOutput>(
-          {
-            method: "POST",
-            path: `/api/plugin/reload`,
-            query: { location: input["location"] },
-            body: { target: input["target"] },
-            successStatus: 200,
-            declaredStatuses: [400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ),
     },
     session: {
       list: (input?: SessionListInput, requestOptions?: RequestOptions) =>
@@ -1729,6 +1686,18 @@ export function make(options: ClientOptions) {
     },
     experimental: {
       persistentPty: {
+        read: (input: ExperimentalPersistentPtyReadInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: ExperimentalPersistentPtyReadOutput }>(
+            {
+              method: "GET",
+              path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal/read`,
+              query: { lines: input["lines"] },
+              successStatus: 200,
+              declaredStatuses: [503, 401, 400],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
         list: (input: ExperimentalPersistentPtyListInput, requestOptions?: RequestOptions) =>
           request<{ readonly data: ExperimentalPersistentPtyListOutput }>(
             {

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

@@ -16,8 +16,6 @@ export type PluginSource =
   | { type: "local"; path: string }
   | { type: "sdk" }
 
-export type PluginPackageStatus = { installed?: string; available?: string; mutable: boolean }
-
 export type SessionForkBoundary = { type: "before"; messageID: string } | { type: "through"; messageID: string }
 
 export type MoneyUSD = number
@@ -380,6 +378,14 @@ export type SessionStatus =
 
 export type PtyTicketConnectToken = { ticket: string; expires_in: number }
 
+export type PersistentPtyReadResult = {
+  ptyID: string
+  title: string
+  cwd: string
+  foregroundProcess: string | null
+  screen: { text: string; cols: number; rows: number; cursor: { x: number; y: number } }
+}
+
 export type PersistentPtyHandoff = { directory: string; instanceID: string; ticket: string; expiresAt: number }
 
 export type ShellInfo1 = {
@@ -435,24 +441,8 @@ export type ProviderRequest = {
 export type PermissionRule = { action: string; resource: string; effect: PermissionEffect }
 
 export type PluginInfo =
-  | {
-      id: string
-      source: PluginSource
-      status: "active"
-      tui: boolean
-      revision?: string
-      generation?: string
-      error?: string
-    }
-  | {
-      id?: string
-      source: PluginSource
-      status: "failed"
-      error: string
-      tui: boolean
-      revision?: string
-      generation?: string
-    }
+  | { id: string; source: PluginSource; status: "active"; tui: boolean }
+  | { id?: string; source: PluginSource; status: "failed"; error: string; tui: boolean }
 
 export type SessionMessageLocationSwitched = {
   id: string
@@ -2348,10 +2338,6 @@ export type AgentNotFoundError = {
 export const isAgentNotFoundError = (value: unknown): value is AgentNotFoundError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "AgentNotFoundError"
 
-export type PluginOperationError = { readonly _tag: "PluginOperationError"; readonly message: string }
-export const isPluginOperationError = (value: unknown): value is PluginOperationError =>
-  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PluginOperationError"
-
 export type InvalidCursorError = { readonly _tag: "InvalidCursorError"; readonly message: string }
 export const isInvalidCursorError = (value: unknown): value is InvalidCursorError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InvalidCursorError"
@@ -2562,42 +2548,6 @@ export type PluginListOutput = {
   data: Array<PluginInfo>
 }
 
-export type PluginCheckInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-  readonly target: { readonly target: string }["target"]
-}
-
-export type PluginCheckOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string; canonical: string } }
-  data: PluginPackageStatus
-}
-
-export type PluginUpdateInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-  readonly target: { readonly target: string }["target"]
-}
-
-export type PluginUpdateOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string; canonical: string } }
-  data: Array<PluginInfo>
-}
-
-export type PluginReloadInput = {
-  readonly location?: {
-    readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-  }["location"]
-  readonly target: { readonly target: string }["target"]
-}
-
-export type PluginReloadOutput = {
-  location: { directory: string; workspaceID?: string; project: { id: string; directory: string; canonical: string } }
-  data: Array<PluginInfo>
-}
-
 export type SessionListInput = {
   readonly workspace?: {
     readonly workspace?: string | undefined
@@ -5827,6 +5777,13 @@ export type PtyConnectTokenOutput = {
   data: PtyTicketConnectToken
 }
 
+export type ExperimentalPersistentPtyReadInput = {
+  readonly sessionID: { readonly sessionID: string }["sessionID"]
+  readonly lines?: { readonly lines?: number | undefined }["lines"]
+}
+
+export type ExperimentalPersistentPtyReadOutput = { data: PersistentPtyReadResult | null }["data"]
+
 export type ExperimentalPersistentPtyListInput = { readonly sessionID: { readonly sessionID: string }["sessionID"] }
 
 export type ExperimentalPersistentPtyListOutput = { data: Array<PersistentPtyInfo> }["data"]

packages/client/src/solid/data.ts

@@ -215,8 +215,10 @@ export function createData(config: CreateDataInput) {
   )
   const messageIndex = new Map<string, Map<string, number>>()
   const sync = createSync()
+  let activeUpdates: Map<string, DataSessionStatus | undefined> | undefined
 
   function setSessionActive(sessionID: string, status: DataSessionStatus) {
+    activeUpdates?.set(sessionID, status)
     setStore("session", "active", sessionID, status)
   }
 
@@ -473,6 +475,7 @@ export function createData(config: CreateDataInput) {
   }
 
   function removeSession(sessionID: string) {
+    activeUpdates?.set(sessionID, undefined)
     store.session.pending[sessionID]?.forEach((item) => outbox.delete(item.id))
     messageIndex.delete(sessionID)
     sync.invalidate(`session:${sessionID}`)
@@ -504,17 +507,25 @@ export function createData(config: CreateDataInput) {
 
   function handleEvent(event: OpenCodeEvent) {
     switch (event.type) {
-      case "server.connected":
+      case "server.connected": {
+        const updates = new Map<string, DataSessionStatus | undefined>()
+        activeUpdates = updates
         void api()
           .session.active()
           .then((active) => {
-            setStore(
-              "session",
-              "active",
-              reconcile(Object.fromEntries(Object.keys(active).map((sessionID) => [sessionID, "running" as const]))),
-            )
+            if (activeUpdates !== updates) return
+            // Lifecycle events received during hydration supersede the snapshot.
+            const snapshot = new Map<string, DataSessionStatus>(Object.keys(active).map((id) => [id, "running"]))
+            updates.forEach((status, id) => {
+              if (status === undefined) return snapshot.delete(id)
+              snapshot.set(id, status)
+            })
+            activeUpdates = undefined
+            setStore("session", "active", reconcile(Object.fromEntries(snapshot)))
+          })
+          .catch(() => {
+            if (activeUpdates === updates) activeUpdates = undefined
           })
-          .catch(() => undefined)
         void api()
           .location.get({ location: locationQuery(defaultLocation()) })
           .then((location) => {
@@ -525,6 +536,7 @@ export function createData(config: CreateDataInput) {
         void result.location.vcs.sync().catch((error) => console.error("Failed to preload VCS info", error))
         void result.project.sync().catch((error) => console.error("Failed to preload projects", error))
         return
+      }
       case "project.updated":
         setStore("project", "info", event.data.id, reconcile(event.data))
         return

packages/client/test/promise.test.ts

@@ -50,6 +50,8 @@ test("exposes every standard HTTP API group", () => {
   expect(Object.keys(client.vcs)).toEqual(["get", "status", "branches", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove", "connect"])
   expect(Object.keys(client.pty.connect)).toEqual(["token"])
+  expect(Object.keys(client.experimental)).toEqual(["persistentPty"])
+  expect(client.experimental.persistentPty.read).toBeFunction()
   expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "timeout", "output", "remove"])
   expect(Object.keys(client.project)).toEqual(["list", "update", "current"])
   expect(Object.keys(client.worktree)).toEqual(["list", "create", "remove", "refresh"])

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

@@ -485,6 +485,102 @@ test("preserves assistant content replacement events across an active message re
   }
 })
 
+test.each([
+  "session.execution.succeeded",
+  "session.execution.failed",
+  "session.execution.interrupted",
+  "session.execution.started",
+  "session.deleted",
+] as const)("preserves %s activity when an older snapshot arrives", async (type) => {
+  const release = Promise.withResolvers<void>()
+  const requested = Promise.withResolvers<void>()
+  const setup = activityFixture(async () => {
+    requested.resolve()
+    await release.promise
+    return Response.json({
+      data: {
+        ...(type === "session.execution.started" ? {} : { ses_refresh: { type: "running" } }),
+        ses_hydrated: { type: "running" },
+      },
+    })
+  })
+
+  try {
+    if (type !== "session.execution.started") setup.data.session.setStatus("ses_refresh", "running")
+    setup.emit({ type: "server.connected", data: {} })
+    await requested.promise
+    setup.emit({
+      id: "evt_activity",
+      created: 2,
+      type,
+      durable: { aggregateID: "ses_refresh", seq: 2, version: 1 },
+      data: { sessionID: "ses_refresh", reason: "user" },
+    })
+    expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
+    release.resolve()
+    await wait(() => setup.data.session.status("ses_hydrated") === "running")
+    expect(setup.data.session.status("ses_refresh")).toBe(type === "session.execution.started" ? "running" : "idle")
+  } finally {
+    release.resolve()
+    setup.dispose()
+  }
+})
+
+test("ignores activity snapshots from an older connection", async () => {
+  const reads: ReturnType<typeof Promise.withResolvers<Response>>[] = []
+  const setup = activityFixture(() => {
+    const read = Promise.withResolvers<Response>()
+    reads.push(read)
+    return read.promise
+  })
+
+  try {
+    setup.emit({ type: "server.connected", data: {} })
+    await wait(() => reads.length === 1)
+    setup.emit({ type: "server.connected", data: {} })
+    await wait(() => reads.length === 2)
+    reads[1]?.resolve(Response.json({ data: { ses_new: { type: "running" } } }))
+    await wait(() => setup.data.session.status("ses_new") === "running")
+    reads[0]?.resolve(Response.json({ data: { ses_old: { type: "running" } } }))
+    await Bun.sleep(20)
+    expect(setup.data.session.status("ses_new")).toBe("running")
+    expect(setup.data.session.status("ses_old")).toBe("idle")
+  } finally {
+    reads.forEach((read) => read.resolve(Response.json({ data: {} })))
+    setup.dispose()
+  }
+})
+
+function activityFixture(read: () => Response | Promise<Response>) {
+  const listeners = new Set<Parameters<CreateDataInput["event"]["listen"]>[0]>()
+  const api = OpenCode.make({
+    baseUrl: "http://opencode.local",
+    fetch: async (input, init) => {
+      const request = input instanceof Request ? input : new Request(input, init)
+      const path = new URL(request.url).pathname
+      if (path === "/api/session/active") return read()
+      if (path === "/api/project") return Response.json([])
+      if (path === "/api/location") return Response.json({ directory: "/project" })
+      return Response.json({ location: { directory: "/project" }, data: { branch: "main" } })
+    },
+  })
+  return createRoot((dispose) => ({
+    data: createData({
+      api: () => api,
+      directory: "/project",
+      event: {
+        on: () => () => {},
+        listen(handler) {
+          listeners.add(handler)
+          return () => listeners.delete(handler)
+        },
+      },
+    }),
+    emit: (details: OpenCodeEvent) => listeners.forEach((listener) => listener({ name: details.type, details })),
+    dispose,
+  }))
+}
+
 async function wait(check: () => boolean) {
   const started = Date.now()
   while (!check()) {

packages/core/src/aisdk.ts

@@ -612,12 +612,12 @@ function streamLanguage(language: LanguageModelV3, options: LanguageModelV3CallO
     Stream.unwrap(
       Effect.tryPromise({
         try: () => language.doStream(options),
-        catch: llmError,
+        catch: (error) => llmError(error, "request"),
       }).pipe(
         Effect.map((result) =>
           Stream.fromReadableStream({
             evaluate: () => result.stream,
-            onError: llmError,
+            onError: (error) => llmError(error, "read"),
           }).pipe(
             Stream.mapEffect((event) => streamPartEvents(state, event)),
             Stream.flatMap((events) => Stream.fromIterable(events)),
@@ -744,7 +744,7 @@ function streamPartEvents(
         }),
       ])
     case "error":
-      return Effect.fail(llmError(event.error))
+      return Effect.fail(llmError(event.error, "read"))
   }
 }
 
@@ -794,9 +794,20 @@ function messageValue(input: unknown) {
   }
 }
 
-function llmError(error: unknown) {
+function llmError(error: unknown, operation: "request" | "read") {
   if (error instanceof AIError) return error
   if (APICallError.isInstance(error)) return apiCallError(error)
+  const network = networkFailure(error)
+  if (network)
+    return new AIError({
+      reason: new TransportError({
+        message: network.message.trim() === "" ? unknownErrorMessage(error) : network.message,
+        cause: error,
+        transport: "http",
+        operation,
+        code: network.code,
+      }),
+    })
   return new AIError({
     reason: new UnknownProviderError({
       message: unknownErrorMessage(error),
@@ -806,6 +817,50 @@ function llmError(error: unknown) {
   })
 }
 
+// Runtime-generated network failure shapes. The codes mirror the AI SDK's own
+// Bun network error list in handleFetchError; the messages are undici's fetch
+// TypeError and stream termination strings plus our SSE chunk timeout error.
+// Unrecognized shapes still retry via the UnknownProvider default; this match
+// only adds transport semantics (continuation eligibility, display).
+const NETWORK_ERROR_CODES = new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EPIPE",
+  "ConnectionRefused",
+  "ConnectionClosed",
+  "FailedToOpenSocket",
+])
+const NETWORK_ERROR_MESSAGES = new Set([
+  "fetch failed",
+  "failed to fetch",
+  "terminated",
+  "other side closed",
+  "sse read timed out",
+])
+
+const NativeErrorShape = Schema.Struct({
+  message: Schema.String,
+  code: Schema.optionalKey(Schema.String),
+  cause: Schema.optionalKey(Schema.Unknown),
+})
+const decodeNativeErrorShape = Schema.decodeUnknownOption(NativeErrorShape)
+
+function networkFailure(error: unknown, depth = 0): { message: string; code?: string } | undefined {
+  if (depth > 4) return undefined
+  const shape = Option.getOrUndefined(decodeNativeErrorShape(error))
+  if (!shape) return undefined
+  // Prefer the deepest match: wrappers like undici's "fetch failed" TypeError
+  // carry the specific network code on their cause.
+  const cause = networkFailure(shape.cause, depth + 1)
+  if (cause) return cause
+  if (shape.code !== undefined && (NETWORK_ERROR_CODES.has(shape.code) || shape.code.startsWith("UND_ERR")))
+    return { message: shape.message, code: shape.code }
+  if (NETWORK_ERROR_MESSAGES.has(shape.message.trim().toLowerCase()))
+    return { message: shape.message, code: shape.code }
+  return undefined
+}
+
 function apiCallError(error: APICallError) {
   const failure = RequestExecutor.httpFailure({
     message: providerErrorMessage(error),

packages/core/src/config.ts

@@ -1,31 +1,15 @@
 export * as Config from "./config.js"
 
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-import path from "path"
-import { isDeepStrictEqual } from "node:util"
-import { type ParseError, parse } from "jsonc-parser"
-import { applyEdits, modify } from "jsonc-parser"
-import { Context, Effect, Layer, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect"
-import { produce, type Draft } from "immer"
-import {
-  AgentsDirectory,
-  ClaudeDirectory,
-  Directory,
-  Document,
-  Info,
-  type Entry,
-  Event,
-} from "@opencode-ai/schema/config"
-import { isRecord } from "@opencode-ai/ai/utils/record"
+import { Context, Effect, Layer, PubSub, Ref, Stream } from "effect"
+import type { Document, Entry, Info } from "@opencode-ai/schema/config"
 import { Credential } from "./credential.js"
 import { Bus } from "./bus.js"
 import { Watcher } from "./filesystem/watcher.js"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Global } from "@opencode-ai/util/global"
 import { Location } from "./location.js"
-import { AbsolutePath } from "./schema.js"
-import { ConfigVariable } from "./config/variable.js"
-import { ConfigNormalize } from "./config/normalize.js"
+import { ConfigDiscovery } from "./config/discovery.js"
 import { WellKnown } from "./wellknown.js"
 
 export function latest<K extends keyof Info>(entries: readonly Entry[], key: K): Info[K] | undefined {
@@ -36,29 +20,15 @@ export function latest<K extends keyof Info>(entries: readonly Entry[], key: K):
 export interface Interface {
   /** Returns location config documents and discovery sources from lowest to highest priority. */
   readonly entries: () => Effect.Effect<Entry[]>
-  /** Updates the first file-backed configuration document. */
-  readonly update: (update: (draft: Draft<Info>) => void) => Effect.Effect<Info, UpdateError>
   /**
-   * Streams raw filesystem updates under config roots. Config owns root
-   * topology and watch reconciliation; domain owners filter this feed for the
-   * source files they parse and rebuild their own state.
+   * Streams raw filesystem updates under config roots from the discovery engine.
+   * Domain owners filter this feed for the source files they parse and rebuild
+   * their own state.
    */
   readonly changes: () => Stream.Stream<Watcher.Update>
 }
 
-export class UpdateError extends Schema.TaggedError<UpdateError>()("Config.UpdateError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
-export const Options = Schema.Struct({
-  project: Schema.optional(Schema.Boolean),
-  // false skips the global config dir, ~/.claude, and ~/.agents; wellknown,
-  // file, and content entries still load.
-  global: Schema.optional(Schema.Boolean),
-  file: Schema.optional(Schema.String),
-  content: Schema.optional(Schema.String),
-})
+export const Options = ConfigDiscovery.Options
 export type Options = typeof Options.Type
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Config") {}
@@ -80,20 +50,6 @@ export const testLayer = (initial: Entry[] = []) =>
       const updates = yield* PubSub.unbounded<Watcher.Update>()
       const service = Test.of({
         entries: () => Ref.get(entries),
-        update: (update) =>
-          Effect.gen(function* () {
-            const current = yield* Ref.get(entries)
-            const index = current.findIndex((entry) => entry.type === "document" && entry.path !== undefined)
-            const entry = current[index]
-            if (!entry || entry.type !== "document")
-              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const info = yield* Effect.try({
-              try: () => produce(entry.info, update),
-              catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
-            })
-            yield* Ref.set(entries, current.with(index, new Document({ type: "document", path: entry.path, info })))
-            return info
-          }),
         changes: () => Stream.fromPubSub(updates),
         setEntries: (next) => Ref.set(entries, next),
         emitChange: (update) => PubSub.publish(updates, update).pipe(Effect.asVoid),
@@ -102,356 +58,7 @@ export const testLayer = (initial: Entry[] = []) =>
     }),
   )
 
-export const layer = (options?: Options) =>
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const fs = yield* FSUtil.Service
-      const global = yield* Global.Service
-      const location = yield* Location.Service
-      const watcher = yield* Watcher.Service
-      const bus = yield* Bus.Service
-      const credentials = yield* Credential.Service
-      const wellknown = yield* WellKnown.Service
-      const names = ["opencode.json", "opencode.jsonc"]
-      const reloadLock = Semaphore.makeUnsafe(1)
-      const fileTargets = new Set<AbsolutePath>()
-      const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
-      const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
-      const parseInfo = Effect.fn("Config.parseInfo")(function* (text: string, source: string) {
-        const errors: ParseError[] = []
-        const input: unknown = parse(text, errors, { allowTrailingComma: true })
-        if (errors.length) {
-          yield* Effect.logWarning("configuration normalization diagnostic", {
-            source,
-            path: "$",
-            kind: "invalid",
-            action: "rejected malformed JSON or JSONC document",
-          })
-          return
-        }
-        const result = ConfigNormalize.normalize(input)
-        yield* Effect.forEach(result.diagnostics, (diagnostic) =>
-          Effect.logWarning("configuration normalization diagnostic", {
-            source,
-            path: diagnostic.path[0] === "$" ? "$" : `$.${diagnostic.path.join(".")}`,
-            kind: diagnostic.kind,
-            action: diagnostic.message,
-          }),
-        )
-        if (result.type === "rejected") return
-        const info = Option.getOrUndefined(decodeInfo(result.encoded))
-        if (info) return info
-        yield* Effect.logWarning("configuration normalization diagnostic", {
-          source,
-          path: "$",
-          kind: "invalid",
-          action: "rejected canonical configuration after final validation",
-        })
-      })
-
-      const loadFile = Effect.fnUntraced(function* (filepath: string) {
-        const text = yield* fs.readFileStringSafe(filepath)
-        if (text === undefined) return
-        const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
-        const info = yield* parseInfo(substituted, filepath)
-        if (!info) return
-        return new Document({ type: "document", path: AbsolutePath.make(filepath), info })
-      })
-
-      const loadWellknownEntry = Effect.fnUntraced(function* (entry: WellKnown.Entry) {
-        const auth = entry.manifest.auth
-        if (!auth) return []
-        const credential = (yield* credentials.list(entry.integrationID)).at(-1)
-        if (!credential || credential.value.type !== "key") return []
-        const variables = { [auth.env]: credential.value.key }
-        const configs = yield* wellknown
-          .resolve(entry, variables)
-          .pipe(
-            Effect.catch(() =>
-              Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(
-                Effect.as([] as const),
-              ),
-            ),
-          )
-        return yield* Effect.forEach(configs, (config) =>
-          ConfigVariable.substitute({
-            type: "virtual",
-            source: entry.origin,
-            dir: entry.origin,
-            text: JSON.stringify(config),
-            env: variables,
-          }).pipe(
-            Effect.flatMap((text) => parseInfo(text, entry.origin)),
-            Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
-          ),
-        ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
-      })
-
-      const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
-        const entries = yield* wellknown
-          .entries()
-          .pipe(
-            Effect.catch((error) =>
-              Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([] as const)),
-            ),
-          )
-        return yield* Effect.forEach(entries, loadWellknownEntry).pipe(Effect.map((documents) => documents.flat()))
-      })
-
-      const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
-        return [
-          ...(yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(
-            Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
-          )),
-          new Directory({ type: "directory", path: directory }),
-        ]
-      })
-
-      const discover = Effect.fn("Config.discover")(function* () {
-        const globalDirectory = AbsolutePath.make(global.config)
-        const globalAgentsDirectory = AbsolutePath.make(path.join(global.home, ".agents"))
-        const globalClaudeDirectory = AbsolutePath.make(path.join(global.home, ".claude"))
-        const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
-        const discovered =
-          locationIsGlobal || options?.project === false
-            ? []
-            : yield* fs
-                .up({
-                  targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
-                  start: location.directory,
-                })
-                .pipe(Effect.orDie)
-
-        const globalEnabled = options?.global !== false
-        // A walked path that resolves into a global root is global config
-        // however the walk reached it (home above the project, or a location
-        // beneath the global config dir), so global: false excludes it
-        // uniformly — classified once here, not per consumer below.
-        const globalRoots = [globalDirectory, globalClaudeDirectory, globalAgentsDirectory].map((item) =>
-          path.resolve(item),
-        )
-        const visible = globalEnabled
-          ? discovered
-          : discovered.filter((item) => {
-              const resolved = path.resolve(item)
-              return !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
-            })
-        // We load certain files from a few other folders in the ecosystem
-        const claude = [
-          ...new Set([
-            ...(globalEnabled && (yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : []),
-            ...visible.filter((item) => path.basename(item) === ".claude").toReversed(),
-          ]),
-        ].map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) }))
-        const agents = [
-          ...new Set([
-            ...(globalEnabled && (yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : []),
-            ...visible.filter((item) => path.basename(item) === ".agents").toReversed(),
-          ]),
-        ].map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) }))
-
-        const projectDirectories = visible
-          .filter((item) => path.basename(item) === ".opencode")
-          .toReversed()
-          .map((directory) => AbsolutePath.make(directory))
-        const directPaths = visible
-          .filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item)))
-          .toReversed()
-        fileTargets.clear()
-        directPaths.forEach((filepath) => fileTargets.add(AbsolutePath.make(filepath)))
-        const direct = yield* Effect.forEach(directPaths, (filepath) => loadFile(filepath)).pipe(
-          Effect.orDie,
-          Effect.map((entries) => entries.filter((entry): entry is Document => entry !== undefined)),
-        )
-
-        const file = options?.file
-        if (file) fileTargets.add(AbsolutePath.make(path.resolve(file)))
-        const explicit = file
-          ? yield* loadFile(path.resolve(file)).pipe(
-              Effect.map((config) => (config ? [config] : [])),
-              Effect.orDie,
-            )
-          : []
-        const content =
-          options?.content !== undefined
-            ? yield* ConfigVariable.substitute({
-                type: "virtual",
-                source: "OPENCODE_CONFIG_CONTENT",
-                dir: location.directory,
-                text: options.content,
-              }).pipe(
-                Effect.flatMap((text) => parseInfo(text, "OPENCODE_CONFIG_CONTENT")),
-                Effect.map((info) => (info ? [new Document({ type: "document", info })] : [])),
-                Effect.orDie,
-              )
-            : []
-
-        // Global entries sit below explicit and direct files; project
-        // directories rank above them.
-        const globalSupplementary = globalEnabled ? yield* loadDirectory(globalDirectory).pipe(Effect.orDie) : []
-        const projectSupplementary = yield* Effect.forEach(projectDirectories, loadDirectory).pipe(
-          Effect.orDie,
-          Effect.map((entries) => entries.flat()),
-        )
-        return [
-          ...(yield* loadWellknown().pipe(Effect.orDie)),
-          ...claude,
-          ...agents,
-          ...globalSupplementary,
-          ...explicit,
-          ...direct,
-          ...projectSupplementary,
-          ...content,
-        ]
-      })
-
-      const initial = yield* discover()
-      let configs = initial
-      const updates = yield* PubSub.unbounded<Watcher.Update>()
-      // Vendored trees inside config roots (a plugin's node_modules, a nested
-      // .git) produce event blizzards that can never change discovery output.
-      const ignore = ["node_modules", ".git", "**/{node_modules,.git}/**"]
-      // Watch-once: roots leave discovery only by deletion, so a stale watch is
-      // inert, bounded, and dies with this layer — and keeping a deleted root's
-      // watch alive is exactly what makes its recreation observable.
-      const watched = new Set<string>()
-      const reconcile = Effect.fn("Config.reconcileWatches")(function* (entries: readonly Entry[]) {
-        const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
-        const files = [
-          ...entries.flatMap((entry) => (entry.type === "document" && entry.path ? [entry.path] : [])),
-          ...fileTargets,
-        ]
-        const targets = [
-          ...directories.map((path) => ({ path, type: "directory" as const, ignore })),
-          ...files
-            .filter((file) => !directories.some((directory) => FSUtil.contains(directory, file)))
-            .map((path) => ({ path, type: "file" as const })),
-        ]
-        for (const target of targets) {
-          const key = JSON.stringify(target)
-          if (watched.has(key)) continue
-          watched.add(key)
-          const stream = yield* watcher.subscribe(target)
-          yield* stream.pipe(
-            Stream.runForEach((update) => PubSub.publish(updates, update)),
-            Effect.forkScoped({ startImmediately: true }),
-          )
-        }
-      })
-
-      const reload = Effect.fn("Config.reload")(() =>
-        reloadLock.withPermit(
-          Effect.gen(function* () {
-            const next = yield* discover()
-            yield* reconcile(next)
-            if (isDeepStrictEqual(configs, next)) return
-            configs = next
-            yield* bus.publish(Event.Updated, {})
-          }),
-        ),
-      )
-
-      yield* Stream.fromPubSub(updates).pipe(
-        Stream.debounce("100 millis"),
-        Stream.runForEach((update) =>
-          reload().pipe(
-            Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause })),
-          ),
-        ),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* bus.subscribe(Credential.Event.Switched).pipe(
-        Stream.filterEffect((event) =>
-          wellknown.entries().pipe(
-            Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)),
-            Effect.orElseSucceed(() => false),
-          ),
-        ),
-        Stream.runForEach(() =>
-          reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown config", { cause }))),
-        ),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* bus.subscribe(WellKnown.Event.Updated).pipe(
-        Stream.runForEach(() =>
-          reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown sources", { cause }))),
-        ),
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* Effect.sleep("10 minutes").pipe(
-        Effect.andThen(
-          Effect.suspend(() => {
-            if (!wellknown.snapshot().length) return Effect.void
-            return Effect.gen(function* () {
-              const changed = yield* wellknown
-                .refresh()
-                .pipe(
-                  Effect.catch((error) =>
-                    Effect.logWarning("failed to refresh wellknown manifests", { error }).pipe(Effect.as(false)),
-                  ),
-                )
-              if (!changed) yield* reload()
-            }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to refresh wellknown config", { cause })))
-          }),
-        ),
-        Effect.forever,
-        Effect.forkScoped({ startImmediately: true }),
-      )
-      yield* reconcile(initial)
-
-      const update = Effect.fn("Config.update")((mutate: (draft: Draft<Info>) => void) =>
-        reloadLock.withPermit(
-          Effect.gen(function* () {
-            // TODO: Replace entry-order selection with an explicit config scope/target model.
-            const document = configs.find((entry) => entry.type === "document" && entry.path !== undefined)
-            if (!document || document.type !== "document" || !document.path)
-              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const next = yield* Effect.try({
-              try: () => produce(document.info, mutate),
-              catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
-            })
-            const edits = changes(document.info, next)
-            if (!edits.length) return document.info
-            const text = yield* fs
-              .readFileString(document.path)
-              .pipe(
-                Effect.mapError(
-                  (cause) => new UpdateError({ message: `Failed to read config: ${document.path}`, cause }),
-                ),
-              )
-            const updated = edits.reduce(
-              (text, edit) =>
-                applyEdits(
-                  text,
-                  modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-                ),
-              text,
-            )
-            const info = yield* parseInfo(updated, document.path)
-            if (!info)
-              return yield* Effect.fail(new UpdateError({ message: `Invalid config update: ${document.path}` }))
-            const temporary = document.path + ".tmp"
-            yield* fs.writeFileString(temporary, updated.endsWith("\n") ? updated : updated + "\n").pipe(
-              Effect.andThen(fs.rename(temporary, document.path)),
-              Effect.mapError(
-                (cause) => new UpdateError({ message: `Failed to write config: ${document.path}`, cause }),
-              ),
-            )
-            return info
-          }),
-        ),
-      )
-
-      return Service.of({
-        entries: Effect.fnUntraced(function* () {
-          return configs
-        }),
-        update,
-        changes: () => Stream.fromPubSub(updates),
-      })
-    }),
-  )
+export const layer = (options?: Options) => Layer.effect(Service, ConfigDiscovery.make(options))
 
 export function configured(options?: Options) {
   return makeLocationNode({
@@ -462,17 +69,3 @@ export function configured(options?: Options) {
 }
 
 export const node = configured()
-
-type Edit = { readonly path: (string | number)[]; readonly value: unknown }
-
-function changes(before: unknown, after: unknown, path: (string | number)[] = []): Edit[] {
-  if (Object.is(before, after)) return []
-  if (isRecord(before) && isRecord(after)) {
-    return [...new Set([...Object.keys(before), ...Object.keys(after)])].flatMap((key) => {
-      if (!(key in after)) return [{ path: [...path, key], value: undefined }]
-      if (!(key in before)) return [{ path: [...path, key], value: after[key] }]
-      return changes(before[key], after[key], [...path, key])
-    })
-  }
-  return [{ path, value: after }]
-}

packages/core/src/config/discovery.ts

@@ -0,0 +1,337 @@
+export * as ConfigDiscovery from "./discovery.js"
+
+import path from "path"
+import { isDeepStrictEqual } from "node:util"
+import { type ParseError, parse } from "jsonc-parser"
+import { Effect, Option, PubSub, Schema, Semaphore, Stream } from "effect"
+import {
+  AgentsDirectory,
+  ClaudeDirectory,
+  Directory,
+  Document,
+  Info,
+  type Entry,
+  Event,
+} from "@opencode-ai/schema/config"
+import { Credential } from "../credential.js"
+import { Bus } from "../bus.js"
+import { Watcher } from "../filesystem/watcher.js"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Global } from "@opencode-ai/util/global"
+import { Location } from "../location.js"
+import { AbsolutePath } from "../schema.js"
+import { ConfigVariable } from "./variable.js"
+import { ConfigNormalize } from "./normalize.js"
+import { WellKnown } from "../wellknown.js"
+
+export const Options = Schema.Struct({
+  project: Schema.optional(Schema.Boolean),
+  // false skips the global config dir, ~/.claude, and ~/.agents; wellknown,
+  // file, and content entries still load.
+  global: Schema.optional(Schema.Boolean),
+  file: Schema.optional(Schema.String),
+  content: Schema.optional(Schema.String),
+})
+export type Options = typeof Options.Type
+
+/** Builds the scoped discovery engine without requiring the Config service. */
+export const make = Effect.fn("ConfigDiscovery.make")(function* (options?: Options) {
+  const fs = yield* FSUtil.Service
+  const global = yield* Global.Service
+  const location = yield* Location.Service
+  const watcher = yield* Watcher.Service
+  const bus = yield* Bus.Service
+  const credentials = yield* Credential.Service
+  const wellknown = yield* WellKnown.Service
+  const names = ["opencode.json", "opencode.jsonc"]
+  const reloadLock = Semaphore.makeUnsafe(1)
+  const fileTargets = new Set<AbsolutePath>()
+  const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
+  const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
+  const parseInfo = Effect.fn("Config.parseInfo")(function* (text: string, source: string) {
+    const errors: ParseError[] = []
+    const input: unknown = parse(text, errors, { allowTrailingComma: true })
+    if (errors.length) {
+      yield* Effect.logWarning("configuration normalization diagnostic", {
+        source,
+        path: "$",
+        kind: "invalid",
+        action: "rejected malformed JSON or JSONC document",
+      })
+      return
+    }
+    const result = ConfigNormalize.normalize(input)
+    yield* Effect.forEach(result.diagnostics, (diagnostic) =>
+      Effect.logWarning("configuration normalization diagnostic", {
+        source,
+        path: diagnostic.path[0] === "$" ? "$" : `$.${diagnostic.path.join(".")}`,
+        kind: diagnostic.kind,
+        action: diagnostic.message,
+      }),
+    )
+    if (result.type === "rejected") return
+    const info = Option.getOrUndefined(decodeInfo(result.encoded))
+    if (info) return info
+    yield* Effect.logWarning("configuration normalization diagnostic", {
+      source,
+      path: "$",
+      kind: "invalid",
+      action: "rejected canonical configuration after final validation",
+    })
+  })
+
+  const loadFile = Effect.fnUntraced(function* (filepath: string) {
+    const text = yield* fs.readFileStringSafe(filepath)
+    if (text === undefined) return
+    const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
+    const info = yield* parseInfo(substituted, filepath)
+    if (!info) return
+    return new Document({ type: "document", path: AbsolutePath.make(filepath), info })
+  })
+
+  const loadWellknownEntry = Effect.fnUntraced(function* (entry: WellKnown.Entry) {
+    const auth = entry.manifest.auth
+    if (!auth) return []
+    const credential = (yield* credentials.list(entry.integrationID)).at(-1)
+    if (!credential || credential.value.type !== "key") return []
+    const variables = { [auth.env]: credential.value.key }
+    const configs = yield* wellknown
+      .resolve(entry, variables)
+      .pipe(
+        Effect.catch(() =>
+          Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(Effect.as([] as const)),
+        ),
+      )
+    return yield* Effect.forEach(configs, (config) =>
+      ConfigVariable.substitute({
+        type: "virtual",
+        source: entry.origin,
+        dir: entry.origin,
+        text: JSON.stringify(config),
+        env: variables,
+      }).pipe(
+        Effect.flatMap((text) => parseInfo(text, entry.origin)),
+        Effect.map((info) => (info ? new Document({ type: "document", info }) : undefined)),
+      ),
+    ).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)))
+  })
+
+  const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
+    const entries = yield* wellknown
+      .entries()
+      .pipe(
+        Effect.catch((error) =>
+          Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([] as const)),
+        ),
+      )
+    return yield* Effect.forEach(entries, loadWellknownEntry).pipe(Effect.map((documents) => documents.flat()))
+  })
+
+  const loadDirectory = Effect.fnUntraced(function* (directory: AbsolutePath) {
+    return [
+      ...(yield* Effect.forEach(names, (file) => loadFile(path.join(directory, file))).pipe(
+        Effect.map((configs) => configs.filter((config): config is Document => config !== undefined)),
+      )),
+      new Directory({ type: "directory", path: directory }),
+    ]
+  })
+
+  const discover = Effect.fn("Config.discover")(function* () {
+    const globalDirectory = AbsolutePath.make(global.config)
+    const globalAgentsDirectory = AbsolutePath.make(path.join(global.home, ".agents"))
+    const globalClaudeDirectory = AbsolutePath.make(path.join(global.home, ".claude"))
+    const locationIsGlobal = path.resolve(location.directory) === path.resolve(global.config)
+    const discovered =
+      locationIsGlobal || options?.project === false
+        ? []
+        : yield* fs
+            .up({
+              targets: [".opencode", ".claude", ".agents", ...names.toReversed()],
+              start: location.directory,
+            })
+            .pipe(Effect.orDie)
+
+    const globalEnabled = options?.global !== false
+    // A walked path that resolves into a global root is global config
+    // however the walk reached it (home above the project, or a location
+    // beneath the global config dir), so global: false excludes it
+    // uniformly — classified once here, not per consumer below.
+    const globalRoots = [globalDirectory, globalClaudeDirectory, globalAgentsDirectory].map((item) =>
+      path.resolve(item),
+    )
+    const visible = globalEnabled
+      ? discovered
+      : discovered.filter((item) => {
+          const resolved = path.resolve(item)
+          return !globalRoots.some((root) => resolved === root || resolved.startsWith(root + path.sep))
+        })
+    // We load certain files from a few other folders in the ecosystem
+    const claude = [
+      ...new Set([
+        ...(globalEnabled && (yield* fs.isDir(globalClaudeDirectory)) ? [globalClaudeDirectory] : []),
+        ...visible.filter((item) => path.basename(item) === ".claude").toReversed(),
+      ]),
+    ].map((directory) => new ClaudeDirectory({ type: "claude", path: AbsolutePath.make(directory) }))
+    const agents = [
+      ...new Set([
+        ...(globalEnabled && (yield* fs.isDir(globalAgentsDirectory)) ? [globalAgentsDirectory] : []),
+        ...visible.filter((item) => path.basename(item) === ".agents").toReversed(),
+      ]),
+    ].map((directory) => new AgentsDirectory({ type: "agents", path: AbsolutePath.make(directory) }))
+
+    const projectDirectories = visible
+      .filter((item) => path.basename(item) === ".opencode")
+      .toReversed()
+      .map((directory) => AbsolutePath.make(directory))
+    const directPaths = visible
+      .filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item)))
+      .toReversed()
+    fileTargets.clear()
+    directPaths.forEach((filepath) => fileTargets.add(AbsolutePath.make(filepath)))
+    const direct = yield* Effect.forEach(directPaths, (filepath) => loadFile(filepath)).pipe(
+      Effect.orDie,
+      Effect.map((entries) => entries.filter((entry): entry is Document => entry !== undefined)),
+    )
+
+    const file = options?.file
+    if (file) fileTargets.add(AbsolutePath.make(path.resolve(file)))
+    const explicit = file
+      ? yield* loadFile(path.resolve(file)).pipe(
+          Effect.map((config) => (config ? [config] : [])),
+          Effect.orDie,
+        )
+      : []
+    const content =
+      options?.content !== undefined
+        ? yield* ConfigVariable.substitute({
+            type: "virtual",
+            source: "OPENCODE_CONFIG_CONTENT",
+            dir: location.directory,
+            text: options.content,
+          }).pipe(
+            Effect.flatMap((text) => parseInfo(text, "OPENCODE_CONFIG_CONTENT")),
+            Effect.map((info) => (info ? [new Document({ type: "document", info })] : [])),
+            Effect.orDie,
+          )
+        : []
+
+    // Global entries sit below explicit and direct files; project
+    // directories rank above them.
+    const globalSupplementary = globalEnabled ? yield* loadDirectory(globalDirectory).pipe(Effect.orDie) : []
+    const projectSupplementary = yield* Effect.forEach(projectDirectories, loadDirectory).pipe(
+      Effect.orDie,
+      Effect.map((entries) => entries.flat()),
+    )
+    return [
+      ...(yield* loadWellknown().pipe(Effect.orDie)),
+      ...claude,
+      ...agents,
+      ...globalSupplementary,
+      ...explicit,
+      ...direct,
+      ...projectSupplementary,
+      ...content,
+    ]
+  })
+
+  const initial = yield* discover()
+  let configs = initial
+  const updates = yield* PubSub.unbounded<Watcher.Update>()
+  // Vendored trees inside config roots (a plugin's node_modules, a nested
+  // .git) produce event blizzards that can never change discovery output.
+  const ignore = ["node_modules", ".git", "**/{node_modules,.git}/**"]
+  // Watch-once: roots leave discovery only by deletion, so a stale watch is
+  // inert, bounded, and dies with this layer — and keeping a deleted root's
+  // watch alive is exactly what makes its recreation observable.
+  const watched = new Set<string>()
+  const reconcile = Effect.fn("Config.reconcileWatches")(function* (entries: readonly Entry[]) {
+    const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
+    const files = [
+      ...entries.flatMap((entry) => (entry.type === "document" && entry.path ? [entry.path] : [])),
+      ...fileTargets,
+    ]
+    const targets = [
+      ...directories.map((path) => ({ path, type: "directory" as const, ignore })),
+      ...files
+        .filter((file) => !directories.some((directory) => FSUtil.contains(directory, file)))
+        .map((path) => ({ path, type: "file" as const })),
+    ]
+    for (const target of targets) {
+      const key = JSON.stringify(target)
+      if (watched.has(key)) continue
+      watched.add(key)
+      const stream = yield* watcher.subscribe(target)
+      yield* stream.pipe(
+        Stream.runForEach((update) => PubSub.publish(updates, update)),
+        Effect.forkScoped({ startImmediately: true }),
+      )
+    }
+  })
+
+  const reload = Effect.fn("Config.reload")(() =>
+    reloadLock.withPermit(
+      Effect.gen(function* () {
+        const next = yield* discover()
+        yield* reconcile(next)
+        if (isDeepStrictEqual(configs, next)) return
+        configs = next
+        yield* bus.publish(Event.Updated, {})
+      }),
+    ),
+  )
+
+  yield* Stream.fromPubSub(updates).pipe(
+    Stream.debounce("100 millis"),
+    Stream.runForEach((update) =>
+      reload().pipe(
+        Effect.catchCause((cause) => Effect.logError("failed to reload config", { path: update.path, cause })),
+      ),
+    ),
+    Effect.forkScoped({ startImmediately: true }),
+  )
+  yield* bus.subscribe(Credential.Event.Switched).pipe(
+    Stream.filterEffect((event) =>
+      wellknown.entries().pipe(
+        Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)),
+        Effect.orElseSucceed(() => false),
+      ),
+    ),
+    Stream.runForEach(() =>
+      reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown config", { cause }))),
+    ),
+    Effect.forkScoped({ startImmediately: true }),
+  )
+  yield* bus.subscribe(WellKnown.Event.Updated).pipe(
+    Stream.runForEach(() =>
+      reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown sources", { cause }))),
+    ),
+    Effect.forkScoped({ startImmediately: true }),
+  )
+  yield* Effect.sleep("10 minutes").pipe(
+    Effect.andThen(
+      Effect.suspend(() => {
+        if (!wellknown.snapshot().length) return Effect.void
+        return Effect.gen(function* () {
+          const changed = yield* wellknown
+            .refresh()
+            .pipe(
+              Effect.catch((error) =>
+                Effect.logWarning("failed to refresh wellknown manifests", { error }).pipe(Effect.as(false)),
+              ),
+            )
+          if (!changed) yield* reload()
+        }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to refresh wellknown config", { cause })))
+      }),
+    ),
+    Effect.forever,
+    Effect.forkScoped({ startImmediately: true }),
+  )
+  yield* reconcile(initial)
+
+  return {
+    entries: Effect.fnUntraced(function* () {
+      return configs
+    }),
+    changes: () => Stream.fromPubSub(updates),
+  }
+})

packages/core/src/config/file.ts

@@ -0,0 +1,150 @@
+export * as ConfigFile from "./file.js"
+
+import { isDeepStrictEqual } from "node:util"
+import { isRecord } from "@opencode-ai/ai/utils/record"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Effect, Schema, Semaphore } from "effect"
+import {
+  applyEdits,
+  createScanner,
+  findNodeAtLocation,
+  modify,
+  parseTree,
+  type Node,
+  type ParseError,
+} from "jsonc-parser"
+
+export class UpdateError extends Schema.TaggedError<UpdateError>()("ConfigFile.UpdateError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect()),
+}) {}
+
+const isJson = Schema.is(Schema.MutableJson)
+const isDocument = (value: unknown): value is Schema.MutableJsonObject => isRecord(value) && isJson(value)
+const lock = Semaphore.makeUnsafe(1)
+
+/**
+ * Edits an existing JSON(C) file using raw source values, not resolved Config.Info.
+ * The synchronous callback mutates a source clone; its return value is ignored.
+ * Validates JSON only; normalization and substitution remain the reader's job.
+ * Does not discover files, start watchers, or refresh Config state.
+ * Read-modify-write calls are serialized within this process.
+ */
+export const update = Effect.fn("ConfigFile.update")(
+  function* (
+    filepath: string,
+    mutate: (draft: Schema.MutableJsonObject) => void,
+  ): Effect.fn.Return<Schema.JsonObject, UpdateError, FSUtil.Service> {
+    const fs = yield* FSUtil.Service
+    const text = yield* fs
+      .readFileString(filepath)
+      .pipe(Effect.mapError((cause) => new UpdateError({ message: `Failed to read config: ${filepath}`, cause })))
+    const errors: ParseError[] = []
+    const current = parseSource(text, errors)
+    if (errors.length || !isDocument(current))
+      return yield* Effect.fail(new UpdateError({ message: `Invalid config file: ${filepath}` }))
+
+    const next = yield* Effect.try({
+      try: () => {
+        const draft = structuredClone(current)
+        mutate(draft)
+        return draft
+      },
+      catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
+    })
+    if (!isDocument(next))
+      return yield* Effect.fail(new UpdateError({ message: `Config update must produce a JSON object: ${filepath}` }))
+
+    const edits = changes(current, next)
+    if (!edits.length) return next
+    const updated = yield* Effect.try({
+      try: () => edits.reduce(patch, text),
+      catch: (cause) => new UpdateError({ message: `Failed to patch config: ${filepath}`, cause }),
+    })
+    // Duplicate keys can make parse choose the last value while modify edits the first.
+    const written = parseSource(updated, errors)
+    if (errors.length || !isDeepStrictEqual(written, next))
+      return yield* Effect.fail(
+        new UpdateError({ message: `Config patch does not match the requested update: ${filepath}` }),
+      )
+    const temporary = filepath + ".tmp"
+    yield* fs.writeFileString(temporary, updated.endsWith("\n") ? updated : updated + "\n").pipe(
+      Effect.andThen(fs.rename(temporary, filepath)),
+      Effect.mapError((cause) => new UpdateError({ message: `Failed to write config: ${filepath}`, cause })),
+    )
+    return next
+  },
+  (effect) => lock.withPermit(effect),
+)
+
+type Edit = { readonly path: (string | number)[]; readonly value: unknown }
+
+function parseSource(text: string, errors: ParseError[]) {
+  const root = parseTree(text, errors, { allowTrailingComma: true })
+  if (!root || errors.length) return undefined
+  // parse() assigns onto {}, invoking the __proto__ setter instead of retaining
+  // an own JSON key. Construct object entries from the AST without those setters.
+  const value = (node: Node): unknown => {
+    if (node.type === "array") return (node.children ?? []).map(value)
+    if (node.type === "object")
+      return Object.fromEntries(
+        (node.children ?? []).map((property) => {
+          const child = property.children?.[1]
+          return [property.children?.[0]?.value, child && value(child)]
+        }),
+      )
+    return node.value
+  }
+  return value(root)
+}
+
+function patch(text: string, edit: Edit) {
+  if (edit.value !== undefined)
+    return applyEdits(
+      text,
+      modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
+    )
+
+  const tree = parseTree(text)
+  const node = tree && findNodeAtLocation(tree, edit.path)
+  if (!node) return text
+  // jsonc-parser removes adjacent comments along with the separator. Remove only
+  // the property/element itself and one comma, leaving surrounding comments intact.
+  const target = node.parent?.type === "property" ? node.parent : node
+  const siblings = target.parent?.children ?? []
+  const previous = siblings[siblings.indexOf(target) - 1]
+  const scanner = createScanner(text, true)
+  scanner.setPosition(target.offset + target.length)
+  scanner.scan()
+  const following = text[scanner.getTokenOffset()] === ","
+  if (!following && previous) {
+    scanner.setPosition(previous.offset + previous.length)
+    scanner.scan()
+  }
+  return applyEdits(text, [
+    { offset: target.offset, length: target.length, content: "" },
+    ...(following || previous ? [{ offset: scanner.getTokenOffset(), length: 1, content: "" }] : []),
+  ])
+}
+
+function changes(before: unknown, after: unknown, path: (string | number)[] = []): Edit[] {
+  if (isDeepStrictEqual(before, after)) return []
+  if (Array.isArray(before) && Array.isArray(after)) {
+    return [
+      ...after.flatMap((value, index) => changes(before[index], value, [...path, index])),
+      // Remove from the end so earlier deletions cannot shift later paths.
+      ...before
+        .slice(after.length)
+        .map((_, index) => ({ path: [...path, after.length + index], value: undefined }))
+        .toReversed(),
+    ]
+  }
+  if (isRecord(before) && isRecord(after)) {
+    return [...new Set([...Object.keys(before), ...Object.keys(after)])].flatMap((key) => {
+      if (!Object.hasOwn(after, key)) return [{ path: [...path, key], value: undefined }]
+      if (!Object.hasOwn(before, key)) return [{ path: [...path, key], value: after[key] }]
+      return changes(before[key], after[key], [...path, key])
+    })
+  }
+  return [{ path, value: after }]
+}

packages/core/src/instance.ts

@@ -23,7 +23,6 @@ import { Mcp } from "./mcp/index.js"
 import { Permission } from "./permission.js"
 import { Plugin } from "./plugin.js"
 import { PluginHooks } from "./plugin/hooks.js"
-import { PluginExecution } from "./plugin/execution.js"
 import { InstancePlugins } from "./plugin/instance.js"
 import { PluginSupervisor } from "./plugin/supervisor.js"
 import { Worktree } from "./worktree.js"
@@ -68,7 +67,6 @@ const nodes = [
   AISDK.node,
   Plugin.node,
   PluginHooks.node,
-  PluginExecution.node,
   InstancePlugins.node,
   PluginSupervisor.node,
   Worktree.refreshNode,

packages/core/src/persistent-pty/daemon.ts

@@ -59,6 +59,13 @@ export const WireResponse = Schema.Union([
     cursor_x: Schema.Number,
     cursor_y: Schema.Number,
   }),
+  Schema.Struct({
+    type: Schema.Literal("rows"),
+    terminal: WireTerminal,
+    lines: Schema.Array(Schema.String),
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number,
+  }),
   Schema.Struct({
     type: Schema.Literal("attached"),
     terminal: WireTerminal,

packages/core/src/persistent-pty/index.ts

@@ -4,7 +4,7 @@ import os from "node:os"
 import path from "node:path"
 import { Context, Effect, Layer, Schema } from "effect"
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
-import { Added, Handoff, Removed } from "@opencode-ai/schema/persistent-pty"
+import { Added, Handoff, ReadLines, Removed, type ReadResult } from "@opencode-ai/schema/persistent-pty"
 import { Session } from "@opencode-ai/schema/session"
 import { Bus } from "../bus.js"
 import { Pty } from "@opencode-ai/schema/pty"
@@ -103,6 +103,7 @@ export interface Interface {
     data: Uint8Array,
   ) => Effect.Effect<void, NotFoundError | UnavailableError>
   readonly snapshot: (id: Pty.ID) => Effect.Effect<Snapshot, NotFoundError | UnavailableError>
+  readonly read: (sessionID: Session.ID, lines?: number) => Effect.Effect<ReadResult | null, UnavailableError>
   readonly remove: (id: Pty.ID) => Effect.Effect<void, NotFoundError | UnavailableError>
   readonly shutdown: () => Effect.Effect<void, UnavailableError>
   readonly handoff: () => Effect.Effect<Handoff | null, UnavailableError>
@@ -140,6 +141,8 @@ export const configured = (options: Options = {}) =>
         options.handoff,
       ).pipe(Effect.mapError(unavailable))
       const removing = new Set<Pty.ID>()
+      // Controller activity selects a terminal; observer reads and pane visibility do not.
+      const current = new Map<Session.ID, Pty.ID>()
 
       const list = Effect.fn("PersistentPty.list")(function* (sessionID?: Session.ID) {
         const response = yield* optionalRequest(daemon, { op: "list" })
@@ -207,7 +210,7 @@ export const configured = (options: Options = {}) =>
         rows: number,
         attachmentID?: string,
       ) {
-        yield* get(id)
+        const terminal = yield* get(id)
         const response = yield* request(daemon, {
           op: "resize",
           id: fromID(id),
@@ -216,6 +219,7 @@ export const configured = (options: Options = {}) =>
           rows,
         })
         if (response.type !== "ok") return yield* unexpected(response)
+        current.set(terminal.sessionID, id)
         return undefined
       })
 
@@ -225,7 +229,7 @@ export const configured = (options: Options = {}) =>
         cols: number,
         rows: number,
       ) {
-        yield* get(id)
+        const terminal = yield* get(id)
         const response = yield* request(daemon, {
           op: "control",
           id: fromID(id),
@@ -234,6 +238,7 @@ export const configured = (options: Options = {}) =>
           rows,
         })
         if (response.type !== "ok") return yield* unexpected(response)
+        current.set(terminal.sessionID, id)
         return undefined
       })
 
@@ -244,7 +249,7 @@ export const configured = (options: Options = {}) =>
         rows: number,
         data: Uint8Array,
       ) {
-        yield* get(id)
+        const terminal = yield* get(id)
         const response = yield* request(daemon, {
           op: "input",
           id: fromID(id),
@@ -254,6 +259,7 @@ export const configured = (options: Options = {}) =>
           data_base64: Buffer.from(data).toString("base64"),
         })
         if (response.type !== "ok") return yield* unexpected(response)
+        current.set(terminal.sessionID, id)
         return undefined
       })
 
@@ -269,16 +275,46 @@ export const configured = (options: Options = {}) =>
         }
       })
 
+      const read = Effect.fn("PersistentPty.read")(function* (sessionID: Session.ID, lines?: number) {
+        if (lines !== undefined && !Schema.is(ReadLines)(lines))
+          return yield* new UnavailableError({ message: "lines must be an integer between 1 and 65535" })
+        const id = current.get(sessionID)
+        if (!id) return null
+        const terminal = yield* get(id).pipe(Effect.catchTag("PersistentPty.NotFoundError", () => Effect.succeed(null)))
+        if (!terminal || terminal.sessionID !== sessionID) {
+          if (current.get(sessionID) === id) current.delete(sessionID)
+          return null
+        }
+        // Let the daemon choose the live height in the same snapshot when lines is omitted.
+        const response = yield* request(daemon, { op: "read_rows", id: fromID(id), rows: lines })
+        if (response.type !== "rows") return yield* unexpected(response)
+        const info = toInfo(response.terminal)
+        return {
+          ptyID: info.id,
+          title: info.title,
+          cwd: info.cwd,
+          foregroundProcess: info.foregroundProcess,
+          screen: {
+            text: response.lines.join("\n"),
+            cols: info.size.cols,
+            rows: info.size.rows,
+            cursor: { x: response.cursor_x, y: response.cursor_y },
+          },
+        }
+      })
+
       const remove = Effect.fn("PersistentPty.remove")(function* (id: Pty.ID) {
         const terminal = yield* get(id)
         const response = yield* request(daemon, { op: "terminate", id: fromID(id) })
         if (response.type !== "ok") return yield* unexpected(response)
+        if (current.get(terminal.sessionID) === id) current.delete(terminal.sessionID)
         yield* bus.publish(Removed, { sessionID: terminal.sessionID, ptyID: id })
         return undefined
       })
 
       const shutdown = Effect.fn("PersistentPty.shutdown")(function* () {
         const response = yield* daemon.shutdown.pipe(Effect.mapError(unavailable))
+        current.clear()
         if (!response) return
         if (response.type !== "ok") return yield* unexpected(response)
       })
@@ -321,6 +357,7 @@ export const configured = (options: Options = {}) =>
             },
           })
           .pipe(Effect.mapError(unavailable))
+        if (attachment.role === "controller") current.set(Session.ID.make(attachment.terminal.group_id), id)
         return {
           info: toInfo(attachment.terminal),
           role: attachment.role,
@@ -340,6 +377,7 @@ export const configured = (options: Options = {}) =>
         control,
         input,
         snapshot,
+        read,
         remove,
         shutdown,
         handoff,

packages/core/src/plugin.ts

@@ -1,5 +1,5 @@
 export * as Plugin from "./plugin.js"
-export { Event, ID, Info, Source, PackageStatus, OperationError } from "@opencode-ai/schema/plugin"
+export { Event, ID, Info, Source } from "@opencode-ai/schema/plugin"
 
 import { Plugin } from "@opencode-ai/schema/plugin"
 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
@@ -26,7 +26,6 @@ import { Vcs } from "./vcs.js"
 import { PluginHooks } from "./plugin/hooks.js"
 import { Generate } from "./generate.js"
 import { Permission } from "./permission.js"
-import { PluginExecution } from "./plugin/execution.js"
 
 export interface Interface {
   readonly activate: (
@@ -39,8 +38,6 @@ export interface Interface {
 export type Versioned = PluginDefinition & {
   readonly version: string
   readonly source?: Plugin.Source
-  readonly revision?: string
-  readonly generation?: string
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Plugin") {}
@@ -50,12 +47,8 @@ const layer = Layer.effect(
   Effect.gen(function* () {
     const bus = yield* Bus.Service
     const kv = yield* KV.Service
-    const execution = yield* PluginExecution.Service
     const scope = yield* Scope.make()
-    const active = new Map<
-      Plugin.ID,
-      { readonly plugin: Versioned; readonly scope: Scope.Closeable; readonly error?: string }
-    >()
+    const active = new Map<Plugin.ID, { readonly plugin: Versioned; readonly scope: Scope.Closeable }>()
     const lock = Semaphore.makeUnsafe(1)
     let inventory: Plugin.Info[] = []
     let host: Parameters<PluginDefinition["effect"]>[0]
@@ -82,7 +75,7 @@ const layer = Layer.effect(
         "plugin.id": plugin.id,
         cause: loaded.cause,
       })
-      return { error: errorMessage(loaded.cause) } as const
+      return { error: Cause.pretty(loaded.cause) } as const
     })
 
     const activate = Effect.fn("Plugin.activate")(function* (
@@ -105,84 +98,55 @@ const layer = Layer.effect(
               return entry.plugin.id === definition?.id && entry.plugin.version === definition.version
             })
           ) {
-            const nextInventory = withFailures(
-              Array.from(active.values(), (entry) => activeInfo(entry.plugin, entry.error)),
-              failures,
-            )
+            const nextInventory = [...Array.from(active.values(), (entry) => activeInfo(entry.plugin)), ...failures]
             if (JSON.stringify(inventory) === JSON.stringify(nextInventory)) return
             inventory = nextInventory
             yield* bus.publish(Plugin.Event.Updated, {})
             return
           }
 
-          yield* execution.exclusive(
-            State.batch(
-              Effect.gen(function* () {
-                const nextInventory: Plugin.Info[] = []
-                // Registrations are append-ordered. Preserve the unchanged prefix, then rebuild the suffix.
-                const current = Array.from(active.values(), (entry) => entry.plugin)
-                const prefix = definitions.findIndex(
-                  (definition, index) =>
-                    definition.id !== current[index]?.id || definition.version !== current[index]?.version,
-                )
-                const keep = prefix === -1 ? definitions.length : prefix
-                const previousEntries = new Map(active)
-                const closing = Array.from(active.entries()).slice(keep).toReversed()
-                yield* Effect.forEach(
-                  closing,
-                  ([id, entry]) =>
-                    Effect.gen(function* () {
-                      yield* Scope.close(entry.scope, Exit.void).pipe(
-                        Effect.catchCause((cause) =>
-                          Effect.logWarning("failed to clean up plugin", { "plugin.id": id, cause }),
-                        ),
-                      )
-                      active.delete(id)
-                    }),
-                  { discard: true },
-                )
-                for (const [index, definition] of definitions.entries()) {
-                  if (index < keep) {
-                    nextInventory.push(activeInfo(definition, active.get(definition.id)?.error))
-                    continue
-                  }
-                  const previous = previousEntries.get(definition.id)
+          yield* State.batch(
+            Effect.gen(function* () {
+              const nextInventory: Plugin.Info[] = []
+              for (const definition of definitions) {
+                const previous = active.get(definition.id)
+                active.delete(definition.id)
+                if (previous) yield* Scope.close(previous.scope, Exit.void).pipe(Effect.ignore)
 
-                  const loaded = yield* load(definition)
-                  if (loaded.scope !== undefined) {
-                    active.set(definition.id, { plugin: definition, scope: loaded.scope })
-                    nextInventory.push(activeInfo(definition))
-                    continue
-                  }
-                  const failed: Plugin.Info = {
-                    id: definition.id,
-                    source: definition.source ?? { type: "builtin" },
-                    status: "failed",
-                    error: loaded.error,
-                    tui: definition.tui ?? false,
-                    ...(definition.revision === undefined ? {} : { revision: definition.revision }),
-                    ...(definition.generation === undefined ? {} : { generation: definition.generation }),
-                  }
-
-                  if (!previous) {
-                    nextInventory.push(failed)
-                    continue
-                  }
-                  const restored = yield* load(previous.plugin)
-                  if (restored.scope !== undefined) {
-                    active.set(definition.id, { plugin: previous.plugin, scope: restored.scope, error: loaded.error })
-                    nextInventory.push({ ...activeInfo(previous.plugin), error: loaded.error })
-                    continue
-                  }
-                  yield* Effect.logError("failed to restore plugin; deactivating", {
-                    "plugin.id": definition.id,
-                  })
-                  nextInventory.push(failed)
+                const loaded = yield* load(definition)
+                if (loaded.scope !== undefined) {
+                  active.set(definition.id, { plugin: definition, scope: loaded.scope })
+                  nextInventory.push(activeInfo(definition))
+                  continue
                 }
+                nextInventory.push({
+                  id: definition.id,
+                  source: definition.source ?? { type: "builtin" },
+                  status: "failed",
+                  error: loaded.error,
+                  tui: definition.tui ?? false,
+                })
 
-                inventory = withFailures(nextInventory, failures)
-              }),
-            ).pipe(Effect.uninterruptible),
+                if (!previous) continue
+                const restored = yield* load(previous.plugin)
+                if (restored.scope !== undefined) {
+                  active.set(definition.id, { plugin: previous.plugin, scope: restored.scope })
+                  continue
+                }
+                yield* Effect.logError("failed to restore plugin; deactivating", {
+                  "plugin.id": definition.id,
+                })
+              }
+
+              const removed = Array.from(active.entries())
+                .filter(([id]) => !ids.has(id))
+                .toReversed()
+              removed.forEach(([id]) => active.delete(id))
+              yield* Effect.forEach(removed, ([, entry]) => Scope.close(entry.scope, Exit.void).pipe(Effect.ignore), {
+                discard: true,
+              })
+              inventory = [...nextInventory, ...failures]
+            }),
           )
           yield* bus.publish(Plugin.Event.Updated, {})
         }),
@@ -207,41 +171,15 @@ const layer = Layer.effect(
   }),
 )
 
-function activeInfo(plugin: Versioned, error?: string): Plugin.Info {
+function activeInfo(plugin: Versioned): Plugin.Info {
   return {
     id: Plugin.ID.make(plugin.id),
     source: plugin.source ?? { type: "builtin" },
     status: "active",
     tui: plugin.tui ?? false,
-    ...(plugin.revision === undefined ? {} : { revision: plugin.revision }),
-    ...(plugin.generation === undefined ? {} : { generation: plugin.generation }),
-    ...(error === undefined ? {} : { error }),
   }
 }
 
-/** Inventory errors must not expose credentials or unbounded import/setup traces. */
-export function errorMessage(cause: Cause.Cause<unknown>) {
-  return Cause.pretty(cause)
-    .replace(/https?:\/\/[^\s"'<>]+/g, (value) => {
-      if (!URL.canParse(value)) return "[URL]"
-      const url = new URL(value)
-      url.username = ""
-      url.password = ""
-      url.search = ""
-      url.hash = ""
-      return url.href
-    })
-    .slice(0, 2000)
-}
-
-function withFailures(active: Plugin.Info[], failures: readonly Extract<Plugin.Info, { readonly status: "failed" }>[]) {
-  return failures.reduce((inventory, failure) => {
-    const index = inventory.findIndex((entry) => JSON.stringify(entry.source) === JSON.stringify(failure.source))
-    if (index === -1) return [...inventory, failure]
-    return inventory.map((entry, current) => (current === index ? { ...entry, error: failure.error } : entry))
-  }, active)
-}
-
 export const node = makeLocationNode({
   service: Service,
   layer,
@@ -265,6 +203,5 @@ export const node = makeLocationNode({
     WebSearch.node,
     Generate.node,
     Permission.node,
-    PluginExecution.node,
   ],
 })

packages/core/src/plugin/execution.ts

@@ -1,74 +0,0 @@
-export * as PluginExecution from "./execution.js"
-
-import { Context, Effect, Latch, Layer, Semaphore } from "effect"
-import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
-
-export interface Interface {
-  readonly lease: <A, E, R>(
-    session: { readonly id: string; readonly parentID?: string; readonly admission?: boolean },
-    effect: Effect.Effect<A, E, R>,
-  ) => Effect.Effect<A, E, R>
-  readonly exclusive: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/PluginExecution") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const admission = yield* Latch.make(true)
-    const idle = yield* Latch.make(true)
-    const mutations = yield* Semaphore.make(1)
-    const readers = new Map<string, number>()
-    let leases = 0
-
-    const acquire = (session: {
-      readonly id: string
-      readonly parentID?: string
-      readonly admission?: boolean
-    }): Effect.Effect<void> =>
-      Effect.suspend(() => {
-        // Child execution must finish the parent's tool call even while activation waits.
-        if (
-          !admission.isOpen() &&
-          !readers.has(session.id) &&
-          !(session.parentID && readers.has(session.parentID)) &&
-          !(session.admission && leases > 0)
-        )
-          return Effect.interruptible(admission.await).pipe(Effect.andThen(acquire(session)))
-        // Admission protects callbacks but does not establish Session execution ownership.
-        if (!session.admission) readers.set(session.id, (readers.get(session.id) ?? 0) + 1)
-        leases++
-        return idle.close
-      })
-
-    return Service.of({
-      lease: (session, effect) =>
-        Effect.acquireUseRelease(
-          acquire(session),
-          () => effect,
-          () =>
-            Effect.suspend(() => {
-              leases--
-              if (!session.admission) {
-                const count = (readers.get(session.id) ?? 1) - 1
-                if (count === 0) readers.delete(session.id)
-                else readers.set(session.id, count)
-              }
-              return leases === 0 ? idle.open : Effect.void
-            }),
-        ),
-      exclusive: (effect) =>
-        mutations.withPermit(
-          Effect.uninterruptibleMask((restore) =>
-            admission.close.pipe(
-              Effect.andThen(restore(idle.await).pipe(Effect.andThen(restore(effect)))),
-              Effect.ensuring(admission.open),
-            ),
-          ),
-        ),
-    })
-  }),
-)
-
-export const node = makeLocationNode({ service: Service, layer, deps: [] })

packages/core/src/plugin/host.ts

@@ -4,7 +4,6 @@ import { Plugin } from "@opencode-ai/plugin/effect"
 import type { IntegrationMethodRegistration } from "@opencode-ai/plugin/effect/integration"
 import { EventManifest } from "@opencode-ai/schema/event-manifest"
 import { ServerConfig } from "@opencode-ai/schema/mcp"
-import { OperationError } from "@opencode-ai/schema/plugin"
 import { App } from "../app.js"
 import { Effect, Schema, Stream } from "effect"
 import { Agent } from "../agent.js"
@@ -194,6 +193,11 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
     event: {
       subscribe: () => bus.subscribe().pipe(Stream.filter(EventManifest.isServer)),
     },
+    experimental: {
+      terminal: {
+        read: (input) => runtime.persistentPty.read(input.sessionID, input.lines),
+      },
+    },
     generate: {
       text: (input) => generate.text(input).pipe(Effect.map((text) => ({ text }))),
     },
@@ -328,10 +332,6 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: Interface, p
     },
     plugin: {
       list: () => response(plugin.list()),
-      // In-process management can wait on its own setup/tool lease. Use an external client instead.
-      check: () => Effect.fail(new OperationError({ message: "Check plugin updates through an external client." })),
-      update: () => Effect.fail(new OperationError({ message: "Update plugins through an external client." })),
-      reload: () => Effect.fail(new OperationError({ message: "Reload plugins through an external client." })),
     },
     reference: {
       list: () => response(reference.list()),

packages/core/src/plugin/module.ts

@@ -36,22 +36,15 @@ const Definition = Schema.Struct({
 
 export const load = Effect.fn("PluginModule.load")(function* (
   operation: Extract<ConfigPluginSource.Operation, { type: "add" }>,
-  fresh?: Npm.EntryPoint,
 ) {
   const npm = yield* Npm.Service
-  const resolved =
-    fresh ??
-    (path.isAbsolute(operation.target)
-      ? { entrypoint: pathToFileURL(operation.target).href, revision: undefined, generation: undefined }
-      : yield* npm.add(operation.target, { subpaths: ["server", ""], refresh: true }))
-  const entrypoint = resolved.entrypoint
+  const entrypoint = path.isAbsolute(operation.target)
+    ? pathToFileURL(operation.target).href
+    : (yield* npm.add(operation.target, { subpaths: ["server", ""], refresh: true })).entrypoint
   if (!entrypoint) return yield* Effect.fail(new Error(`Plugin entrypoint not found: ${operation.target}`))
   // Bun currently ignores query parameters when caching file:// imports.
-  const target =
-    typeof Bun !== "undefined" && path.isAbsolute(operation.target)
-      ? operation.target.replaceAll("\\", "/")
-      : entrypoint
-  const source = fresh || operation.mtime === undefined ? entrypoint : `${target}?mtime=${operation.mtime}`
+  const target = typeof Bun !== "undefined" ? operation.target.replaceAll("\\", "/") : entrypoint
+  const source = operation.mtime === undefined ? entrypoint : `${target}?mtime=${operation.mtime}`
   yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint: source })
   const mod = yield* Effect.promise(() => importModule(source))
   const value = (yield* Schema.decodeUnknownEffect(Definition)(mod)).default
@@ -60,9 +53,7 @@ export const load = Effect.fn("PluginModule.load")(function* (
     id: plugin.id,
     tui: plugin.tui,
     vcs: plugin.vcs,
-    version: JSON.stringify([operation, resolved.generation]),
-    revision: resolved.revision,
-    generation: resolved.generation,
+    version: JSON.stringify(operation),
     source: path.isAbsolute(operation.target)
       ? { type: "local" as const, path: operation.target }
       : { type: "package" as const, package: operation.target },

packages/core/src/plugin/runtime.ts

@@ -7,6 +7,7 @@ import { Job } from "../job.js"
 import { Location } from "../location.js"
 import { LocationServiceMap } from "../location-service-map.js"
 import { Mcp } from "../mcp/index.js"
+import { PersistentPty } from "../persistent-pty.js"
 import { Session } from "../session.js"
 
 export interface Interface {
@@ -29,6 +30,7 @@ export interface Interface {
     | "context"
   >
   readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel" | "completeBackground">
+  readonly persistentPty: Pick<PersistentPty.Interface, "read">
   readonly location: {
     readonly agent: {
       readonly list: (
@@ -90,6 +92,9 @@ export const layerWithCell = (cell: Cell) =>
         completeBackground: (notificationID) =>
           require(cell, (runtime) => runtime.job.completeBackground(notificationID)),
       },
+      persistentPty: {
+        read: (sessionID, lines) => require(cell, (runtime) => runtime.persistentPty.read(sessionID, lines)),
+      },
       location: {
         agent: {
           list: (ref) => require(cell, (runtime) => runtime.location.agent.list(ref)),
@@ -107,9 +112,11 @@ export const providerLayerWithCell = (cell: Cell) =>
       const sessions = yield* Session.Service
       const jobs = yield* Job.Service
       const locations = yield* LocationServiceMap.Service
+      const persistentPty = yield* PersistentPty.Service
       const runtime: Interface = {
         session: sessions,
         job: jobs,
+        persistentPty,
         location: {
           agent: {
             list: (ref) =>
@@ -162,7 +169,7 @@ export const providerNodeWithCell = (cell: Cell) =>
   makeGlobalNode({
     name: "plugin-runtime-provider",
     layer: providerLayerWithCell(cell),
-    deps: [node, Session.node, Job.node, LocationServiceMap.node],
+    deps: [node, Session.node, Job.node, LocationServiceMap.node, PersistentPty.node],
   })
 
 export const providerNode = providerNodeWithCell(defaultCell)

packages/core/src/plugin/supervisor-service.ts

@@ -1,7 +1,6 @@
 export * as PluginSupervisor from "./supervisor-service.js"
 
 import { Context, Effect } from "effect"
-import type { Plugin } from "@opencode-ai/schema/plugin"
 
 /**
  * Dependency-only supervisor seam. Keep this module free of implementation
@@ -10,11 +9,6 @@ import type { Plugin } from "@opencode-ai/schema/plugin"
 export interface Interface {
   /** Wait for the initial plugin generation and startup updates to settle. */
   readonly flush: Effect.Effect<void>
-  /** Initial reconciliation barrier; it never closes again after startup settles. */
-  readonly initialized: Effect.Effect<void>
-  readonly check: (target: string) => Effect.Effect<Plugin.PackageStatus, Plugin.OperationError>
-  readonly update: (target: string) => Effect.Effect<Plugin.Info[], Plugin.OperationError>
-  readonly reload: (target: string) => Effect.Effect<Plugin.Info[], Plugin.OperationError>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/PluginSupervisor") {}

packages/core/src/plugin/supervisor.ts

@@ -2,10 +2,8 @@ export * as PluginSupervisor from "./supervisor.js"
 export { Service, type Interface } from "./supervisor-service.js"
 
 import { Event } from "@opencode-ai/schema/config"
-import { Cause, Effect, Latch, Layer, Option, Scope, Semaphore, Stream } from "effect"
+import { Cause, Effect, Latch, Layer, Stream } from "effect"
 import path from "path"
-import { randomUUID } from "node:crypto"
-import { pathToFileURL } from "node:url"
 import { ConfigPluginSource } from "../config/plugin/source.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "../bus.js"
@@ -17,13 +15,10 @@ import { PluginModule } from "./module.js"
 import { SdkPlugins } from "./sdk.js"
 import { Service } from "./supervisor-service.js"
 
-type Cached = { readonly operation: string; readonly plugin: Plugin.Versioned; readonly error?: string }
-
 const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
   pre: readonly Plugin.Versioned[],
   post: readonly Plugin.Versioned[],
   operations: readonly ConfigPluginSource.Operation[],
-  cache: Map<string, Cached>,
 ) {
   const matches = (selector: string, target: string) =>
     selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target)
@@ -31,7 +26,6 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
   const enabled = new Set(definitions.map((plugin) => plugin.id))
   const packages = new Map<string, Plugin.Versioned>()
   const failures = new Map<string, Extract<Plugin.Info, { readonly status: "failed" }>>()
-  const previousSources = new Map(cache)
   const plugins = () => [...definitions, ...packages.values()]
 
   for (const operation of operations) {
@@ -54,23 +48,13 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
       continue
     }
 
-    const cached = previousSources.get(operation.target)
-    const key = JSON.stringify(operation)
-    const plugin =
-      cached?.operation === key
-        ? cached.plugin
-        : yield* PluginModule.load(operation).pipe(
-            Effect.flatMap((plugin) =>
-              cached && plugin.id !== cached.plugin.id
-                ? Effect.fail(new Error(`Plugin ID changed from ${cached.plugin.id} to ${plugin.id}`))
-                : Effect.succeed(plugin),
-            ),
-            Effect.catchCause((cause) =>
-              Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(
-                Effect.as({ error: Plugin.errorMessage(cause) }),
-              ),
-            ),
-          )
+    const plugin = yield* PluginModule.load(operation).pipe(
+      Effect.catchCause((cause) =>
+        Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(
+          Effect.as({ error: Cause.pretty(cause) }),
+        ),
+      ),
+    )
     if ("error" in plugin) {
       failures.set(operation.target, {
         source: pluginSource(operation.target),
@@ -78,24 +62,9 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
         error: plugin.error,
         tui: false,
       })
-      if (cached) {
-        cache.set(operation.target, { ...cached, operation: key, error: plugin.error })
-        packages.set(operation.target, cached.plugin)
-        enabled.add(cached.plugin.id)
-      }
       continue
     }
-    if (cached?.operation === key && cached.error) {
-      failures.set(operation.target, {
-        source: pluginSource(operation.target),
-        status: "failed",
-        error: cached.error,
-        tui: plugin.tui ?? false,
-      })
-    } else {
-      failures.delete(operation.target)
-      cache.set(operation.target, { operation: key, plugin })
-    }
+    failures.delete(operation.target)
     const previous = packages.get(operation.target)
     if (previous) enabled.delete(previous.id)
     packages.set(operation.target, plugin)
@@ -108,12 +77,7 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
       ...[...packages.values()].filter((plugin) => enabled.has(plugin.id)),
       ...post.filter((plugin) => enabled.has(plugin.id)),
     ],
-    failures: [...failures.entries()]
-      .filter(([target]) => {
-        const plugin = packages.get(target)
-        return !plugin || enabled.has(plugin.id)
-      })
-      .map(([, failure]) => failure),
+    failures: [...failures.values()],
   }
 })
 
@@ -125,20 +89,12 @@ export const layer = Layer.effect(
     const instance = yield* InstancePlugins.Service
     const sources = yield* ConfigPluginSource.Service
     const bus = yield* Bus.Service
-    const npm = yield* Npm.Service
-    const scope = yield* Scope.Scope
     const ready = yield* Latch.make()
-    const initialized = yield* Latch.make()
-    const mutations = yield* Semaphore.make(1)
-    const cache = new Map<string, Cached>()
-    // Internal definitions capture stable Location services; SDK contributions remain dynamic.
-    const internal = yield* PluginInternal.list()
     let observed = 0
 
-    const activate = Effect.fn("PluginSupervisor.activate")(function* (
-      operations: readonly ConfigPluginSource.Operation[],
-      previous: ReadonlyMap<string, Cached> = new Map(cache),
-    ) {
+    const activate = Effect.fn("PluginSupervisor.activate")(function* () {
+      // Resolve OpenCode's internal plugins with their privileged Location services.
+      const internal = yield* PluginInternal.list()
       // Combine internal plugins with host-contributed plugins in boot order.
       // Instance-bound plugins come last: later activation can override earlier
       // container writes, so the instance's explicit choices win over globals.
@@ -152,117 +108,12 @@ export const layer = Layer.effect(
         version: "internal",
         source: { type: "builtin" as const },
       }))
+      const operations = yield* sources.operations()
       // Apply config operations and load enabled package plugins into one ordered generation.
-      const resolved = yield* resolve(pre, post, operations, cache).pipe(Effect.provideService(Npm.Service, npm))
+      const resolved = yield* resolve(pre, post, operations)
       // Replace the active generation in one scoped, batched activation.
-      const activated = yield* registry.activate(resolved.plugins, resolved.failures).pipe(Effect.exit)
-      if (activated._tag === "Failure") {
-        cache.clear()
-        previous.forEach((entry, target) => cache.set(target, entry))
-        return yield* Effect.failCause(activated.cause)
-      }
-      const inventory = yield* registry.list()
-      for (const [target, entry] of cache) {
-        if (!operations.some((operation) => operation.type === "add" && operation.target === target)) {
-          cache.delete(target)
-          continue
-        }
-        const active = inventory.find((item) =>
-          item.source.type === "local"
-            ? item.source.path === target
-            : item.source.type === "package" && item.source.package === target,
-        )
-        if (active?.status !== "active" || !active.error) continue
-        const old = previous.get(target)
-        if (old) cache.set(target, { ...old, operation: entry.operation, error: active.error })
-      }
-      return inventory
+      yield* registry.activate(resolved.plugins, resolved.failures)
     })
-
-    const operation = Effect.fnUntraced(function* (target: string) {
-      const operations = yield* sources.operations().pipe(Effect.provideService(Scope.Scope, scope))
-      const entry = operations.findLast((entry) => entry.type === "add" && entry.target === target)
-      const inventory = yield* registry.list()
-      if (
-        !entry ||
-        entry.type !== "add" ||
-        target === "*" ||
-        target.endsWith(".*") ||
-        target.startsWith("opencode.") ||
-        (!cache.has(target) &&
-          !inventory.some((item) =>
-            item.source.type === "local"
-              ? item.source.path === target
-              : item.source.type === "package" && item.source.package === target,
-          ))
-      )
-        return yield* new Plugin.OperationError({ message: `Not a configured plugin source: ${target}` })
-      return { entry, operations }
-    })
-
-    const mutate = (target: string, action: "update" | "reload") =>
-      initialized.await.pipe(
-        Effect.andThen(
-          mutations.withPermit(
-            Effect.gen(function* () {
-              const selected = yield* operation(target)
-              if (action === "update") {
-                if (path.isAbsolute(target) || !(yield* npm.inspect(target)).mutable)
-                  return yield* new Plugin.OperationError({ message: `Plugin source cannot be updated: ${target}` })
-              }
-              const previous = new Map(cache)
-              const generation = randomUUID()
-              const staged = path.isAbsolute(target)
-                ? {
-                    directory: path.dirname(target),
-                    generation,
-                    entrypoint: `${typeof Bun !== "undefined" ? target.replaceAll("\\", "/") : pathToFileURL(target).href}?reload=${generation}`,
-                  }
-                : yield* action === "update"
-                    ? npm.update(target, { subpaths: ["server", ""] })
-                    : npm.reload(target, {
-                        subpaths: ["server", ""],
-                        revision: cache.get(target)?.plugin.revision,
-                        generation: cache.get(target)?.plugin.generation,
-                      })
-              const loaded = yield* PluginModule.load(selected.entry, staged).pipe(
-                Effect.provideService(Npm.Service, npm),
-                Effect.exit,
-              )
-              if (loaded._tag === "Failure") {
-                const old = cache.get(target)
-                if (!old) return yield* Effect.failCause(loaded.cause)
-                cache.set(target, {
-                  ...old,
-                  operation: JSON.stringify(selected.entry),
-                  error: Plugin.errorMessage(loaded.cause),
-                })
-                return yield* activate(selected.operations, previous)
-              }
-              const old = cache.get(target)
-              if (old && loaded.value.id !== old.plugin.id) {
-                cache.set(target, {
-                  ...old,
-                  operation: JSON.stringify(selected.entry),
-                  error: `Plugin ID changed from ${old.plugin.id} to ${loaded.value.id}`,
-                })
-                return yield* activate(selected.operations, previous)
-              }
-              cache.set(target, { operation: JSON.stringify(selected.entry), plugin: loaded.value })
-              return yield* activate(selected.operations, previous)
-            }),
-          ),
-        ),
-        Effect.catchCause((cause) => {
-          if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt
-          const error = Option.getOrUndefined(Cause.findErrorOption(cause))
-          return Effect.fail(
-            error instanceof Plugin.OperationError
-              ? error
-              : new Plugin.OperationError({ message: `Unable to ${action} plugin source.` }),
-          )
-        }),
-      )
     const updates = Stream.merge(sources.changes(), bus.subscribe([Event.Updated, SdkPlugins.Updated])).pipe(
       // Make accepted work visible to flush before coalescing the burst.
       Stream.mapEffect(() =>
@@ -279,48 +130,13 @@ export const layer = Layer.effect(
       Stream.debounce("100 millis"),
       Stream.runForEach((target) =>
         Effect.gen(function* () {
-          yield* mutations
-            .withPermit(
-              Effect.gen(function* () {
-                return yield* activate(yield* sources.operations().pipe(Effect.provideService(Scope.Scope, scope)))
-              }),
-            )
-            .pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })))
-          if (observed === target) {
-            yield* initialized.open
-            yield* ready.open
-          }
+          yield* activate().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause })))
+          if (observed === target) yield* ready.open
         }),
       ),
       Effect.forkScoped({ startImmediately: true }),
     )
-    return Service.of({
-      flush: ready.await,
-      initialized: initialized.await,
-      check: (target) =>
-        initialized.await.pipe(
-          Effect.andThen(
-            mutations.withPermit(
-              Effect.gen(function* () {
-                yield* operation(target)
-                if (path.isAbsolute(target)) return { mutable: false }
-                return yield* npm.check(target)
-              }),
-            ),
-          ),
-          Effect.catchCause((cause) => {
-            if (Cause.hasInterruptsOnly(cause)) return Effect.interrupt
-            const error = Option.getOrUndefined(Cause.findErrorOption(cause))
-            return Effect.fail(
-              error instanceof Plugin.OperationError
-                ? error
-                : new Plugin.OperationError({ message: "Unable to check plugin source." }),
-            )
-          }),
-        ),
-      update: (target) => mutate(target, "update"),
-      reload: (target) => mutate(target, "reload"),
-    })
+    return Service.of({ flush: ready.await })
   }),
 )
 

packages/core/src/session.ts

@@ -41,7 +41,6 @@ import { Session } from "@opencode-ai/schema/session"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Image } from "./image.js"
 import { PluginSupervisor } from "./plugin/supervisor-service.js"
-import { PluginExecution } from "./plugin/execution.js"
 import { PluginHooks } from "./plugin/hooks.js"
 import { Mime } from "./mime.js"
 import type { EventLog } from "@opencode-ai/schema/event-log"
@@ -691,39 +690,30 @@ const layer = Layer.effect(
       ),
       generate: Effect.fn("Session.generate")(function* (input) {
         const session = yield* result.get(input.sessionID)
-        return yield* Effect.gen(function* () {
-          const plugins = yield* PluginSupervisor.Service
-          yield* plugins.initialized
-          const gate = yield* PluginExecution.Service
-          const generate = yield* SessionGenerate.Service
-          return yield* gate.lease({ id: session.id, admission: true }, generate.generate(input))
-        }).pipe(Effect.provide(locations.get(session.location)))
+        const generate = yield* SessionGenerate.Service.pipe(Effect.provide(locations.get(session.location)))
+        return yield* generate.generate(input)
       }),
       command: Effect.fn("Session.command")(function* (input) {
         const session = yield* result.get(input.sessionID)
-        yield* Effect.gen(function* () {
+        const commands = yield* Effect.gen(function* () {
           const plugins = yield* PluginSupervisor.Service
-          yield* plugins.initialized
-          const gate = yield* PluginExecution.Service
-          const commands = yield* Command.Service
-          // Commands may await child Sessions, so they retain ownership that lets those children drain.
-          return yield* gate.lease(
-            session,
-            commands.execute({
-              name: input.command,
-              invocation: {
-                sessionID: input.sessionID,
-                prompt: {
-                  text: input.text,
-                  files: input.files,
-                  agents: input.agents,
-                  skills: input.skills,
-                },
-                delivery: input.delivery ?? "steer",
-              },
-            }),
-          )
+          yield* plugins.flush
+          return yield* Command.Service
         }).pipe(Effect.provide(locations.get(session.location)))
+        const delivery = input.delivery ?? "steer"
+        yield* commands.execute({
+          name: input.command,
+          invocation: {
+            sessionID: input.sessionID,
+            prompt: {
+              text: input.text,
+              files: input.files,
+              agents: input.agents,
+              skills: input.skills,
+            },
+            delivery,
+          },
+        })
       }),
       shell: Effect.fn("Session.shell")(function* (input) {
         const session = yield* result.get(input.sessionID)
@@ -733,20 +723,16 @@ const layer = Layer.effect(
             yield* execution.awaitIdle(input.sessionID)
             const started = yield* Effect.gen(function* () {
               const plugins = yield* PluginSupervisor.Service
-              yield* plugins.initialized
-              const gate = yield* PluginExecution.Service
+              yield* plugins.flush
               const shell = yield* Shell.Service
-              return yield* gate.lease(
-                { id: input.sessionID, admission: true },
-                shell
-                  .create({
-                    command: input.command,
-                    cwd: session.location.directory,
-                    timeout: 0,
-                    metadata: { sessionID: input.sessionID },
-                  })
-                  .pipe(Effect.orDie),
-              )
+              return yield* shell
+                .create({
+                  command: input.command,
+                  cwd: session.location.directory,
+                  timeout: 0,
+                  metadata: { sessionID: input.sessionID },
+                })
+                .pipe(Effect.orDie)
             }).pipe(Effect.provide(locations.get(session.location)))
             yield* bus.publish(
               SessionEvent.Shell.Started,
@@ -978,14 +964,10 @@ const layer = Layer.effect(
             return yield* new BusyError({ sessionID: input.sessionID })
           return yield* Effect.gen(function* () {
             const plugins = yield* PluginSupervisor.Service
-            yield* plugins.initialized
-            const gate = yield* PluginExecution.Service
-            return yield* gate.lease(
-              { id: session.id, admission: true },
-              SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
-                Effect.provideService(Database.Service, database),
-                Effect.provideService(Bus.Service, bus),
-              ),
+            yield* plugins.flush
+            return yield* SessionRevert.stage({ session, messageID: input.messageID, files: input.files }).pipe(
+              Effect.provideService(Database.Service, database),
+              Effect.provideService(Bus.Service, bus),
             )
           }).pipe(Effect.provide(locations.get(session.location)))
         }),
@@ -994,12 +976,8 @@ const layer = Layer.effect(
           if ((yield* execution.active).has(sessionID)) return yield* new BusyError({ sessionID })
           const revert = yield* Effect.gen(function* () {
             const plugins = yield* PluginSupervisor.Service
-            yield* plugins.initialized
-            const gate = yield* PluginExecution.Service
-            return yield* gate.lease(
-              { id: session.id, admission: true },
-              SessionRevert.clear(session).pipe(Effect.provideService(Bus.Service, bus)),
-            )
+            yield* plugins.flush
+            return yield* SessionRevert.clear(session).pipe(Effect.provideService(Bus.Service, bus))
           }).pipe(Effect.provide(locations.get(session.location)))
           yield* execution.wake(sessionID)
           return revert
@@ -1041,65 +1019,59 @@ const preparePrompt = Effect.fn("Session.preparePrompt")(function* (
   messageID: SessionMessage.ID,
 ) {
   const plugins = yield* PluginSupervisor.Service
-  yield* plugins.initialized
-  const gate = yield* PluginExecution.Service
-  return yield* gate.lease(
-    { id: request.sessionID, admission: true },
-    Effect.gen(function* () {
-      const hooks = yield* PluginHooks.Service
-      const event = yield* hooks.trigger("session", "prompt", {
-        sessionID: request.sessionID,
-        messageID,
-        prompt: structuredClone({
-          text: request.text,
-          files: request.files?.slice(),
-          agents: request.agents?.slice(),
-          skills: request.skills?.slice(),
-        }),
-        metadata: structuredClone(request.metadata),
-        delivery: request.delivery ?? "steer",
-      })
-      const input = event.prompt
-      const fs = yield* FSUtil.Service
-      const files = input.files
-        ? yield* Effect.forEach(input.files, (file) => materializeAttachment(fs, file), { concurrency: 8 })
-        : undefined
-      const requested = input.skills
-      const selected = yield* Effect.gen(function* () {
-        if (!requested?.length) return undefined
-        const skillService = yield* Skill.Service
-        const prepared = new Map<Skill.ID, Skill.Name>()
-        return yield* Effect.forEach(requested, (attachment) =>
-          Effect.gen(function* () {
-            const name = prepared.get(attachment.id)
-            if (name !== undefined) return { id: attachment.id, name, mention: attachment.mention }
-            const skill = yield* skillService.get(attachment.id)
-            if (!skill) return yield* new SkillNotFoundError({ skill: attachment.id })
-            prepared.set(skill.id, skill.name)
-            return {
-              id: skill.id,
-              name: skill.name,
-              text: (yield* Skill.prepare(fs, skill).pipe(Effect.orDie)).output,
-              mention: attachment.mention,
-            }
-          }),
-        )
-      })
-      return SessionInbox.Item.make({
-        type: "user",
-        payload: {
-          ...Prompt.make({
-            text: input.text,
-            agents: input.agents,
-            files,
-            skills: selected?.length ? selected : undefined,
-          }),
-          metadata: event.metadata,
-        },
-        delivery: event.delivery,
-      })
+  yield* plugins.flush
+  const hooks = yield* PluginHooks.Service
+  const event = yield* hooks.trigger("session", "prompt", {
+    sessionID: request.sessionID,
+    messageID,
+    prompt: structuredClone({
+      text: request.text,
+      files: request.files?.slice(),
+      agents: request.agents?.slice(),
+      skills: request.skills?.slice(),
     }),
-  )
+    metadata: structuredClone(request.metadata),
+    delivery: request.delivery ?? "steer",
+  })
+  const input = event.prompt
+  const fs = yield* FSUtil.Service
+  const files = input.files
+    ? yield* Effect.forEach(input.files, (file) => materializeAttachment(fs, file), { concurrency: 8 })
+    : undefined
+  const requested = input.skills
+  const selected = yield* Effect.gen(function* () {
+    if (!requested?.length) return undefined
+    const skillService = yield* Skill.Service
+    const prepared = new Map<Skill.ID, Skill.Name>()
+    return yield* Effect.forEach(requested, (attachment) =>
+      Effect.gen(function* () {
+        const name = prepared.get(attachment.id)
+        if (name !== undefined) return { id: attachment.id, name, mention: attachment.mention }
+        const skill = yield* skillService.get(attachment.id)
+        if (!skill) return yield* new SkillNotFoundError({ skill: attachment.id })
+        prepared.set(skill.id, skill.name)
+        return {
+          id: skill.id,
+          name: skill.name,
+          text: (yield* Skill.prepare(fs, skill).pipe(Effect.orDie)).output,
+          mention: attachment.mention,
+        }
+      }),
+    )
+  })
+  return SessionInbox.Item.make({
+    type: "user",
+    payload: {
+      ...Prompt.make({
+        text: input.text,
+        agents: input.agents,
+        files,
+        skills: selected?.length ? selected : undefined,
+      }),
+      metadata: event.metadata,
+    },
+    delivery: event.delivery,
+  })
 })
 
 const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024

packages/core/src/session/compaction.ts

@@ -1,7 +1,6 @@
 export * as SessionCompaction from "./compaction.js"
 
-import { LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
-import type { StreamOptions } from "@opencode-ai/ai/route"
+import { LLMClient, LLMEvent, Message } from "@opencode-ai/ai"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Context, Effect, Layer, Stream } from "effect"
 import { Bus } from "../bus.js"
@@ -65,13 +64,6 @@ export type Draft = {
   configure: (settings: Partial<Settings>) => void
 }
 
-type Dependencies = {
-  readonly bus: Bus.Interface
-  readonly llm: {
-    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
-  }
-}
-
 export type AutoInput = {
   readonly session: SessionSchema.Info
   readonly messages: readonly SessionMessage.Info[]
@@ -240,195 +232,196 @@ const planContent = (messages: readonly SessionMessage.Info[], tokens: number) =
   }
 }
 
-const make = (dependencies: Dependencies) => {
-  const state = State.create<Settings, Draft>({
-    name: "session-compaction",
-    initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
-    draft: (draft) => ({
-      configure: (settings) => {
-        if (settings.auto !== undefined) draft.auto = settings.auto
-        if (settings.buffer !== undefined) draft.buffer = settings.buffer
-        if (settings.tokens !== undefined) draft.tokens = settings.tokens
-      },
-    }),
-  })
-  const failed = Effect.fnUntraced(function* (input: {
-    readonly sessionID: SessionSchema.ID
-    readonly reason: SessionMessage.Compaction["reason"]
-    readonly error: SessionError.Error
-    readonly inputID?: SessionMessage.ID
-  }) {
-    yield* dependencies.bus.publish(SessionEvent.Compaction.Failed, input)
-    return { status: "failed" as const, error: input.error }
-  })
-  const execute = Effect.fn("SessionCompaction.execute")(function* (plan: Plan) {
-    if (!plan.started)
-      yield* dependencies.bus.publish(SessionEvent.Compaction.Started, {
-        sessionID: plan.session.id,
-        reason: plan.reason,
-        recent: plan.recent,
-        inputID: plan.inputID,
-      })
-
-    const chunks: string[] = []
-    let failure: SessionError.Error | undefined
-    let usage: SessionUsage.Recorded | undefined
-    const recordUsage = Effect.suspend(() =>
-      usage
-        ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
-            sessionID: plan.session.id,
-            source: "compaction",
-            ...usage,
-          })
-        : Effect.void,
-    )
-    const prepared = yield* plan.prepare({
-      scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
-      transcript: { system: [], messages: [Message.user(plan.prompt)] },
-      contextHooks: false,
-    })
-    yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-      Stream.runForEach((event) => {
-        if (LLMEvent.is.providerError(event))
-          failure = {
-            type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
-            message: event.message,
-          }
-        if (LLMEvent.is.textDelta(event)) {
-          chunks.push(event.text)
-          return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
-            sessionID: plan.session.id,
-            text: event.text,
-          })
-        }
-        if (LLMEvent.is.stepFinish(event)) {
-          const step = SessionUsage.record(event.usage, plan.resolved.cost)
-          usage = usage ? SessionUsage.add(usage, step) : step
-        }
-        return Effect.void
-      }),
-      Effect.catchTag("AI.Error", (error) =>
-        Effect.sync(() => {
-          failure = toSessionError(error)
-        }),
-      ),
-      Effect.onInterrupt(() =>
-        recordUsage.pipe(
-          Effect.andThen(
-            plan.reason === "auto"
-              ? failed({
-                  sessionID: plan.session.id,
-                  reason: plan.reason,
-                  error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-                  inputID: plan.inputID,
-                }).pipe(Effect.asVoid)
-              : Effect.void,
-          ),
-        ),
-      ),
-    )
-    yield* recordUsage
-    const summary = chunks.join("")
-    if (failure || !summary.trim()) {
-      const error = failure ?? { type: "compaction.failed" as const, message: "Compaction produced no summary" }
-      return yield* failed({
-        sessionID: plan.session.id,
-        reason: plan.reason,
-        error,
-        inputID: plan.inputID,
-      })
-    }
-    yield* dependencies.bus.publish(SessionEvent.Compaction.Ended, {
-      sessionID: plan.session.id,
-      reason: plan.reason,
-      text: summary,
-      recent: plan.recent,
-    })
-    return { status: "completed" as const }
-  })
-  const compact = Effect.fn("SessionCompaction.compact")(function* (input: AutoInput) {
-    const content = planContent(input.messages, state.get().tokens)
-    if (content)
-      return yield* execute({
-        session: input.session,
-        resolved: input.resolved,
-        prepare: input.prepare,
-        reason: "auto",
-        ...content,
-      })
-    return yield* failed({
-      sessionID: input.session.id,
-      reason: "auto",
-      error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-    })
-  })
-  const required = (input: RequiredInput) => {
-    const config = state.get()
-    if (!config.auto) return false
-    const limit = input.resolved.limit
-    const context = limit.context
-    if (context <= 0) return false
-    const last = input.messages.findLast(
-      (message): message is SessionMessage.Assistant & { tokens: NonNullable<SessionMessage.Assistant["tokens"]> } =>
-        message.type === "assistant" && message.tokens !== undefined,
-    )
-    if (!last) return false
-    const output = Math.min(limit.output, OUTPUT_TOKEN_MAX)
-    const promptCeiling = Math.min(
-      limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer,
-      context - Math.max(output, config.buffer),
-    )
-    const used =
-      last.tokens.input + last.tokens.output + last.tokens.reasoning + last.tokens.cache.read + last.tokens.cache.write
-    if (used <= 0) return false
-    return used >= promptCeiling
-  }
-  const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
-    const content = planContent(input.messages, state.get().tokens)
-    if (!content)
-      return yield* failed({
-        sessionID: input.session.id,
-        reason: "manual",
-        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
-        inputID: input.inputID,
-      })
-    const resolved = yield* input.resolveModel(input.session).pipe(
-      Effect.catch((cause) =>
-        failed({
-          sessionID: input.session.id,
-          reason: "manual",
-          error: toSessionError(cause),
-          inputID: input.inputID,
-        }),
-      ),
-    )
-    if ("status" in resolved) return resolved
-    return yield* execute({
-      session: input.session,
-      resolved,
-      prepare: input.prepare,
-      reason: "manual",
-      inputID: input.inputID,
-      started: input.started,
-      ...content,
-    })
-  })
-  return Service.of({
-    transform: state.transform,
-    reload: state.reload,
-    enabled: () => state.get().auto,
-    required,
-    compact,
-    compactManual,
-  })
-}
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
     const llm = yield* LLMClient.Service
-    return make({ bus, llm })
+
+    const state = State.create<Settings, Draft>({
+      name: "session-compaction",
+      initial: () => ({ auto: true, buffer: DEFAULT_BUFFER, tokens: DEFAULT_KEEP_TOKENS }),
+      draft: (draft) => ({
+        configure: (settings) => {
+          if (settings.auto !== undefined) draft.auto = settings.auto
+          if (settings.buffer !== undefined) draft.buffer = settings.buffer
+          if (settings.tokens !== undefined) draft.tokens = settings.tokens
+        },
+      }),
+    })
+    const failed = Effect.fnUntraced(function* (input: {
+      readonly sessionID: SessionSchema.ID
+      readonly reason: SessionMessage.Compaction["reason"]
+      readonly error: SessionError.Error
+      readonly inputID?: SessionMessage.ID
+    }) {
+      yield* bus.publish(SessionEvent.Compaction.Failed, input)
+      return { status: "failed" as const, error: input.error }
+    })
+    const execute = Effect.fn("SessionCompaction.execute")(function* (plan: Plan) {
+      if (!plan.started)
+        yield* bus.publish(SessionEvent.Compaction.Started, {
+          sessionID: plan.session.id,
+          reason: plan.reason,
+          recent: plan.recent,
+          inputID: plan.inputID,
+        })
+
+      const chunks: string[] = []
+      let failure: SessionError.Error | undefined
+      let usage: SessionUsage.Recorded | undefined
+      const recordUsage = Effect.suspend(() =>
+        usage
+          ? bus.publish(SessionEvent.UsageRecorded, {
+              sessionID: plan.session.id,
+              source: "compaction",
+              ...usage,
+            })
+          : Effect.void,
+      )
+      const prepared = yield* plan.prepare({
+        scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
+        transcript: { system: [], messages: [Message.user(plan.prompt)] },
+        contextHooks: false,
+      })
+      yield* llm.stream(prepared.request, prepared.options).pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event))
+            failure = {
+              type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
+              message: event.message,
+            }
+          if (LLMEvent.is.textDelta(event)) {
+            chunks.push(event.text)
+            return bus.publish(SessionEvent.Compaction.Delta, {
+              sessionID: plan.session.id,
+              text: event.text,
+            })
+          }
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, plan.resolved.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.catchTag("AI.Error", (error) =>
+          Effect.sync(() => {
+            failure = toSessionError(error)
+          }),
+        ),
+        Effect.onInterrupt(() =>
+          recordUsage.pipe(
+            Effect.andThen(
+              plan.reason === "auto"
+                ? failed({
+                    sessionID: plan.session.id,
+                    reason: plan.reason,
+                    error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
+                    inputID: plan.inputID,
+                  }).pipe(Effect.asVoid)
+                : Effect.void,
+            ),
+          ),
+        ),
+      )
+      yield* recordUsage
+      const summary = chunks.join("")
+      if (failure || !summary.trim()) {
+        const error = failure ?? { type: "compaction.failed" as const, message: "Compaction produced no summary" }
+        return yield* failed({
+          sessionID: plan.session.id,
+          reason: plan.reason,
+          error,
+          inputID: plan.inputID,
+        })
+      }
+      yield* bus.publish(SessionEvent.Compaction.Ended, {
+        sessionID: plan.session.id,
+        reason: plan.reason,
+        text: summary,
+        recent: plan.recent,
+      })
+      return { status: "completed" as const }
+    })
+    const compact = Effect.fn("SessionCompaction.compact")(function* (input: AutoInput) {
+      const content = planContent(input.messages, state.get().tokens)
+      if (content)
+        return yield* execute({
+          session: input.session,
+          resolved: input.resolved,
+          prepare: input.prepare,
+          reason: "auto",
+          ...content,
+        })
+      return yield* failed({
+        sessionID: input.session.id,
+        reason: "auto",
+        error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+      })
+    })
+    const required = (input: RequiredInput) => {
+      const config = state.get()
+      if (!config.auto) return false
+      const limit = input.resolved.limit
+      const context = limit.context
+      if (context <= 0) return false
+      const last = input.messages.findLast(
+        (message): message is SessionMessage.Assistant & { tokens: NonNullable<SessionMessage.Assistant["tokens"]> } =>
+          message.type === "assistant" && message.tokens !== undefined,
+      )
+      if (!last) return false
+      const output = Math.min(limit.output, OUTPUT_TOKEN_MAX)
+      const promptCeiling = Math.min(
+        limit.input === undefined ? Number.POSITIVE_INFINITY : limit.input - config.buffer,
+        context - Math.max(output, config.buffer),
+      )
+      const used =
+        last.tokens.input +
+        last.tokens.output +
+        last.tokens.reasoning +
+        last.tokens.cache.read +
+        last.tokens.cache.write
+      if (used <= 0) return false
+      return used >= promptCeiling
+    }
+    const compactManual = Effect.fn("SessionCompaction.compactManual")(function* (input: ManualInput) {
+      const content = planContent(input.messages, state.get().tokens)
+      if (!content)
+        return yield* failed({
+          sessionID: input.session.id,
+          reason: "manual",
+          error: { type: "compaction.unavailable", message: "Nothing to compact yet" },
+          inputID: input.inputID,
+        })
+      const resolved = yield* input.resolveModel(input.session).pipe(
+        Effect.catch((cause) =>
+          failed({
+            sessionID: input.session.id,
+            reason: "manual",
+            error: toSessionError(cause),
+            inputID: input.inputID,
+          }),
+        ),
+      )
+      if ("status" in resolved) return resolved
+      return yield* execute({
+        session: input.session,
+        resolved,
+        prepare: input.prepare,
+        reason: "manual",
+        inputID: input.inputID,
+        started: input.started,
+        ...content,
+      })
+    })
+    return Service.of({
+      transform: state.transform,
+      reload: state.reload,
+      enabled: () => state.get().auto,
+      required,
+      compact,
+      compactManual,
+    })
   }),
 )
 

packages/core/src/session/context.ts

@@ -125,7 +125,7 @@ const layer = Layer.effect(
       if (session.location.directory !== location.directory || session.location.workspaceID !== location.workspaceID)
         return yield* Effect.interrupt
 
-      yield* plugins.initialized
+      yield* plugins.flush
       yield* mcpTools.flush
       const agent = yield* agents.select(session.agent)
       if (!agent.info) return yield* new AgentNotFoundError({ sessionID: session.id, agent: session.agent ?? agent.id })

packages/core/src/session/prompt-cache-diagnostics.ts

@@ -1,95 +0,0 @@
-export * as PromptCacheDiagnostics from "./prompt-cache-diagnostics.js"
-
-import type { LLMRequest } from "@opencode-ai/ai"
-import { Hash } from "@opencode-ai/util/hash"
-
-interface Entry {
-  readonly label: string
-  readonly hash: string
-}
-
-export interface Snapshot {
-  readonly settings: string
-  readonly tools: ReadonlyArray<Entry>
-  readonly system: ReadonlyArray<Entry>
-  readonly messages: ReadonlyArray<Entry>
-}
-
-export type Comparison =
-  | { readonly status: "initial" }
-  | { readonly status: "stable"; readonly messages: number }
-  | { readonly status: "append-only"; readonly previousMessages: number; readonly currentMessages: number }
-  | {
-      readonly status: "changed"
-      readonly component: "settings" | "tools" | "system" | "messages"
-      readonly index: number
-      readonly label: string
-    }
-
-const hash = (value: unknown) => Hash.sha256(JSON.stringify(value)).slice(0, 16)
-
-export function snapshot(request: LLMRequest): Snapshot {
-  return {
-    settings: hash({
-      route: request.model.route.id,
-      provider: request.model.provider,
-      model: request.model.id,
-      modelDefaults: request.model.defaults,
-      compatibility: request.model.compatibility,
-      routeDefaults: {
-        generation: request.model.route.defaults.generation,
-        providerOptions: request.model.route.defaults.providerOptions,
-        http: request.model.route.defaults.http,
-      },
-      generation: request.generation,
-      providerOptions: request.providerOptions,
-      http: request.http,
-      toolChoice: request.toolChoice,
-      cache: request.cache,
-    }),
-    tools: request.tools.map((tool) => ({ label: tool.name, hash: hash(tool) })),
-    system: request.system.map((part, index) => ({ label: `system[${index}]`, hash: hash(part) })),
-    messages: request.messages.map((message, index) => ({
-      label: message.id ?? `${message.role}[${index}]`,
-      hash: hash(message),
-    })),
-  }
-}
-
-export function compare(previous: Snapshot | undefined, current: Snapshot): Comparison {
-  if (!previous) return { status: "initial" }
-  if (previous.settings !== current.settings)
-    return {
-      status: "changed",
-      component: "settings",
-      index: 0,
-      label: "model settings",
-    }
-  const tools = firstChange(previous.tools, current.tools, false)
-  if (tools) return { status: "changed", component: "tools", ...tools }
-  const system = firstChange(previous.system, current.system, false)
-  if (system) return { status: "changed", component: "system", ...system }
-  const messages = firstChange(previous.messages, current.messages, true)
-  if (messages) return { status: "changed", component: "messages", ...messages }
-  if (previous.messages.length === current.messages.length)
-    return { status: "stable", messages: current.messages.length }
-  return {
-    status: "append-only",
-    previousMessages: previous.messages.length,
-    currentMessages: current.messages.length,
-  }
-}
-
-function firstChange(previous: ReadonlyArray<Entry>, current: ReadonlyArray<Entry>, allowAppend: boolean) {
-  const index = previous.findIndex((entry, index) => entry.hash !== current[index]?.hash)
-  if (index >= 0)
-    return {
-      index,
-      label: current[index]?.label ?? previous[index]?.label ?? `entry[${index}]`,
-    }
-  if (current.length === previous.length || (allowAppend && current.length > previous.length)) return
-  return {
-    index: previous.length,
-    label: current[previous.length]?.label ?? `entry[${previous.length}]`,
-  }
-}

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

@@ -1,7 +1,7 @@
 export * as SessionRunnerLLM from "./llm.js"
 
 import { Message } from "@opencode-ai/ai"
-import { Cause, Config, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect"
+import { Cause, Effect, Exit, FiberMap, Layer, Pull, Schedule } from "effect"
 import { Database } from "../../database/database.js"
 import { Bus } from "../../bus.js"
 import { InstructionState } from "../instruction-state.js"
@@ -24,9 +24,7 @@ import { SessionRunnerRetry } from "./retry.js"
 import { SessionStep } from "./step.js"
 import { ToolOutput } from "../../tool-output.js"
 import { PluginSupervisor } from "../../plugin/supervisor.js"
-import { PromptCacheDiagnostics } from "../prompt-cache-diagnostics.js"
 import { MAX_STEPS_PROMPT } from "./max-steps.js"
-import { PluginExecution } from "../../plugin/execution.js"
 
 const CONTINUE_AFTER_INCOMPLETE_STREAM =
   "The previous response was interrupted. Continue from where you left off without repeating completed content."
@@ -41,35 +39,8 @@ const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const compaction = yield* SessionCompaction.Service
     const plugins = yield* PluginSupervisor.Service
-    const pluginExecution = yield* PluginExecution.Service
     const title = yield* SessionTitle.Service
     const steps = yield* SessionStep.make
-    const diagnostics = yield* Config.boolean("OPENCODE_PROMPT_CACHE_DIAGNOSTICS").pipe(
-      Config.withDefault(false),
-      Effect.orDie,
-    )
-    const promptCacheSnapshots = diagnostics ? new Map<string, PromptCacheDiagnostics.Snapshot>() : undefined
-    const diagnosePromptCache = Effect.fn("SessionRunner.diagnosePromptCache")(function* (
-      sessionID: SessionSchema.ID,
-      request: Parameters<typeof PromptCacheDiagnostics.snapshot>[0],
-    ) {
-      if (!promptCacheSnapshots) return
-      const current = PromptCacheDiagnostics.snapshot(request)
-      const comparison = PromptCacheDiagnostics.compare(promptCacheSnapshots.get(sessionID), current)
-      promptCacheSnapshots.delete(sessionID)
-      promptCacheSnapshots.set(sessionID, current)
-      const oldest = promptCacheSnapshots.keys().next().value
-      if (promptCacheSnapshots.size > 100 && oldest !== undefined) promptCacheSnapshots.delete(oldest)
-      yield* Effect.logInfo("prompt cache prefix").pipe(
-        Effect.annotateLogs({
-          sessionID,
-          toolCount: current.tools.length,
-          systemParts: current.system.length,
-          messageCount: current.messages.length,
-          ...comparison,
-        }),
-      )
-    })
     // Title generation starts once input is visible and must not delay model execution.
     const titles = yield* FiberMap.make<SessionSchema.ID, void, never>()
 
@@ -91,6 +62,7 @@ const layer = Layer.effect(
         const control = pending.type === "compaction" || pending.type === "move"
         if (promotable === "steer" && pending.delivery === "queue" && !control) return DrainResult.Complete()
       }
+      yield* plugins.flush
       yield* settleStaleToolCalls(sessionID)
 
       const advanceToStep = Effect.fn("SessionRunner.advanceToStep")(() =>
@@ -244,14 +216,12 @@ const layer = Layer.effect(
           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()
@@ -314,14 +284,7 @@ const layer = Layer.effect(
       }
     })
 
-    return Service.of({
-      drain: Effect.fnUntraced(function* (input) {
-        yield* plugins.initialized
-        const session = yield* store.get(input.sessionID)
-        if (!session) return yield* Effect.die(new Error(`Session not found: ${input.sessionID}`))
-        return yield* pluginExecution.lease(session, drain(input))
-      }),
-    })
+    return Service.of({ drain })
   }),
 )
 
@@ -340,6 +303,5 @@ export const node = makeLocationNode({
     Snapshot.node,
     ToolOutput.node,
     Database.node,
-    PluginExecution.node,
   ],
 })

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

@@ -396,7 +396,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* text.append(event.id, event.text, providerState(event.providerMetadata))
         return
       case "text-end":
-        yield* text.end(event.id, providerState(event.providerMetadata))
+        yield* text.end(event.id, providerState(event.providerMetadata), event.text)
         return
       case "reasoning-start":
         outputStarted = true
@@ -412,7 +412,7 @@ export const createLLMEventPublisher = (bus: Pick<Bus.Interface, "publish">, inp
         yield* reasoning.append(event.id, event.text, providerState(event.providerMetadata))
         return
       case "reasoning-end":
-        yield* reasoning.end(event.id, providerState(event.providerMetadata))
+        yield* reasoning.end(event.id, providerState(event.providerMetadata), event.text)
         return
       case "tool-input-start":
         outputStarted = true

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

@@ -26,12 +26,16 @@ export function isRetryable(error: AIError) {
       return error.reason.delivery === undefined || error.reason.delivery === "not-sent"
     case "InvalidProviderOutput":
       return error.reason.classification === "incomplete-stream"
+    // Unrecognized failures retry: classification records affirmative
+    // deterministic evidence, and transient failures are exactly the ones
+    // that arrive in shapes no classifier anticipates.
+    case "UnknownProvider":
+      return true
     case "Authentication":
     case "QuotaExceeded":
     case "ContentPolicy":
     case "InvalidRequest":
     case "NoRoute":
-    case "UnknownProvider":
       return false
     default: {
       const exhaustive: never = error.reason

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

@@ -44,7 +44,6 @@ interface Input {
   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>
@@ -73,11 +72,12 @@ export const make = Effect.gen(function* () {
     })
     const toolRuns: Array<{
       readonly call: ToolCall
-      readonly fiber: Fiber.Fiber<void, SessionModelRequest.ExecuteError>
+      readonly fiber: Fiber.Fiber<void, Permission.DeclinedError | QuestionTool.CancelledError>
     }> = []
     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" })
+      if (input.prepared.request.toolChoice?.type === "none")
+        return new Tool.Error({ message: "Tools are disabled after the maximum agent steps" })
       return input.prepared.executeTool({
         sessionID: input.sessionID,
         agent: input.agent,
@@ -132,10 +132,7 @@ export const make = Effect.gen(function* () {
         if (streamInterrupted) yield* interruptTools
         const joined = yield* restore(Fiber.awaitAll(toolRuns.map((run) => run.fiber))).pipe(Effect.exit)
         if (Exit.isFailure(joined)) yield* interruptTools
-        const tools = classifyToolExits(
-          joined,
-          toolRuns.map((run) => run.call),
-        )
+        const tools = classifyToolExits(joined, toolRuns)
 
         if (
           !publisher.record().outputStarted &&
@@ -240,7 +237,7 @@ export const make = Effect.gen(function* () {
         if (tools.interrupted && Exit.isFailure(joined)) return yield* Effect.failCause(joined.cause)
         if (record.failure) return yield* new StepFailedError({ error: record.failure })
         return Outcome.Completed({
-          needsContinuation: !input.toolsDisabled && record.needsContinuation,
+          needsContinuation: input.prepared.request.toolChoice?.type !== "none" && record.needsContinuation,
         })
       }),
     )
@@ -249,27 +246,22 @@ export const make = Effect.gen(function* () {
   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. */
+/** Tool.Error settles in each fiber; only user declines remain in the typed error channel. */
 const classifyToolExits = (
-  settled: Exit.Exit<Array<Exit.Exit<void, SessionModelRequest.ExecuteError>>>,
-  calls: ReadonlyArray<ToolCall>,
+  settled: Exit.Exit<Array<Exit.Exit<void, Permission.DeclinedError | QuestionTool.CancelledError>>>,
+  runs: ReadonlyArray<{ readonly call: ToolCall }>,
 ) => {
   const exits = Exit.isSuccess(settled) ? settled.value : []
   const declines = exits.flatMap((exit, index) =>
     Exit.isFailure(exit)
       ? exit.cause.reasons.flatMap((reason) =>
-          Cause.isFailReason(reason) && isDecline(reason.error) ? [{ call: calls[index], reason: reason.error }] : [],
+          Cause.isFailReason(reason) ? [{ call: runs[index].call, reason: reason.error }] : [],
         )
       : [],
   )
@@ -279,11 +271,8 @@ const classifyToolExits = (
   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)] : []
+      const reasons = cause.reasons.filter(Cause.isDieReason)
+      return reasons.length > 0 ? [Cause.fromReasons<never>(reasons)] : []
     })
     .at(0)
   return { interrupted: causes.some(Cause.hasInterrupts), declines, failure }

packages/core/src/session/title.ts

@@ -1,8 +1,7 @@
 export * as SessionTitle from "./title.js"
 
 import { isDeepStrictEqual } from "node:util"
-import { LLMClient, AIError, LLMEvent, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
-import type { StreamOptions } from "@opencode-ai/ai/route"
+import { LLMClient, LLMEvent, Message, SystemPart } from "@opencode-ai/ai"
 import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import type { Agent } from "../agent.js"
 import { Database } from "../database/database.js"
@@ -17,22 +16,12 @@ import type { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
 import { SessionUsage } from "./usage.js"
 import { SessionStore } from "./store.js"
-import { PluginExecution } from "../plugin/execution.js"
 
 const MAX_LENGTH = 100
 const MAX_CONTEXT_LENGTH = 8_000
 const MAX_FIRST_MESSAGE_LENGTH = 2_000
 const titleChanged = Symbol("Session title changed")
 
-type Dependencies = {
-  readonly bus: Bus.Interface
-  readonly llm: {
-    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
-  }
-  readonly context: SessionContext.Interface
-  readonly store: SessionStore.Interface
-}
-
 export interface Interface {
   /** Generates an initial title or regenerates one from bounded conversation history. */
   readonly generate: (sessionID: SessionSchema.ID) => Effect.Effect<void>
@@ -47,117 +36,6 @@ export const isUntitled = (session: SessionSchema.Info) =>
     time: { created: DateTime.toEpochMillis(session.time.created) },
   })
 
-const attempt = Effect.fn("SessionTitle.attempt")(function* (
-  dependencies: Dependencies,
-  input: {
-    readonly session: SessionSchema.Info
-    readonly agent: Agent.Info
-    readonly text: string
-    readonly model: SessionRunnerModel.Resolved
-  },
-) {
-  const chunks: string[] = []
-  let failed = false
-  let usage: SessionUsage.Recorded | undefined
-  const recordUsage = Effect.suspend(() =>
-    usage
-      ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
-          sessionID: input.session.id,
-          source: "title",
-          ...usage,
-        })
-      : Effect.void,
-  )
-  const prepared = yield* dependencies.context.prepare({
-    scope: { session: input.session, agentID: input.agent.id, model: input.model },
-    transcript: {
-      system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
-      messages: [Message.user(input.text)],
-    },
-    contextHooks: false,
-  })
-  yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-    Stream.runForEach((event) => {
-      if (LLMEvent.is.providerError(event)) failed = true
-      if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
-      if (LLMEvent.is.stepFinish(event)) {
-        const step = SessionUsage.record(event.usage, input.model.cost)
-        usage = usage ? SessionUsage.add(usage, step) : step
-      }
-      return Effect.void
-    }),
-    Effect.catchTag("AI.Error", () =>
-      Effect.sync(() => {
-        failed = true
-      }),
-    ),
-    Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
-  )
-  yield* recordUsage
-  if (failed) return
-  return chunks
-    .join("")
-    .split("\n")
-    .map((line) => line.trim())
-    .find((line) => line.length > 0)
-})
-
-const make = (dependencies: Dependencies) => {
-  const generate = Effect.fn("SessionTitle.generate")(function* (
-    db: Database.Interface["db"],
-    sessionID: SessionSchema.ID,
-  ) {
-    const session = yield* dependencies.store.get(sessionID)
-    if (!session) return
-    const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
-    if (!firstUser) return
-    const text = !isUntitled(session)
-      ? yield* dependencies.store.context(session.id).pipe(
-          Effect.map((messages) => {
-            const original = `Original request:\n${firstUser.text.slice(0, MAX_FIRST_MESSAGE_LENGTH)}`
-            const recent = messages
-              .flatMap((message) => {
-                if (message.type === "user" && message.id !== firstUser.id) return [`User: ${message.text.trim()}`]
-                if (message.type !== "assistant") return []
-                const text = message.content
-                  .flatMap((part) => (part.type === "text" ? [part.text.trim()] : []))
-                  .filter(Boolean)
-                  .join("\n")
-                return text ? [`Assistant: ${text}`] : []
-              })
-              .join("\n\n")
-            if (!recent) return original
-            const prefix = `${original}\n\nRecent conversation:\n`
-            return `${prefix}${recent.slice(-(MAX_CONTEXT_LENGTH - prefix.length))}`
-          }),
-          Effect.orElseSucceed(() => firstUser.text),
-        )
-      : firstUser.text
-    const selection = yield* dependencies.context.selectTitle(session)
-    if (!selection) return
-    const title =
-      (yield* attempt(dependencies, { session, agent: selection.agent, text, model: selection.selected })) ??
-      (selection.primary && !isDeepStrictEqual(selection.selected.ref, selection.primary.ref)
-        ? yield* attempt(dependencies, { session, agent: selection.agent, text, model: selection.primary })
-        : undefined)
-    if (!title) return
-    const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
-    const current = yield* dependencies.store.get(sessionID)
-    if (!current || current.title !== session.title || current.title === truncate(title)) return
-    yield* dependencies.bus
-      .publish(
-        SessionEvent.Renamed,
-        {
-          sessionID: session.id,
-          title: truncate(title),
-        },
-        { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
-      )
-      .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
-  })
-  return { generate }
-}
-
 export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
@@ -165,21 +43,115 @@ export const layer = Layer.effect(
     const llm = yield* LLMClient.Service
     const context = yield* SessionContext.Service
     const store = yield* SessionStore.Service
-    const database = yield* Database.Service
-    const gate = yield* PluginExecution.Service
-    const title = make({ bus, llm, context, store })
-    return Service.of({
-      generate: Effect.fnUntraced(function* (sessionID) {
-        const session = yield* store.get(sessionID)
-        if (!session) return
-        return yield* gate.lease({ id: session.id, admission: true }, title.generate(database.db, sessionID))
-      }),
+    const db = (yield* Database.Service).db
+
+    const attempt = Effect.fn("SessionTitle.attempt")(function* (input: {
+      readonly session: SessionSchema.Info
+      readonly agent: Agent.Info
+      readonly text: string
+      readonly model: SessionRunnerModel.Resolved
+    }) {
+      const chunks: string[] = []
+      let failed = false
+      let usage: SessionUsage.Recorded | undefined
+      const recordUsage = Effect.suspend(() =>
+        usage
+          ? bus.publish(SessionEvent.UsageRecorded, {
+              sessionID: input.session.id,
+              source: "title",
+              ...usage,
+            })
+          : Effect.void,
+      )
+      const prepared = yield* context.prepare({
+        scope: { session: input.session, agentID: input.agent.id, model: input.model },
+        transcript: {
+          system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
+          messages: [Message.user(input.text)],
+        },
+        contextHooks: false,
+      })
+      yield* llm.stream(prepared.request, prepared.options).pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event)) failed = true
+          if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, input.model.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.catchTag("AI.Error", () =>
+          Effect.sync(() => {
+            failed = true
+          }),
+        ),
+        Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
+      )
+      yield* recordUsage
+      if (failed) return
+      return chunks
+        .join("")
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.length > 0)
     })
+
+    const generate = Effect.fn("SessionTitle.generate")(function* (sessionID: SessionSchema.ID) {
+      const session = yield* store.get(sessionID)
+      if (!session) return
+      const firstUser = yield* SessionHistory.firstUserMessage(db, session.id)
+      if (!firstUser) return
+      const text = !isUntitled(session)
+        ? yield* store.context(session.id).pipe(
+            Effect.map((messages) => {
+              const original = `Original request:\n${firstUser.text.slice(0, MAX_FIRST_MESSAGE_LENGTH)}`
+              const recent = messages
+                .flatMap((message) => {
+                  if (message.type === "user" && message.id !== firstUser.id) return [`User: ${message.text.trim()}`]
+                  if (message.type !== "assistant") return []
+                  const text = message.content
+                    .flatMap((part) => (part.type === "text" ? [part.text.trim()] : []))
+                    .filter(Boolean)
+                    .join("\n")
+                  return text ? [`Assistant: ${text}`] : []
+                })
+                .join("\n\n")
+              if (!recent) return original
+              const prefix = `${original}\n\nRecent conversation:\n`
+              return `${prefix}${recent.slice(-(MAX_CONTEXT_LENGTH - prefix.length))}`
+            }),
+            Effect.orElseSucceed(() => firstUser.text),
+          )
+        : firstUser.text
+      const selection = yield* context.selectTitle(session)
+      if (!selection) return
+      const title =
+        (yield* attempt({ session, agent: selection.agent, text, model: selection.selected })) ??
+        (selection.primary && !isDeepStrictEqual(selection.selected.ref, selection.primary.ref)
+          ? yield* attempt({ session, agent: selection.agent, text, model: selection.primary })
+          : undefined)
+      if (!title) return
+      const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
+      const current = yield* store.get(sessionID)
+      if (!current || current.title !== session.title || current.title === truncate(title)) return
+      yield* bus
+        .publish(
+          SessionEvent.Renamed,
+          {
+            sessionID: session.id,
+            title: truncate(title),
+          },
+          { commit: (sequence) => (sequence === expectedSequence ? Effect.void : Effect.die(titleChanged)) },
+        )
+        .pipe(Effect.catchDefect((defect) => (defect === titleChanged ? Effect.void : Effect.die(defect))))
+    })
+    return Service.of({ generate })
   }),
 )
 
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node, llmClient, SessionContext.node, SessionStore.node, Database.node, PluginExecution.node],
+  deps: [Bus.node, llmClient, SessionContext.node, SessionStore.node, Database.node],
 })

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

@@ -19,7 +19,7 @@ export const name = "shell"
 export const DEFAULT_TIMEOUT_MS = 2 * 60 * 1_000
 
 const BACKGROUND_INSTRUCTION =
-  "You will be notified automatically when the command finishes. Avoid sleep commands or polling for completion; if you need the output before then, read the file directly."
+  "You will be notified automatically when the command finishes. The notification will include the command's output. DO NOT run sleep commands or poll the output file to check for completion. You can read from the file when its current output would be useful, such as when inspecting logs from a background server. Otherwise, continue with other work or end your response."
 const OS =
   process.platform === "darwin"
     ? "macOS"

packages/core/test/aisdk.test.ts

@@ -757,7 +757,7 @@ it.effect("classifies data-only AI SDK authentication errors", () =>
         data: { error: { code: "authentication_error" } },
       }),
     )
-    expect(error.reason).toMatchObject({ _tag: "Authentication", kind: "invalid" })
+    expect(error.reason).toMatchObject({ _tag: "Authentication" })
     expect(SessionRunnerRetry.isRetryable(error)).toBeFalse()
   }),
 )
@@ -776,7 +776,7 @@ Object.entries({
         responseBody,
       })
       const error = yield* streamFailure(cause)
-      expect(error.reason).toMatchObject({ _tag: "Authentication", kind: "invalid" })
+      expect(error.reason).toMatchObject({ _tag: "Authentication" })
       expect(SessionRunnerRetry.isRetryable(error)).toBeFalse()
       expect(error.reason.body).toBe(responseBody)
       expect(error.reason.cause).toBe(cause)
@@ -823,6 +823,55 @@ it.effect("retries status-less AI SDK transport failures", () =>
   }),
 )
 
+it.effect("classifies native fetch failures as request transport errors", () =>
+  Effect.gen(function* () {
+    const cause = Object.assign(new TypeError("fetch failed"), {
+      cause: Object.assign(new Error("connect ECONNREFUSED 127.0.0.1:443"), { code: "ECONNREFUSED" }),
+    })
+    const error = yield* streamFailure(cause)
+    expect(error.reason).toMatchObject({
+      _tag: "Transport",
+      transport: "http",
+      operation: "request",
+      code: "ECONNREFUSED",
+    })
+    expect(error.message).toBe("connect ECONNREFUSED 127.0.0.1:443")
+    expect(error.reason.cause).toBe(cause)
+    expect(SessionRunnerRetry.isRetryable(error)).toBeTrue()
+  }),
+)
+
+it.effect("classifies mid-stream socket drops as read transport errors", () =>
+  Effect.gen(function* () {
+    const cause = Object.assign(new Error("terminated"), {
+      cause: Object.assign(new Error("other side closed"), { code: "UND_ERR_SOCKET" }),
+    })
+    const error = yield* streamFailure(cause, true)
+    expect(error.reason).toMatchObject({
+      _tag: "Transport",
+      transport: "http",
+      operation: "read",
+      code: "UND_ERR_SOCKET",
+    })
+    expect(SessionRunnerRetry.isRetryable(error)).toBeTrue()
+  }),
+)
+
+it.effect("classifies the SSE chunk timeout as a read transport error", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(new Error("SSE read timed out"), true)
+    expect(error.reason).toMatchObject({ _tag: "Transport", transport: "http", operation: "read" })
+    expect(SessionRunnerRetry.isRetryable(error)).toBeTrue()
+  }),
+)
+
+it.effect("keeps unrecognized error codes on the unknown provider path", () =>
+  Effect.gen(function* () {
+    const error = yield* streamFailure(Object.assign(new Error("kaput"), { code: "E_SOMETHING_ELSE" }), true)
+    expect(error.reason).toBeInstanceOf(UnknownProviderError)
+  }),
+)
+
 it.effect("prefers a structured provider message over the code fallback", () =>
   Effect.gen(function* () {
     const error = yield* streamFailure(

packages/core/test/config/config.test.ts

@@ -76,57 +76,6 @@ const provider = {
 }
 
 describe("Config", () => {
-  it.live("updates the first file-backed document", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) => {
-        const global = path.join(tmp.path, "global")
-        const project = path.join(tmp.path, "project")
-        const globalFile = path.join(global, "opencode.jsonc")
-        const projectFile = path.join(project, "opencode.json")
-        return Effect.promise(async () => {
-          await Promise.all([fs.mkdir(global, { recursive: true }), fs.mkdir(project, { recursive: true })])
-          await Promise.all([
-            fs.writeFile(globalFile, '{\n  // Keep this comment.\n  "shell": "global"\n}\n'),
-            fs.writeFile(projectFile, JSON.stringify({ shell: "project" })),
-          ])
-        }).pipe(
-          Effect.andThen(
-            Effect.gen(function* () {
-              const config = yield* Config.Service
-              const content = yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))
-              const cause = new Error("Rejected config update")
-              const error = yield* config
-                .update((draft) => {
-                  draft.shell = "discarded"
-                  throw cause
-                })
-                .pipe(Effect.flip)
-
-              expect(error).toBeInstanceOf(Config.UpdateError)
-              expect(error.message).toBe("Config update failed")
-              expect(error.cause).toBe(cause)
-              expect(yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))).toBe(content)
-
-              const updated = yield* config.update((draft) => {
-                draft.shell = "updated"
-              })
-
-              expect(updated.shell).toBe("updated")
-              expect(yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))).toContain("// Keep this comment.")
-              expect(yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))).toContain('"shell": "updated"')
-              expect(JSON.parse(yield* Effect.promise(() => fs.readFile(projectFile, "utf8")))).toEqual({
-                shell: "project",
-              })
-            }).pipe(Effect.provide(testLayer(project, global))),
-          ),
-        )
-      }),
-    ),
-  )
-
   it.live("excludes home-level claude and agents directories when global is disabled", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -206,16 +155,6 @@ describe("Config", () => {
     ),
   )
 
-  it.effect("fails updates when no file-backed document exists", () =>
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-      const error = yield* config.update((draft) => void draft).pipe(Effect.flip)
-      expect(error.message).toBe("No editable config document found")
-    }).pipe(
-      Effect.provide(Config.testLayer([new Document({ type: "document", info: new Info({ shell: "virtual" }) })])),
-    ),
-  )
-
   it.live("loads explicit file and content overrides in priority order", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -430,38 +369,6 @@ describe("Config", () => {
     }).pipe(Effect.provide(Config.testLayer())),
   )
 
-  it.effect("keeps test config unchanged after an update callback fails", () =>
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-      const test = yield* Config.Test
-      const entry = new Document({
-        type: "document",
-        path: AbsolutePath.make(path.join(import.meta.dir, "opencode.json")),
-        info: new Info({ shell: "initial" }),
-      })
-      yield* test.setEntries([entry])
-      const cause = new Error("Rejected config update")
-      const error = yield* config
-        .update((draft) => {
-          draft.shell = "discarded"
-          throw cause
-        })
-        .pipe(Effect.flip)
-
-      expect(error).toBeInstanceOf(Config.UpdateError)
-      expect(error.message).toBe("Config update failed")
-      expect(error.cause).toBe(cause)
-      expect(yield* config.entries()).toEqual([entry])
-      expect(entry.info.shell).toBe("initial")
-
-      const updated = yield* config.update((draft) => {
-        draft.shell = "recovered"
-      })
-      expect(updated.shell).toBe("recovered")
-      expect(Config.latest(yield* test.entries(), "shell")).toBe("recovered")
-    }).pipe(Effect.provide(Config.testLayer())),
-  )
-
   it.effect("returns the latest defined scalar from priority-ordered documents", () =>
     Effect.sync(() => {
       const entries = [

packages/core/test/config/discovery.test.ts

@@ -0,0 +1,78 @@
+import path from "path"
+import { describe, expect } from "bun:test"
+import { Config } from "@opencode-ai/core/config"
+import { ConfigDiscovery } from "@opencode-ai/core/config/discovery"
+import { Bus } from "@opencode-ai/core/bus"
+import { Credential } from "@opencode-ai/core/credential"
+import { Location } from "@opencode-ai/core/location"
+import { Watcher } from "@opencode-ai/core/filesystem/watcher"
+import { WellKnown } from "@opencode-ai/core/wellknown"
+import { AbsolutePath } from "@opencode-ai/core/schema"
+import { Event } from "@opencode-ai/schema/config"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { Global } from "@opencode-ai/util/global"
+import { Effect, Fiber, Layer, Stream } from "effect"
+import { emptyCredentialNode, emptyWellknownNode } from "../fixture/config-nodes"
+import { location } from "../fixture/location"
+import { tmpdirScoped } from "../fixture/tmpdir"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(
+  AppNodeBuilder.build(LayerNode.group([FSUtil.node, Bus.node, Watcher.node, Credential.node, WellKnown.node]), [
+    [Watcher.node, Watcher.testLayer],
+    [Credential.node, emptyCredentialNode],
+    [WellKnown.node, emptyWellknownNode],
+  ]).pipe(Layer.merge(Watcher.testLayer)),
+)
+
+describe("ConfigDiscovery", () => {
+  it.live("discovers and refreshes ordered entries without the Config service", () =>
+    Effect.gen(function* () {
+      const tmp = yield* tmpdirScoped()
+      const fs = yield* FSUtil.Service
+      const target = path.join(tmp.path, "custom.jsonc")
+      yield* fs.writeFileString(target, '{ "shell": "before" }')
+      yield* Effect.gen(function* () {
+        const watcher = yield* Watcher.Test
+        const bus = yield* Bus.Service
+        const discovery: Config.Interface = yield* ConfigDiscovery.make({
+          project: false,
+          global: false,
+          file: target,
+          content: '{ "shell": "inline" }',
+        })
+        expect(Config.Options).toBe(ConfigDiscovery.Options)
+        expect(yield* discovery.entries()).toMatchObject([
+          { type: "document", path: target, info: { shell: "before" } },
+          { type: "document", info: { shell: "inline" } },
+        ])
+        expect(yield* watcher.subscriptions()).toEqual([{ path: target, type: "file" }])
+        const updated = yield* bus.subscribe(Event.Updated).pipe(
+          Stream.take(1),
+          Stream.mapEffect(() => discovery.entries()),
+          Stream.runCollect,
+          Effect.forkScoped({ startImmediately: true }),
+        )
+        const changed = yield* discovery
+          .changes()
+          .pipe(Stream.take(1), Stream.runCollect, Effect.forkScoped({ startImmediately: true }))
+        yield* fs.writeFileString(target, '{ "shell": "after" }')
+        expect((yield* discovery.entries())[0]).toMatchObject({ info: { shell: "before" } })
+        yield* watcher.emit({ path: target, type: "update" })
+        expect(yield* Fiber.join(changed)).toEqual([{ path: target, type: "update" }])
+        // The update event is a read barrier: its subscriber sees refreshed entries.
+        expect(yield* Fiber.join(updated)).toMatchObject([
+          [
+            { type: "document", path: target, info: { shell: "after" } },
+            { type: "document", info: { shell: "inline" } },
+          ],
+        ])
+      }).pipe(
+        Effect.provideService(Location.Service, location({ directory: AbsolutePath.make(tmp.path) })),
+        Effect.provideService(Global.Service, Global.make({ config: path.join(tmp.path, "global"), home: tmp.path })),
+      )
+    }),
+  )
+})

packages/core/test/config/entry-observer.test.ts

@@ -14,7 +14,6 @@ describe("ConfigEntryObserver", () => {
       const reloaded = yield* Deferred.make<void>()
       const config = Config.Service.of({
         entries: () => Ref.get(current),
-        update: () => Effect.die("unused config.update"),
         changes: () => Stream.empty,
       })
       const event = {

packages/core/test/config/file.test.ts

@@ -0,0 +1,411 @@
+import path from "path"
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { parse } from "jsonc-parser"
+import { isRecord } from "@opencode-ai/ai/utils/record"
+import { ConfigFile } from "@opencode-ai/core/config/file"
+import { FSUtil } from "@opencode-ai/util/fs-util"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { withTempDir } from "../fixture/tmpdir"
+import { testEffect } from "../lib/effect"
+
+// No Config, Location, Watcher, Credential, or WellKnown services are provided.
+const it = testEffect(LayerNode.compile(FSUtil.node))
+
+describe("ConfigFile", () => {
+  it.live("edits the explicit target and preserves comments and unrelated fields", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const global = path.join(tmp.path, "global", "opencode.jsonc")
+        const target = path.join(tmp.path, "project", "custom.jsonc")
+        const text = '{\n  // Keep this comment.\n  "shell": "project",\n  "custom": { "value": 1 },\n}\n'
+        yield* fs.writeWithDirs(global, '{ "shell": "global" }')
+        yield* fs.writeWithDirs(target, text)
+
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "updated"
+        })
+
+        expect(updated).toEqual({ shell: "updated", custom: { value: 1 } })
+        expect(yield* fs.readFileString(target)).toBe(text.replace('"project"', '"updated"'))
+        expect(yield* fs.readFileString(global)).toBe('{ "shell": "global" }')
+      }),
+    ),
+  )
+
+  it.live("leaves raw substitutions, model shorthand, and legacy shapes unresolved", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.jsonc")
+        const text = `{
+  "model": "{env:OPENCODE_TEST_CONFIG_MODEL}",
+  "shell": "{file:missing-shell.txt}",
+  "skills": { "paths": ["./skills"] },
+  "agent": { "review": { "model": "acme/reasoner" } },
+  "username": "before"
+}
+`
+        yield* fs.writeFileString(target, text)
+        yield* ConfigFile.update(target, (draft) => {
+          expect(draft.model).toBe("{env:OPENCODE_TEST_CONFIG_MODEL}")
+          expect(draft.shell).toBe("{file:missing-shell.txt}")
+          expect(draft.skills).toEqual({ paths: ["./skills"] })
+          draft.username = "after"
+        })
+
+        expect(yield* fs.readFileString(target)).toBe(text.replace('"before"', '"after"'))
+      }),
+    ),
+  )
+
+  it.live("patches nested source fields and deletes legacy keys without migrating them", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.jsonc")
+        yield* fs.writeFileString(
+          target,
+          `{
+  "agent": {
+    "review": { "description": "before", "hidden": true },
+    // Keep the other definition.
+    "build": { "description": "unchanged" }
+  },
+  "snapshot": true
+}
+`,
+        )
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          const agent: unknown = draft.agent
+          if (!isRecord(agent) || !isRecord(agent.review)) throw new Error("Missing fixture agent")
+          agent.review.description = "after"
+          agent.review.color = "blue"
+          delete agent.review.hidden
+          delete draft.snapshot
+        })
+
+        expect(updated).toEqual({
+          agent: { review: { description: "after", color: "blue" }, build: { description: "unchanged" } },
+        })
+        expect(parse(yield* fs.readFileString(target))).toEqual(updated)
+        expect(yield* fs.readFileString(target)).toContain("// Keep the other definition.")
+      }),
+    ),
+  )
+
+  it.live("patches array elements without rewriting untouched comments", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.jsonc")
+        const text = `{
+  "plugins": [
+    // Keep the first plugin.
+    "first",
+    "second",
+    // Keep the third plugin.
+    "third",
+    "fourth"
+  ]
+}
+`
+        yield* fs.writeFileString(target, text)
+        yield* ConfigFile.update(target, (draft) => {
+          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
+          draft.plugins[1] = "updated"
+        })
+        expect(yield* fs.readFileString(target)).toBe(text.replace('"second"', '"updated"'))
+
+        const shortened = yield* ConfigFile.update(target, (draft) => {
+          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
+          draft.plugins.splice(1, 3)
+        })
+        expect(shortened.plugins).toEqual(["first"])
+        expect(parse(yield* fs.readFileString(target))).toEqual(shortened)
+
+        const extended = yield* ConfigFile.update(target, (draft) => {
+          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
+          draft.plugins.push("added", "last")
+        })
+        expect(extended.plugins).toEqual(["first", "added", "last"])
+        expect(parse(yield* fs.readFileString(target))).toEqual(extended)
+        expect(yield* fs.readFileString(target)).toContain("// Keep the first plugin.")
+      }),
+    ),
+  )
+
+  it.live("preserves adjacent comments when deleting properties and array elements", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.jsonc")
+        yield* fs.writeFileString(
+          target,
+          `{
+  "shell": "remove",
+  // Keep the model explanation.
+  "model": "acme/reasoner",
+  "plugins": ["first", "second", /* Keep the plugin explanation. */ "third"],
+  "skills": [/* Keep the source explanation. */ "remove",],
+}
+`,
+        )
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          delete draft.shell
+          if (!Array.isArray(draft.plugins)) throw new Error("Missing fixture plugins")
+          draft.plugins.splice(1, 1)
+          draft.skills = []
+        })
+
+        expect(parse(yield* fs.readFileString(target))).toEqual(updated)
+        expect(updated).toEqual({ model: "acme/reasoner", plugins: ["first", "third"], skills: [] })
+        expect(yield* fs.readFileString(target)).toContain("// Keep the model explanation.")
+        expect(yield* fs.readFileString(target)).toContain("/* Keep the plugin explanation. */")
+        expect(yield* fs.readFileString(target)).toContain("/* Keep the source explanation. */")
+      }),
+    ),
+  )
+
+  it.live("deletes own JSON keys that also exist on Object.prototype", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        yield* fs.writeFileString(
+          target,
+          '{ "\\u005f_proto__": "remove", "constructor": "remove", "toString": "remove", "shell": "keep" }',
+        )
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          ;["__proto__", "constructor", "toString"].forEach((key) => {
+            delete draft[key]
+          })
+        })
+
+        expect(updated).toEqual({ shell: "keep" })
+        expect(yield* fs.readJson(target)).toEqual(updated)
+      }),
+    ),
+  )
+
+  it.live("preserves and edits object-valued __proto__ source keys", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        yield* fs.writeFileString(target, '{ "__proto__": { "value": "before" }, "shell": "keep" }')
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          expect(Object.hasOwn(draft, "__proto__")).toBe(true)
+          const entry: unknown = draft["__proto__"]
+          if (!isRecord(entry)) throw new Error("Missing fixture entry")
+          entry.value = "after"
+        })
+
+        expect(updated).toEqual({ ["__proto__"]: { value: "after" }, shell: "keep" })
+        expect(yield* fs.readJson(target)).toEqual(updated)
+        expect(Object.getPrototypeOf(updated)).toBe(Object.prototype)
+      }),
+    ),
+  )
+
+  it.live("rejects a duplicate-key patch that would not change the effective value", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        const text = '{ "shell": "first", "shell": "second" }'
+        yield* fs.writeFileString(target, text)
+        const error = yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "after"
+        }).pipe(Effect.flip)
+
+        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+        expect(error.message).toBe(`Config patch does not match the requested update: ${target}`)
+        expect(yield* fs.readFileString(target)).toBe(text)
+        expect(yield* fs.exists(target + ".tmp")).toBe(false)
+      }),
+    ),
+  )
+
+  it.live("rereads the selected file for consecutive edits without a watcher", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        yield* fs.writeFileString(target, '{ "shell": "first" }')
+        yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "second"
+        })
+        yield* ConfigFile.update(target, (draft) => {
+          expect(draft.shell).toBe("second")
+          draft.username = "added"
+        })
+        expect(yield* fs.readJson(target)).toEqual({ shell: "second", username: "added" })
+
+        yield* fs.writeFileString(target, '{ "shell": "external", "username": "added" }')
+        const updated = yield* ConfigFile.update(target, (draft) => {
+          expect(draft.shell).toBe("external")
+          draft.snapshots = false
+        })
+        expect(yield* fs.readJson(target)).toEqual(updated)
+        expect(updated).toEqual({ shell: "external", username: "added", snapshots: false })
+      }),
+    ),
+  )
+
+  it.live("serializes concurrent read-modify-write calls", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        yield* fs.writeFileString(target, '{ "count": 0 }')
+        const increment = ConfigFile.update(target, (draft) => {
+          if (typeof draft.count !== "number") throw new Error("Missing fixture count")
+          draft.count++
+        })
+        yield* Effect.all([increment, increment, increment], { concurrency: "unbounded" })
+
+        expect(yield* fs.readJson(target)).toEqual({ count: 3 })
+      }),
+    ),
+  )
+
+  it.live("does not rewrite no-op or structurally equal edits", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        const text = '{\r\n  "plugins": ["first"]\r\n}'
+        yield* fs.writeFileString(target, text)
+        const before = yield* fs.stat(target)
+        yield* ConfigFile.update(target, () => {})
+        yield* ConfigFile.update(target, (draft) => {
+          draft.plugins = ["first"]
+        })
+
+        expect(yield* fs.readFileString(target)).toBe(text)
+        expect((yield* fs.stat(target)).ino).toEqual(before.ino)
+        expect((yield* fs.stat(target)).mtime).toEqual(before.mtime)
+        expect(yield* fs.exists(target + ".tmp")).toBe(false)
+      }),
+    ),
+  )
+
+  it.live("leaves the file unchanged when a callback throws and permits a later edit", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        const text = '{ "shell": "before" }'
+        yield* fs.writeFileString(target, text)
+        const cause = new Error("Rejected config update")
+        const error = yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "discarded"
+          throw cause
+        }).pipe(Effect.flip)
+
+        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+        expect(error.message).toBe("Config update failed")
+        expect(error.cause).toBe(cause)
+        expect(yield* fs.readFileString(target)).toBe(text)
+        expect(yield* fs.exists(target + ".tmp")).toBe(false)
+
+        yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "recovered"
+        })
+        expect(yield* fs.readJson(target)).toEqual({ shell: "recovered" })
+      }),
+    ),
+  )
+
+  it.live("ignores callback return values instead of replacing the document", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        yield* fs.writeFileString(target, "{}")
+
+        expect(yield* ConfigFile.update(target, () => new Date(0))).toEqual({})
+        expect(yield* fs.readFileString(target)).toBe("{}")
+
+        const updated = yield* ConfigFile.update(target, (draft) => (draft.shell = "updated"))
+        expect(updated).toEqual({ shell: "updated" })
+        expect(yield* fs.readJson(target)).toEqual(updated)
+      }),
+    ),
+  )
+
+  it.live("rejects non-JSON mutations before writing", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        const text = '{ "shell": "before" }'
+        yield* fs.writeFileString(target, text)
+        const error = yield* ConfigFile.update(target, (draft) => {
+          draft.invalid = Number.NaN
+        }).pipe(Effect.flip)
+
+        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+        expect(error.message).toBe(`Config update must produce a JSON object: ${target}`)
+        expect(yield* fs.readFileString(target)).toBe(text)
+        expect(yield* fs.exists(target + ".tmp")).toBe(false)
+      }),
+    ),
+  )
+  ;["", "{", "[]", "null"].forEach((text) => {
+    it.live(`rejects invalid or non-object source ${JSON.stringify(text)}`, () =>
+      withTempDir((tmp) =>
+        Effect.gen(function* () {
+          const fs = yield* FSUtil.Service
+          const target = path.join(tmp.path, "opencode.json")
+          yield* fs.writeFileString(target, text)
+          const error = yield* ConfigFile.update(target, () => {
+            throw new Error("Callback must not run")
+          }).pipe(Effect.flip)
+
+          expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+          expect(error.message).toBe(`Invalid config file: ${target}`)
+          expect(yield* fs.readFileString(target)).toBe(text)
+          expect(yield* fs.exists(target + ".tmp")).toBe(false)
+        }),
+      ),
+    )
+  })
+
+  it.live("reports a missing target without creating it", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "missing.json")
+        const error = yield* ConfigFile.update(target, () => {}).pipe(Effect.flip)
+
+        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+        expect(error.message).toBe(`Failed to read config: ${target}`)
+        expect(error.cause).toBeDefined()
+        expect(yield* fs.exists(target)).toBe(false)
+      }),
+    ),
+  )
+
+  it.live("reports write failures without replacing the target", () =>
+    withTempDir((tmp) =>
+      Effect.gen(function* () {
+        const fs = yield* FSUtil.Service
+        const target = path.join(tmp.path, "opencode.json")
+        const text = '{ "shell": "before" }'
+        yield* fs.writeFileString(target, text)
+        yield* fs.makeDirectory(target + ".tmp")
+        const error = yield* ConfigFile.update(target, (draft) => {
+          draft.shell = "discarded"
+        }).pipe(Effect.flip)
+
+        expect(error).toBeInstanceOf(ConfigFile.UpdateError)
+        expect(error.message).toBe(`Failed to write config: ${target}`)
+        expect(error.cause).toBeDefined()
+        expect(yield* fs.readFileString(target)).toBe(text)
+      }),
+    ),
+  )
+})

packages/core/test/config/image.test.ts

@@ -55,7 +55,6 @@ describe("ConfigImagePlugin.Plugin", () => {
       let reads = 0
       const config = Config.Service.of({
         entries: () => Effect.sync(() => [document({ max_width: reads++ === 0 ? 1_200 : 700, max_base64_bytes: 1 })]),
-        update: () => Effect.die(new Error("Config update is unavailable")),
         changes: () => Stream.empty,
       })
       yield* ConfigImagePlugin.Plugin.effect(yield* PluginHost.make(plugins)).pipe(

packages/core/test/config/plugin.test.ts

@@ -19,15 +19,13 @@ import { Model } from "@opencode-ai/core/model"
 import { Provider } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Effect, Fiber, Logger, Stream } from "effect"
-import { Npm } from "@opencode-ai/util/npm"
 import { Database } from "../../src/database/database"
 import { tmpdir } from "../fixture/tmpdir"
-import { git } from "../fixture/git"
 import { tempGlobalLayer } from "../fixture/global"
 import { testEffect } from "../lib/effect"
 
 const it = testEffect(
-  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node, Npm.node]), [
+  AppNodeBuilder.build(LayerNode.group([Database.node, Bus.node, SdkPlugins.node, LocationServiceMap.node]), [
     [Global.node, tempGlobalLayer],
   ]),
 )
@@ -39,85 +37,6 @@ const staticIt = testEffect(
 )
 
 describe("PluginSupervisor config", () => {
-  it.live(
-    "updates a real package graph and retains its active revision after failed import and setup",
-    () =>
-      withLocation(
-        undefined,
-        Effect.gen(function* () {
-          yield* ready()
-          const location = yield* Location.Service
-          const registry = yield* Plugin.Service
-          const supervisor = yield* PluginSupervisor.Service
-          const agents = yield* Agent.Service
-          const npm = yield* Npm.Service
-          const repository = path.join(location.directory, "package")
-          const target = `git+${pathToFileURL(repository).href}#fixture-branch`
-          const initial = (yield* registry.list())[0]
-          expect(initial?.revision).toMatch(/^[0-9a-f]{40}$/)
-          expect((yield* agents.get(Agent.ID.make("package-agent")))?.description).toBe("first")
-          yield* Effect.promise(() => fs.writeFile(path.join(repository, "value.js"), `export const value = "second"`))
-          yield* commitPackage(repository)
-          const check = yield* supervisor.check(target)
-          expect(check.mutable).toBe(true)
-          expect(check.installed).toBe(initial?.revision)
-          expect(check.available).not.toBe(initial?.revision)
-          const updated = (yield* supervisor.update(target))[0]
-          expect(updated?.revision).toBe(check.available)
-          expect(updated?.generation).not.toBe(initial?.generation)
-          expect((yield* agents.get(Agent.ID.make("package-agent")))?.description).toBe("second")
-
-          yield* Effect.promise(() => fs.writeFile(path.join(repository, "index.js"), packagePlugin(true)))
-          yield* commitPackage(repository)
-          const failedSetup = (yield* supervisor.update(target))[0]
-          expect(failedSetup).toEqual({ ...updated, error: expect.stringContaining("package setup failed") })
-          expect((yield* agents.get(Agent.ID.make("package-agent")))?.description).toBe("second")
-          expect((yield* npm.inspect(target)).installed).not.toBe(updated?.revision)
-
-          yield* Effect.promise(() =>
-            fs.writeFile(path.join(repository, "index.js"), `import "./missing.js"; ${packagePlugin()}`),
-          )
-          yield* commitPackage(repository)
-          const failedImport = (yield* supervisor.update(target))[0]
-          expect(failedImport).toEqual({ ...updated, error: expect.stringContaining("missing.js") })
-          expect((yield* agents.get(Agent.ID.make("package-agent")))?.description).toBe("second")
-          const reloaded = (yield* supervisor.reload(target))[0]
-          expect(reloaded?.status).toBe("active")
-          expect(reloaded?.revision).toBe(updated?.revision)
-          expect(reloaded?.error).toBeUndefined()
-          expect(reloaded?.generation).not.toBe(updated?.generation)
-        }),
-        false,
-        async (directory) => {
-          const repository = path.join(directory, "package")
-          await fs.mkdir(repository)
-          await fs.writeFile(
-            path.join(repository, "package.json"),
-            JSON.stringify({
-              name: "fixture-core-plugin",
-              version: "1.0.0",
-              type: "module",
-              exports: "./index.js",
-            }),
-          )
-          await fs.writeFile(path.join(repository, "index.js"), packagePlugin())
-          await fs.writeFile(path.join(repository, "value.js"), `export const value = "first"`)
-          await git(repository, "init", "-q", "-b", "fixture-branch")
-          await Effect.runPromise(commitPackage(repository))
-          await fs.writeFile(
-            path.join(directory, "opencode.json"),
-            JSON.stringify({
-              plugins: [
-                "-*",
-                { package: `git+${pathToFileURL(repository).href}#fixture-branch`, options: { selection: "first" } },
-                { package: `git+${pathToFileURL(repository).href}#fixture-branch`, options: { selection: "last" } },
-              ],
-            }),
-          )
-        },
-      ),
-    30_000,
-  )
   it.live("applies selectors in order", () =>
     withLocation(
       { plugins: ["-opencode.provider.*", "opencode.provider.openai"] },
@@ -586,30 +505,6 @@ export default Plugin.define({
 `
 }
 
-function packagePlugin(fail = false) {
-  return `import { value } from "./value.js"
-export default { id: "package-plugin", tui: true, async setup(ctx) {
-  await ctx.agent.transform((draft) => draft.update("package-agent", (agent) => { agent.description = value }))
-  ${fail ? 'throw new Error("package setup failed")' : ""}
-} }`
-}
-
-const commitPackage = (repository: string) =>
-  Effect.promise(async () => {
-    await git(repository, "add", ".")
-    await git(
-      repository,
-      "-c",
-      "user.name=fixture",
-      "-c",
-      "user.email=fixture@example.com",
-      "commit",
-      "-q",
-      "-m",
-      "fixture",
-    )
-  })
-
 function discoveredPlugin(id: string) {
   return `export default { id: ${JSON.stringify(id)}, setup() {} }`
 }

packages/core/test/filesystem/watcher.test.ts

@@ -22,7 +22,6 @@ import { location } from "../fixture/location"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
 import { host } from "../plugin/host"
-import { noopPluginSupervisor } from "../fixture/plugin-supervisor"
 
 type WatcherEvent = { file: string; event: "add" | "change" | "unlink" }
 const describeNative = process.env.CI ? describe.skip : describe
@@ -32,7 +31,7 @@ const it = testEffect(AppNodeBuilder.build(LayerNode.group([FSUtil.node, Bus.nod
 const configLayer = Config.testLayer()
 const pluginNode = makeLocationNode({
   service: PluginSupervisor.Service,
-  layer: Layer.succeed(PluginSupervisor.Service, noopPluginSupervisor()),
+  layer: Layer.succeed(PluginSupervisor.Service, PluginSupervisor.Service.of({ flush: Effect.void })),
   deps: [],
 })
 
@@ -256,7 +255,6 @@ describe("LocationWatcher subscriptions", () => {
       Config.Service,
       Config.Service.of({
         entries: () => Effect.sync(() => entries.current),
-        update: () => Effect.die("unused config.update"),
         changes: () => Stream.never,
       }),
     )
@@ -315,7 +313,7 @@ describe("LocationWatcher subscriptions", () => {
         Effect.gen(function* () {
           const policy = yield* LocationWatcherPolicy.Service
           yield* policy.transform((draft) => draft.add([".git"]))
-          return noopPluginSupervisor()
+          return PluginSupervisor.Service.of({ flush: Effect.void })
         }),
       ),
       deps: [LocationWatcherPolicy.node],

packages/core/test/fixture/plugin-supervisor.ts

@@ -1,11 +0,0 @@
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor-service"
-import { Effect } from "effect"
-
-export const noopPluginSupervisor = (flush: Effect.Effect<unknown> = Effect.void) =>
-  PluginSupervisor.Service.of({
-    flush: Effect.asVoid(flush),
-    initialized: Effect.asVoid(flush),
-    check: () => Effect.die("unused plugin.check"),
-    update: () => Effect.die("unused plugin.update"),
-    reload: () => Effect.die("unused plugin.reload"),
-  })

packages/core/test/fixture/prompt-location.ts

@@ -2,20 +2,17 @@ import { LocationServiceMap } from "@opencode-ai/core/location-service-map"
 import type { LocationServices } from "@opencode-ai/core/location-services"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor-service"
-import { PluginExecution } from "@opencode-ai/core/plugin/execution"
-import { noopPluginSupervisor } from "./plugin-supervisor"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { Layer, LayerMap } from "effect"
+import { Effect, Layer, LayerMap } from "effect"
 
 // Plain-prompt unit fixtures use virtual directories and need only the admission hook services.
 export const promptLocationLayer = Layer.effect(
   LocationServiceMap.Service,
   LayerMap.make(
     () =>
-      Layer.mergeAll(
+      Layer.merge(
         LayerNode.compile(PluginHooks.node),
-        PluginExecution.layer,
-        Layer.succeed(PluginSupervisor.Service, noopPluginSupervisor()),
+        Layer.succeed(PluginSupervisor.Service, { flush: Effect.void }),
       ) as Layer.Layer<LocationServices>,
   ),
 )

packages/core/test/fixture/tmpdir.ts

@@ -3,23 +3,34 @@ import os from "os"
 import path from "path"
 import { Effect } from "effect"
 
+type TempDir = { readonly path: string }
+
 export const tmpdir = async (prefix = "opencode-core-test-") => {
-  const dir = await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), prefix)))
+  const dir = await make(prefix)
   return {
     path: dir,
-    async [Symbol.asyncDispose]() {
-      await remove(dir)
+    [Symbol.asyncDispose]() {
+      return remove(dir)
     },
   }
 }
 
-export const withTempDir = <A, E, R>(body: (tmp: Awaited<ReturnType<typeof tmpdir>>) => Effect.Effect<A, E, R>) =>
+export const tmpdirScoped = (prefix = "opencode-core-test-") =>
+  Effect.acquireRelease(
+    Effect.tryPromise(() => make(prefix)),
+    (dir) => Effect.tryPromise(() => remove(dir)).pipe(Effect.orDie),
+  ).pipe(Effect.map((path) => ({ path })))
+
+export const withTempDir = <A, E, R>(body: (tmp: TempDir) => Effect.Effect<A, E, R>) =>
   Effect.acquireUseRelease(
-    Effect.promise(() => tmpdir()),
-    body,
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
+    Effect.tryPromise(() => make("opencode-core-test-")),
+    (path) => body({ path }),
+    (dir) => Effect.tryPromise(() => remove(dir)).pipe(Effect.orDie),
   )
 
+const make = async (prefix: string) => fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(), prefix)))
+
+// Bun's callback APIs expose short paths and can hang during recursive removal on Windows.
 async function remove(dir: string, retries = 30): Promise<void> {
   try {
     await fs.rm(dir, { recursive: true, force: true })

packages/core/test/generate.test.ts

@@ -65,7 +65,7 @@ const aisdk = Layer.mock(AISDK.Service, {
   },
   model: () => Effect.succeed(runtime),
 })
-const client = TestLLM.clientLayer.pipe(Layer.provide(TestLLM.layer({ fallback: TestLLM.text("OK", "generate") })))
+const client = TestLLM.testLayer({ fallback: TestLLM.text("OK", "generate") })
 
 const resolver = ModelResolver.layer.pipe(Layer.provide(Layer.mergeAll(catalog, integrations, npm, aisdk)))
 const it = testEffect(Generate.layer.pipe(Layer.provide(Layer.merge(resolver, client))))

packages/core/test/location-layer.test.ts

@@ -304,7 +304,7 @@ describe("LocationServiceMap", () => {
     ),
   )
 
-  itWithSdk.live("reconciles Config updates during startup without restarting unchanged plugins", () =>
+  itWithSdk.live("reruns activation for Config updates during startup", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
       (dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
@@ -316,14 +316,18 @@ describe("LocationServiceMap", () => {
           yield* Effect.promise(() => fs.writeFile(file, "{}"))
           const firstStarted = yield* Deferred.make<void>()
           const releaseFirst = yield* Deferred.make<void>()
+          const secondStarted = yield* Deferred.make<void>()
+          const releaseSecond = yield* Deferred.make<void>()
           const sdk = yield* SdkPlugins.Service
           yield* sdk.register(
             EffectPlugin.define({
               id: "blocked-config-reload",
               effect: () =>
                 Effect.sync(() => ++activations.count).pipe(
-                  Effect.andThen(
-                    Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst))),
+                  Effect.flatMap((activation) =>
+                    activation === 1
+                      ? Deferred.succeed(firstStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseFirst)))
+                      : Deferred.succeed(secondStarted, undefined).pipe(Effect.andThen(Deferred.await(releaseSecond))),
                   ),
                 ),
             }),
@@ -351,17 +355,12 @@ describe("LocationServiceMap", () => {
             Effect.provide(context),
             Effect.forkChild,
           )
-          const initialFiber = yield* PluginSupervisor.Service.use((supervisor) => supervisor.initialized).pipe(
-            Effect.provide(context),
-            Effect.forkChild({ startImmediately: true }),
-          )
-          expect(initialFiber.pollUnsafe()).toBeUndefined()
           yield* Deferred.succeed(releaseFirst, undefined)
+          yield* Deferred.await(secondStarted)
+          expect(flushFiber.pollUnsafe()).toBeUndefined()
+          yield* Deferred.succeed(releaseSecond, undefined)
           yield* Fiber.join(flushFiber)
-          yield* Fiber.join(initialFiber)
-          expect(activations.count).toBe(1)
-          const inventory = yield* Plugin.Service.use((plugins) => plugins.list()).pipe(Effect.provide(context))
-          expect(inventory.map((plugin) => plugin.id)).toContain(Plugin.ID.make("config-effect-plugin"))
+          expect(activations.count).toBe(2)
         }),
       ),
     ),

packages/core/test/mcp.test.ts

@@ -205,7 +205,6 @@ function resourceMcpLayer(
               Config.Service,
               Config.Service.of({
                 entries: overrides.entries,
-                update: () => Effect.die("unused config update"),
                 changes: () => Stream.never,
               }),
             )

packages/core/test/npm.test.ts

@@ -2,12 +2,11 @@ import fs from "fs/promises"
 import path from "path"
 import { pathToFileURL } from "url"
 import { describe, expect, test } from "bun:test"
-import { Cause, Effect, Exit, Fiber, Layer } from "effect"
+import { Effect } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Global } from "@opencode-ai/util/global"
 import { Npm } from "@opencode-ai/util/npm"
-import { tmpdir, withTempDir } from "./fixture/tmpdir"
-import { testEffect } from "./lib/effect"
+import { tmpdir } from "./fixture/tmpdir"
 
 const win = process.platform === "win32"
 
@@ -28,27 +27,12 @@ async function createGitFixture(directory: string) {
   await fs.mkdir(path.join(repository, "dependency"), { recursive: true })
   await writePackage(repository, {
     name: "fixture-git-plugin",
-    type: "module",
-    exports: { ".": "./index.js", "./cjs": "./index.cjs" },
+    exports: "./index.js",
     dependencies: { "fixture-dependency": "file:./dependency" },
   })
-  await writePackage(path.join(repository, "dependency"), {
-    name: "fixture-dependency",
-    type: "module",
-    exports: { import: "./index.js", require: "./index.cjs" },
-  })
-  await Bun.write(
-    path.join(repository, "index.js"),
-    'import { dependency } from "fixture-dependency"\nimport { relative } from "./relative.js"\nexport default { root: true }\nexport { dependency, relative }\n',
-  )
-  await Bun.write(path.join(repository, "relative.js"), 'export const relative = { value: "first" }\n')
-  await Bun.write(path.join(repository, "dependency", "index.js"), 'export const dependency = { value: "first" }\n')
-  await Bun.write(
-    path.join(repository, "index.cjs"),
-    'module.exports = { relative: require("./relative.cjs"), dependency: require("fixture-dependency") }\n',
-  )
-  await Bun.write(path.join(repository, "relative.cjs"), 'module.exports = { value: "first" }\n')
-  await Bun.write(path.join(repository, "dependency", "index.cjs"), 'module.exports = { value: "first" }\n')
+  await writePackage(path.join(repository, "dependency"), { name: "fixture-dependency", exports: "./index.js" })
+  await Bun.write(path.join(repository, "index.js"), "export default { root: true }\n")
+  await Bun.write(path.join(repository, "dependency", "index.js"), "export const dependency = true\n")
 
   const subdirectory = path.join(repository, "packages", "subdirectory-plugin")
   await fs.mkdir(path.join(subdirectory, "dependency"), { recursive: true })
@@ -71,123 +55,6 @@ async function createGitFixture(directory: string) {
   return { repository, commit }
 }
 
-async function advanceGitFixture(repository: string, value: string) {
-  await Bun.write(path.join(repository, "relative.js"), `export const relative = { value: ${JSON.stringify(value)} }\n`)
-  await Bun.write(
-    path.join(repository, "dependency", "index.js"),
-    `export const dependency = { value: ${JSON.stringify(value)} }\n`,
-  )
-  await Bun.write(path.join(repository, "relative.cjs"), `module.exports = { value: ${JSON.stringify(value)} }\n`)
-  await Bun.write(
-    path.join(repository, "dependency", "index.cjs"),
-    `module.exports = { value: ${JSON.stringify(value)} }\n`,
-  )
-  await Bun.$`git -C ${repository} add .`
-  await Bun.$`git -C ${repository} -c user.name=fixture -c user.email=fixture@example.com commit -qm ${value}`
-  return Bun.$`git -C ${repository} rev-parse HEAD`.text().then((value) => value.trim())
-}
-
-async function createRegistryFixture(directory: string) {
-  const tarballs = new Map<string, Uint8Array>()
-  for (const version of ["1.0.0", "1.1.0", "1.2.0"]) {
-    const root = path.join(directory, version)
-    const pkg = path.join(root, "package")
-    await fs.mkdir(pkg, { recursive: true })
-    await writePackage(pkg, {
-      name: "@fixture/registry-plugin",
-      version,
-      type: "module",
-      exports: { ".": "./index.js", "./tui": "./index.js" },
-      dependencies: { "@fixture/registry-dependency": "^1.0.0" },
-    })
-    await Bun.write(
-      path.join(pkg, "index.js"),
-      'export { relative } from "./relative.js"\nexport { dependency } from "@fixture/registry-dependency"\n',
-    )
-    await Bun.write(path.join(pkg, "relative.js"), `export const relative = { value: ${JSON.stringify(version)} }\n`)
-    await Bun.$`tar -czf ${path.join(root, "package.tgz")} -C ${root} package`
-    tarballs.set(version, await Bun.file(path.join(root, "package.tgz")).bytes())
-  }
-  for (const version of ["1.0.0", "1.1.0"]) {
-    const root = path.join(directory, `dependency-${version}`)
-    const pkg = path.join(root, "package")
-    await fs.mkdir(pkg, { recursive: true })
-    await writePackage(pkg, { name: "@fixture/registry-dependency", version, type: "module", exports: "./index.js" })
-    await Bun.write(path.join(pkg, "index.js"), `export const dependency = { value: ${JSON.stringify(version)} }\n`)
-    await Bun.$`tar -czf ${path.join(root, "package.tgz")} -C ${root} package`
-    tarballs.set(`dependency-${version}`, await Bun.file(path.join(root, "package.tgz")).bytes())
-  }
-  const state = {
-    latest: "1.0.0",
-    dependency: "1.0.0",
-    requests: 0,
-    offline: false,
-    beforeTarball: () => Promise.resolve(),
-  }
-  const server = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    async fetch(request) {
-      state.requests++
-      if (state.offline) return new Response("offline", { status: 503 })
-      if (request.headers.get("authorization") !== "Bearer fixture-only-token")
-        return new Response("unauthorized", { status: 401 })
-      const url = new URL(request.url)
-      if (decodeURIComponent(url.pathname) === "/@fixture/registry-dependency")
-        return Response.json({
-          name: "@fixture/registry-dependency",
-          "dist-tags": { latest: state.dependency },
-          versions: Object.fromEntries(
-            ["1.0.0", ...(state.dependency === "1.1.0" ? ["1.1.0"] : [])].map((version) => [
-              version,
-              {
-                name: "@fixture/registry-dependency",
-                version,
-                dist: { tarball: `${url.origin}/tarball/dependency-${version}.tgz` },
-              },
-            ]),
-          ),
-        })
-      if (decodeURIComponent(url.pathname) === "/@fixture/registry-plugin")
-        return Response.json({
-          name: "@fixture/registry-plugin",
-          "dist-tags": { latest: state.latest },
-          versions: Object.fromEntries(
-            ["1.0.0", "1.1.0", "1.2.0", "1.3.0"].map((version) => [
-              version,
-              {
-                name: "@fixture/registry-plugin",
-                version,
-                dependencies: { "@fixture/registry-dependency": "^1.0.0" },
-                dist: { tarball: `${url.origin}/tarball/${version}.tgz` },
-              },
-            ]),
-          ),
-        })
-      const tarball = tarballs.get(url.pathname.replace("/tarball/", "").replace(".tgz", ""))
-      if (tarball) await state.beforeTarball()
-      return tarball ? new Response(tarball) : new Response("missing tarball", { status: 404 })
-    },
-  })
-  return {
-    state,
-    async configure(cache: string, spec: string) {
-      const root = path.join(cache, "packages", await Npm.cacheKey(spec))
-      await fs.mkdir(root, { recursive: true })
-      await Bun.write(
-        path.join(root, ".npmrc"),
-        `registry=${server.url}\n@fixture:registry=${server.url}\n//${server.url.host}/:_authToken=fixture-only-token\ncache=${path.join(directory, "npm-cache")}\nfetch-retries=0\naudit=false\n`,
-      )
-      return root
-    },
-    async [Symbol.asyncDispose]() {
-      await server.stop(true)
-    },
-  }
-}
-
-const it = testEffect(Layer.empty)
-
 describe("Npm.sanitize", () => {
   test("keeps normal scoped package specs unchanged", () => {
     expect(Npm.sanitize("@opencode/acme")).toBe("@opencode/acme")
@@ -336,10 +203,7 @@ describe("Npm.add", () => {
       expect(
         await fs.stat(path.join(path.dirname(entries.added.directory), "fixture-dependency", "package.json")),
       ).toBeTruthy()
-      expect(entries.added.directory).toContain(
-        path.join("packages", await Npm.cacheKey(spec), "generations", entries.added.generation, "node_modules"),
-      )
-      expect(entries.added.revision).toBe(fixture.commit)
+      expect(entries.added.directory).toContain(path.join("packages", await Npm.cacheKey(spec), "node_modules"))
     }
   })
 
@@ -357,15 +221,6 @@ describe("Npm.add", () => {
     expect(
       await fs.stat(path.join(path.dirname(entry.directory), "fixture-subdirectory-dependency", "package.json")),
     ).toBeTruthy()
-    await advanceGitFixture(fixture.repository, "second")
-    const exact = await Effect.gen(function* () {
-      const npm = yield* Npm.Service
-      return yield* npm.add(`git+file://${fixture.repository}#fixture-branch::path:packages/subdirectory-plugin`, {
-        revision: fixture.commit,
-      })
-    }).pipe(Effect.provide(npmLayer(path.join(tmp.path, "cache"))), Effect.runPromise)
-    expect(exact.revision).toBe(fixture.commit)
-    expect(exact.directory).toEndWith(path.join("node_modules", "fixture-subdirectory-plugin"))
   })
 
   // Several real Git installs and refreshes exceed Bun's default timeout on Windows.
@@ -438,427 +293,3 @@ describe("Npm.resolve", () => {
     expect(resolved.entrypoint).toEndWith("/tui.js")
   })
 })
-
-describe("Npm generations", () => {
-  it.live(
-    "loads the cached immutable graph while an updater holds the install lock",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.acquireRelease(
-          Effect.promise(() => createRegistryFixture(tmp.path)),
-          (fixture) => Effect.promise(() => fixture[Symbol.asyncDispose]()),
-        )
-        const cache = path.join(tmp.path, "cache")
-        const spec = "@fixture/registry-plugin@latest"
-        yield* Effect.promise(() => fixture.configure(cache, spec))
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const first = yield* npm.add(spec, { refresh: true })
-          fixture.state.latest = "1.1.0"
-          fixture.state.dependency = "1.1.0"
-          const started = Promise.withResolvers<void>()
-          const resume = Promise.withResolvers<void>()
-          fixture.state.beforeTarball = () => {
-            started.resolve()
-            return resume.promise
-          }
-          const updating = yield* npm.update(spec).pipe(Effect.forkScoped)
-          yield* Effect.gen(function* () {
-            yield* Effect.promise(() => started.promise).pipe(Effect.timeout("5 seconds"))
-            const adding = yield* Effect.all([
-              npm.add(spec),
-              npm.add(spec, { revision: first.revision, subpaths: ["tui"] }),
-              npm.add(spec, { refresh: true }),
-            ]).pipe(Effect.forkScoped)
-            // Timeout the join, not uninterruptible lock acquisition; release the updater before scoped cleanup.
-            expect(yield* Fiber.join(adding).pipe(Effect.timeout("5 seconds"))).toEqual([first, first, first])
-            expect(updating.pollUnsafe()).toBeUndefined()
-          }).pipe(Effect.ensuring(Effect.sync(() => resume.resolve())))
-          const updated = yield* Fiber.join(updating)
-          expect(updated.revision).toBe("1.1.0")
-          expect(updated.generation).not.toBe(first.generation)
-          expect(yield* npm.add(spec)).toEqual(updated)
-          const retained = yield* Effect.promise(() => import(first.entrypoint ?? ""))
-          expect(retained.relative.value).toBe("1.0.0")
-          expect(retained.dependency.value).toBe("1.0.0")
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-    30_000,
-  )
-
-  it.live(
-    "reloads the retained local generation when the same npm revision acquired a different dependency graph",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.acquireRelease(
-          Effect.promise(() => createRegistryFixture(tmp.path)),
-          (fixture) => Effect.promise(() => fixture[Symbol.asyncDispose]()),
-        )
-        const cache = path.join(tmp.path, "cache")
-        const spec = "@fixture/registry-plugin@latest"
-        const pinned = "@fixture/registry-plugin@1.0.0"
-        const root = yield* Effect.promise(() => fixture.configure(cache, spec))
-        yield* Effect.promise(() => fixture.configure(cache, pinned))
-        const entries = yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const first = yield* npm.add(spec)
-          const loaded = yield* Effect.promise(() => import(first.entrypoint ?? ""))
-          expect(loaded.dependency.value).toBe("1.0.0")
-          fixture.state.dependency = "1.1.0"
-          const second = yield* npm.update(spec)
-          expect(second.revision).toBe(first.revision)
-          expect(second.generation).not.toBe(first.generation)
-          expect((yield* Effect.promise(() => import(second.entrypoint ?? ""))).dependency.value).toBe("1.1.0")
-          expect(yield* npm.resolve(spec, { revision: first.revision })).toEqual(second)
-          const foreign = yield* npm.add(pinned)
-          return { first, second, foreign, loaded }
-        }).pipe(Effect.provide(npmLayer(cache)))
-        fixture.state.offline = true
-        const requests = fixture.state.requests
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          expect(yield* npm.resolve(spec)).toEqual(entries.second)
-          expect((yield* npm.reload(spec, { generation: "../../outside" }).pipe(Effect.flip))._tag).toBe(
-            "NpmInstallFailedError",
-          )
-          expect((yield* npm.reload(spec, { generation: entries.foreign.generation }).pipe(Effect.flip))._tag).toBe(
-            "NpmInstallFailedError",
-          )
-          expect(
-            (yield* npm.reload(spec, { generation: entries.first.generation, revision: "1.1.0" }).pipe(Effect.flip))
-              ._tag,
-          ).toBe("NpmInstallFailedError")
-          expect(yield* npm.resolve(spec)).toEqual(entries.second)
-          const reloaded = yield* npm.reload(spec, {
-            generation: entries.first.generation,
-            revision: entries.first.revision,
-          })
-          expect(reloaded.revision).toBe(entries.first.revision)
-          expect(reloaded.generation).not.toBe(entries.first.generation)
-          const fresh = yield* Effect.promise(() => import(reloaded.entrypoint ?? ""))
-          expect(fresh.dependency.value).toBe("1.0.0")
-          expect(fresh.dependency).not.toBe(entries.loaded.dependency)
-          expect(yield* npm.resolve(spec)).toEqual(reloaded)
-          expect(fixture.state.requests).toBe(requests)
-          expect(
-            yield* Effect.promise(() =>
-              Bun.file(path.join(root, "generations", entries.first.generation, "generation.json")).json(),
-            ),
-          ).toEqual({ name: "@fixture/registry-plugin", generation: entries.first.generation, revision: "1.0.0" })
-          expect(
-            yield* Effect.promise(() =>
-              Bun.file(path.join(path.dirname(entries.second.directory), "registry-dependency", "index.js")).text(),
-            ),
-          ).toContain('"1.1.0"')
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-    30_000,
-  )
-
-  it.live(
-    "defers cancellation through publication without removing the committed generation",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.acquireRelease(
-          Effect.promise(() => createRegistryFixture(tmp.path)),
-          (fixture) => Effect.promise(() => fixture[Symbol.asyncDispose]()),
-        )
-        const cache = path.join(tmp.path, "cache")
-        const spec = "@fixture/registry-plugin@latest"
-        const root = yield* Effect.promise(() => fixture.configure(cache, spec))
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const first = yield* npm.add(spec)
-          fixture.state.latest = "1.1.0"
-          const started = Promise.withResolvers<void>()
-          const resume = Promise.withResolvers<void>()
-          fixture.state.beforeTarball = () => {
-            started.resolve()
-            return resume.promise
-          }
-          const updating = yield* npm.update(spec).pipe(Effect.forkScoped)
-          yield* Effect.promise(() => started.promise)
-          updating.interruptUnsafe()
-          expect(updating.pollUnsafe()).toBeUndefined()
-          resume.resolve()
-          const exit = yield* Fiber.await(updating)
-          expect(Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause)).toBe(true)
-          // The pending interrupt is observed after publication, outside staging's cleanup boundary.
-          const published = yield* npm.resolve(spec)
-          expect(published.revision).toBe("1.1.0")
-          expect(published.generation).not.toBe(first.generation)
-          expect((yield* Effect.promise(() => import(published.entrypoint ?? ""))).relative.value).toBe("1.1.0")
-          expect(yield* Effect.promise(() => Bun.file(path.join(first.directory, "relative.js")).text())).toContain(
-            '"1.0.0"',
-          )
-          expect((yield* Effect.promise(() => fs.readdir(path.join(root, "generations")))).length).toBe(2)
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-    30_000,
-  )
-
-  it.live(
-    "finds binaries in published generations and keeps their old files usable after reload",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = path.join(tmp.path, "binary")
-        yield* Effect.promise(async () => {
-          await fs.mkdir(fixture)
-          await writePackage(fixture, {
-            name: "fixture-bin",
-            bin: { "fixture-bin": "./cli.js", "fixture-other": "./other.js" },
-          })
-          await Bun.write(path.join(fixture, "cli.js"), '#!/usr/bin/env node\nconsole.log(require("./value.cjs"))\n')
-          await Bun.write(path.join(fixture, "value.cjs"), 'module.exports = "fixture"\n')
-          await Bun.write(path.join(fixture, "other.js"), '#!/usr/bin/env node\nconsole.log("other")\n')
-        })
-        const spec = `fixture-bin@file:${fixture}`
-        const cache = path.join(tmp.path, "cache")
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const binary = yield* npm.which(spec)
-          expect(binary).toEndWith(path.join(".bin", "fixture-bin"))
-          expect(yield* npm.which(spec, "fixture-other")).toEndWith(path.join(".bin", "fixture-other"))
-          expect(yield* npm.which(spec, "missing")).toBeUndefined()
-          const original = yield* npm.resolve(spec)
-          const reloaded = yield* npm.reload(spec)
-          expect(reloaded.generation).not.toBe(original.generation)
-          const fresh = yield* npm.which(spec)
-          expect(fresh).not.toBe(binary)
-          expect(fresh).toContain(reloaded.generation)
-          expect(yield* Effect.promise(() => Bun.file(binary ?? "").text())).toContain("value.cjs")
-          expect(yield* Effect.promise(() => Bun.file(fresh ?? "").text())).toContain("value.cjs")
-          if (!win)
-            yield* Effect.promise(async () => {
-              const child = Bun.spawn([process.execPath, fresh ?? ""], { stdout: "pipe", stderr: "pipe" })
-              expect(await child.exited, await new Response(child.stderr).text()).toBe(0)
-              expect(await new Response(child.stdout).text()).toBe("fixture\n")
-            })
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-  )
-
-  it.live(
-    "checks without changing files, updates repeatedly, preserves pins, and reloads the whole Git graph offline",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.promise(() => createGitFixture(tmp.path))
-        const cache = path.join(tmp.path, "cache")
-        const spec = `git+${pathToFileURL(fixture.repository).href}#fixture-branch`
-        const pinned = `git+${pathToFileURL(fixture.repository).href}#${fixture.commit}`
-        const entries = yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const first = yield* npm.add(spec, { refresh: true })
-          const pin = yield* npm.add(pinned)
-          const firstModule = yield* Effect.promise(() => import(first.entrypoint ?? ""))
-          expect(firstModule.relative.value).toBe("first")
-          expect(firstModule.dependency.value).toBe("first")
-          const secondCommit = yield* Effect.promise(() => advanceGitFixture(fixture.repository, "second"))
-          expect(yield* npm.check(spec)).toEqual({ installed: fixture.commit, available: secondCommit, mutable: true })
-          expect(yield* npm.resolve(spec)).toEqual(first)
-          expect(yield* npm.add(spec, { refresh: true })).toEqual(first)
-          const second = yield* npm.update(spec)
-          expect(second.revision).toBe(secondCommit)
-          const secondModule = yield* Effect.promise(() => import(second.entrypoint ?? ""))
-          expect(secondModule.relative.value).toBe("second")
-          expect(secondModule.dependency.value).toBe("second")
-          expect(second.generation).not.toBe(first.generation)
-          const thirdCommit = yield* Effect.promise(() => advanceGitFixture(fixture.repository, "third"))
-          const third = yield* npm.update(spec)
-          expect(third.revision).toBe(thirdCommit)
-          const thirdModule = yield* Effect.promise(() => import(third.entrypoint ?? ""))
-          expect(thirdModule.relative.value).toBe("third")
-          expect(thirdModule.dependency.value).toBe("third")
-          const thirdCjs = yield* npm.resolve(spec, { subpaths: ["cjs"] })
-          const thirdCommonJs = yield* Effect.promise(() => import(thirdCjs.entrypoint ?? ""))
-          expect(thirdCommonJs.default.relative.value).toBe("third")
-          expect(thirdCommonJs.default.dependency.value).toBe("third")
-          expect(yield* npm.check(pinned)).toEqual({
-            installed: fixture.commit,
-            available: fixture.commit,
-            mutable: false,
-          })
-          expect(yield* npm.update(pinned)).toEqual(pin)
-          const companionCommit = yield* Effect.promise(() => advanceGitFixture(fixture.repository, "companion"))
-          const companion = yield* npm.add(spec, { revision: companionCommit })
-          expect(companion.revision).toBe(companionCommit)
-          expect((yield* Effect.promise(() => import(companion.entrypoint ?? ""))).dependency.value).toBe("companion")
-          expect(yield* npm.resolve(spec)).toEqual(third)
-          expect(yield* npm.resolve(spec, { revision: companionCommit })).toEqual(companion)
-          yield* Effect.promise(() => fs.rename(fixture.repository, `${fixture.repository}-offline`))
-          const root = path.join(cache, "packages", yield* Effect.promise(() => Npm.cacheKey(spec)))
-          const before = yield* Effect.promise(() => fs.readdir(path.join(root, "generations")))
-          expect((yield* npm.update(spec).pipe(Effect.flip))._tag).toBe("NpmInstallFailedError")
-          expect(yield* Effect.promise(() => fs.readdir(path.join(root, "generations")))).toEqual(before)
-          expect(yield* npm.resolve(spec)).toEqual(third)
-          const reloaded = yield* npm.reload(spec)
-          expect(reloaded.revision).toBe(thirdCommit)
-          expect(reloaded.generation).not.toBe(third.generation)
-          const reloadedModule = yield* Effect.promise(() => import(reloaded.entrypoint ?? ""))
-          expect(reloadedModule.relative).toEqual(thirdModule.relative)
-          expect(reloadedModule.relative).not.toBe(thirdModule.relative)
-          expect(reloadedModule.dependency).not.toBe(thirdModule.dependency)
-          const freshCjs = yield* npm.resolve(spec, { subpaths: ["cjs"] })
-          const freshCommonJs = yield* Effect.promise(() => import(freshCjs.entrypoint ?? ""))
-          expect(freshCommonJs.default.relative).not.toBe(thirdCommonJs.default.relative)
-          expect(freshCommonJs.default.dependency).not.toBe(thirdCommonJs.default.dependency)
-          const exactReload = yield* npm.reload(spec, { revision: companionCommit })
-          expect(exactReload.revision).toBe(companionCommit)
-          expect(yield* npm.resolve(spec)).toEqual(reloaded)
-          expect(yield* npm.update(pinned)).toEqual(pin)
-          expect(yield* Effect.promise(() => Bun.file(path.join(first.directory, "relative.js")).text())).toContain(
-            '"first"',
-          )
-          expect(yield* Effect.promise(() => Bun.file(path.join(second.directory, "relative.js")).text())).toContain(
-            '"second"',
-          )
-          return { first, third, reloaded, exactReload, thirdCjs, freshCjs }
-        }).pipe(Effect.provide(npmLayer(cache)))
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          expect(yield* npm.resolve(spec)).toEqual(entries.reloaded)
-          expect(yield* npm.inspect(spec)).toEqual({ installed: entries.third.revision, mutable: true })
-          expect(yield* npm.resolve(spec, { revision: entries.exactReload.revision })).toEqual(entries.exactReload)
-        }).pipe(Effect.provide(npmLayer(cache)))
-        // Exercise the same realpaths in Node's ESM loader as well as Bun's loader above.
-        const node = Bun.which("node")
-        if (node)
-          yield* Effect.promise(async () => {
-            const script = `
-        import assert from "node:assert/strict";
-        const first = await import(${JSON.stringify(entries.first.entrypoint)});
-        const third = await import(${JSON.stringify(entries.third.entrypoint)});
-        const fresh = await import(${JSON.stringify(entries.reloaded.entrypoint)});
-        assert.equal(first.relative.value, "first");
-        assert.equal(third.relative.value, "third");
-        assert.equal(third.dependency.value, "third");
-        assert.notEqual(fresh.relative, third.relative);
-        assert.notEqual(fresh.dependency, third.dependency);
-        const thirdCjs = await import(${JSON.stringify(entries.thirdCjs.entrypoint)});
-        const freshCjs = await import(${JSON.stringify(entries.freshCjs.entrypoint)});
-        assert.equal(thirdCjs.default.relative.value, "third");
-        assert.equal(thirdCjs.default.dependency.value, "third");
-        assert.notEqual(freshCjs.default.relative, thirdCjs.default.relative);
-        assert.notEqual(freshCjs.default.dependency, thirdCjs.default.dependency);
-      `
-            const child = Bun.spawn([node, "--input-type=module", "-e", script], { stdout: "pipe", stderr: "pipe" })
-            expect(await child.exited, await new Response(child.stderr).text()).toBe(0)
-          })
-      }),
-    ),
-    30_000,
-  )
-
-  it.live(
-    "auto-refreshes a legacy Git install once without overwriting it",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.promise(() => createGitFixture(tmp.path))
-        const cache = path.join(tmp.path, "cache")
-        const spec = `git+${pathToFileURL(fixture.repository).href}#fixture-branch`
-        const root = path.join(cache, "packages", yield* Effect.promise(() => Npm.cacheKey(spec)))
-        const initial = yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          return yield* npm.add(spec)
-        }).pipe(Effect.provide(npmLayer(cache)))
-        yield* Effect.promise(async () => {
-          // Recreate the shipped pre-generation cache layout, including its real npm lockfile.
-          await fs.cp(path.join(root, "generations", initial.generation), root, { recursive: true, dereference: true })
-          await fs.rm(path.join(root, "current.json"))
-          await fs.rm(path.join(root, "revisions"), { recursive: true })
-          await fs.rm(path.join(root, "generations"), { recursive: true })
-        })
-        const secondCommit = yield* Effect.promise(() => advanceGitFixture(fixture.repository, "second"))
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          const legacy = yield* npm.resolve(spec)
-          expect(legacy.revision).toBe(fixture.commit)
-          expect(legacy.generation).toStartWith("legacy-")
-          const updated = yield* npm.add(spec, { refresh: true })
-          expect(updated.revision).toBe(secondCommit)
-          expect(updated.directory).not.toBe(legacy.directory)
-          yield* Effect.promise(() => advanceGitFixture(fixture.repository, "third"))
-          expect(yield* npm.add(spec, { refresh: true })).toEqual(updated)
-          expect(yield* Effect.promise(() => Bun.file(path.join(legacy.directory, "relative.js")).text())).toContain(
-            '"first"',
-          )
-          yield* Effect.promise(() => fs.rename(fixture.repository, `${fixture.repository}-offline`))
-          const reloaded = yield* npm.reload(spec, { generation: legacy.generation, revision: legacy.revision })
-          expect(reloaded.revision).toBe(fixture.commit)
-          expect((yield* Effect.promise(() => import(reloaded.entrypoint ?? ""))).dependency.value).toBe("first")
-          expect(yield* npm.resolve(spec)).toEqual(updated)
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-    30_000,
-  )
-
-  it.live(
-    "uses npm configuration, stages exact registry revisions, and retains the old graph after a failed tarball",
-    withTempDir((tmp) =>
-      Effect.gen(function* () {
-        const fixture = yield* Effect.acquireRelease(
-          Effect.promise(() => createRegistryFixture(tmp.path)),
-          (fixture) => Effect.promise(() => fixture[Symbol.asyncDispose]()),
-        )
-        const cache = path.join(tmp.path, "cache")
-        const spec = "@fixture/registry-plugin@latest"
-        const pinned = "@fixture/registry-plugin@1.0.0"
-        const root = yield* Effect.promise(() => fixture.configure(cache, spec))
-        yield* Effect.promise(() => fixture.configure(cache, pinned))
-        const updated = yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          expect(yield* npm.inspect(spec)).toEqual({ installed: undefined, mutable: true })
-          expect(yield* npm.check(spec)).toEqual({ installed: undefined, available: "1.0.0", mutable: true })
-          expect((yield* npm.resolve(spec)).entrypoint).toBeUndefined()
-          const first = yield* npm.add(spec, { refresh: true })
-          const pin = yield* npm.add(pinned)
-          const firstModule = yield* Effect.promise(() => import(first.entrypoint ?? ""))
-          fixture.state.latest = "1.1.0"
-          expect(yield* npm.check(spec)).toEqual({ installed: "1.0.0", available: "1.1.0", mutable: true })
-          expect(yield* npm.resolve(spec)).toEqual(first)
-          const second = yield* npm.update(spec, { subpaths: [""] })
-          expect(second.revision).toBe("1.1.0")
-          expect((yield* Effect.promise(() => import(second.entrypoint ?? ""))).relative.value).toBe("1.1.0")
-          expect((yield* npm.update(spec, { subpaths: ["missing"] }).pipe(Effect.flip))._tag).toBe(
-            "NpmInstallFailedError",
-          )
-          expect(yield* npm.resolve(spec)).toEqual(second)
-          const companion = yield* npm.add(spec, { revision: "1.2.0", subpaths: ["tui"] })
-          expect(companion.revision).toBe("1.2.0")
-          expect(yield* npm.resolve(spec)).toEqual(second)
-          fixture.state.latest = "1.3.0"
-          expect((yield* npm.check(spec)).available).toBe("1.3.0")
-          const before = yield* Effect.promise(() => fs.readdir(path.join(root, "generations")))
-          expect((yield* npm.update(spec).pipe(Effect.flip))._tag).toBe("NpmInstallFailedError")
-          expect(yield* Effect.promise(() => fs.readdir(path.join(root, "generations")))).toEqual(before)
-          expect(yield* npm.resolve(spec)).toEqual(second)
-          expect((yield* npm.add(spec, { revision: "latest" }).pipe(Effect.flip))._tag).toBe("NpmInstallFailedError")
-          const requests = fixture.state.requests
-          fixture.state.offline = true
-          expect(yield* npm.check(pinned)).toEqual({ installed: "1.0.0", available: "1.0.0", mutable: false })
-          expect(yield* npm.update(pinned)).toEqual(pin)
-          const reloaded = yield* npm.reload(spec)
-          expect(reloaded.revision).toBe("1.1.0")
-          expect(fixture.state.requests).toBe(requests)
-          expect((yield* Effect.promise(() => import(reloaded.entrypoint ?? ""))).relative.value).toBe("1.1.0")
-          expect(firstModule.relative.value).toBe("1.0.0")
-          expect(yield* Effect.promise(() => Bun.file(path.join(first.directory, "relative.js")).text())).toContain(
-            '"1.0.0"',
-          )
-          return reloaded
-        }).pipe(Effect.provide(npmLayer(cache)))
-        yield* Effect.gen(function* () {
-          const npm = yield* Npm.Service
-          expect(yield* npm.resolve(spec)).toEqual(updated)
-          expect((yield* npm.resolve(spec, { revision: "1.2.0" })).revision).toBe("1.2.0")
-        }).pipe(Effect.provide(npmLayer(cache)))
-      }),
-    ),
-    30_000,
-  )
-})

packages/core/test/plugin.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import { ToolFailure } from "@opencode-ai/ai"
-import { Cause, Context, Effect, Exit, Fiber, Latch, Schema, Stream } from "effect"
+import { Context, Effect, Exit, Fiber, Schema, Stream } from "effect"
 import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect"
 import { Config as ConfigSchema } from "@opencode-ai/schema/config"
 import { Agent } from "@opencode-ai/core/agent"
@@ -8,15 +8,15 @@ import { Bus } from "@opencode-ai/core/bus"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
-import { PluginExecution } from "@opencode-ai/core/plugin/execution"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { Location } from "@opencode-ai/core/location"
+import { PersistentPty } from "@opencode-ai/core/persistent-pty"
 import { Project } from "@opencode-ai/core/project"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Session } from "@opencode-ai/core/session"
 import { SessionMessage } from "@opencode-ai/core/session/message"
 import { Tool } from "@opencode-ai/core/tool"
 import { Vcs } from "@opencode-ai/core/vcs"
+import { Pty } from "@opencode-ai/schema/pty"
 import { testEffect } from "./lib/effect"
 import { PluginTestLayer } from "./plugin/fixture"
 
@@ -27,178 +27,54 @@ class Secret extends Context.Service<Secret, string>()("@opencode/test/PluginSec
 const versioned = <R>(plugin: EffectPlugin.Plugin<R>, version = "1") => ({ ...plugin, version })
 
 describe("Plugin", () => {
-  it.effect("closes the entire suffix after cleanup defects without leaving old hooks behind", () =>
+  it.effect("routes experimental terminal reads through the runtime cell without wrapping results", () =>
     Effect.gen(function* () {
       const plugins = yield* Plugin.Service
-      const registry = yield* PluginHooks.Service
-      const closed: string[] = []
-      const observed: string[] = []
-      const definition = (id: string, version: string, broken = false) => ({
-        id,
-        version,
-        effect: (ctx: EffectPlugin.Context) =>
-          Effect.gen(function* () {
-            yield* ctx.session.hook("prompt", () =>
-              Effect.sync(() => {
-                observed.push(`${id}${version}`)
-              }),
-            )
-            yield* Effect.addFinalizer(() =>
-              Effect.sync(() => {
-                closed.push(`${id}${version}`)
-                if (broken) throw new Error("cleanup failed")
-              }),
-            )
-          }),
-      })
-      const first = [definition("a", "1"), definition("b", "1"), definition("c", "1", true)]
-      yield* plugins.activate(first)
-      yield* plugins.activate([definition("a", "2"), ...first.slice(1)])
-      expect(closed).toEqual(["c1", "b1", "a1"])
-      expect((yield* plugins.list()).map((plugin) => [plugin.id, plugin.status])).toEqual(
-        ["a", "b", "c"].map((id) => [Plugin.ID.make(id), "active"]),
-      )
-      yield* plugins.activate([definition("a", "2"), definition("b", "2"), definition("c", "2")])
-      yield* registry.trigger("session", "prompt", {
-        sessionID: Session.ID.make("ses_cleanup"),
-        messageID: SessionMessage.ID.make("msg_cleanup"),
-        prompt: { text: "hello" },
-        delivery: "steer",
-        metadata: undefined,
-      })
-      expect(observed).toEqual(["a2", "b2", "c2"])
-      expect(closed).toEqual(["c1", "b1", "a1", "c1", "b1"])
-      yield* plugins.activate([])
-      expect(closed.slice(-3)).toEqual(["c2", "b2", "a2"])
-      expect(yield* plugins.list()).toEqual([])
-    }),
-  )
-  it.effect("does not gate an unchanged generation while a Session lease is held", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const gate = yield* PluginExecution.Service
-      const definitions = [{ id: "unchanged", version: "1", effect: () => Effect.void }]
-      yield* plugins.activate(definitions)
-      yield* gate.lease({ id: "running" }, plugins.activate(definitions))
-      expect((yield* plugins.list())[0]?.status).toBe("active")
-    }),
-  )
-  it.effect("bounds inventory errors and removes URL credentials and query strings", () =>
-    Effect.sync(() => {
-      const error = Plugin.errorMessage(
-        Cause.die(new Error(`https://user:password@example.com/plugin?token=secret ${"x".repeat(3000)}`)),
-      )
-      expect(error.length).toBeLessThanOrEqual(2000)
-      expect(error).toContain("https://example.com/plugin")
-      expect(error).not.toContain("password")
-      expect(error).not.toContain("token=secret")
-    }),
-  )
-  it.effect("keeps the unchanged registration prefix and preserves suffix ordering", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const agents = yield* Agent.Service
-      const loads: string[] = []
-      const closed: string[] = []
-      const definition = (id: string, version: string) => ({
-        id,
-        version,
-        effect: (ctx: EffectPlugin.Context) =>
-          Effect.gen(function* () {
-            loads.push(`${id}:${version}`)
-            yield* Effect.addFinalizer(() => Effect.sync(() => closed.push(id)))
-            yield* ctx.agent.transform((draft) =>
-              draft.update("ordered", (agent) => {
-                agent.description = `${agent.description ?? ""}${id}:${version};`
-              }),
-            )
-          }),
-      })
-      const prefix = definition("prefix", "1")
-      const suffix = definition("suffix", "1")
-      yield* plugins.activate([prefix, definition("target", "1"), suffix])
-      yield* plugins.activate([prefix, definition("target", "2"), suffix])
-      expect(loads).toEqual(["prefix:1", "target:1", "suffix:1", "target:2", "suffix:1"])
-      expect(closed).toEqual(["suffix", "target"])
-      expect((yield* agents.get(Agent.ID.make("ordered")))?.description).toBe("prefix:1;target:2;suffix:1;")
+      const runtime = yield* PluginRuntime.Service
+      const cell = PluginRuntime.makeCell()
+      const host = yield* PluginHost.make(plugins).pipe(Effect.provide(PluginRuntime.layerWithCell(cell)))
+      const sessionID = Session.ID.make("ses_terminal")
+      const pending = host.experimental.terminal.read({ sessionID, lines: 3 })
+      const seen: unknown[] = []
+      const terminal = {
+        ptyID: Pty.ID.make("pty_terminal"),
+        title: "Build",
+        cwd: "/workspace",
+        foregroundProcess: null,
+        screen: { text: "one\ntwo\nthree", cols: 80, rows: 2, cursor: { x: 3, y: 1 } },
+      }
+      const error = new PersistentPty.UnavailableError({ message: "terminal daemon unavailable" })
+      cell.runtime = {
+        ...runtime,
+        persistentPty: {
+          read: (id, lines) => {
+            seen.push({ sessionID: id, lines })
+            if (id === Session.ID.make("ses_failure")) return Effect.fail(error)
+            return Effect.succeed(id === sessionID ? terminal : null)
+          },
+        },
+      }
+
+      expect(Object.keys(host.experimental)).toEqual(["terminal"])
+      expect(Object.keys(host.experimental.terminal)).toEqual(["read"])
+      expect(yield* pending).toBe(terminal)
+      expect(yield* host.experimental.terminal.read({ sessionID })).toBe(terminal)
+      expect(yield* host.experimental.terminal.read({ sessionID: Session.ID.make("ses_empty") })).toBeNull()
+      expect(
+        yield* host.experimental.terminal.read({ sessionID: Session.ID.make("ses_failure") }).pipe(Effect.flip),
+      ).toBe(error)
+      expect(seen).toEqual([
+        { sessionID, lines: 3 },
+        { sessionID, lines: undefined },
+        { sessionID: Session.ID.make("ses_empty"), lines: undefined },
+        { sessionID: Session.ID.make("ses_failure"), lines: undefined },
+      ])
+
+      cell.runtime = undefined
+      expect(Exit.isFailure(yield* pending.pipe(Effect.exit))).toBe(true)
     }),
   )
 
-  it.effect("does not close plugin resources while a leased snapshot executes", () =>
-    Effect.gen(function* () {
-      const plugins = yield* Plugin.Service
-      const tools = yield* Tool.Service
-      const gate = yield* PluginExecution.Service
-      const started = yield* Latch.make()
-      const finish = yield* Latch.make()
-      let closed = false
-      yield* plugins.activate([
-        {
-          id: "leased",
-          version: "1",
-          revision: "1.0.0",
-          generation: "first",
-          tui: true,
-          effect: (ctx) =>
-            Effect.gen(function* () {
-              yield* Effect.addFinalizer(() =>
-                Effect.sync(() => {
-                  closed = true
-                }),
-              )
-              yield* ctx.tool.transform((draft) =>
-                draft.add({
-                  name: "leased",
-                  description: "Leased tool",
-                  input: Schema.Struct({}),
-                  options: { codemode: false },
-                  execute: () =>
-                    Effect.gen(function* () {
-                      yield* started.open
-                      yield* finish.await
-                      expect(closed).toBe(false)
-                      return { content: "first" }
-                    }),
-                }),
-              )
-            }),
-        },
-      ])
-      const running = yield* gate
-        .lease(
-          { id: "ses_running" },
-          Effect.gen(function* () {
-            const snapshot = yield* tools.snapshot()
-            return yield* snapshot.execute({
-              sessionID: Session.ID.make("ses_running"),
-              agent: Agent.ID.make("build"),
-              messageID: SessionMessage.ID.make("msg_message"),
-              call: { type: "tool-call", id: "call", name: "leased", input: {} },
-            })
-          }),
-        )
-        .pipe(Effect.forkScoped({ startImmediately: true }))
-      yield* started.await
-      const replacement = yield* plugins
-        .activate([
-          {
-            id: "leased",
-            version: "2",
-            revision: "2.0.0",
-            generation: "second",
-            effect: () => Effect.void,
-          },
-        ])
-        .pipe(Effect.forkScoped({ startImmediately: true }))
-      expect(closed).toBe(false)
-      expect((yield* plugins.list())[0]?.revision).toBe("1.0.0")
-      yield* finish.open
-      yield* Fiber.join(running)
-      yield* Fiber.join(replacement)
-      expect(closed).toBe(true)
-      expect((yield* plugins.list())[0]?.revision).toBe("2.0.0")
-    }),
-  )
   it.effect("exposes the current location to activated plugins", () =>
     Effect.gen(function* () {
       const plugins = yield* Plugin.Service
@@ -574,18 +450,16 @@ describe("Plugin", () => {
           }),
       })
 
-      yield* plugins.activate([{ ...versioned(previous), revision: "1.0.0", generation: "previous", tui: true }])
-      yield* plugins.activate([{ ...versioned(replacement, "2"), revision: "2.0.0", generation: "replacement" }])
+      yield* plugins.activate([versioned(previous)])
+      yield* plugins.activate([versioned(replacement, "2")])
 
       expect(yield* plugins.list()).toEqual([
         {
           id: Plugin.ID.make("managed"),
           source: { type: "builtin" },
-          status: "active",
+          status: "failed",
           error: expect.stringContaining("replacement failed"),
-          tui: true,
-          revision: "1.0.0",
-          generation: "previous",
+          tui: false,
         },
       ])
       expect((yield* agents.get(Agent.ID.make("configured")))?.description).toBe("previous")

packages/core/test/plugin/execution.test.ts

@@ -1,152 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Fiber, Latch } from "effect"
-import { PluginExecution } from "@opencode-ai/core/plugin/execution"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(PluginExecution.layer)
-
-it.effect("defers activation through awaited children and titles, blocking unrelated selections", () =>
-  Effect.gen(function* () {
-    const gate = yield* PluginExecution.Service
-    const childAllowed = yield* Latch.make()
-    const titleFinished = yield* Latch.make()
-    const events: string[] = []
-    const parent = yield* gate
-      .lease(
-        { id: "parent" },
-        Effect.gen(function* () {
-          yield* childAllowed.await
-          yield* gate.lease(
-            { id: "child", parentID: "parent" },
-            Effect.gen(function* () {
-              yield* gate.lease(
-                { id: "grandchild", parentID: "child" },
-                Effect.sync(() => events.push("child")),
-              )
-            }),
-          )
-          yield* gate.lease(
-            { id: "new-prompt", admission: true },
-            Effect.sync(() => events.push("admitted")),
-          )
-          events.push("parent")
-        }),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const title = yield* gate
-      .lease(
-        { id: "parent", admission: true },
-        titleFinished.await.pipe(Effect.andThen(Effect.sync(() => events.push("title")))),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const activation = yield* gate
-      .exclusive(Effect.sync(() => events.push("activation")))
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const unrelated = yield* gate
-      .lease(
-        { id: "unrelated" },
-        Effect.sync(() => events.push("selection")),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    expect(events).toEqual([])
-    yield* childAllowed.open
-    yield* Fiber.join(parent)
-    expect(events).toEqual(["child", "admitted", "parent"])
-    yield* titleFinished.open
-    yield* Fiber.join(title)
-    yield* Fiber.join(activation)
-    yield* Fiber.join(unrelated)
-    expect(events).toEqual(["child", "admitted", "parent", "title", "activation", "selection"])
-  }),
-)
-
-it.effect("releases reader leases and pending admission on interruption", () =>
-  Effect.gen(function* () {
-    const gate = yield* PluginExecution.Service
-    const reader = yield* gate.lease({ id: "reader" }, Effect.never).pipe(Effect.forkScoped({ startImmediately: true }))
-    const writer = yield* gate.exclusive(Effect.never).pipe(Effect.forkScoped({ startImmediately: true }))
-    const waiting = yield* gate
-      .lease({ id: "waiting" }, Effect.never)
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    yield* Fiber.interrupt(waiting)
-    yield* Fiber.interrupt(writer)
-    expect(yield* gate.lease({ id: "new" }, Effect.succeed("open"))).toBe("open")
-    yield* Fiber.interrupt(reader)
-    expect(yield* gate.exclusive(Effect.succeed("idle"))).toBe("idle")
-  }),
-)
-
-it.effect("does not let admission-only work establish same-Session or child execution ownership", () =>
-  Effect.gen(function* () {
-    const gate = yield* PluginExecution.Service
-    const finishParent = yield* Latch.make()
-    const finishAdmission = yield* Latch.make()
-    const events: string[] = []
-    const parent = yield* gate
-      .lease({ id: "parent" }, finishParent.await)
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const writer = yield* gate
-      .exclusive(Effect.sync(() => events.push("activation")))
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const admission = yield* gate
-      .lease({ id: "unrelated", admission: true }, finishAdmission.await)
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const unrelated = yield* gate
-      .lease(
-        { id: "unrelated" },
-        Effect.sync(() => events.push("unrelated")),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const child = yield* gate
-      .lease(
-        { id: "child", parentID: "unrelated" },
-        Effect.sync(() => events.push("child")),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    expect(events).toEqual([])
-    yield* finishParent.open
-    yield* Fiber.join(parent)
-    expect(events).toEqual([])
-    yield* finishAdmission.open
-    yield* Fiber.join(admission)
-    yield* Fiber.join(writer)
-    yield* Fiber.join(unrelated)
-    yield* Fiber.join(child)
-    expect(events[0]).toBe("activation")
-    expect(events.slice(1).toSorted()).toEqual(["child", "unrelated"])
-  }),
-)
-
-it.effect("a title-only helper protects its resources without allowing an idle Session or child to drain", () =>
-  Effect.gen(function* () {
-    const gate = yield* PluginExecution.Service
-    const finishTitle = yield* Latch.make()
-    const events: string[] = []
-    const title = yield* gate
-      .lease({ id: "idle", admission: true }, finishTitle.await)
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const writer = yield* gate
-      .exclusive(Effect.sync(() => events.push("activation")))
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const session = yield* gate
-      .lease(
-        { id: "idle" },
-        Effect.sync(() => events.push("session")),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    const child = yield* gate
-      .lease(
-        { id: "child", parentID: "idle" },
-        Effect.sync(() => events.push("child")),
-      )
-      .pipe(Effect.forkScoped({ startImmediately: true }))
-    expect(events).toEqual([])
-    yield* finishTitle.open
-    yield* Fiber.join(title)
-    yield* Fiber.join(writer)
-    yield* Fiber.join(session)
-    yield* Fiber.join(child)
-    expect(events[0]).toBe("activation")
-    expect(events.slice(1).toSorted()).toEqual(["child", "session"])
-  }),
-)

packages/core/test/plugin/fixture.ts

@@ -19,7 +19,6 @@ import { Mcp } from "@opencode-ai/core/mcp/index"
 import { Npm } from "@opencode-ai/util/npm"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
-import { PluginExecution } from "@opencode-ai/core/plugin/execution"
 import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
 import { Permission } from "@opencode-ai/core/permission"
 import { Reference } from "@opencode-ai/core/reference"
@@ -36,12 +35,8 @@ import { emptyMcpLayer } from "../fixture/mcp"
 const npmLayer = Layer.succeed(
   Npm.Service,
   Npm.Service.of({
-    add: () => Effect.succeed({ directory: "", entrypoint: undefined, generation: "test" }),
-    resolve: () => Effect.succeed({ directory: "", entrypoint: undefined, generation: "test" }),
-    inspect: () => Effect.succeed({ mutable: false }),
-    check: () => Effect.succeed({ mutable: false }),
-    update: () => Effect.die("unused npm.update"),
-    reload: () => Effect.die("unused npm.reload"),
+    add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
+    resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
     which: () => Effect.undefined,
   }),
 )
@@ -83,7 +78,6 @@ export const PluginTestLayer = LayerNode.compile(
     PluginRuntime.node,
     Permission.node,
     PluginHooks.node,
-    PluginExecution.node,
     Reference.node,
     Skill.node,
     SkillDiscovery.node,

packages/core/test/plugin/host.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Bus } from "@opencode-ai/core/bus"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { Watcher } from "@opencode-ai/core/filesystem/watcher"
+import { PersistentPty } from "@opencode-ai/core/persistent-pty"
+import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
+import { SessionExecution } from "@opencode-ai/core/session/execution"
+import { Session } from "@opencode-ai/schema/session"
+import { Global } from "@opencode-ai/util/global"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { tempGlobalLayer } from "../fixture/global"
+import { testEffect } from "../lib/effect"
+
+const cell = PluginRuntime.makeCell()
+const it = testEffect(
+  AppNodeBuilder.build(
+    LayerNode.group([
+      Global.node,
+      Bus.node,
+      PersistentPty.node,
+      PluginRuntime.node,
+      PluginRuntime.providerNodeWithCell(cell),
+    ]),
+    [
+      [Global.node, tempGlobalLayer],
+      [Watcher.node, Watcher.configured({ enabled: false })],
+      [SessionExecution.node, SessionExecution.noopLayer],
+      [PluginRuntime.node, PluginRuntime.layerWithCell(cell)],
+      [PersistentPty.node, PersistentPty.configured()],
+    ],
+  ),
+)
+
+describe("Plugin runtime terminal reads", () => {
+  it.live("shares the configured global PTY service and validates lines before an empty selection", () =>
+    Effect.gen(function* () {
+      const runtime = yield* PluginRuntime.Service
+      const persistentPty = yield* PersistentPty.Service
+      const sessionID = Session.ID.make("ses_no_terminal")
+
+      expect(cell.runtime?.persistentPty).toBe(persistentPty)
+      expect(yield* runtime.persistentPty.read(sessionID)).toBeNull()
+      expect(yield* runtime.persistentPty.read(sessionID, 1)).toBeNull()
+      expect(yield* runtime.persistentPty.read(sessionID, 65535)).toBeNull()
+      yield* Effect.forEach([0, -1, 1.5, 65536, NaN, Infinity], (lines) =>
+        Effect.gen(function* () {
+          const error = yield* runtime.persistentPty.read(sessionID, lines).pipe(Effect.flip)
+          expect(error).toBeInstanceOf(PersistentPty.UnavailableError)
+          expect(error.message).toContain("lines")
+        }),
+      )
+    }),
+  )
+})

packages/core/test/plugin/host.ts

@@ -58,6 +58,11 @@ export function host(overrides: Overrides = {}): Plugin.Context {
     event: overrides.event ?? {
       subscribe: () => Stream.empty,
     },
+    experimental: overrides.experimental ?? {
+      terminal: {
+        read: () => Effect.die("unused experimental.terminal.read"),
+      },
+    },
     generate: overrides.generate ?? {
       text: () => Effect.die("unused generate.text"),
     },
@@ -98,9 +103,6 @@ export function host(overrides: Overrides = {}): Plugin.Context {
     },
     plugin: overrides.plugin ?? {
       list: () => Effect.die("unused plugin.list"),
-      check: () => Effect.die("unused plugin.check"),
-      update: () => Effect.die("unused plugin.update"),
-      reload: () => Effect.die("unused plugin.reload"),
     },
     reference: overrides.reference ?? {
       list: () => Effect.die("unused reference.list"),

packages/core/test/plugin/promise.test.ts

@@ -22,6 +22,8 @@ import { AbsolutePath } from "@opencode-ai/core/schema"
 import { define } from "@opencode-ai/plugin/promise/plugin"
 import type { Info } from "@opencode-ai/plugin/promise/tool"
 import { Money } from "@opencode-ai/schema/money"
+import { PersistentPty } from "@opencode-ai/schema/persistent-pty"
+import { Pty } from "@opencode-ai/schema/pty"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -30,6 +32,84 @@ import { host as testHost } from "./host"
 const it = testEffect(PluginTestLayer)
 
 describe("fromPromise", () => {
+  it.effect("validates and forwards experimental terminal reads through the protocol schema", () =>
+    Effect.gen(function* () {
+      const seen: unknown[] = []
+      const terminal = PersistentPty.ReadResult.make({
+        ptyID: Pty.ID.make("pty_terminal"),
+        title: "Build",
+        cwd: "/workspace",
+        foregroundProcess: "bun",
+        screen: { text: "one\ntwo\nthree", cols: 80, rows: 2, cursor: { x: 3, y: 1 } },
+      })
+      const host = testHost({
+        experimental: {
+          terminal: {
+            read: (input) => {
+              seen.push(input)
+              return Effect.succeed(terminal)
+            },
+          },
+        },
+      })
+
+      yield* PluginPromise.fromPromise(
+        define({
+          id: "promise-terminal-read",
+          setup: async (ctx) => {
+            expect(Object.keys(ctx.experimental)).toEqual(["terminal"])
+            expect(Object.keys(ctx.experimental.terminal)).toEqual(["read"])
+            for (const lines of [0, -1, 1.5, 65536, NaN, Infinity, "3"]) {
+              await expect(
+                Reflect.apply(ctx.experimental.terminal.read, undefined, [{ sessionID: "ses_terminal", lines }]),
+              ).rejects.toBeDefined()
+            }
+            await expect(Reflect.apply(ctx.experimental.terminal.read, undefined, [{ lines: 3 }])).rejects.toBeDefined()
+            expect(seen).toEqual([])
+            expect(await ctx.experimental.terminal.read({ sessionID: "ses_terminal" })).toEqual(terminal)
+            expect(await ctx.experimental.terminal.read({ sessionID: "ses_terminal", lines: 3 })).toEqual(terminal)
+            await ctx.experimental.terminal.read({ sessionID: "ses_terminal", lines: 1 })
+            await ctx.experimental.terminal.read({ sessionID: "ses_terminal", lines: 65535 })
+          },
+        }),
+      ).effect(host)
+
+      expect(seen).toEqual([
+        { sessionID: Session.ID.make("ses_terminal") },
+        { sessionID: Session.ID.make("ses_terminal"), lines: 3 },
+        { sessionID: Session.ID.make("ses_terminal"), lines: 1 },
+        { sessionID: Session.ID.make("ses_terminal"), lines: 65535 },
+      ])
+    }),
+  )
+
+  it.effect("preserves null terminal reads and rejects daemon failures", () =>
+    Effect.gen(function* () {
+      const host = testHost({
+        experimental: {
+          terminal: {
+            read: (input) =>
+              input.sessionID === Session.ID.make("ses_failure")
+                ? Effect.fail(new Error("terminal daemon unavailable"))
+                : Effect.succeed(null),
+          },
+        },
+      })
+
+      yield* PluginPromise.fromPromise(
+        define({
+          id: "promise-terminal-null",
+          setup: async (ctx) => {
+            expect(await ctx.experimental.terminal.read({ sessionID: "ses_empty" })).toBeNull()
+            await expect(ctx.experimental.terminal.read({ sessionID: "ses_failure" })).rejects.toThrow(
+              "terminal daemon unavailable",
+            )
+          },
+        }),
+      ).effect(host)
+    }),
+  )
+
   it.effect("exposes the host location including workspace and project metadata", () =>
     Effect.gen(function* () {
       const plugins = yield* Plugin.Service

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

@@ -22,12 +22,8 @@ const itWithAISDK = testEffect(Layer.mergeAll(PluginTestLayer, AppNodeBuilder.bu
 
 function npmEntrypoint(entrypoint?: string) {
   return Npm.Service.of({
-    add: () => Effect.succeed({ directory: "", entrypoint, generation: "test" }),
-    resolve: () => Effect.succeed({ directory: "", entrypoint, generation: "test" }),
-    inspect: () => Effect.succeed({ mutable: false }),
-    check: () => Effect.succeed({ mutable: false }),
-    update: () => Effect.die("unused npm.update"),
-    reload: () => Effect.die("unused npm.reload"),
+    add: () => Effect.succeed({ directory: "", entrypoint }),
+    resolve: () => Effect.succeed({ directory: "", entrypoint }),
     which: () => Effect.undefined,
   })
 }

packages/core/test/plugin/provider-sap-ai-core.test.ts

@@ -13,12 +13,8 @@ import { PluginTestLayer } from "./fixture"
 const fixtureProvider = new URL("./fixtures/provider-factory.ts", import.meta.url).href
 const it = testEffect(PluginTestLayer)
 const npm = Npm.Service.of({
-  add: () => Effect.succeed({ directory: "", entrypoint: undefined, generation: "test" }),
-  resolve: () => Effect.succeed({ directory: "", entrypoint: undefined, generation: "test" }),
-  inspect: () => Effect.succeed({ mutable: false }),
-  check: () => Effect.succeed({ mutable: false }),
-  update: () => Effect.die("unused npm.update"),
-  reload: () => Effect.die("unused npm.reload"),
+  add: () => Effect.succeed({ directory: "", entrypoint: undefined }),
+  resolve: () => Effect.succeed({ directory: "", entrypoint: undefined }),
   which: () => Effect.undefined,
 })
 

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

@@ -1,129 +0,0 @@
-import { expect } from "bun:test"
-import { Effect, Fiber, Latch, Layer } from "effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { App } from "@opencode-ai/core/app"
-import { Bus } from "@opencode-ai/core/bus"
-import { Database } from "@opencode-ai/core/database/database"
-import { KV } from "@opencode-ai/core/kv"
-import { Location } from "@opencode-ai/core/location"
-import { LocationServiceMap } from "@opencode-ai/core/location-services"
-import { PluginExecution } from "@opencode-ai/core/plugin/execution"
-import { Plugin } from "@opencode-ai/core/plugin"
-import { PluginHost } from "@opencode-ai/core/plugin/host"
-import { PluginPromise } from "@opencode-ai/core/plugin/promise"
-import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
-import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
-import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Session } from "@opencode-ai/core/session"
-import { SessionExecution } from "@opencode-ai/core/session/execution"
-import { SessionGenerate } from "@opencode-ai/core/session/generate"
-import { SessionGenerateNode } from "@opencode-ai/core/session/generate-node"
-import { SessionProjector } from "@opencode-ai/core/session/projector"
-import { Global } from "@opencode-ai/util/global"
-import { LayerNode } from "@opencode-ai/util/effect/layer-node"
-import { tempGlobalLayer } from "../fixture/global"
-import { tmpdir } from "../fixture/tmpdir"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(
-  AppNodeBuilder.build(
-    LayerNode.group([
-      Database.node,
-      Bus.node,
-      Session.node,
-      SessionProjector.node,
-      LocationServiceMap.node,
-      PluginRuntime.providerNode,
-      PluginRuntime.node,
-      KV.node,
-      App.node,
-    ]),
-    [
-      [Global.node, tempGlobalLayer],
-      [Bus.node, Bus.configured({ persist: true })],
-      [SessionExecution.node, SessionExecution.noopLayer],
-      [
-        SessionGenerateNode.node,
-        Layer.succeed(
-          SessionGenerate.Service,
-          SessionGenerate.Service.of({
-            generate: () => Effect.succeed("generated"),
-          }),
-        ),
-      ],
-    ],
-  ),
-)
-
-for (const mode of ["Effect", "Promise"]) {
-  it.live(`${mode} prompt hooks can await auxiliary Session generation without granting drain ownership`, () =>
-    Effect.gen(function* () {
-      const tmp = yield* Effect.acquireDisposable(Effect.promise(() => tmpdir("opencode-plugin-reentry-")))
-      const locations = yield* LocationServiceMap.Service
-      const sessions = yield* Session.Service
-      const ref = Location.Ref.make({ directory: AbsolutePath.make(tmp.path) })
-      const session = yield* sessions.create({ location: ref })
-      yield* Effect.gen(function* () {
-        const plugins = yield* PluginSupervisor.Service
-        yield* plugins.initialized
-        const gate = yield* PluginExecution.Service
-        const registry = yield* Plugin.Service
-        const host = yield* PluginHost.make(registry)
-        const entered = yield* Latch.make()
-        const proceed = yield* Latch.make()
-        const events: string[] = []
-        if (mode === "Effect") {
-          yield* host.session.hook(
-            "prompt",
-            (event) =>
-              Effect.gen(function* () {
-                yield* entered.open
-                yield* proceed.await
-                events.push(
-                  (yield* host.session
-                    .generate({ sessionID: event.sessionID, prompt: "Generate inside admission" })
-                    .pipe(Effect.orDie)).text,
-                )
-              }),
-            undefined,
-          )
-        }
-        if (mode === "Promise") {
-          yield* PluginPromise.fromPromise({
-            id: "nested-generation",
-            setup: async (ctx) => {
-              await ctx.session.hook("prompt", async (event) => {
-                await Effect.runPromise(entered.open)
-                await Effect.runPromise(proceed.await)
-                events.push(
-                  (await ctx.session.generate({ sessionID: event.sessionID, prompt: "Generate inside admission" }))
-                    .text,
-                )
-              })
-            },
-          }).effect(host)
-        }
-        const preparing = yield* sessions
-          .prompt({ sessionID: session.id, text: "hello", resume: false })
-          .pipe(Effect.forkScoped({ startImmediately: true }))
-        yield* Effect.addFinalizer(() => proceed.open)
-        yield* entered.await
-        const writer = yield* gate
-          .exclusive(Effect.sync(() => events.push("activation")))
-          .pipe(Effect.forkScoped({ startImmediately: true }))
-        const drain = yield* gate
-          .lease(
-            { id: session.id },
-            Effect.sync(() => events.push("drain")),
-          )
-          .pipe(Effect.forkScoped({ startImmediately: true }))
-        expect(events).toEqual([])
-        yield* proceed.open
-        yield* Fiber.join(preparing)
-        yield* Fiber.join(writer)
-        yield* Fiber.join(drain)
-        expect(events).toEqual(["generated", "activation", "drain"])
-      }).pipe(Effect.provide(locations.get(ref)))
-    }),
-  )
-}

packages/core/test/prompt-cache-diagnostics.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { GenerationOptions, LLM, LLMRequest, Message, LanguageModel, ToolDefinition } from "@opencode-ai/ai"
-import { OpenAIChat } from "@opencode-ai/ai/protocols"
-import { PromptCacheDiagnostics } from "@opencode-ai/core/session/prompt-cache-diagnostics"
-
-const model = LanguageModel.make({ id: "test", provider: "test", route: OpenAIChat.route })
-const tool = ToolDefinition.make({
-  name: "read",
-  description: "Read a file",
-  inputSchema: { type: "object", properties: {} },
-})
-
-const request = LLM.request({
-  model,
-  system: "System",
-  prompt: "First",
-  tools: [tool],
-})
-const compare = (current: LLMRequest) =>
-  PromptCacheDiagnostics.compare(PromptCacheDiagnostics.snapshot(request), PromptCacheDiagnostics.snapshot(current))
-
-describe("PromptCacheDiagnostics", () => {
-  test("distinguishes initial and stable requests", () => {
-    const snapshot = PromptCacheDiagnostics.snapshot(request)
-    expect(PromptCacheDiagnostics.compare(undefined, snapshot)).toEqual({ status: "initial" })
-    expect(PromptCacheDiagnostics.compare(snapshot, snapshot)).toEqual({ status: "stable", messages: 1 })
-  })
-
-  test("recognizes append-only history", () => {
-    const current = LLMRequest.update(request, { messages: [...request.messages, Message.assistant("Second")] })
-    expect(compare(current)).toEqual({ status: "append-only", previousMessages: 1, currentMessages: 2 })
-  })
-
-  test("detects cache-sensitive setting changes", () => {
-    const current = LLMRequest.update(request, { generation: GenerationOptions.make({ temperature: 0.5 }) })
-    expect(compare(current)).toEqual({ status: "changed", component: "settings", index: 0, label: "model settings" })
-  })
-
-  test("finds the first changed prefix component", () => {
-    const changedTool = ToolDefinition.make({ ...tool, description: "Read one file" })
-    const current = LLMRequest.update(request, { tools: [changedTool] })
-    expect(compare(current)).toEqual({ status: "changed", component: "tools", index: 0, label: "read" })
-  })
-
-  test("treats appended tools as a prefix change", () => {
-    const write = ToolDefinition.make({
-      name: "write",
-      description: "Write a file",
-      inputSchema: { type: "object", properties: {} },
-    })
-    const current = LLMRequest.update(request, { tools: [...request.tools, write] })
-    expect(compare(current)).toEqual({ status: "changed", component: "tools", index: 1, label: "write" })
-  })
-})