chore: merge v2

.opencode/skills/ideal-pseudocode/SKILL.md

@@ -1,68 +0,0 @@
----
-name: ideal-pseudocode
-description: Function-by-function refactoring loop driven by ideal pseudocode. Use when the user says "ideal pseudocode", asks to make a function read like its pseudocode, or wants a dense module cleaned up one function at a time.
----
-
-# Ideal Pseudocode
-
-Clean up one function at a time by writing the pseudocode it _should_ read as, naming every delta between that and the real code, and closing only the gaps the user approves.
-
-## Loop
-
-One function per round. Never touch code before the user picks a direction.
-
-1. **Pick the target** with the user — usually the next function up or down the call chain from the last round.
-2. **Read the current code** fresh from disk. It may have unsaved or parallel edits; ask before overwriting anything unexpected.
-3. **Distill.** Write the function's ideal pseudocode in a `ts`-fenced code block — TypeScript-flavored for syntax highlighting, but pseudocode: comments over mechanics, one line per idea, every arm of a loop visible as an arm. For a dense or unfamiliar function, first show the _current_ structure as pseudocode, then the ideal.
-4. **Name the deltas.** A numbered list; each delta is one concrete gap: control flow smuggled through combinators, a flag-typed parameter, colliding names, side-effect plumbing drowning a loop body, twin functions differing only by a filter. For each, give an honest cost/benefit and a decisive recommendation — including "leave it" when the density has reasons (state the reasons).
-5. **Verify before proposing.** Any API the proposal builds on (a combinator, schedule, matcher) gets checked against the installed version's source, not memory.
-6. **Get buy-in, then apply.** Minimal edits. Quarantine irreducible ugliness inside a small helper whose name is the pseudocode line it implements. Collapse shallow sibling functions into one deep function only when the distinguishing argument is a domain noun, not a behavior switch.
-7. **Validate.** Typecheck and the focused test suites from the package directory; rerun timing-sensitive tests repeatedly. Flag any semantic change the restructure introduced, even when tests pass.
-8. **Offer the next target** and stop.
-
-## Style
-
-- Keep each round tight: pseudocode block, deltas, recommendation, one question.
-- State mutation belongs in one visible place (usually the loop tail), never spread across error channels or callback closures.
-- Prefer early return and `if` chains for control flow; matchers are for producing values.
-- Compare names against the question each caller is actually asking; rename toward the domain noun.
-
-## Example round
-
-Every round should read like this (abridged from a real one, on an Effect step-runner):
-
-> `runStep` it is. The ideal pseudocode:
->
-> ```ts
-> // One logical step: one settled model call, however many attempts it takes.
-> // An attempt can end without settling in two ways:
-> //   transient provider failure -> retry the same call, same assistant message
-> //   compaction rewrote history -> rebuild the request and call again
-> function runStep(session, promotable, step) {
->   while (true) {
->     const result = callModel(session, promotable, step)
->
->     if (result.completed) return result
->
->     if (result.retryable) {
->       wait(retrySchedule) // exhausted -> publish Step.Failed, fail drain
->       promotable = none // never re-promote on a second attempt
->       continue
->     }
->
->     // compaction restarted the step: fresh request from rewritten history
->     promotable = none
->     step = result.step
->   }
-> }
-> ```
->
-> Comparing against the real thing, three deltas:
->
-> 1. **The retry arm doesn't live in the loop.** In the pseudocode, retry is just another loop arm. In the real code it's smuggled through the error channel: `Effect.tapError` mutating loop variables via `Effect.sync` closures, then `Effect.retryOrElse` re-running a suspended call. Four mutable variables mutated from three different places — the state flow is invisible unless you already know the trick.
-> 2. **`recoverOverflow: typeof compaction.compact | undefined`** — a function-typed parameter used as a one-shot armed/disarmed flag. The callee already closes over `compaction`; a boolean says what it is.
-> 3. **`assistantMessageID`** exists solely to resume the same durable message across retries — fine, but only legible once the retry arm is visible in the loop.
->
-> The unifying move for (1): a schedule driver, so a retryable failure becomes a caught value handled in the loop body exactly like the compaction arm. One honest trade: it's more manual than the blessed combinator — but the manual version is the loop the combinator was hiding, and the loop already exists for restarts. Two restart mechanisms, one control structure.
->
-> Want me to apply it — unified loop, simplified schedule input, boolean `recoverOverflow`?

packages/ai/example/tutorial.ts

@@ -78,10 +78,7 @@ const streamText = LLM.stream(request).pipe(
   Stream.tap((event) =>
     Effect.sync(() => {
       if (event.type === "text-delta") process.stdout.write(`\ntext: ${event.text}`)
-      if (event.type === "finish")
-        process.stdout.write(
-          `\nfinish: ${event.reason.normalized}${event.reason.raw ? ` (${event.reason.raw})` : ""}\n`,
-        )
+      if (event.type === "finish") process.stdout.write(`\nfinish: ${event.reason}\n`)
     }),
   ),
   Stream.runDrain,
@@ -197,7 +194,7 @@ const FakeProtocol = Protocol.make<FakeBody, string, string, void>({
     event: Schema.String,
     initial: () => undefined,
     step: (_, frame) => Effect.succeed([undefined, [{ type: "text-delta", id: "text-0", text: frame }]] as const),
-    onHalt: () => [{ type: "finish", reason: { normalized: "stop" } }],
+    onHalt: () => [{ type: "finish", reason: "stop" }],
   },
 })
 

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

@@ -75,15 +75,6 @@ const AnthropicThinkingBlock = Schema.Struct({
   cache_control: Schema.optional(AnthropicCacheControl),
 })
 
-// Safety-filtered thinking arrives as an opaque encrypted `data` payload with
-// no visible text. It must round-trip verbatim so multi-turn thinking + tool
-// use conversations keep their reasoning continuity.
-const AnthropicRedactedThinkingBlock = Schema.Struct({
-  type: Schema.tag("redacted_thinking"),
-  data: Schema.String,
-  cache_control: Schema.optional(AnthropicCacheControl),
-})
-
 const AnthropicToolUseBlock = Schema.Struct({
   type: Schema.tag("tool_use"),
   id: Schema.String,
@@ -145,7 +136,6 @@ type AnthropicUserBlock = Schema.Schema.Type<typeof AnthropicUserBlock>
 const AnthropicAssistantBlock = Schema.Union([
   AnthropicTextBlock,
   AnthropicThinkingBlock,
-  AnthropicRedactedThinkingBlock,
   AnthropicToolUseBlock,
   AnthropicServerToolUseBlock,
   AnthropicServerToolResultBlock,
@@ -224,9 +214,6 @@ const AnthropicStreamBlock = Schema.Struct({
   text: Schema.optional(Schema.String),
   thinking: Schema.optional(Schema.String),
   signature: Schema.optional(Schema.String),
-  // redacted_thinking blocks arrive whole in content_block_start with the
-  // encrypted payload in `data`; there is no streaming delta sequence.
-  data: Schema.optional(Schema.String),
   input: Schema.optional(Schema.Unknown),
   // *_tool_result blocks arrive whole as content_block_start (no streaming
   // delta) with the structured payload in `content` and the originating
@@ -300,12 +287,6 @@ const signatureFromMetadata = (metadata: ProviderMetadata | undefined): string |
   return typeof anthropic.signature === "string" ? anthropic.signature : undefined
 }
 
-const redactedDataFromMetadata = (metadata: ProviderMetadata | undefined): string | undefined => {
-  const anthropic = metadata?.anthropic
-  if (!ProviderShared.isRecord(anthropic)) return undefined
-  return typeof anthropic.redactedData === "string" ? anthropic.redactedData : undefined
-}
-
 const lowerTool = (breakpoints: Cache.Breakpoints, tool: ToolDefinition, inputSchema: JsonSchema): AnthropicTool => ({
   name: tool.name,
   description: tool.description,
@@ -491,16 +472,11 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (
           continue
         }
         if (part.type === "reasoning") {
-          // Mirrors Vercel's @ai-sdk/anthropic: a signature marks visible
-          // thinking; only signature-less parts carrying redactedData
-          // round-trip as opaque redacted_thinking blocks.
-          const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata)
-          const redactedData = redactedDataFromMetadata(part.providerMetadata)
-          if (signature === undefined && redactedData !== undefined) {
-            content.push({ type: "redacted_thinking", data: redactedData })
-            continue
-          }
-          content.push({ type: "thinking", thinking: part.text, signature })
+          content.push({
+            type: "thinking",
+            thinking: part.text,
+            signature: part.encrypted ?? signatureFromMetadata(part.providerMetadata),
+          })
           continue
         }
         if (part.type === "tool-call") {
@@ -625,7 +601,7 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
 // =============================================================================
 const mapFinishReason = (reason: string | null | undefined): FinishReason => {
   if (reason === "end_turn" || reason === "stop_sequence" || reason === "pause_turn") return "stop"
-  if (reason === "max_tokens" || reason === "model_context_window_exceeded") return "length"
+  if (reason === "max_tokens") return "length"
   if (reason === "tool_use") return "tool-calls"
   if (reason === "refusal") return "content-filter"
   return "unknown"
@@ -771,25 +747,6 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
     ]
   }
 
-  // Redacted thinking surfaces as an empty reasoning part carrying the opaque
-  // payload as `redactedData` metadata (same model as Vercel's
-  // @ai-sdk/anthropic). The existing content_block_stop closes the part.
-  if (block.type === "redacted_thinking" && block.data) {
-    const events: LLMEvent[] = []
-    return [
-      {
-        ...state,
-        lifecycle: Lifecycle.reasoningStart(
-          state.lifecycle,
-          events,
-          `reasoning-${event.index ?? 0}`,
-          anthropicMetadata({ redactedData: block.data }),
-        ),
-      },
-      events,
-    ]
-  }
-
   const result = serverToolResultEvent(block)
   if (!result) return [state, NO_EVENTS]
   const events: LLMEvent[] = []
@@ -879,10 +836,7 @@ const onMessageDelta = (state: ParserState, event: AnthropicEvent): StepResult =
   const usage = mergeUsage(state.usage, mapUsage(event.usage))
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-    reason: {
-      normalized: mapFinishReason(event.delta?.stop_reason),
-      raw: event.delta?.stop_reason ?? undefined,
-    },
+    reason: mapFinishReason(event.delta?.stop_reason),
     usage,
     providerMetadata: event.delta?.stop_sequence
       ? anthropicMetadata({ stopSequence: event.delta.stop_sequence })

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

@@ -8,7 +8,6 @@ import {
   Usage,
   type CacheHint,
   type FinishReason,
-  type FinishReasonDetails,
   type JsonSchema,
   type LLMRequest,
   type ModelToolSchemaCompatibility,
@@ -436,10 +435,9 @@ const fromRequest = Effect.fn("BedrockConverse.fromRequest")(function* (request:
 // =============================================================================
 const mapFinishReason = (reason: string): FinishReason => {
   if (reason === "end_turn" || reason === "stop_sequence") return "stop"
-  if (reason === "max_tokens" || reason === "model_context_window_exceeded") return "length"
+  if (reason === "max_tokens") return "length"
   if (reason === "tool_use") return "tool-calls"
   if (reason === "content_filtered" || reason === "guardrail_intervened") return "content-filter"
-  if (reason === "malformed_model_output" || reason === "malformed_tool_use") return "error"
   return "unknown"
 }
 
@@ -468,7 +466,7 @@ interface ParserState {
   // 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.
-  readonly pendingFinish: { readonly reason: FinishReasonDetails; readonly usage?: Usage } | undefined
+  readonly pendingFinish: { readonly reason: FinishReason; readonly usage?: Usage } | undefined
   readonly hasToolCalls: boolean
   readonly lifecycle: Lifecycle.State
   readonly reasoningSignatures: Readonly<Record<number, string>>
@@ -585,13 +583,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
       return [
         {
           ...state,
-          pendingFinish: {
-            reason: {
-              normalized: mapFinishReason(event.messageStop.stopReason),
-              raw: event.messageStop.stopReason,
-            },
-            usage: state.pendingFinish?.usage,
-          },
+          pendingFinish: { reason: mapFinishReason(event.messageStop.stopReason), usage: state.pendingFinish?.usage },
         },
         [],
       ] as const
@@ -599,16 +591,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
 
     if (event.metadata) {
       const usage = mapUsage(event.metadata.usage)
-      return [
-        {
-          ...state,
-          pendingFinish: {
-            reason: state.pendingFinish?.reason ?? { normalized: "stop" },
-            usage,
-          },
-        },
-        [],
-      ] as const
+      return [{ ...state, pendingFinish: { reason: state.pendingFinish?.reason ?? "stop", usage } }, []] as const
     }
 
     const exception = (
@@ -641,13 +624,8 @@ const onHalt = (state: ParserState): ReadonlyArray<LLMEvent> =>
     ? (() => {
         const events: LLMEvent[] = []
         Lifecycle.finish(state.lifecycle, events, {
-          reason: {
-            ...state.pendingFinish.reason,
-            normalized:
-              state.pendingFinish.reason.normalized === "stop" && state.hasToolCalls
-                ? "tool-calls"
-                : state.pendingFinish.reason.normalized,
-          },
+          reason:
+            state.pendingFinish.reason === "stop" && state.hasToolCalls ? "tool-calls" : state.pendingFinish.reason,
           usage: state.pendingFinish.usage,
         })
         return events

packages/ai/src/protocols/gemini.ts

@@ -382,22 +382,10 @@ const mapFinishReason = (finishReason: string | undefined, hasToolCalls: boolean
     finishReason === "SAFETY" ||
     finishReason === "BLOCKLIST" ||
     finishReason === "PROHIBITED_CONTENT" ||
-    finishReason === "SPII" ||
-    finishReason === "MODEL_ARMOR" ||
-    finishReason === "IMAGE_PROHIBITED_CONTENT" ||
-    finishReason === "IMAGE_RECITATION" ||
-    finishReason === "LANGUAGE"
+    finishReason === "SPII"
   )
     return "content-filter"
-  if (
-    finishReason === "MALFORMED_FUNCTION_CALL" ||
-    finishReason === "UNEXPECTED_TOOL_CALL" ||
-    finishReason === "NO_IMAGE" ||
-    finishReason === "TOO_MANY_TOOL_CALLS" ||
-    finishReason === "MISSING_THOUGHT_SIGNATURE" ||
-    finishReason === "MALFORMED_RESPONSE"
-  )
-    return "error"
+  if (finishReason === "MALFORMED_FUNCTION_CALL") return "error"
   return "unknown"
 }
 
@@ -414,10 +402,7 @@ const finish = (state: ParserState): ReadonlyArray<LLMEvent> =>
             )
           : state.lifecycle
         Lifecycle.finish(lifecycle, events, {
-          reason: {
-            normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
-            raw: state.finishReason,
-          },
+          reason: mapFinishReason(state.finishReason, state.hasToolCalls),
           usage: state.usage,
         })
         return events

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

@@ -5,11 +5,9 @@ import { Endpoint } from "../route/endpoint"
 import { HttpTransport } from "../route/transport"
 import { Protocol } from "../route/protocol"
 import {
-  LLMError,
   LLMEvent,
   Usage,
   type FinishReason,
-  type FinishReasonDetails,
   type JsonSchema,
   type LLMRequest,
   type MediaPart,
@@ -19,7 +17,6 @@ import {
   type ToolDefinition,
   type ToolContent,
 } from "../schema"
-import { classifyProviderFailure } from "../provider-error"
 import { isRecord, JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared"
 import { OpenAIOptions } from "./utils/openai-options"
 import { Lifecycle } from "./utils/lifecycle"
@@ -167,18 +164,11 @@ const OpenAIChatDelta = Schema.StructWithRest(
 const OpenAIChatChoice = Schema.Struct({
   delta: optionalNull(OpenAIChatDelta),
   finish_reason: optionalNull(Schema.String),
-  native_finish_reason: optionalNull(Schema.String),
-})
-
-const OpenAIChatError = Schema.Struct({
-  code: optionalNull(Schema.Union([Schema.String, Schema.Number])),
-  message: Schema.String,
 })
 
 export const OpenAIChatEvent = Schema.Struct({
-  choices: optionalNull(Schema.Array(OpenAIChatChoice)),
+  choices: Schema.Array(OpenAIChatChoice),
   usage: optionalNull(OpenAIChatUsage),
-  error: optionalNull(OpenAIChatError),
 })
 export type OpenAIChatEvent = Schema.Schema.Type<typeof OpenAIChatEvent>
 type OpenAIChatRequestMessage = LLMRequest["messages"][number]
@@ -194,7 +184,7 @@ export interface ParserState {
   readonly pendingTools: Partial<Record<number, PendingToolDelta>>
   readonly toolCallEvents: ReadonlyArray<LLMEvent>
   readonly usage?: Usage
-  readonly finishReason?: FinishReasonDetails
+  readonly finishReason?: FinishReason
   readonly lifecycle: Lifecycle.State
   readonly reasoningField?: string
   readonly reasoningDetails: Array<unknown>
@@ -449,7 +439,6 @@ const mapFinishReason = (reason: string | null | undefined): FinishReason => {
   if (reason === "length") return "length"
   if (reason === "content_filter") return "content-filter"
   if (reason === "function_call" || reason === "tool_calls") return "tool-calls"
-  if (reason === "error") return "error"
   return "unknown"
 }
 
@@ -543,22 +532,10 @@ const reasoningMetadata = (field: ParserState["reasoningField"], details?: Reado
 
 const step = (state: ParserState, event: OpenAIChatEvent) =>
   Effect.gen(function* () {
-    if (event.error)
-      return yield* new LLMError({
-        module: ADAPTER,
-        method: "stream",
-        reason: classifyProviderFailure({
-          message: event.error.message,
-          code: event.error.code === undefined || event.error.code === null ? undefined : String(event.error.code),
-          status: typeof event.error.code === "number" ? event.error.code : undefined,
-        }),
-      })
     const events: LLMEvent[] = []
     const usage = mapUsage(event.usage) ?? state.usage
-    const choice = event.choices?.[0]
-    const finishReason = choice?.finish_reason
-      ? { normalized: mapFinishReason(choice.finish_reason), raw: choice.native_finish_reason ?? choice.finish_reason }
-      : state.finishReason
+    const choice = event.choices[0]
+    const finishReason = choice?.finish_reason ? mapFinishReason(choice.finish_reason) : state.finishReason
     const delta = choice?.delta
     const toolDeltas = delta?.tool_calls ?? []
     let tools = state.tools
@@ -650,13 +627,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
 const finishEvents = (state: ParserState): ReadonlyArray<LLMEvent> => {
   const events: LLMEvent[] = []
   const hasToolCalls = state.toolCallEvents.length > 0
-  const reason = state.finishReason
-    ? {
-        ...state.finishReason,
-        normalized:
-          state.finishReason.normalized === "stop" && hasToolCalls ? "tool-calls" : state.finishReason.normalized,
-      }
-    : undefined
+  const reason = state.finishReason === "stop" && hasToolCalls ? "tool-calls" : state.finishReason
   const metadata = reasoningMetadata(
     state.reasoningField,
     state.reasoningDetailsObserved ? state.reasoningDetails : undefined,

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

@@ -979,10 +979,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
 const onResponseFinish = (state: ParserState, event: OpenAIResponsesEvent): StepResult => {
   const events: LLMEvent[] = []
   const lifecycle = Lifecycle.finish(state.lifecycle, events, {
-    reason: {
-      normalized: mapFinishReason(event, state.hasFunctionCall),
-      raw: event.response?.incomplete_details?.reason,
-    },
+    reason: mapFinishReason(event, state.hasFunctionCall),
     usage: mapUsage(event.response?.usage),
     providerMetadata:
       event.response?.id || event.response?.service_tier

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

@@ -1,4 +1,4 @@
-import { LLMEvent, type FinishReasonDetails, type ProviderMetadata, type Usage } from "../../schema"
+import { LLMEvent, type FinishReason, type ProviderMetadata, type Usage } from "../../schema"
 
 export interface State {
   readonly stepStarted: boolean
@@ -81,7 +81,7 @@ export const finish = (
   state: State,
   events: LLMEvent[],
   input: {
-    readonly reason: FinishReasonDetails
+    readonly reason: FinishReason
     readonly usage?: Usage
     readonly providerMetadata?: ProviderMetadata
   },

packages/ai/src/schema/events.ts

@@ -191,16 +191,10 @@ export const ToolError = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.ToolError" })
 export type ToolError = Schema.Schema.Type<typeof ToolError>
 
-export const FinishReasonDetails = Schema.Struct({
-  normalized: FinishReason,
-  raw: Schema.optional(Schema.String),
-}).annotate({ identifier: "LLM.FinishReasonDetails" })
-export type FinishReasonDetails = Schema.Schema.Type<typeof FinishReasonDetails>
-
 export const StepFinish = Schema.Struct({
   type: Schema.tag("step-finish"),
   index: Schema.Number,
-  reason: FinishReasonDetails,
+  reason: FinishReason,
   usage: Schema.optional(Usage),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.StepFinish" })
@@ -208,7 +202,7 @@ export type StepFinish = Schema.Schema.Type<typeof StepFinish>
 
 export const Finish = Schema.Struct({
   type: Schema.tag("finish"),
-  reason: FinishReasonDetails,
+  reason: FinishReason,
   usage: Schema.optional(Usage),
   providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.Finish" })
@@ -371,7 +365,7 @@ interface ResponseState {
   readonly events: ReadonlyArray<LLMEvent>
   readonly message: Message
   readonly usage?: Usage
-  readonly finishReason?: FinishReasonDetails
+  readonly finishReason?: FinishReason
   readonly textParts: Readonly<Record<string, ContentAssembly>>
   readonly reasoningParts: Readonly<Record<string, ContentAssembly>>
   readonly toolInputs: Readonly<Record<string, ToolInputAssembly>>
@@ -399,7 +393,7 @@ const appendEvent = (state: ResponseState, event: LLMEvent): ResponseState => {
     return {
       ...state,
       events,
-      finishReason: state.finishReason ?? { normalized: "error" },
+      finishReason: state.finishReason ?? "error",
     }
   }
   return {
@@ -586,7 +580,7 @@ export class LLMResponse extends Schema.Class<LLMResponse>("LLM.Response")({
   message: Message,
   events: Schema.Array(LLMEvent),
   usage: Schema.optional(Usage),
-  finishReason: FinishReasonDetails,
+  finishReason: FinishReason,
 }) {
   /** Concatenated assistant text assembled from streamed `text-delta` events. */
   get text() {

packages/ai/test/adapter.test.ts

@@ -40,7 +40,7 @@ const fakeFraming: FramingDef<FakeEvent> = {
 
 const raiseEvent = (event: FakeEvent): import("../src/schema").LLMEvent =>
   event.type === "finish"
-    ? { type: "finish", reason: { normalized: event.reason } }
+    ? { type: "finish", reason: event.reason }
     : { type: "text-delta", id: "text-0", text: event.text }
 
 const fakeProtocol = Protocol.make<FakeBody, FakeEvent, FakeEvent, void>({

packages/ai/test/lib/tool-runtime.ts

@@ -83,7 +83,7 @@ const indexStep = (event: LLMEvent, index: number): LLMEvent => {
 const stepState = (events: ReadonlyArray<LLMEvent>) => {
   const assistantContent: ContentPart[] = []
   const toolCalls: ToolCallPart[] = []
-  let reason: Extract<LLMEvent, { type: "finish" }>["reason"] = { normalized: "unknown" }
+  let reason: Extract<LLMEvent, { type: "finish" }>["reason"] = "unknown"
   let usage: Usage | undefined
   let providerMetadata: ProviderMetadata | undefined
 

packages/ai/test/llm.test.ts

@@ -191,7 +191,7 @@ describe("llm constructors", () => {
       LLMResponse.text({
         events: [
           { type: "text-delta", id: "text-0", text: "hi" },
-          { type: "finish", reason: { normalized: "stop" } },
+          { type: "finish", reason: "stop" },
         ],
       }),
     ).toBe("hi")

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

@@ -409,34 +409,6 @@ describe("Anthropic Messages route", () => {
     }),
   )
 
-  it.effect("round-trips redacted thinking as redacted_thinking blocks", () =>
-    Effect.gen(function* () {
-      const prepared = yield* LLMClient.prepare(
-        LLM.request({
-          model,
-          messages: [
-            Message.assistant([
-              { type: "reasoning", text: "", providerMetadata: { anthropic: { redactedData: "opaque_1" } } },
-              { type: "reasoning", text: "visible", providerMetadata: { anthropic: { signature: "sig_1" } } },
-            ]),
-          ],
-        }),
-      )
-
-      expect(prepared.body).toMatchObject({
-        messages: [
-          {
-            role: "assistant",
-            content: [
-              { type: "redacted_thinking", data: "opaque_1" },
-              { type: "thinking", thinking: "visible", signature: "sig_1" },
-            ],
-          },
-        ],
-      })
-    }),
-  )
-
   it.effect("parses text, reasoning, and usage stream fixtures", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -476,149 +448,12 @@ describe("Anthropic Messages route", () => {
       ])
       expect(response.events.at(-1)).toMatchObject({
         type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
+        reason: "stop",
         providerMetadata: { anthropic: { stopSequence: "\n\nHuman:" } },
       })
     }),
   )
 
-  it.effect("parses redacted thinking into empty reasoning with redactedData metadata", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        { type: "message_start", message: { usage: { input_tokens: 5 } } },
-        { type: "content_block_start", index: 0, content_block: { type: "redacted_thinking", data: "opaque_1" } },
-        { type: "content_block_stop", index: 0 },
-        { type: "content_block_start", index: 1, content_block: { type: "text", text: "" } },
-        { type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "Hello" } },
-        { type: "content_block_stop", index: 1 },
-        { type: "message_delta", delta: { stop_reason: "end_turn" }, usage: { output_tokens: 2 } },
-        { type: "message_stop" },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find((event) => event.type === "reasoning-start")).toMatchObject({
-        providerMetadata: { anthropic: { redactedData: "opaque_1" } },
-      })
-      expect(response.message.content).toEqual([
-        { type: "reasoning", text: "", providerMetadata: { anthropic: { redactedData: "opaque_1" } } },
-        { type: "text", text: "Hello" },
-      ])
-    }),
-  )
-
-  it.effect("round-trips streamed redacted thinking with tool use into a continuation request", () =>
-    Effect.gen(function* () {
-      // Anthropic types `redacted_thinking.data` as an opaque string. Its
-      // contents are provider-owned and must be replayed without inspection.
-      const redactedData = "cmVkYWN0ZWQtdGhpbmtpbmc="
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "content_block_start",
-                index: 0,
-                content_block: { type: "redacted_thinking", data: redactedData },
-              },
-              { type: "content_block_stop", index: 0 },
-              {
-                type: "content_block_start",
-                index: 1,
-                content_block: { type: "tool_use", id: "call_1", name: "lookup" },
-              },
-              {
-                type: "content_block_delta",
-                index: 1,
-                delta: { type: "input_json_delta", partial_json: '{"query":"weather"}' },
-              },
-              { type: "content_block_stop", index: 1 },
-              { type: "message_delta", delta: { stop_reason: "tool_use" }, usage: { output_tokens: 1 } },
-              { type: "message_stop" },
-            ),
-          ),
-        ),
-      )
-      const prepared = yield* LLMClient.prepare<AnthropicMessages.AnthropicMessagesBody>(
-        LLM.request({
-          model,
-          messages: [
-            Message.user("Say hello."),
-            response.message,
-            Message.tool({ id: "call_1", name: "lookup", result: "sunny", resultType: "text" }),
-          ],
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-          cache: "none",
-        }),
-      )
-
-      expect(prepared.body.messages).toEqual([
-        { role: "user", content: [{ type: "text", text: "Say hello." }] },
-        {
-          role: "assistant",
-          content: [
-            { type: "redacted_thinking", data: redactedData },
-            { type: "tool_use", id: "call_1", name: "lookup", input: { query: "weather" } },
-          ],
-        },
-        {
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: "call_1",
-              content: "sunny",
-              is_error: undefined,
-              cache_control: undefined,
-            },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("maps context-window truncation to length", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              {
-                type: "message_delta",
-                delta: { stop_reason: "model_context_window_exceeded" },
-                usage: { output_tokens: 1 },
-              },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.finishReason).toEqual({ normalized: "length", raw: "model_context_window_exceeded" })
-    }),
-  )
-
-  it.effect("preserves pause_turn while normalizing it to stop", () =>
-    Effect.gen(function* () {
-      const response = yield* LLMClient.generate(request).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents(
-              { type: "message_start", message: { usage: { input_tokens: 5 } } },
-              { type: "message_delta", delta: { stop_reason: "pause_turn" }, usage: { output_tokens: 1 } },
-            ),
-          ),
-        ),
-      )
-
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "pause_turn" })
-    }),
-  )
-
   it.effect("assembles streamed tool call input", () =>
     Effect.gen(function* () {
       const body = sseEvents(
@@ -668,16 +503,10 @@ describe("Anthropic Messages route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "tool_use" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: "tool_use" },
+          reason: "tool-calls",
           providerMetadata: undefined,
           usage,
         },
@@ -845,10 +674,7 @@ describe("Anthropic Messages route", () => {
         },
       })
       expect(response.text).toBe("Found it.")
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 

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

@@ -290,10 +290,7 @@ describe("Bedrock Converse route", () => {
       // `metadata` (carries usage). We consolidate them into a single
       // terminal `finish` event with both.
       expect(finishes).toHaveLength(1)
-      expect(finishes[0]).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "end_turn" },
-      })
+      expect(finishes[0]).toMatchObject({ type: "finish", reason: "stop" })
       expect(response.usage).toMatchObject({
         inputTokens: 5,
         outputTokens: 2,
@@ -302,23 +299,6 @@ describe("Bedrock Converse route", () => {
     }),
   )
 
-  it.effect("maps truncation and malformed output stop reasons", () =>
-    Effect.gen(function* () {
-      const reasons = [
-        ["model_context_window_exceeded", "length"],
-        ["malformed_model_output", "error"],
-        ["malformed_tool_use", "error"],
-      ] as const
-
-      for (const [raw, normalized] of reasons) {
-        const response = yield* LLMClient.generate(baseRequest).pipe(
-          Effect.provide(fixedBytes(eventStreamBody(["messageStop", { stopReason: raw }]))),
-        )
-        expect(response.finishReason).toEqual({ normalized, raw })
-      }
-    }),
-  )
-
   it.effect("adds cache reads and writes to Bedrock input usage", () =>
     Effect.gen(function* () {
       const body = eventStreamBody(
@@ -382,10 +362,7 @@ describe("Bedrock Converse route", () => {
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: '{"query"' },
         { type: "tool-input-delta", id: "tool_1", name: "lookup", text: ':"weather"}' },
       ])
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "tool-calls", raw: "tool_use" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 
@@ -411,7 +388,7 @@ describe("Bedrock Converse route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: "end_turn" })
+      expect(response.finishReason).toBe("tool-calls")
     }),
   )
 

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

@@ -373,16 +373,10 @@ describe("Gemini route", () => {
         { type: "text-delta", id: "text-0", text: "Hello" },
         { type: "text-delta", id: "text-0", text: "!" },
         { type: "text-end", id: "text-0" },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "stop", raw: "STOP" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: "STOP" },
+          reason: "stop",
           usage,
         },
       ])
@@ -535,16 +529,10 @@ describe("Gemini route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "STOP" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: "STOP" },
+          reason: "tool-calls",
           usage,
         },
       ])
@@ -583,10 +571,7 @@ describe("Gemini route", () => {
         },
         { type: "tool-call", id: "tool_1", name: "lookup", input: { query: "news" } },
       ])
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "tool-calls", raw: "STOP" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "tool-calls" })
     }),
   )
 
@@ -606,41 +591,9 @@ describe("Gemini route", () => {
       )
 
       expect(length.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(length.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "length", raw: "MAX_TOKENS" },
-      })
+      expect(length.events.at(-1)).toMatchObject({ type: "finish", reason: "length" })
       expect(filtered.events.map((event) => event.type)).toEqual(["step-start", "step-finish", "finish"])
-      expect(filtered.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "content-filter", raw: "SAFETY" },
-      })
-    }),
-  )
-
-  it.effect("maps current blocking and invalid-output finish reasons", () =>
-    Effect.gen(function* () {
-      const reasons = [
-        ["MODEL_ARMOR", "content-filter"],
-        ["IMAGE_PROHIBITED_CONTENT", "content-filter"],
-        ["IMAGE_RECITATION", "content-filter"],
-        ["LANGUAGE", "content-filter"],
-        ["UNEXPECTED_TOOL_CALL", "error"],
-        ["NO_IMAGE", "error"],
-        ["IMAGE_OTHER", "unknown"],
-        ["TOO_MANY_TOOL_CALLS", "error"],
-        ["MISSING_THOUGHT_SIGNATURE", "error"],
-        ["MALFORMED_RESPONSE", "error"],
-      ] as const
-
-      for (const [raw, normalized] of reasons) {
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(sseEvents({ candidates: [{ content: { role: "model", parts: [] }, finishReason: raw }] })),
-          ),
-        )
-        expect(response.finishReason).toEqual({ normalized, raw })
-      }
+      expect(filtered.events.at(-1)).toMatchObject({ type: "finish", reason: "content-filter" })
     }),
   )
 

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

@@ -569,16 +569,10 @@ describe("OpenAI Chat route", () => {
         { type: "text-delta", id: "text-0", text: "Hello" },
         { type: "text-delta", id: "text-0", text: "!" },
         { type: "text-end", id: "text-0" },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "stop", raw: "stop" },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "stop", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: "stop" },
+          reason: "stop",
           usage,
         },
       ])
@@ -1043,14 +1037,8 @@ describe("OpenAI Chat route", () => {
           providerExecuted: undefined,
           providerMetadata: undefined,
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: "tool_calls" },
-          usage: undefined,
-          providerMetadata: undefined,
-        },
-        { type: "finish", reason: { normalized: "tool-calls", raw: "tool_calls" }, usage: undefined },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage: undefined, providerMetadata: undefined },
+        { type: "finish", reason: "tool-calls", usage: undefined },
       ])
     }),
   )

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

@@ -232,10 +232,7 @@ describe("OpenAI-compatible Chat route", () => {
 
       expect(response.text).toBe("Hello!")
       expect(response.usage).toMatchObject({ inputTokens: 5, outputTokens: 2, totalTokens: 7 })
-      expect(response.events.at(-1)).toMatchObject({
-        type: "finish",
-        reason: { normalized: "stop", raw: "stop" },
-      })
+      expect(response.events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
     }),
   )
 })

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

@@ -856,13 +856,13 @@ describe("OpenAI Responses route", () => {
         {
           type: "step-finish",
           index: 0,
-          reason: { normalized: "stop", raw: undefined },
+          reason: "stop",
           providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
           usage,
         },
         {
           type: "finish",
-          reason: { normalized: "stop", raw: undefined },
+          reason: "stop",
           providerMetadata: { openai: { responseId: "resp_1", serviceTier: "default" } },
           usage,
         },
@@ -887,18 +887,11 @@ describe("OpenAI Responses route", () => {
       const length = yield* generate({ reason: "max_output_tokens" })
       const contentFilter = yield* generate({ reason: "content_filter" })
       const unknown = yield* generate({})
-      const custom = yield* generate({ reason: "provider_limit" })
 
-      expect([
-        length.finishReason,
-        contentFilter.finishReason,
-        unknown.finishReason,
-        custom.finishReason,
-      ]).toEqual([
-        { normalized: "length", raw: "max_output_tokens" },
-        { normalized: "content-filter", raw: "content_filter" },
-        { normalized: "unknown", raw: undefined },
-        { normalized: "unknown", raw: "provider_limit" },
+      expect([length.finishReason, contentFilter.finishReason, unknown.finishReason]).toEqual([
+        "length",
+        "content-filter",
+        "unknown",
       ])
     }),
   )
@@ -953,8 +946,8 @@ describe("OpenAI Responses route", () => {
         { type: "text-delta", id: "msg_1", text: "Hello" },
         { type: "reasoning-end", id: "rs_1" },
         { type: "text-end", id: "msg_1" },
-        { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
-        { type: "finish", reason: { normalized: "stop", raw: undefined } },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
       ])
       expect(response.events.filter((event) => event.type === "finish")).toHaveLength(1)
       expect(response.message.content).toEqual([
@@ -1045,8 +1038,8 @@ describe("OpenAI Responses route", () => {
           id: "rs_1:1",
           providerMetadata: { openai: { itemId: "rs_1", reasoningEncryptedContent: "encrypted-state" } },
         },
-        { type: "step-finish", index: 0, reason: { normalized: "stop", raw: undefined } },
-        { type: "finish", reason: { normalized: "stop", raw: undefined } },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
       ])
     }),
   )
@@ -1429,16 +1422,10 @@ describe("OpenAI Responses route", () => {
           providerExecuted: undefined,
           providerMetadata: { openai: { itemId: "item_1" } },
         },
-        {
-          type: "step-finish",
-          index: 0,
-          reason: { normalized: "tool-calls", raw: undefined },
-          usage,
-          providerMetadata: undefined,
-        },
+        { type: "step-finish", index: 0, reason: "tool-calls", usage, providerMetadata: undefined },
         {
           type: "finish",
-          reason: { normalized: "tool-calls", raw: undefined },
+          reason: "tool-calls",
           providerMetadata: undefined,
           usage,
         },
@@ -1478,7 +1465,7 @@ describe("OpenAI Responses route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason.normalized).toBe("tool-calls")
+      expect(response.finishReason).toBe("tool-calls")
       expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
     }),
   )
@@ -1505,7 +1492,7 @@ describe("OpenAI Responses route", () => {
         name: "lookup",
         raw: '{"query":"partial',
       })
-      expect(response.finishReason.normalized).toBe("tool-calls")
+      expect(response.finishReason).toBe("tool-calls")
     }),
   )
 

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

@@ -4,8 +4,6 @@ import { LLM, Message } from "../../src"
 import { LLMClient } from "../../src/route"
 import * as OpenRouter from "../../src/providers/openrouter"
 import { it } from "../lib/effect"
-import { fixedResponse } from "../lib/http"
-import { sseEvents } from "../lib/sse"
 
 describe("OpenRouter", () => {
   it.effect("prepares OpenRouter models through the OpenAI-compatible Chat route", () =>
@@ -56,42 +54,6 @@ describe("OpenRouter", () => {
     }),
   )
 
-  it.effect("preserves the upstream provider finish reason", () =>
-    Effect.gen(function* () {
-      const model = OpenRouter.configure({ apiKey: "test-key" }).model("anthropic/claude-sonnet-4.6")
-      const response = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              choices: [{ delta: { content: "Hello" }, finish_reason: "stop", native_finish_reason: "end_turn" }],
-            }),
-          ),
-        ),
-      )
-
-      expect(response.finishReason).toEqual({ normalized: "stop", raw: "end_turn" })
-    }),
-  )
-
-  it.effect("fails on a mid-stream provider error", () =>
-    Effect.gen(function* () {
-      const model = OpenRouter.configure({ apiKey: "test-key" }).model("openai/gpt-4o-mini")
-      const error = yield* LLMClient.generate(LLM.request({ model, prompt: "Say hello." })).pipe(
-        Effect.provide(
-          fixedResponse(
-            sseEvents({
-              error: { code: 502, message: "Provider disconnected" },
-            }),
-          ),
-        ),
-        Effect.flip,
-      )
-
-      expect(error.reason).toMatchObject({ _tag: "ProviderInternal" })
-      expect(error.message).toContain("Provider disconnected")
-    }),
-  )
-
   it.effect("preserves manually supplied reasoning details", () =>
     Effect.gen(function* () {
       const details = [

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

@@ -106,7 +106,7 @@ const readPdfRuntime = Tool.make({
 })
 
 const expectCode = (response: LLMResponse) => {
-  expect(response.finishReason.normalized).toBe("stop")
+  expect(response.finishReason).toBe("stop")
   expect(response.text.toUpperCase()).toContain(CODE)
 }
 
@@ -166,7 +166,7 @@ describe("PDF recorded", () => {
               tools: { read_pdf: readPdfRuntime },
             }).pipe(Stream.runCollect),
           )
-          expect(events.at(-1)).toMatchObject({ type: "finish", reason: { normalized: "stop" } })
+          expect(events.at(-1)).toMatchObject({ type: "finish", reason: "stop" })
           expect(LLMResponse.text({ events }).toUpperCase()).toContain(CODE)
           return
         }

packages/ai/test/recorded-scenarios.ts

@@ -125,8 +125,8 @@ const assistantContent = (events: ReadonlyArray<LLMEvent>) =>
 
 export const expectFinish = (
   events: ReadonlyArray<LLMEvent>,
-  reason: FinishReason,
-) => expect(events.at(-1)).toMatchObject({ type: "finish", reason: { normalized: reason } })
+  reason: Extract<LLMEvent, { readonly type: "finish" }>["reason"],
+) => expect(events.at(-1)).toMatchObject({ type: "finish", reason })
 
 export const expectWeatherToolCall = (response: LLMResponse) =>
   expect(response.toolCalls).toMatchObject([
@@ -136,10 +136,10 @@ export const expectWeatherToolCall = (response: LLMResponse) =>
 export const expectWeatherToolLoop = (events: ReadonlyArray<LLMEvent>) => {
   const finishes = events.filter(LLMEvent.is.finish)
   expect(finishes).toHaveLength(1)
-  expect(finishes[0]?.reason.normalized).toBe("stop")
+  expect(finishes[0]?.reason).toBe("stop")
 
   const stepFinishes = events.filter(LLMEvent.is.stepFinish)
-  expect(stepFinishes.map((event) => event.reason.normalized)).toEqual(["tool-calls", "stop"])
+  expect(stepFinishes.map((event) => event.reason)).toEqual(["tool-calls", "stop"])
 
   const toolCalls = events.filter(LLMEvent.is.toolCall)
   expect(toolCalls).toHaveLength(1)
@@ -503,7 +503,7 @@ export const eventSummary = (events: ReadonlyArray<LLMEvent>) => {
       continue
     }
     if (event.type === "finish") {
-      summary.push({ type: "finish", reason: event.reason.normalized, usage: usageSummary(event.usage) })
+      summary.push({ type: "finish", reason: event.reason, usage: usageSummary(event.usage) })
     }
   }
   return summary.map((item) => Object.fromEntries(Object.entries(item).filter((entry) => entry[1] !== undefined)))

packages/ai/test/response.test.ts

@@ -14,11 +14,11 @@ describe("LLMResponse reducer", () => {
       LLMEvent.reasoningEnd({ id: "r1", providerMetadata: { anthropic: { signature: "sig" } } }),
       LLMEvent.textDelta({ id: "t1", text: "Answer" }),
       LLMEvent.textEnd({ id: "t1" }),
-      LLMEvent.finish({ reason: { normalized: "stop" }, usage: { outputTokens: 5 } }),
+      LLMEvent.finish({ reason: "stop", usage: { outputTokens: 5 } }),
     ]
     const response = LLMResponse.fromEvents(events)
 
-    expect(response?.finishReason).toEqual({ normalized: "stop" })
+    expect(response?.finishReason).toBe("stop")
     expect(response?.usage).toMatchObject({ outputTokens: 5 })
     expect(response?.events).toEqual(events)
     expect(response?.events.map((event) => event.type)).toEqual([
@@ -62,26 +62,18 @@ describe("LLMResponse reducer", () => {
 
   test("uses terminal usage when present and keeps prior usage when finish omits it", () => {
     const withFinishUsage = LLMResponse.fromEvents([
-      LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" }, usage: { inputTokens: 3 } }),
-      LLMEvent.finish({ reason: { normalized: "stop" }, usage: { outputTokens: 2 } }),
+      LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 3 } }),
+      LLMEvent.finish({ reason: "stop", usage: { outputTokens: 2 } }),
     ])
     const withoutFinishUsage = LLMResponse.fromEvents([
-      LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" }, usage: { inputTokens: 3 } }),
-      LLMEvent.finish({ reason: { normalized: "stop" } }),
+      LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 3 } }),
+      LLMEvent.finish({ reason: "stop" }),
     ])
 
     expect(withFinishUsage?.usage).toMatchObject({ outputTokens: 2 })
     expect(withoutFinishUsage?.usage).toMatchObject({ inputTokens: 3 })
   })
 
-  test("preserves the raw finish reason", () => {
-    const response = LLMResponse.fromEvents([
-      LLMEvent.finish({ reason: { normalized: "unknown", raw: "provider_limit" } }),
-    ])
-
-    expect(response?.finishReason).toEqual({ normalized: "unknown", raw: "provider_limit" })
-  })
-
   test("assembles tool-call content only after the completed tool call event", () => {
     const pending = reduce([
       LLMEvent.toolInputStart({ id: "call_1", name: "lookup" }),
@@ -96,7 +88,7 @@ describe("LLMResponse reducer", () => {
       LLMEvent.toolInputDelta({ id: "call_1", name: "lookup", text: ':"weather"}' }),
       LLMEvent.toolInputEnd({ id: "call_1", name: "lookup" }),
       LLMEvent.toolCall({ id: "call_1", name: "lookup", input: { query: "weather" } }),
-      LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+      LLMEvent.finish({ reason: "tool-calls" }),
     ])
 
     expect(response?.message.content).toEqual([

packages/ai/test/schema.test.ts

@@ -48,12 +48,8 @@ describe("llm schema", () => {
   })
 
   test("finish constructors accept usage input", () => {
-    expect(
-      LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" }, usage: { inputTokens: 1 } }).usage,
-    ).toBeInstanceOf(Usage)
-    expect(LLMEvent.finish({ reason: { normalized: "stop" }, usage: { outputTokens: 2 } }).usage).toBeInstanceOf(
-      Usage,
-    )
+    expect(LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 1 } }).usage).toBeInstanceOf(Usage)
+    expect(LLMEvent.finish({ reason: "stop", usage: { outputTokens: 2 } }).usage).toBeInstanceOf(Usage)
   })
 
   test("content part tagged union exposes guards", () => {

packages/codemode/src/tool-runtime.ts

@@ -21,7 +21,6 @@ import {
 } from "./values.js"
 
 const estimateTokens = (input: string) => Math.max(0, Math.round(input.length / 4))
-const compareText = (left: string, right: string) => (left < right ? -1 : left > right ? 1 : 0)
 
 export type Services<T> = ServicesOf<T, []>
 
@@ -327,15 +326,12 @@ const describeTool = <R>(path: string, tool: Tool<R>): ToolDescription => ({
   signature: `${toolExpression(path)}(input: ${inputTypeScript(tool, true)}): Promise<${outputTypeScript(tool, true)}>`,
 })
 
-// Discovery bytes are durable instructions, so order only after canonical-path collisions settle.
 const visibleTools = <R>(tools: Tools<R>) =>
-  flattenTools(toolTrie(tools))
-    .sort((left, right) => compareText(left.path, right.path))
-    .map(({ path, tool }) => ({
-      path,
-      tool,
-      description: describeTool(path, tool),
-    }))
+  flattenTools(toolTrie(tools)).map(({ path, tool }) => ({
+    path,
+    tool,
+    description: describeTool(path, tool),
+  }))
 
 export type DiscoveryPlan = {
   readonly catalog: ReadonlyArray<ToolDescription>
@@ -407,7 +403,7 @@ const makeSearchTool = (searchIndex: ReadonlyArray<SearchEntry>): Tool => ({
               .filter(({ score }) => terms.length === 0 || score > 0)
               .sort(
                 (left, right) =>
-                  right.score - left.score || compareText(left.entry.description.path, right.entry.description.path),
+                  right.score - left.score || left.entry.description.path.localeCompare(right.entry.description.path),
               )
               .map(({ entry }) => entry)
       const items = ranked.slice(offset, offset + (request.limit ?? defaultSearchLimit)).map(({ description }) => ({
@@ -466,14 +462,14 @@ export const prepare = <R>(tools: Tools<R>, catalogBudget = defaultCatalogBudget
     group.push(tool)
     namespaces.set(namespace, group)
   }
-  const ordered = [...namespaces].sort(([left], [right]) => compareText(left, right))
+  const ordered = [...namespaces].sort(([left], [right]) => left.localeCompare(right))
 
   const selections = ordered.map(([namespace, group]) => ({
     namespace,
     picked: new Set<ToolDescription>(),
     queue: [...group].sort(
       (left, right) =>
-        estimateTokens(catalogLine(left)) - estimateTokens(catalogLine(right)) || compareText(left.path, right.path),
+        estimateTokens(catalogLine(left)) - estimateTokens(catalogLine(right)) || left.path.localeCompare(right.path),
     ),
   }))
   let used = 0

packages/codemode/test/codemode.test.ts

@@ -629,41 +629,6 @@ describe("CodeMode public contract", () => {
     }
   })
 
-  test("renders equivalent catalogs identically regardless of tool insertion order", () => {
-    const alpha = Tool.make({
-      description: "Alpha tool",
-      input: Schema.Struct({}),
-      output: Schema.Void,
-      execute: () => Effect.void,
-    })
-    const zeta = Tool.make({
-      description: "Zeta tool",
-      input: Schema.Struct({}),
-      output: Schema.Void,
-      execute: () => Effect.void,
-    })
-    const first = CodeMode.make({ tools: { zeta: { zeta, alpha }, alpha: { zeta, alpha } } })
-    const second = CodeMode.make({ tools: { alpha: { alpha, zeta }, zeta: { alpha, zeta } } })
-
-    expect(first.catalog()).toStrictEqual(second.catalog())
-    expect(first.instructions()).toBe(second.instructions())
-    expect(first.catalog().map((tool) => tool.path)).toEqual(["alpha.alpha", "alpha.zeta", "zeta.alpha", "zeta.zeta"])
-
-    for (const catalogBudget of [0, 10, 20, 40]) {
-      expect(
-        CodeMode.make({
-          tools: { zeta: { zeta, alpha }, alpha: { zeta, alpha } },
-          discovery: { catalogBudget },
-        }).instructions(),
-      ).toBe(
-        CodeMode.make({
-          tools: { alpha: { alpha, zeta }, zeta: { alpha, zeta } },
-          discovery: { catalogBudget },
-        }).instructions(),
-      )
-    }
-  })
-
   test("renders bracket notation for tool names that are not JavaScript identifiers", async () => {
     const resolveLibrary = Tool.make({
       description: "Resolve a library ID",

packages/codemode/test/tool-paths.test.ts

@@ -106,7 +106,7 @@ describe("blocked member names on tool paths", () => {
   })
 
   test("tools may use blocked member names because path segments never touch real properties", async () => {
-    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues.constructor", "nested.__proto__", "prototype"])
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["prototype", "issues.constructor", "nested.__proto__"])
     expect(await value(runtime, `return await tools.prototype({})`)).toBe("proto")
     expect(await value(runtime, `return await tools.issues.constructor({})`)).toBe("ctor")
     expect(await value(runtime, `return await tools["issues.constructor"]({})`)).toBe("ctor")
@@ -155,7 +155,8 @@ describe("canonical path collisions", () => {
         "issues.close": echo("Close issue", "closed"),
       },
     })
-    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues.close", "issues.get", "issues.list"])
+    // Catalog order follows first appearance of each canonical path.
+    expect(runtime.catalog().map((tool) => tool.path)).toEqual(["issues.list", "issues.get", "issues.close"])
     expect(await value(runtime, `return await tools.issues.list({})`)).toBe("second")
     expect(await value(runtime, `return await tools.issues.get({})`)).toBe("got")
     expect(await value(runtime, `return await tools.issues.close({})`)).toBe("closed")

packages/core/src/aisdk.ts

@@ -659,12 +659,12 @@ function streamPartEvents(
       return Effect.succeed([
         LLMEvent.stepFinish({
           index: state.step++,
-          reason: { normalized: finishReason(event.finishReason), raw: event.finishReason.raw },
+          reason: finishReason(event.finishReason),
           usage: usage(event.usage),
           providerMetadata: providerMetadata(event.providerMetadata),
         }),
         LLMEvent.finish({
-          reason: { normalized: finishReason(event.finishReason), raw: event.finishReason.raw },
+          reason: finishReason(event.finishReason),
           usage: usage(event.usage),
           providerMetadata: providerMetadata(event.providerMetadata),
         }),

packages/core/src/codemode/instructions.ts

@@ -1,24 +1,45 @@
 export * as CodeModeInstructions from "./instructions"
 
-import { Effect, Schema } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
+import { AgentV2 } from "../agent"
+import { CodeMode } from "../codemode"
 import { Instructions } from "../instructions/index"
 
-const key = Instructions.Key.make("core/codemode")
-const codec = Schema.toCodecJson(Schema.String)
-const render = {
-  initial: (current: string) => current,
-  changed: (_previous: string, current: string) =>
-    [
-      "The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.",
-      current,
-    ].join("\n\n"),
-  removed: () => "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools.",
+export interface Interface {
+  readonly load: (agent: AgentV2.Selection) => Effect.Effect<Instructions.Instructions>
 }
 
-export const make = (content?: string): Instructions.Instructions =>
-  Instructions.make({
-    key,
-    codec,
-    read: Effect.succeed(content ?? Instructions.removed),
-    render,
-  })
+export class Service extends Context.Service<Service, Interface>()("@opencode/v2/CodeModeInstructions") {}
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const codeMode = yield* CodeMode.Service
+
+    return Service.of({
+      load: Effect.fn("CodeModeInstructions.load")(function* (selection) {
+        const instructions = selection.info
+          ? (yield* codeMode.materialize(selection.info.permissions)).instructions
+          : undefined
+        return Instructions.make({
+          key: Instructions.Key.make("core/codemode"),
+          codec: Schema.toCodecJson(Schema.String),
+          read: Effect.succeed(instructions ?? Instructions.removed),
+          render: {
+            initial: (current) => current,
+            changed: (_previous, current) =>
+              [
+                "The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.",
+                current,
+              ].join("\n\n"),
+            removed: () =>
+              "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools.",
+          },
+        })
+      }),
+    })
+  }),
+)
+
+export const node = makeLocationNode({ service: Service, layer, deps: [CodeMode.node] })

packages/core/src/file-mutation.ts

@@ -44,6 +44,11 @@ export interface WriteResult {
   readonly existed: boolean
 }
 
+export interface TextWriteResult extends WriteResult {
+  readonly before: string
+  readonly after: string
+}
+
 export interface RemoveResult {
   readonly operation: "remove"
   readonly target: string
@@ -56,7 +61,7 @@ export interface Interface {
   readonly create: (input: WriteInput) => Effect.Effect<WriteResult, TargetExistsError | FSUtil.Error>
   readonly write: (input: WriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
   /** Write text while retaining an existing UTF-8 BOM and emitting at most one BOM. */
-  readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<WriteResult, FSUtil.Error>
+  readonly writeTextPreservingBom: (input: TextWriteInput) => Effect.Effect<TextWriteResult, FSUtil.Error>
   /** Commit only if an existing target still has the expected bytes. */
   readonly writeIfUnchanged: (
     input: ConditionalWriteInput,
@@ -112,11 +117,13 @@ const layer = Layer.effect(
           const current = yield* fs
             .readFile(input.target.canonical)
             .pipe(Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(undefined)))
-          yield* fs.writeWithDirs(
-            input.target.canonical,
-            joinBom(next.text, Boolean(current && hasUtf8Bom(current)) || next.bom),
-          )
-          return writeResult(input.target, current !== undefined)
+          const content = joinBom(next.text, Boolean(current && hasUtf8Bom(current)) || next.bom)
+          yield* fs.writeWithDirs(input.target.canonical, content)
+          return {
+            ...writeResult(input.target, current !== undefined),
+            before: current ? new TextDecoder().decode(current).replace(/^\uFEFF/, "") : "",
+            after: content.replace(/^\uFEFF/, ""),
+          }
         }),
       ),
     )

packages/core/src/location-services.ts

@@ -3,6 +3,7 @@ import { AgentV2 } from "./agent"
 import { AISDK } from "./aisdk"
 import { Catalog } from "./catalog"
 import { CodeMode } from "./codemode"
+import { CodeModeInstructions } from "./codemode/instructions"
 import { CommandV2 } from "./command"
 import { Config } from "./config"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
@@ -81,6 +82,7 @@ const locationServiceNodes = [
   ToolRegistry.toolsNode,
   Image.node,
   SkillInstructions.node,
+  CodeModeInstructions.node,
   ReferenceInstructions.node,
   InstructionEntry.node,
   Form.node,

packages/core/src/session/context.ts

@@ -2,7 +2,6 @@ export * as SessionContext from "./context"
 
 import { Context, Effect, Layer } from "effect"
 import { AgentV2 } from "../agent"
-import { CodeModeInstructions } from "../codemode/instructions"
 import { Database } from "../database/database"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { InstructionDiscovery } from "../instruction-discovery"
@@ -13,7 +12,7 @@ import { McpInstructions } from "../mcp/instructions"
 import { PluginSupervisor } from "../plugin/supervisor"
 import { ReferenceInstructions } from "../reference/instructions"
 import { SkillInstructions } from "../skill/instructions"
-import { ToolRegistry } from "../tool/registry"
+import { CodeModeInstructions } from "../codemode/instructions"
 import { AgentNotFoundError } from "./error"
 import { SessionHistory } from "./history"
 import { InstructionEntry } from "./instruction-entry"
@@ -26,7 +25,6 @@ export interface Selection {
   readonly session: SessionSchema.Info
   readonly agent: AgentV2.Selection & { readonly info: AgentV2.Info }
   readonly instructions: Instructions.Instructions
-  readonly toolSet: ToolRegistry.ToolSet
 }
 
 export interface Loaded {
@@ -35,17 +33,15 @@ export interface Loaded {
   readonly model: SessionRunnerModel.Resolved
   readonly initial: string
   readonly messages: ReadonlyArray<SessionMessage.Info>
-  readonly toolSet: ToolRegistry.ToolSet
 }
 
 /**
  * Resolves model-request state in two phases: `select` fixes the Session,
- * agent, instruction sources, and tool snapshot; `load` adds the model and
- * active history for that selection. This module does not build or execute the
- * model request.
+ * agent, and instruction sources; `load` adds the model and active history for
+ * that selection. This module does not build or execute the model request.
  */
 export interface Interface {
-  /** Selects the Session, agent, instructions, and tools used by subsequent work. */
+  /** Selects the Session, agent, and instruction sources used by subsequent work. */
   readonly select: (sessionID: SessionSchema.ID) => Effect.Effect<Selection, AgentNotFoundError>
   /** Resolves the model and active history for that selection. */
   readonly load: (selection: Selection) => Effect.Effect<Loaded, SessionRunnerModel.Error>
@@ -59,6 +55,7 @@ const layer = Layer.effect(
   Effect.gen(function* () {
     const agents = yield* AgentV2.Service
     const builtins = yield* InstructionBuiltIns.Service
+    const codeModeInstructions = yield* CodeModeInstructions.Service
     const db = (yield* Database.Service).db
     const discovery = yield* InstructionDiscovery.Service
     const entries = yield* InstructionEntry.Service
@@ -69,7 +66,6 @@ const layer = Layer.effect(
     const referenceInstructions = yield* ReferenceInstructions.Service
     const skillInstructions = yield* SkillInstructions.Service
     const store = yield* SessionStore.Service
-    const registry = yield* ToolRegistry.Service
 
     const select = Effect.fn("SessionContext.select")(function* (sessionID: SessionSchema.ID) {
       const session = yield* store.get(sessionID)
@@ -80,32 +76,19 @@ const layer = Layer.effect(
       yield* plugins.flush
       const agent = yield* agents.select(session.agent)
       if (!agent.info) return yield* new AgentNotFoundError({ sessionID: session.id, agent: session.agent ?? agent.id })
-      const loaded = yield* Effect.all(
-        {
-          toolSet: registry.snapshot(agent.info.permissions),
-          builtins: builtins.load(sessionID),
-          discovery: discovery.load(),
-          skills: skillInstructions.load(agent),
-          references: referenceInstructions.load(),
-          mcp: mcpInstructions.load(agent),
-          entries: entries.load(sessionID),
-        },
+      const instructions = yield* Effect.all(
+        [
+          builtins.load(sessionID),
+          codeModeInstructions.load(agent),
+          discovery.load(),
+          skillInstructions.load(agent),
+          referenceInstructions.load(),
+          mcpInstructions.load(agent),
+          entries.load(sessionID),
+        ],
         { concurrency: "unbounded" },
-      )
-      return {
-        session,
-        agent: { ...agent, info: agent.info },
-        instructions: Instructions.combine([
-          loaded.builtins,
-          CodeModeInstructions.make(loaded.toolSet.codeModeInstructions),
-          loaded.discovery,
-          loaded.skills,
-          loaded.references,
-          loaded.mcp,
-          loaded.entries,
-        ]),
-        toolSet: loaded.toolSet,
-      }
+      ).pipe(Effect.map(Instructions.combine))
+      return { session, agent: { ...agent, info: agent.info }, instructions }
     })
 
     const load = Effect.fn("SessionContext.load")(function* (selection: Selection) {
@@ -117,7 +100,6 @@ const layer = Layer.effect(
         model,
         initial: history.initial,
         messages: history.entries.map((entry) => entry.message),
-        toolSet: selection.toolSet,
       }
     })
 
@@ -130,6 +112,7 @@ export const node = makeLocationNode({
   layer,
   deps: [
     AgentV2.node,
+    CodeModeInstructions.node,
     Database.node,
     InstructionBuiltIns.node,
     InstructionDiscovery.node,
@@ -141,6 +124,5 @@ export const node = makeLocationNode({
     SessionRunnerModel.node,
     SessionStore.node,
     SkillInstructions.node,
-    ToolRegistry.node,
   ],
 })

packages/core/src/session/generate-node.ts

@@ -12,6 +12,7 @@ import { SessionGenerate } from "./generate"
 import { SessionHistory } from "./history"
 import { SessionModelHeaders } from "./model-headers"
 import { SessionRunnerModel } from "./runner/model"
+import { ToolRegistry } from "../tool/registry"
 import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message"
 
@@ -23,6 +24,7 @@ export const layer = Layer.effect(
     const hooks = yield* PluginHooks.Service
     const llm = yield* LLMClient.Service
     const models = yield* SessionRunnerModel.Service
+    const registry = yield* ToolRegistry.Service
     const app = yield* App.Metadata
 
     return SessionGenerate.Service.of({
@@ -34,7 +36,7 @@ export const layer = Layer.effect(
         const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(selection.session.id)
           ? selection.session.id.slice(4)
           : selection.session.id
-        const toolSet = selection.toolSet
+        const toolSet = yield* registry.snapshot(selection.agent.info.permissions)
         const toolDefinitions = toolSet.definitions
         const toolsByName = new Map(toolDefinitions.map((tool) => [tool.name, tool]))
         const contextEvent = yield* hooks.trigger("session", "context", {
@@ -87,5 +89,13 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
   service: SessionGenerate.Service,
   layer,
-  deps: [SessionContext.node, Database.node, PluginHooks.node, SessionRunnerModel.node, App.node, llmClient],
+  deps: [
+    SessionContext.node,
+    Database.node,
+    PluginHooks.node,
+    SessionRunnerModel.node,
+    ToolRegistry.node,
+    App.node,
+    llmClient,
+  ],
 })

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

@@ -86,6 +86,7 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const hooks = yield* PluginHooks.Service
+    const registry = yield* ToolRegistry.Service
     const app = yield* App.Metadata
 
     const prepare = Effect.fn("SessionModelRequest.prepare")(function* (input: PrepareInput) {
@@ -97,7 +98,7 @@ export const layer = Layer.effect(
       const stepLimitReached = agent.info.steps !== undefined && input.step >= agent.info.steps
       // The final Step keeps definitions available to protocols with native "none",
       // preserving their prompt cache prefix. Calls are still rejected at execution.
-      const toolSet = input.context.toolSet
+      const toolSet = yield* registry.snapshot(agent.info.permissions)
       const promptCacheKey = /^ses_[0-9a-f]{64}$/.test(session.id) ? session.id.slice(4) : session.id
       const system = [agent.info.system ? agent.info.system : PROMPT_DEFAULT, input.context.initial]
         .filter((part) => part.length > 0)
@@ -161,5 +162,5 @@ export const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [PluginHooks.node, App.node],
+  deps: [PluginHooks.node, ToolRegistry.node, App.node],
 })

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

@@ -58,7 +58,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
   let stepFailure: SessionError.Error | undefined
   let stepSettlement:
     | {
-        readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]["normalized"]
+        readonly finish: Extract<LLMEvent, { type: "step-finish" }>["reason"]
         readonly tokens: ReturnType<typeof SessionUsage.tokens>
       }
     | undefined
@@ -449,8 +449,8 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
       case "step-finish":
         yield* flush()
         if (stepSettlement) return yield* Effect.die(new Error("Duplicate step finish"))
-        stepSettlement = { finish: event.reason.normalized, tokens: SessionUsage.tokens(event.usage) }
-        if (event.reason.normalized === "content-filter") {
+        stepSettlement = { finish: event.reason, tokens: SessionUsage.tokens(event.usage) }
+        if (event.reason === "content-filter") {
           providerFailed = true
           yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" })
           return

packages/core/src/tool/patch.ts

@@ -5,7 +5,6 @@ import { ToolFailure } from "@opencode-ai/ai"
 import { FileDiff } from "@opencode-ai/schema/file-diff"
 import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Schema } from "effect"
-import { PlatformError } from "effect/PlatformError"
 import path from "path"
 import { FSUtil } from "@opencode-ai/util/fs-util"
 import { Location } from "../location"
@@ -82,11 +81,12 @@ export const Plugin = {
               output: Output,
               execute: (input, context) => {
                 const applied: Array<typeof Applied.Type> = []
-                const fail = (operation: string, error: unknown) => {
-                  const completed = applied.map((item) => item.resource).join(", ")
-                  return new ToolFailure({
-                    message: `${operation}: ${errorMessage(error)}${completed ? `. Completed before failure: ${completed}` : ""}`,
-                  })
+                const fail = (path: string, error?: unknown) => {
+                  const prefix =
+                    applied.length === 0
+                      ? `Unable to apply patch at ${path}`
+                      : `Patch partially applied before failing at ${path}. Applied: ${applied.map((item) => item.resource).join(", ")}`
+                  return new ToolFailure({ message: prefix, error })
                 }
                 return Effect.gen(function* () {
                   const source = {
@@ -101,7 +101,11 @@ export const Plugin = {
                     ),
                   )
                   if (hunks.length === 0) {
-                    return yield* new ToolFailure({ message: "patch rejected: empty patch" })
+                    const normalized = input.patchText.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim()
+                    if (normalized === "*** Begin Patch\n*** End Patch") {
+                      return yield* new ToolFailure({ message: "patch rejected: empty patch" })
+                    }
+                    return yield* new ToolFailure({ message: "patch verification failed: no hunks found" })
                   }
                   const prepared: Prepared[] = []
                   const targets: Target[] = []
@@ -141,7 +145,7 @@ export const Plugin = {
                           Effect.mapError(
                             (error) =>
                               new ToolFailure({
-                                message: `patch verification failed: Failed to delete ${target.resource}: ${errorMessage(error)}`,
+                                message: `patch verification failed: ${error instanceof Error ? error.message : String(error)}`,
                               }),
                           ),
                         )
@@ -157,7 +161,7 @@ export const Plugin = {
                             Effect.mapError(
                               (error) =>
                                 new ToolFailure({
-                                  message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
+                                  message: `patch verification failed: Failed to read file to update ${target.canonical}: ${error instanceof Error ? error.message : String(error)}`,
                                 }),
                             ),
                           )
@@ -171,7 +175,7 @@ export const Plugin = {
                               Effect.mapError(
                                 (error) =>
                                   new ToolFailure({
-                                    message: `patch verification failed: Failed to read file to update ${target.canonical}: ${errorMessage(error)}`,
+                                    message: `patch verification failed: Failed to read file to update ${target.canonical}: ${error instanceof Error ? error.message : String(error)}`,
                                   }),
                               ),
                             ),
@@ -180,8 +184,7 @@ export const Plugin = {
                       const before = original.replace(/^\uFEFF/, "")
                       const update = yield* Effect.try({
                         try: () => Patch.derive(hunk.path, hunk.chunks, original),
-                        catch: (error) =>
-                          new ToolFailure({ message: `patch verification failed: ${errorMessage(error)}` }),
+                        catch: (error) => new ToolFailure({ message: `patch verification failed: ${String(error)}` }),
                       })
                       const moveTarget = hunk.movePath ? resolveTarget(location, hunk.movePath) : undefined
                       if (moveTarget) targets.push(moveTarget)
@@ -208,13 +211,7 @@ export const Plugin = {
                         moveTarget,
                       })
                       if (!moveTarget) updates.set(target.canonical, Patch.joinBom(update.content, update.bom))
-                    }).pipe(
-                      Effect.mapError((error) =>
-                        error instanceof ToolFailure
-                          ? error
-                          : new ToolFailure({ message: `Unable to prepare patch at ${hunk.path}`, error }),
-                      ),
-                    )
+                    }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail(hunk.path, error))))
                   }
 
                   const patchFiles = prepared.map(patchFile)
@@ -237,16 +234,12 @@ export const Plugin = {
                     (change) =>
                       Effect.gen(function* () {
                         if (change.type === "add") {
-                          yield* fs
-                            .writeWithDirs(
-                              change.target.canonical,
-                              change.contents.endsWith("\n") || change.contents === ""
-                                ? change.contents
-                                : `${change.contents}\n`,
-                            )
-                            .pipe(
-                              Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)),
-                            )
+                          yield* fs.writeWithDirs(
+                            change.target.canonical,
+                            change.contents.endsWith("\n") || change.contents === ""
+                              ? change.contents
+                              : `${change.contents}\n`,
+                          )
                           applied.push({
                             type: change.type,
                             resource: change.target.resource,
@@ -255,11 +248,7 @@ export const Plugin = {
                           return
                         }
                         if (change.type === "delete") {
-                          yield* fs
-                            .remove(change.target.canonical)
-                            .pipe(
-                              Effect.mapError((error) => fail(`Failed to delete ${change.target.resource}`, error)),
-                            )
+                          yield* fs.remove(change.target.canonical)
                           applied.push({
                             type: change.type,
                             resource: change.target.resource,
@@ -268,15 +257,8 @@ export const Plugin = {
                           return
                         }
                         if (change.moveTarget) {
-                          const moveTarget = change.moveTarget
-                          yield* fs
-                            .writeWithDirs(moveTarget.canonical, change.content)
-                            .pipe(Effect.mapError((error) => fail(`Failed to write ${moveTarget.resource}`, error)))
-                          yield* fs.remove(change.target.canonical).pipe(
-                            Effect.mapError((error) =>
-                              fail(`Wrote ${moveTarget.resource} but failed to remove ${change.target.resource}`, error),
-                            ),
-                          )
+                          yield* fs.writeWithDirs(change.moveTarget.canonical, change.content)
+                          yield* fs.remove(change.target.canonical)
                           applied.push({
                             type: change.type,
                             resource: change.moveTarget.resource,
@@ -284,15 +266,13 @@ export const Plugin = {
                           })
                           return
                         }
-                        yield* fs
-                          .writeWithDirs(change.target.canonical, change.content)
-                          .pipe(Effect.mapError((error) => fail(`Failed to write ${change.target.resource}`, error)))
+                        yield* fs.writeWithDirs(change.target.canonical, change.content)
                         applied.push({
                           type: change.type,
                           resource: change.target.resource,
                           target: change.target.canonical,
                         })
-                      }),
+                      }).pipe(Effect.mapError((error) => fail(change.path, error))),
                     { discard: true },
                   )
                   return { applied, files: patchFiles }
@@ -302,11 +282,7 @@ export const Plugin = {
                     content: toModelOutput(output),
                     metadata: { files: output.files },
                   })),
-                  Effect.mapError((error) =>
-                    error instanceof ToolFailure
-                      ? error
-                      : new ToolFailure({ message: "Unable to apply patch", error }),
-                  ),
+                  Effect.mapError((error) => (error instanceof ToolFailure ? error : fail("patch", error))),
                 )
               },
             }),
@@ -330,14 +306,6 @@ export const Plugin = {
   }),
 }
 
-function errorMessage(error: unknown) {
-  if (error instanceof PlatformError) {
-    if (error.reason._tag === "NotFound") return "file does not exist"
-    return error.reason.description ?? error.reason.message
-  }
-  return error instanceof Error ? error.message : String(error)
-}
-
 function patchFile(change: Prepared): typeof FileDiff.Info.Type {
   const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource
   const patch = trimDiff(

packages/core/src/tool/registry.ts

@@ -44,13 +44,12 @@ export interface Interface {
 }
 
 /**
- * One request-scoped snapshot pairing Code Mode instructions and advertised
- * definitions with captured tools. A model request executes exactly the tool
- * values it advertised even if registration changes while it is in flight.
+ * One request-scoped snapshot pairing advertised definitions with captured
+ * tools. A model request executes exactly the tool values it advertised
+ * even if registration changes while the request is in flight.
  */
 export interface ToolSet {
   readonly definitions: ReadonlyArray<ToolDefinition>
-  readonly codeModeInstructions?: string
   readonly execute: (input: ExecuteInput) => Effect.Effect<ToolOutcome, ToolOutputStore.Error>
 }
 
@@ -321,17 +320,10 @@ const registryLayer = Layer.effect(
               if (whollyDisabled(registration.permission, rules)) continue
               direct.set(name, registration)
             }
-            const codeModeMaterialization = yield* codeMode.materialize(permissions)
-            const codemodeTool = codeModeMaterialization.tool
+            const codemodeTool = (yield* codeMode.materialize(permissions)).tool
             return {
-              ...(codeModeMaterialization.instructions === undefined
-                ? {}
-                : { codeModeInstructions: codeModeMaterialization.instructions }),
               definitions: [
-                // Definitions are prompt-cache prefix bytes, so order only after effective registrations settle.
-                ...Array.from(direct)
-                  .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-                  .map(([name, registration]) => toLLMDefinition(name, registration.tool)),
+                ...Array.from(direct, ([name, registration]) => toLLMDefinition(name, registration.tool)),
                 ...(codemodeTool ? [toLLMDefinition("execute", codemodeTool)] : []),
               ],
               execute: (input: ExecuteInput) => {

packages/core/src/tool/write.ts

@@ -8,6 +8,8 @@ export * as WriteTool from "./write"
 
 import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
 import { ToolFailure } from "@opencode-ai/ai"
+import { FileDiff } from "@opencode-ai/schema/file-diff"
+import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Schema } from "effect"
 import { FileMutation } from "../file-mutation"
 import { LocationMutation } from "../location-mutation"
@@ -30,6 +32,7 @@ export const Output = Schema.Struct({
   target: Schema.String,
   resource: Schema.String,
   existed: Schema.Boolean,
+  files: Schema.Array(FileDiff.Info),
 })
 export type Output = typeof Output.Type
 
@@ -82,7 +85,28 @@ export const Plugin = {
                     agent: context.agent,
                     source,
                   })
-                  return yield* files.writeTextPreservingBom({ target, content: input.content })
+                  const result = yield* files.writeTextPreservingBom({ target, content: input.content })
+                  const counts = diffLines(result.before, result.after).reduce(
+                    (total, item) => ({
+                      additions: total.additions + (item.added ? (item.count ?? 0) : 0),
+                      deletions: total.deletions + (item.removed ? (item.count ?? 0) : 0),
+                    }),
+                    { additions: 0, deletions: 0 },
+                  )
+                  return {
+                    operation: result.operation,
+                    target: result.target,
+                    resource: result.resource,
+                    existed: result.existed,
+                    files: [
+                      {
+                        file: result.resource,
+                        patch: createTwoFilesPatch(result.resource, result.resource, result.before, result.after),
+                        status: result.existed ? "modified" : "added",
+                        ...counts,
+                      },
+                    ],
+                  } satisfies Output
                 }).pipe(
                   Effect.map((output) => ({ output, content: toModelOutput(output) })),
                   Effect.mapError((error) => new ToolFailure({ message: `Unable to write ${input.path}`, error })),

packages/core/test/aisdk.test.ts

@@ -299,7 +299,6 @@ it.effect("emits malformed AI SDK tool input without executing it", () =>
     })
     expect(response.events.some(LLMEvent.is.toolInputEnd)).toBeTrue()
     expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
-    expect(response.finishReason).toEqual({ normalized: "tool-calls", raw: "tool_calls" })
   }),
 )
 

packages/core/test/codemode/instructions.test.ts

@@ -1,66 +1,49 @@
 import { describe, expect } from "bun:test"
+import { AgentV2 } from "@opencode-ai/core/agent"
 import { CodeMode } from "@opencode-ai/core/codemode"
 import { CodeModeInstructions } from "@opencode-ai/core/codemode/instructions"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { Tool } from "@opencode-ai/core/tool/tool"
-import { Effect, Schema } from "effect"
+import { Effect, Layer } from "effect"
 import { it } from "../lib/effect"
 import { readInitial, readUpdate } from "../lib/instructions"
 
+const agent = AgentV2.Info.make(AgentV2.Info.empty(AgentV2.ID.make("build")))
+
 describe("CodeModeInstructions", () => {
-  it.effect("treats equivalent registration orders as an instruction no-op", () => {
-    const alpha = Tool.make({
-      description: "Alpha tool",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.succeed({ output: "alpha" }),
-    })
-    const zeta = Tool.make({
-      description: "Zeta tool",
-      input: Schema.Struct({}),
-      output: Schema.String,
-      execute: () => Effect.succeed({ output: "zeta" }),
-    })
-    const codeModeLayer = AppNodeBuilder.build(CodeMode.node)
-
-    return Effect.gen(function* () {
-      const codeMode = yield* CodeMode.Service
-      const initialized = yield* Effect.scoped(
-        Effect.gen(function* () {
-          yield* codeMode.register(Tool.registrationEntries({ zeta, alpha }, { namespace: "tools" }))
-          const materialization = yield* codeMode.materialize()
-          return yield* readInitial(CodeModeInstructions.make(materialization.instructions))
-        }),
-      )
-      const reordered = yield* Effect.scoped(
-        Effect.gen(function* () {
-          yield* codeMode.register(Tool.registrationEntries({ alpha, zeta }, { namespace: "tools" }))
-          const materialization = yield* codeMode.materialize()
-          return yield* readUpdate(CodeModeInstructions.make(materialization.instructions), initialized)
-        }),
-      )
-
-      expect(reordered.changed).toBe(false)
-      expect(reordered.text).toBe("")
-    }).pipe(Effect.provide(codeModeLayer))
-  })
-
   it.effect("renders catalog changes and removal", () => {
     let catalog: string | undefined = "Initial Code Mode catalog"
+    const layer = AppNodeBuilder.build(CodeModeInstructions.node, [
+      [
+        CodeMode.node,
+        Layer.mock(CodeMode.Service, {
+          materialize: () => Effect.succeed({ ...(catalog === undefined ? {} : { instructions: catalog }) }),
+          register: () => Effect.void,
+        }),
+      ],
+    ])
 
     return Effect.gen(function* () {
-      const initialized = yield* readInitial(CodeModeInstructions.make(catalog))
+      const instructions = yield* CodeModeInstructions.Service
+      const initialized = yield* instructions.load({ id: agent.id, info: agent }).pipe(Effect.flatMap(readInitial))
       expect(initialized.text).toBe("Initial Code Mode catalog")
 
       catalog = "Updated Code Mode catalog"
-      expect(yield* readUpdate(CodeModeInstructions.make(catalog), initialized)).toMatchObject({
+      expect(
+        yield* instructions
+          .load({ id: agent.id, info: agent })
+          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
+      ).toMatchObject({
         text: "The Code Mode tool catalog has changed. This catalog supersedes the previous Code Mode tool catalog.\n\nUpdated Code Mode catalog",
       })
 
       catalog = undefined
-      expect(yield* readUpdate(CodeModeInstructions.make(catalog), initialized)).toMatchObject({
+      expect(
+        yield* instructions
+          .load({ id: agent.id, info: agent })
+          .pipe(Effect.flatMap((context) => readUpdate(context, initialized))),
+      ).toMatchObject({
         text: "Code Mode tools are no longer available. Do not use any previously listed Code Mode tools.",
       })
-    })
+    }).pipe(Effect.provide(layer))
   })
 })

packages/core/test/file-mutation.test.ts

@@ -80,9 +80,14 @@ describe("FileMutation", () => {
         const created = yield* (yield* LocationMutation.Service).resolve({ path: "created.txt" })
         const files = yield* FileMutation.Service
 
-        yield* files.writeTextPreservingBom({ target: preserved, content: "\uFEFFafter" })
-        yield* files.writeTextPreservingBom({ target: created, content: "\uFEFF\uFEFF\uFEFFcreated" })
+        const preservedResult = yield* files.writeTextPreservingBom({ target: preserved, content: "\uFEFFafter" })
+        const createdResult = yield* files.writeTextPreservingBom({
+          target: created,
+          content: "\uFEFF\uFEFF\uFEFFcreated",
+        })
 
+        expect(preservedResult).toMatchObject({ existed: true, before: "before", after: "after" })
+        expect(createdResult).toMatchObject({ existed: false, before: "", after: "created" })
         expect(yield* Effect.promise(() => fs.readFile(preservedPath, "utf8"))).toBe("\uFEFFafter")
         expect(yield* Effect.promise(() => fs.readFile(created.canonical, "utf8"))).toBe("\uFEFFcreated")
       }).pipe(provide(directory)),

packages/core/test/generate.test.ts

@@ -73,7 +73,7 @@ const client = Layer.mock(LLMClient.Service)({
         LLMEvent.textStart({ id: "generate" }),
         LLMEvent.textDelta({ id: "generate", text: "OK" }),
         LLMEvent.textEnd({ id: "generate" }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.finish({ reason: "stop" }),
       ])
       if (!response) throw new Error("Incomplete generate response")
       return response

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

@@ -578,8 +578,7 @@ describe("LocationServiceMap", () => {
           const blockedState = yield* update(blocked.path, blockedID)
           expect(blockedState.providers.some((provider) => provider.id === blockedID)).toBe(true)
           expect(blockedState.providers.some((provider) => provider.id === allowedID)).toBe(false)
-          const blockedTools = blockedState.tools.map((tool) => tool.name)
-          expect(blockedTools.filter((name) => name !== "execute").sort()).toEqual([
+          expect(blockedState.tools.map((tool) => tool.name).sort()).toEqual([
             "edit",
             "glob",
             "grep",
@@ -596,9 +595,7 @@ describe("LocationServiceMap", () => {
           const allowedState = yield* update(allowed.path, allowedID)
           expect(allowedState.providers.some((provider) => provider.id === allowedID)).toBe(true)
           expect(allowedState.providers.some((provider) => provider.id === blockedID)).toBe(false)
-          const allowedTools = allowedState.tools.map((tool) => tool.name)
-          expect(blockedTools.includes("execute")).toBe(allowedTools.includes("execute"))
-          expect(allowedTools.filter((name) => name !== "execute").sort()).toEqual([
+          expect(allowedState.tools.map((tool) => tool.name).sort()).toEqual([
             "edit",
             "glob",
             "grep",

packages/core/test/patch.test.ts

@@ -246,35 +246,6 @@ describe("Patch", () => {
     ).toBe("line 1\nLINE 2\nline 3\nLINE 4\n")
   })
 
-  test("appends a pure-addition chunk to a nonempty file", () => {
-    expect(Patch.derive("update.txt", [{ oldLines: [], newLines: ["added 1", "added 2"] }], "line 1\nline 2\n").content).toBe(
-      "line 1\nline 2\nadded 1\nadded 2\n",
-    )
-  })
-
-  test("applies a pure-addition chunk after an earlier replacement", () => {
-    expect(
-      Patch.derive(
-        "update.txt",
-        [
-          { oldLines: [], newLines: ["after-context", "second-line"] },
-          { oldLines: ["line1", "line2", "line3"], newLines: ["line1", "line2-replacement"] },
-        ],
-        "line1\nline2\nline3\n",
-      ).content,
-    ).toBe("line1\nline2-replacement\nafter-context\nsecond-line\n")
-  })
-
-  test("applies a deletion-only update chunk", () => {
-    expect(
-      Patch.derive(
-        "update.txt",
-        [{ oldLines: ["line1", "line2", "line3"], newLines: ["line1", "line3"] }],
-        "line1\nline2\nline3\n",
-      ).content,
-    ).toBe("line1\nline3\n")
-  })
-
   test("updates empty files and adds a trailing newline", () => {
     expect(Patch.derive("empty.txt", [{ oldLines: [], newLines: ["First line"] }], "").content).toBe("First line\n")
     expect(Patch.derive("no-newline.txt", [{ oldLines: ["old"], newLines: ["new"] }], "old").content).toBe("new\n")
@@ -356,12 +327,6 @@ describe("Patch", () => {
     ).toThrow("Failed to find expected lines")
   })
 
-  test("identifies a missing blank line", () => {
-    expect(() =>
-      Patch.derive("update.txt", [{ oldLines: [""], newLines: ["added"] }], "content\n"),
-    ).toThrow("Failed to find an expected blank line in update.txt")
-  })
-
   test("parses an update without an explicit first chunk header", () => {
     expect(parse("*** Begin Patch\n*** Update File: file.txt\n import foo\n+bar\n*** End Patch")).toEqual([
       {
@@ -448,14 +413,11 @@ describe("Patch", () => {
 
   test("rejects invalid add and delete lines", () => {
     expect(() => parse("*** Begin Patch\n*** Add File: file.txt\nbad\n*** End Patch")).toThrow(
-      "Invalid hunk at line 3: Invalid Add File line for 'file.txt': expected a line starting with '+', got 'bad'",
+      "Invalid hunk at line 3: 'bad' is not a valid hunk header",
     )
     expect(() => parse("*** Begin Patch\n*** Delete File: file.txt\nbad\n*** End Patch")).toThrow(
-      "Invalid hunk at line 3: Unexpected line after Delete File 'file.txt': 'bad'. Delete hunks do not contain body lines",
+      "Invalid hunk at line 3: 'bad' is not a valid hunk header",
     )
-    expect(() =>
-      parse("*** Begin Patch\n*** Delete File: file.txt\n*** Frobnicate File: next.txt\n*** End Patch"),
-    ).toThrow("Invalid hunk at line 3: '*** Frobnicate File: next.txt' is not a valid hunk header")
   })
 
   test("rejects an empty update hunk", () => {
@@ -516,6 +478,6 @@ describe("Patch", () => {
     }
     expect(() =>
       parse("*** Begin Patch\n*** Update File: old.txt\n*** Move to: \n@@\n-old\n+new\n*** End Patch"),
-    ).toThrow("Invalid hunk at line 3: Move destination for 'old.txt' must not be empty")
+    ).toThrow("Invalid hunk at line 3: '*** Move to:' is not a valid hunk header")
   })
 })

packages/core/test/plugin.test.ts

@@ -300,8 +300,8 @@ describe("PluginV2", () => {
       yield* plugins.activate([versioned(plugin)])
 
       expect((yield* registry.snapshot()).definitions.map((tool) => tool.name)).toEqual([
-        "context7_look_up",
         "plain",
+        "context7_look_up",
         "execute",
       ])
     }),

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

@@ -49,7 +49,7 @@ const client = Layer.mock(LLMClient.Service)({
       LLMEvent.textDelta({ id: "summary", text: "manual summary" }),
       LLMEvent.stepFinish({
         index: 0,
-        reason: { normalized: "stop" },
+        reason: "stop",
         usage: {
           inputTokens: 15,
           outputTokens: 6,
@@ -60,7 +60,7 @@ const client = Layer.mock(LLMClient.Service)({
         },
       }),
       LLMEvent.finish({
-        reason: { normalized: "stop" },
+        reason: "stop",
       }),
     )
   },

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

@@ -59,8 +59,8 @@ const client = Layer.mock(LLMClient.Service)({
         LLMEvent.textStart({ id: "generate" }),
         LLMEvent.textDelta({ id: "generate", text: "Transient answer" }),
         LLMEvent.textEnd({ id: "generate" }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" }, usage: { inputTokens: 100, outputTokens: 10 } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop", usage: { inputTokens: 100, outputTokens: 10 } }),
+        LLMEvent.finish({ reason: "stop" }),
       ])
       if (!response) throw new Error("Incomplete generate response")
       return response
@@ -97,7 +97,6 @@ const plugins = Layer.mock(PluginSupervisor.Service, { flush: Effect.void })
 const tools = Layer.mock(ToolRegistry.Service, {
   snapshot: () =>
     Effect.succeed({
-      codeModeInstructions: "Captured Code Mode catalog",
       definitions: [ToolDefinition.make({ name: "lookup", description: "Lookup", inputSchema: { type: "object" } })],
       execute: () => Effect.die(new Error("unused")),
     }),
@@ -286,14 +285,13 @@ it.effect("generates from fresh settled Session context without durable mutation
     expect(requests[0]?.system.map((part) => part.text)).toContain("Initial context")
     expect(requests[0]?.http?.headers).toMatchObject({ "X-Session-Id": sessionID })
     expect(requests[0]?.providerOptions).toMatchObject({ openai: { promptCacheKey: sessionID } })
-    const instructionUpdates = requests[0]?.messages.flatMap((message) =>
-      message.role === "system"
-        ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : []))
-        : [],
-    )
-    expect(instructionUpdates).toHaveLength(1)
-    expect(instructionUpdates?.[0]).toContain("Changed context")
-    expect(instructionUpdates?.[0]).toContain("Captured Code Mode catalog")
+    expect(
+      requests[0]?.messages.flatMap((message) =>
+        message.role === "system"
+          ? message.content.flatMap((content) => (content.type === "text" ? [content.text] : []))
+          : [],
+      ),
+    ).toEqual(["Changed context"])
     expect(userTexts(requests[0])).toEqual(["Existing durable context", "Summarize privately"])
     expect(
       requests[0]?.messages.flatMap((message) =>

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

@@ -255,7 +255,7 @@ test("success event data can carry provider-executed result state", () => {
 test("step finish records settlement without publishing step ended", async () => {
   const { published, publisher } = capture()
   await Effect.runPromise(publisher.publish(LLMEvent.stepStart({ index: 0 })))
-  await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } })))
+  await Effect.runPromise(publisher.publish(LLMEvent.stepFinish({ index: 0, reason: "stop" })))
 
   expect(published.some((event) => event.type === "step.ended.2")).toBe(false)
   expect(publisher.stepSettlement()).toMatchObject({ finish: "stop" })
@@ -268,7 +268,7 @@ test("content-filter finish retains failure evidence until step closeout", async
     publisher.publish(
       LLMEvent.stepFinish({
         index: 0,
-        reason: { normalized: "content-filter" },
+        reason: "content-filter",
         usage: {
           nonCachedInputTokens: 8,
           outputTokens: 3,
@@ -311,7 +311,7 @@ test("content-filter finish preserves partial streamed text and never ends the s
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.textStart({ id: "text" }),
         LLMEvent.textDelta({ id: "text", text: "Partial" }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "content-filter" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "content-filter" }),
       ],
       (event) => publisher.publish(event),
       { discard: true },

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

@@ -121,33 +121,6 @@ describe("ToolRegistry", () => {
     }),
   )
 
-  it.effect("canonicalizes effective definitions and keeps Code Mode last", () =>
-    Effect.gen(function* () {
-      const service = yield* ToolRegistry.Service
-      const tool = make()
-      const capture = (registrations: Parameters<typeof service.registerBatch>[0]) =>
-        Effect.scoped(
-          Effect.gen(function* () {
-            yield* service.registerBatch(registrations)
-            return (yield* service.snapshot()).definitions
-          }),
-        )
-      const first = yield* capture([
-        { tools: { zeta: tool, alpha: tool }, options: { codemode: false } },
-        { tools: { beta: tool }, options: { namespace: "alpha", codemode: false } },
-        { tools: { echo: tool } },
-      ])
-      const second = yield* capture([
-        { tools: { echo: tool } },
-        { tools: { beta: tool }, options: { namespace: "alpha", codemode: false } },
-        { tools: { alpha: tool, zeta: tool }, options: { codemode: false } },
-      ])
-
-      expect(first).toEqual(second)
-      expect(first.map((definition) => definition.name)).toEqual(["alpha", "alpha_beta", "zeta", "execute"])
-    }),
-  )
-
   it.effect("filters disabled tools with edit aliases and ordered wildcard precedence", () =>
     Effect.gen(function* () {
       const service = yield* ToolRegistry.Service
@@ -169,7 +142,7 @@ describe("ToolRegistry", () => {
           { action: "*", resource: "*", effect: "deny" },
         ]),
       ).toEqual([])
-      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual(["bash", "question"])
+      expect(yield* names([{ action: "edit", resource: "*", effect: "deny" }])).toEqual(["question", "bash"])
     }),
   )
 
@@ -533,7 +506,6 @@ describe("ToolRegistry", () => {
         .pipe(Scope.provide(scope))
       const toolSet = yield* service.snapshot()
       const execute = toolSet.definitions.find((tool) => tool.name === "execute")
-      expect(toolSet.codeModeInstructions).toContain("tools.echo")
       expect(execute?.description).toContain("confined Code Mode runtime")
       expect(execute?.description).not.toContain("Echo text")
       yield* Scope.close(scope, Exit.void)

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

@@ -43,7 +43,6 @@ import * as SessionRunnerLLM from "@opencode-ai/core/session/runner/llm"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { SessionUsage } from "@opencode-ai/core/session/usage"
 import { ToolRegistry } from "@opencode-ai/core/tool/registry"
-import { CodeMode } from "@opencode-ai/core/codemode"
 import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { SystemPromptPlugin } from "@opencode-ai/core/plugin/system-prompt"
@@ -120,8 +119,8 @@ const client = Layer.succeed(
 const reply = {
   stop: () => [
     LLMEvent.stepStart({ index: 0 }),
-    LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-    LLMEvent.finish({ reason: { normalized: "stop" } }),
+    LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+    LLMEvent.finish({ reason: "stop" }),
   ],
   text: (text: string, id: string) => fragmentFixture("text", id, [text]).completeEvents,
   textWithUsage: (text: string, id: string, inputTokens: number) =>
@@ -137,8 +136,8 @@ const reply = {
   tool: (id: string, name: string, input: unknown) => [
     LLMEvent.stepStart({ index: 0 }),
     LLMEvent.toolCall({ id, name, input }),
-    LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-    LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+    LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+    LLMEvent.finish({ reason: "tool-calls" }),
   ],
 }
 const model = Model.make({ id: "fake-model", provider: "fake", route: OpenAIChat.route })
@@ -369,12 +368,6 @@ const pluginSupervisor = Layer.succeed(
     flush: Effect.suspend(() => pluginFlushHook),
   }),
 )
-let codeModeMaterializations: ReadonlyArray<CodeMode.Materialization> = []
-let codeModeMaterializationCount = 0
-const codeMode = Layer.mock(CodeMode.Service, {
-  register: () => Effect.void,
-  materialize: () => Effect.sync(() => codeModeMaterializations[codeModeMaterializationCount++] ?? {}),
-})
 const promptCatalog = Layer.mock(Catalog.Service, {
   provider: {
     get: () => Effect.succeed(undefined),
@@ -412,7 +405,6 @@ const runnerLayer = AppNodeBuilder.build(SessionRunnerLLM.node, [
   [McpInstructions.node, mcpInstructions],
   [ToolOutputStore.node, toolOutputStore],
   [PluginSupervisor.node, pluginSupervisor],
-  [CodeMode.node, codeMode],
 ])
 const execution = Layer.effect(
   SessionExecution.Service,
@@ -472,7 +464,6 @@ const it = testEffect(
       [Config.node, config],
       [ToolOutputStore.node, toolOutputStore],
       [PluginSupervisor.node, pluginSupervisor],
-      [CodeMode.node, codeMode],
     ],
   ),
 )
@@ -521,8 +512,6 @@ const setup = Effect.gen(function* () {
   systemLoadHook = Effect.void
   modelResolveHook = Effect.void
   pluginFlushHook = Effect.void
-  codeModeMaterializations = []
-  codeModeMaterializationCount = 0
   currentModel = model
   skillBaselines.clear()
   responses = undefined
@@ -693,8 +682,8 @@ const fragmentFixture = (kind: FragmentKind, id: string, chunks: readonly string
         completeEvents: [
           ...partialEvents,
           LLMEvent.textEnd({ id }),
-          LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-          LLMEvent.finish({ reason: { normalized: "stop" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+          LLMEvent.finish({ reason: "stop" }),
         ],
         expectedAssistant: { type: "assistant", finish: "stop", content: [expectedContent] },
         expectedContent,
@@ -713,8 +702,8 @@ const fragmentFixture = (kind: FragmentKind, id: string, chunks: readonly string
         completeEvents: [
           ...partialEvents,
           LLMEvent.reasoningEnd({ id }),
-          LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-          LLMEvent.finish({ reason: { normalized: "stop" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+          LLMEvent.finish({ reason: "stop" }),
         ],
         expectedAssistant: { type: "assistant", finish: "stop", content: [expectedContent] },
         expectedContent,
@@ -834,45 +823,6 @@ const verifyPartialFlushOnInterruption = (kind: FragmentKind) =>
   })
 
 describe("SessionRunnerLLM", () => {
-  it.effect("uses one Code Mode materialization per request for instructions and execution", () =>
-    Effect.gen(function* () {
-      const executed: string[] = []
-      const execute = (name: string) =>
-        Tool.make({
-          description: `Execute ${name}`,
-          input: Schema.Struct({}),
-          output: Schema.String,
-          execute: () => Effect.sync(() => executed.push(name)).pipe(Effect.as({ output: name })),
-        })
-      const session = yield* setup
-      codeModeMaterializations = [
-        { instructions: "Code Mode catalog A", tool: execute("A") },
-        { instructions: "Code Mode catalog B", tool: execute("B") },
-        { instructions: "Code Mode catalog C", tool: execute("C") },
-        { instructions: "Code Mode catalog D", tool: execute("D") },
-      ]
-      yield* admit(session, "Use Code Mode")
-      responses = [reply.tool("call-execute", "execute", {}), reply.stop()]
-
-      yield* session.resume(sessionID)
-
-      expect(requests).toHaveLength(2)
-      expect(codeModeMaterializationCount).toBe(2)
-      expect(requests[0]?.system.some((part) => part.text.includes("Code Mode catalog A"))).toBe(true)
-      expect(requests[0]?.system.some((part) => part.text.includes("Code Mode catalog B"))).toBe(false)
-      expect(requests[0]?.tools.find((tool) => tool.name === "execute")?.description).toBe("Execute A")
-      expect(executed).toEqual(["A"])
-      expect(requests[1]?.tools.find((tool) => tool.name === "execute")?.description).toBe("Execute B")
-      expect(
-        requests[1]?.messages.some(
-          (message) =>
-            message.role === "system" &&
-            message.content.some((part) => part.type === "text" && part.text.includes("Code Mode catalog B")),
-        ),
-      ).toBe(true)
-    }),
-  )
-
   it.effect("applies session context hooks without exposing unavailable tools", () =>
     Effect.gen(function* () {
       const session = yield* setup
@@ -1049,8 +999,8 @@ describe("SessionRunnerLLM", () => {
         [
           LLMEvent.stepStart({ index: 0 }),
           LLMEvent.toolCall({ id: "call-reloaded", name: "reloaded", input: {} }),
-          LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-          LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+          LLMEvent.finish({ reason: "tool-calls" }),
         ],
         [],
       ]
@@ -1149,7 +1099,7 @@ describe("SessionRunnerLLM", () => {
 
       expect(requests).toHaveLength(1)
       expect(requests[0]?.model).toBe(model)
-      expect(requests[0]?.tools.map((tool) => tool.name)).toEqual(["defect", "echo", "storefail"])
+      expect(requests[0]?.tools.map((tool) => tool.name)).toEqual(["echo", "defect", "storefail"])
       expect(requests[0]?.messages.map((message) => ({ role: message.role, content: message.content }))).toEqual([
         { role: "user", content: [{ type: "text", text: "First" }] },
         { role: "user", content: [{ type: "text", text: "Second" }] },
@@ -2427,7 +2377,7 @@ describe("SessionRunnerLLM", () => {
         }),
         LLMEvent.stepFinish({
           index: 0,
-          reason: { normalized: "tool-calls" },
+          reason: "tool-calls",
           usage: {
             inputTokens: 10,
             nonCachedInputTokens: 8,
@@ -2436,13 +2386,13 @@ describe("SessionRunnerLLM", () => {
             cacheReadInputTokens: 2,
           },
         }),
-        LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+        LLMEvent.finish({ reason: "tool-calls" }),
       ]
 
       yield* session.resume(sessionID)
 
       expect(requests).toHaveLength(1)
-      expect(requests[0]?.tools.map((tool) => tool.name)).toEqual(["defect", "echo", "storefail"])
+      expect(requests[0]?.tools.map((tool) => tool.name)).toEqual(["echo", "defect", "storefail"])
       expect(yield* session.context(sessionID)).toMatchObject([
         { type: "user", text: "Use tools" },
         {
@@ -2585,8 +2535,8 @@ describe("SessionRunnerLLM", () => {
             anthropic: { ignored: true },
           },
         }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+        LLMEvent.finish({ reason: "stop" }),
       ]
       yield* session.resume(sessionID)
       yield* replaySessionProjection(sessionID)
@@ -2650,8 +2600,8 @@ describe("SessionRunnerLLM", () => {
           providerExecuted: true,
           providerMetadata: { openai: { blockType: "web_search_tool_result" }, anthropic: { ignored: true } },
         }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+        LLMEvent.finish({ reason: "stop" }),
       ]
       yield* session.resume(sessionID)
       yield* replaySessionProjection(sessionID)
@@ -2698,8 +2648,8 @@ describe("SessionRunnerLLM", () => {
         ),
       ])
       const final = Stream.fromIterable([
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-        LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+        LLMEvent.finish({ reason: "tool-calls" }),
       ])
       responseStream = Stream.concat(
         initial,
@@ -3655,7 +3605,7 @@ describe("SessionRunnerLLM", () => {
       yield* admit(session, "Reject permission")
       responses = [
         reply.tool("call-permission", "permissionfail", {}),
-        [LLMEvent.stepStart({ index: 0 }), LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } })],
+        [LLMEvent.stepStart({ index: 0 }), LLMEvent.stepFinish({ index: 0, reason: "stop" })],
       ]
 
       yield* session.resume(sessionID)
@@ -4004,10 +3954,10 @@ describe("SessionRunnerLLM", () => {
         LLMEvent.textDelta({ id: "partial", text: "Partial" }),
         LLMEvent.stepFinish({
           index: 0,
-          reason: { normalized: "content-filter" },
+          reason: "content-filter",
           usage: { nonCachedInputTokens: 8, outputTokens: 3, reasoningTokens: 1 },
         }),
-        LLMEvent.finish({ reason: { normalized: "content-filter" } }),
+        LLMEvent.finish({ reason: "content-filter" }),
       ]
 
       expect((yield* session.resume(sessionID).pipe(Effect.flip)).message).toBe("Provider blocked the response")
@@ -4040,8 +3990,8 @@ describe("SessionRunnerLLM", () => {
       response = [
         LLMEvent.stepStart({ index: 0 }),
         LLMEvent.toolCall({ id: "call-before-content-filter", name: "echo", input: { text: "settled" } }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "content-filter" } }),
-        LLMEvent.finish({ reason: { normalized: "content-filter" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "content-filter" }),
+        LLMEvent.finish({ reason: "content-filter" }),
       ]
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
@@ -4332,8 +4282,8 @@ describe("SessionRunnerLLM", () => {
             name: "echo",
             raw,
           }),
-          LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-          LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+          LLMEvent.finish({ reason: "tool-calls" }),
         ],
         reply.stop(),
       ]
@@ -4429,8 +4379,8 @@ describe("SessionRunnerLLM", () => {
             name: "echo",
             raw: '{"text":"partial',
           }),
-          LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-          LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+          LLMEvent.finish({ reason: "tool-calls" }),
         ],
         reply.stop(),
       ]
@@ -4471,8 +4421,8 @@ describe("SessionRunnerLLM", () => {
           name: "echo",
           raw: '{"text":"partial',
         }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-        LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+        LLMEvent.finish({ reason: "tool-calls" }),
       ]
 
       const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
@@ -4580,8 +4530,8 @@ describe("SessionRunnerLLM", () => {
           name: "echo",
           raw: '{"text":"partial',
         }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-        LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+        LLMEvent.finish({ reason: "tool-calls" }),
       ]
       responses = [
         malformed("call-first"),
@@ -4615,8 +4565,8 @@ describe("SessionRunnerLLM", () => {
           name: "echo",
           raw: '{"text":"partial',
         }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "tool-calls" } }),
-        LLMEvent.finish({ reason: { normalized: "tool-calls" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
+        LLMEvent.finish({ reason: "tool-calls" }),
       ]
       responses = [malformed("call-first"), malformed("call-at-limit")]
 
@@ -4777,8 +4727,8 @@ describe("SessionRunnerLLM", () => {
       response = [
         LLMEvent.stepStart({ index: 0 }),
         hostedCall("call-hosted-clean-end", "effect"),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+        LLMEvent.finish({ reason: "stop" }),
       ]
 
       yield* session.resume(sessionID)
@@ -4902,8 +4852,8 @@ describe("SessionRunnerLLM", () => {
         LLMEvent.textStart({ id: "text-2" }),
         LLMEvent.textDelta({ id: "text-2", text: "Second" }),
         LLMEvent.textEnd({ id: "text-2" }),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+        LLMEvent.finish({ reason: "stop" }),
       ]
 
       yield* session.resume(sessionID)
@@ -4956,8 +4906,8 @@ describe("SessionRunnerLLM", () => {
         LLMEvent.toolInputDelta({ id: "call-parsed", name: "web_search", text: '{"query":"hello"}' }),
         LLMEvent.toolInputEnd({ id: "call-parsed", name: "web_search" }),
         hostedCall("call-parsed", "hello"),
-        LLMEvent.stepFinish({ index: 0, reason: { normalized: "stop" } }),
-        LLMEvent.finish({ reason: { normalized: "stop" } }),
+        LLMEvent.stepFinish({ index: 0, reason: "stop" }),
+        LLMEvent.finish({ reason: "stop" }),
       ]
 
       yield* session.resume(sessionID)

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

@@ -47,7 +47,7 @@ const client = Layer.mock(LLMClient.Service)({
       LLMEvent.textDelta({ id: "title", text: "Generated Title\n" }),
       LLMEvent.stepFinish({
         index: 0,
-        reason: { normalized: "stop" },
+        reason: "stop",
         usage: {
           inputTokens: 15,
           outputTokens: 6,
@@ -58,7 +58,7 @@ const client = Layer.mock(LLMClient.Service)({
         },
       }),
       LLMEvent.finish({
-        reason: { normalized: "stop" },
+        reason: "stop",
       }),
     )
   },

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

@@ -2,7 +2,6 @@ import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
 import { Effect, Exit, Layer, Schema } from "effect"
-import { systemError } from "effect/PlatformError"
 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"
@@ -29,8 +28,6 @@ const sessionID = SessionV2.ID.make("ses_patch_tool_test")
 const assertions: PermissionV2.AssertInput[] = []
 let denyAction: string | undefined
 let failRemoveTarget: string | undefined
-let failRemoveErrorTarget: string | undefined
-let failWriteTarget: string | undefined
 let readsBeforeEditApproval = 0
 let editApproved = false
 let afterEditApproval = (): Effect.Effect<void> => Effect.void
@@ -68,8 +65,6 @@ const reset = () => {
   assertions.length = 0
   denyAction = undefined
   failRemoveTarget = undefined
-  failRemoveErrorTarget = undefined
-  failWriteTarget = undefined
   readsBeforeEditApproval = 0
   editApproved = false
   afterEditApproval = () => Effect.void
@@ -87,33 +82,8 @@ const filesystem = Layer.effect(
         }).pipe(Effect.andThen(fs.readFile(target))),
       remove: (target, options) => {
         if (failRemoveTarget && path.basename(target) === failRemoveTarget) return Effect.die("forced remove failure")
-        if (failRemoveErrorTarget && path.basename(target) === failRemoveErrorTarget) {
-          return Effect.fail(
-            systemError({
-              _tag: "Unknown",
-              module: "FileSystem",
-              method: "remove",
-              description: "forced remove failure",
-              pathOrDescriptor: target,
-            }),
-          )
-        }
         return fs.remove(target, options)
       },
-      writeWithDirs: (target, content, mode) => {
-        if (failWriteTarget && path.basename(target) === failWriteTarget) {
-          return Effect.fail(
-            systemError({
-              _tag: "Unknown",
-              module: "FileSystem",
-              method: "writeWithDirs",
-              description: "forced write failure",
-              pathOrDescriptor: target,
-            }),
-          )
-        }
-        return fs.writeWithDirs(target, content, mode)
-      },
     })
   }),
 ).pipe(Layer.provide(LayerNode.compile(FSUtil.node)))
@@ -332,27 +302,6 @@ describe("PatchTool", () => {
     ),
   )
 
-  it.live("moves a file without changing its contents", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        const source = path.join(directory, "old.txt")
-        const destination = path.join(directory, "moved.txt")
-        yield* Effect.promise(() => fs.writeFile(source, "same\n"))
-        expect(
-          yield* executeTool(
-            registry,
-            call("*** Begin Patch\n*** Update File: old.txt\n*** Move to: moved.txt\n@@\n same\n*** End Patch"),
-          ),
-        ).toMatchObject({
-          status: "completed",
-          content: [{ type: "text", text: "Success. Updated the following files:\nM moved.txt" }],
-        })
-        expect(yield* exists(source)).toBe(false)
-        expect(yield* Effect.promise(() => fs.readFile(destination, "utf8"))).toBe("same\n")
-      }),
-    ),
-  )
-
   it.live("moves a symlink without deleting its target", () =>
     withTempTool((directory, registry) =>
       Effect.gen(function* () {
@@ -502,17 +451,10 @@ describe("PatchTool", () => {
   it.live("rejects an empty patch", () =>
     withTempTool((_directory, registry) =>
       Effect.gen(function* () {
-        for (const patchText of [
-          "*** Begin Patch\n*** End Patch",
-          " *** Begin Patch \n *** End Patch ",
-          "<<EOF\n*** Begin Patch\n*** End Patch\nEOF",
-          "*** Begin Patch\n*** Environment ID: remote\n*** End Patch",
-        ]) {
-          expect(yield* executeTool(registry, call(patchText))).toEqual({
-            status: "error",
-            error: { type: "tool.execution", message: "patch rejected: empty patch" },
-          })
-        }
+        expect(yield* executeTool(registry, call("*** Begin Patch\n*** End Patch"))).toEqual({
+          status: "error",
+          error: { type: "tool.execution", message: "patch rejected: empty patch" },
+        })
       }),
     ),
   )
@@ -583,10 +525,7 @@ describe("PatchTool", () => {
           ),
         ).toMatchObject({
           status: "error",
-          error: {
-            type: "tool.execution",
-            message: "patch verification failed: Failed to find expected lines in unchanged.txt:\nmissing",
-          },
+          error: { message: expect.stringContaining("Failed to find expected lines") },
         })
         expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("line1\nline2\n")
       }),
@@ -630,83 +569,12 @@ describe("PatchTool", () => {
     ),
   )
 
-  it.live("identifies a missing delete target", () =>
+  it.live("rejects a delete when the target file is missing", () =>
     withTempTool((_directory, registry) =>
       Effect.gen(function* () {
         expect(
           yield* executeTool(registry, call("*** Begin Patch\n*** Delete File: missing.txt\n*** End Patch")),
-        ).toEqual({
-          status: "error",
-          error: {
-            type: "tool.execution",
-            message: "patch verification failed: Failed to delete missing.txt: file does not exist",
-          },
-        })
-      }),
-    ),
-  )
-
-  it.live("reports the failing destination and filesystem error", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() => fs.writeFile(path.join(directory, "old.txt"), "before\n"))
-        failWriteTarget = "new.txt"
-        expect(
-          yield* executeTool(
-            registry,
-            call("*** Begin Patch\n*** Update File: old.txt\n*** Move to: new.txt\n@@\n-before\n+after\n*** End Patch"),
-          ),
-        ).toEqual({
-          status: "error",
-          error: { type: "tool.execution", message: "Failed to write new.txt: forced write failure" },
-        })
-        expect(yield* Effect.promise(() => fs.readFile(path.join(directory, "old.txt"), "utf8"))).toBe("before\n")
-        expect(yield* exists(path.join(directory, "new.txt"))).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("reports the successful prefix and filesystem error", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        failWriteTarget = "second.txt"
-        expect(
-          yield* executeTool(
-            registry,
-            call("*** Begin Patch\n*** Add File: first.txt\n+first\n*** Add File: second.txt\n+second\n*** End Patch"),
-          ),
-        ).toEqual({
-          status: "error",
-          error: {
-            type: "tool.execution",
-            message: "Failed to write second.txt: forced write failure. Completed before failure: first.txt",
-          },
-        })
-        expect(yield* Effect.promise(() => fs.readFile(path.join(directory, "first.txt"), "utf8"))).toBe("first\n")
-        expect(yield* exists(path.join(directory, "second.txt"))).toBe(false)
-      }),
-    ),
-  )
-
-  it.live("reports a destination written before move removal fails", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        yield* Effect.promise(() => fs.writeFile(path.join(directory, "old.txt"), "before\n"))
-        failRemoveErrorTarget = "old.txt"
-        expect(
-          yield* executeTool(
-            registry,
-            call("*** Begin Patch\n*** Update File: old.txt\n*** Move to: new.txt\n@@\n-before\n+after\n*** End Patch"),
-          ),
-        ).toEqual({
-          status: "error",
-          error: {
-            type: "tool.execution",
-            message: "Wrote new.txt but failed to remove old.txt: forced remove failure",
-          },
-        })
-        expect(yield* Effect.promise(() => fs.readFile(path.join(directory, "old.txt"), "utf8"))).toBe("before\n")
-        expect(yield* Effect.promise(() => fs.readFile(path.join(directory, "new.txt"), "utf8"))).toBe("after\n")
+        ).toMatchObject({ status: "error", error: { message: expect.stringContaining("patch verification failed") } })
       }),
     ),
   )
@@ -760,7 +628,7 @@ describe("PatchTool", () => {
                       registry,
                       call(`*** Begin Patch\n*** Update File: ${target}\n@@\n-before\n+after\n*** End Patch`),
                     ),
-                  ).toMatchObject({ status: "error", error: { type: "permission.rejected" } })
+                  ).toMatchObject({ status: "error" })
                   expect(assertions.map((input) => input.action)).toEqual(["external_directory"])
                   expect(readsBeforeEditApproval).toBe(0)
                   expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("before\n")
@@ -777,24 +645,6 @@ describe("PatchTool", () => {
     ),
   )
 
-  it.live("preserves edit permission rejection", () =>
-    withTempTool((directory, registry) =>
-      Effect.gen(function* () {
-        const target = path.join(directory, "target.txt")
-        yield* Effect.promise(() => fs.writeFile(target, "before\n"))
-        denyAction = "edit"
-        expect(
-          yield* executeTool(
-            registry,
-            call("*** Begin Patch\n*** Update File: target.txt\n@@\n-before\n+after\n*** End Patch"),
-          ),
-        ).toMatchObject({ status: "error", error: { type: "permission.rejected" } })
-        expect(assertions.map((input) => input.action)).toEqual(["edit"])
-        expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("before\n")
-      }),
-    ),
-  )
-
   it.live("treats a sibling path inside the project worktree as internal", () =>
     Effect.acquireUseRelease(
       Effect.promise(() => tmpdir()),

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

@@ -120,13 +120,21 @@ describe("WriteTool", () => {
           Effect.gen(function* () {
             expect((yield* toolDefinitions(registry)).map((tool) => tool.name)).toEqual(["write"])
             const settled = yield* executeTool(registry, call({ path: "src/new.txt", content: "created" }))
-            expect(settled).toEqual({
+            expect(settled).toMatchObject({
               status: "completed",
               output: {
                 operation: "write",
                 target: path.join(yield* Effect.promise(() => fs.realpath(tmp.path)), "src", "new.txt"),
                 resource: "src/new.txt",
                 existed: false,
+                files: [
+                  {
+                    file: "src/new.txt",
+                    status: "added",
+                    additions: 1,
+                    deletions: 0,
+                  },
+                ],
               },
               content: [{ type: "text", text: "Created file successfully: src/new.txt" }],
             })
@@ -156,7 +164,21 @@ describe("WriteTool", () => {
               expect(settled.status).toBe("completed")
               if (settled.status !== "completed") return
               expect(settled.content).toEqual([{ type: "text", text: "Wrote file successfully: existing.txt" }])
-              expect(settled.output).toMatchObject({ resource: "existing.txt", existed: true })
+              expect(settled.output).toMatchObject({
+                resource: "existing.txt",
+                existed: true,
+                files: [
+                  {
+                    file: "existing.txt",
+                    status: "modified",
+                    additions: 1,
+                    deletions: 1,
+                  },
+                ],
+              })
+              const output = settled.output as WriteTool.Output
+              expect(output.files[0]?.patch).toContain("-before")
+              expect(output.files[0]?.patch).toContain("+after")
               expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "existing.txt"), "utf8"))).toBe(
                 "after",
               )

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

@@ -767,23 +767,19 @@ export function RunSubagentSelectBody(props: {
   onRows?: (rows: number) => void
   mono?: boolean
 }) {
-  const [active, setActive] = createSignal(true)
   const entries = createMemo<SubagentEntry[]>(() =>
-    props
-      .tabs()
-      .filter((item) => (active() ? item.status === "running" : item.status !== "running"))
-      .map((item) => {
-        const title = item.description || item.title || item.label
-        return {
-          category: "",
-          display: title,
-          description: title === item.label ? undefined : item.label,
-          footer: subagentStatusLabel(item.status),
-          keywords: `${item.label} ${item.description} ${item.title ?? ""} ${item.status}`,
-          sessionID: item.sessionID,
-          current: props.current() === item.sessionID,
-        }
-      }),
+    props.tabs().map((item) => {
+      const title = item.description || item.title || item.label
+      return {
+        category: "",
+        display: title,
+        description: title === item.label ? undefined : item.label,
+        footer: subagentStatusLabel(item.status),
+        keywords: `${item.label} ${item.description} ${item.title ?? ""} ${item.status}`,
+        sessionID: item.sessionID,
+        current: props.current() === item.sessionID,
+      }
+    }),
   )
   const controller = createSearchablePanelController({
     entries,
@@ -792,12 +788,6 @@ export function RunSubagentSelectBody(props: {
     onSelect: (item) => props.onSelect(item.sessionID),
     isCurrent: (item) => item.current,
     closeOnFirstUp: true,
-    onKey(event) {
-      if (event.name.toLowerCase() !== "tab") return false
-      event.preventDefault()
-      setActive((value) => !value)
-      return true
-    },
     onRows: props.onRows,
   })
 
@@ -811,7 +801,6 @@ export function RunSubagentSelectBody(props: {
       theme={props.theme}
       inputRef={controller.inputRef}
       onQuery={controller.setQuery}
-      hint={`tab show ${active() ? "inactive" : "active"}`}
       mono={props.mono}
     >
       <RunFooterMenu

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

@@ -62,6 +62,7 @@ import parsers from "../../parsers-config"
 import { errorMessage } from "../../util/error"
 import { useToast } from "../../ui/toast"
 import stripAnsi from "strip-ansi"
+import { createTwoFilesPatch } from "diff"
 import { usePromptRef } from "../../context/prompt"
 import { projectedPromptInput } from "../../prompt/codec"
 import { useEpilogue } from "../../context/epilogue"
@@ -2693,28 +2694,56 @@ function Shell(props: ToolProps) {
 }
 
 function Write(props: ToolProps) {
+  const ctx = use()
   const { themeV2, syntax } = useTheme()
   const pathFormatter = usePathFormatter()
   const code = createMemo(() => {
     return stringValue(props.input.content) ?? ""
   })
+  const file = createMemo(() => parseApplyPatchFiles(props.metadata.files)[0])
+  const patch = createMemo(
+    () => file()?.patch ?? createTwoFilesPatch("", stringValue(props.input.path) ?? "", "", code()),
+  )
+  const complete = createMemo(() => props.part.state.status === "completed")
+  const view = createMemo(() => {
+    if (ctx.config.diffs?.view === "unified") return "unified"
+    if (ctx.config.diffs?.view === "split") return "split"
+    return ctx.width > 120 ? "split" : "unified"
+  })
 
   return (
     <Switch>
-      <Match when={props.metadata.diagnostics !== undefined}>
+      <Match when={complete()}>
         <BlockTool
-          path={{ label: "# Wrote", value: pathFormatter.format(stringValue(props.input.path)) }}
+          path={{
+            label: props.metadata.existed === false ? "# Created" : "# Wrote",
+            value: pathFormatter.format(stringValue(props.input.path)),
+          }}
           part={props.part}
         >
-          <line_number fg={themeV2.text.subdued} minWidth={3} paddingRight={1}>
-            <code
-              conceal={false}
-              fg={themeV2.text.default}
-              filetype={filetype(stringValue(props.input.path))}
-              syntaxStyle={syntax()}
-              content={code()}
-            />
-          </line_number>
+          <Show when={code() || file()?.additions || file()?.deletions}>
+            <box paddingLeft={1}>
+              <diff
+                diff={patch()}
+                view={view()}
+                filetype={filetype(stringValue(props.input.path))}
+                syntaxStyle={syntax()}
+                showLineNumbers={true}
+                width="100%"
+                wrapMode={ctx.diffWrapMode()}
+                fg={themeV2.text.default}
+                addedBg={themeV2.diff.background.added}
+                removedBg={themeV2.diff.background.removed}
+                contextBg={themeV2.diff.background.context}
+                addedSignColor={themeV2.diff.highlight.added}
+                removedSignColor={themeV2.diff.highlight.removed}
+                lineNumberFg={themeV2.diff.lineNumber.text}
+                lineNumberBg={themeV2.diff.background.context}
+                addedLineNumberBg={themeV2.diff.lineNumber.background.added}
+                removedLineNumberBg={themeV2.diff.lineNumber.background.removed}
+              />
+            </box>
+          </Show>
           <Diagnostics diagnostics={props.metadata.diagnostics} filePath={stringValue(props.input.path) ?? ""} />
         </BlockTool>
       </Match>

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

@@ -740,7 +740,7 @@ test("direct command panel keeps completed subagents available", async () => {
   }
 })
 
-test("direct subagent panel toggles between active and inactive subagents", async () => {
+test("direct subagent panel renders active subagents", async () => {
   const [tabs] = createSignal([
     subagent({ sessionID: "s-1", label: "Explore", description: "Inspect auth flow" }),
     subagent({ sessionID: "s-2", label: "General", description: "Write migration plan", status: "completed" }),
@@ -776,22 +776,12 @@ test("direct subagent panel toggles between active and inactive subagents", asyn
 
     expect(frame).toContain("Select subagent")
     expect(frame).toContain("Inspect auth flow")
-    expect(frame).not.toContain("Write migration plan")
-    expect(frame).not.toContain("done")
-    expect(frame).toContain("tab show inactive")
+    expect(frame).toContain("Write migration plan")
+    expect(frame).toContain("done")
     expect(frame).not.toContain("┌")
     expect(frame).not.toContain("┃")
     expectPaletteList(list, 0)
-    expect(rows).toBe(7)
-
-    app.mockInput.pressKey("TAB")
-    await app.renderOnce()
-    const inactive = app.captureCharFrame()
-
-    expect(inactive).not.toContain("Inspect auth flow")
-    expect(inactive).toContain("Write migration plan")
-    expect(inactive).toContain("done")
-    expect(inactive).toContain("tab show active")
+    expect(rows).toBe(8)
   } finally {
     app.renderer.destroy()
   }

packages/util/src/patch.ts

@@ -69,7 +69,7 @@ export function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, Par
     }
     if (header.startsWith("*** Add File: ")) {
       const path = header.slice("*** Add File: ".length).trim()
-      const parsed = parseAdd(lines, index + 1, end, path)
+      const parsed = parseAdd(lines, index + 1, end)
       if ("error" in parsed) return Result.fail(parsed.error)
       hunks.push({ type: "add", path, contents: parsed.content })
       index = parsed.next
@@ -77,19 +77,6 @@ export function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, Par
     }
     if (header.startsWith("*** Delete File: ")) {
       const path = header.slice("*** Delete File: ".length).trim()
-      const next = lines[index + 1]?.trim()
-      if (index + 1 < end && next !== undefined && !isBoundary(next)) {
-        if (next.startsWith("*** ")) {
-          return Result.fail(new InvalidHunkError({ line: next, lineNumber: index + 2 }))
-        }
-        return Result.fail(
-          new InvalidHunkError({
-            line: next,
-            lineNumber: index + 2,
-            reason: `Unexpected line after Delete File '${path}': '${next}'. Delete hunks do not contain body lines`,
-          }),
-        )
-      }
       hunks.push({ type: "delete", path })
       index++
       continue
@@ -103,13 +90,7 @@ export function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, Par
       if (move === "*** Move to:" || move?.startsWith("*** Move to: ")) {
         movePath = move.slice("*** Move to: ".length).trim()
         if (!movePath) {
-          return Result.fail(
-            new InvalidHunkError({
-              line: lines[next]!.trim(),
-              lineNumber: next + 1,
-              reason: `Move destination for '${path}' must not be empty`,
-            }),
-          )
+          return Result.fail(new InvalidHunkError({ line: lines[next]!.trim(), lineNumber: next + 1 }))
         }
         next++
       }
@@ -145,20 +126,12 @@ function parseAdd(
   lines: ReadonlyArray<string>,
   start: number,
   end: number,
-  path: string,
 ): { content: string; next: number } | { error: InvalidHunkError } {
   const content: string[] = []
   let index = start
   while (index < end && !isBoundary(lines[index]!.trim())) {
     if (!lines[index]!.startsWith("+")) {
-      const line = lines[index]!.trim()
-      return {
-        error: new InvalidHunkError({
-          line,
-          lineNumber: index + 1,
-          reason: `Invalid Add File line for '${path}': expected a line starting with '+', got '${line}'`,
-        }),
-      }
+      return { error: new InvalidHunkError({ line: lines[index]!.trim(), lineNumber: index + 1 }) }
     }
     content.push(lines[index]!.slice(1))
     index++
@@ -330,11 +303,6 @@ function computeReplacements(lines: ReadonlyArray<string>, path: string, chunks:
       if (newLines.at(-1) === "") newLines = newLines.slice(0, -1)
       found = seek(lines, oldLines, lineIndex, chunk.endOfFile)
     }
-    if (found === -1 && chunk.oldLines.every((line) => line === "")) {
-      const expected =
-        chunk.oldLines.length === 1 ? "an expected blank line" : `${chunk.oldLines.length} consecutive blank lines`
-      throw new Error(`Failed to find ${expected} in ${path}`)
-    }
     if (found === -1) throw new Error(`Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`)
     replacements.push([found, oldLines.length, newLines])
     lineIndex = found + oldLines.length