fix(core): restore external directory defaults

2026-07-17 18:30:07 +00:00
134 changed files with 967 additions and 4693 deletions
@@ -900,9 +900,6 @@
      "version": "1.17.13",
      "dependencies": {
        "@fontsource/commit-mono": "5.2.5",
-        "@fontsource/noto-sans-math": "5.2.5",
-        "@fontsource/noto-sans-symbols": "5.2.5",
-        "@fontsource/noto-sans-symbols-2": "5.2.5",
        "@napi-rs/canvas": "1.0.2",
        "@opencode-ai/ai": "workspace:*",
        "@opencode-ai/core": "workspace:*",
@@ -1798,12 +1795,6 @@

    "@fontsource/inter": ["@fontsource/inter@5.2.8", "", {}, "sha512-P6r5WnJoKiNVV+zvW2xM13gNdFhAEpQ9dQJHt3naLvfg+LkF2ldgSLiF4T41lf1SQCM9QmkqPTn4TH568IRagg=="],

-    "@fontsource/noto-sans-math": ["@fontsource/noto-sans-math@5.2.5", "", {}, "sha512-1bxEvVlF51Vfgpju32mRZzI/CHvsfqjXjI2+sAuEyHYvXABUAIyj+93sCO3QZIoMG5drWyrzgoCqRQRaL6wQ8Q=="],
-
-    "@fontsource/noto-sans-symbols": ["@fontsource/noto-sans-symbols@5.2.5", "", {}, "sha512-mxoIRstsmZpZFzd/SRWiD+l6T7TGhpgCrGs7TEnnuGSQIfjVMrQT9Zej2enh9pkfmPNAFyeaGJkHkszJ1hH++w=="],
-
-    "@fontsource/noto-sans-symbols-2": ["@fontsource/noto-sans-symbols-2@5.2.5", "", {}, "sha512-F4O9WLifwoZS1quNzY1ebjMNo2cQPe/UP68Dmud0ONi2lOxaR6xp6fFPO2gG17MI7DwAnfMyQFl64A2tAd28hg=="],
-
    "@fuma-translate/react": ["@fuma-translate/react@1.0.2", "", { "peerDependencies": { "@types/react": "*", "react": "^19.2.0", "react-dom": "^19.2.0" }, "optionalPeers": ["@types/react"] }, "sha512-uOiOtBx3nRXR8Nu1GzBf1tApgF1FErDBTHxRIAQeyQdyOoZbrNRN6H4kDCWObY4qyGeGbHydG0DHzgeUgFDMIw=="],

    "@fumadocs/tailwind": ["@fumadocs/tailwind@0.1.0", "", { "peerDependencies": { "tailwindcss": "^4.0.0" }, "optionalPeers": ["tailwindcss"] }, "sha512-nF/DCAwOR21HZ4AkjIOv3Iqwyqywzb6pdyeMcoa+aZzirXj5ntvNZbe3jJ0v3ehhtrRfYYeXBezvjn8ZmV+fuQ=="],
@@ -1,6 +1,6 @@
 # LLM Provider Parity Status

-Last reviewed: 2026-07-17
+Last reviewed: 2026-07-16

 This file tracks the gap between the native `@opencode-ai/ai` package and the AI SDK provider packages that opencode still depends on for many catalog/runtime paths.

@@ -20,7 +20,7 @@ This file tracks the gap between the native `@opencode-ai/ai` package and the AI
 | OpenAI Responses WebSocket         | `src/protocols/openai-responses.ts`, `src/route/transport/websocket.ts`                        | Present as `OpenAI.responsesWebSocket(...)`.                                                                                                                             | Runner/catalog support explicitly must not downgrade WebSocket routes; broader runtime selection is not complete.                                                                                                                                         |
 | OpenAI-compatible Chat             | `src/protocols/openai-compatible-chat.ts`, `src/providers/openai-compatible.ts`                | Usable for generic Chat and several profiles: Baseten, Cerebras, DeepInfra, DeepSeek, Fireworks, Groq, TogetherAI.                                                       | Family quirks are mostly endpoint defaults, not full typed behavior.                                                                                                                                                                                      |
 | OpenAI-compatible Responses        | `src/protocols/openai-compatible-responses.ts`, `src/providers/openai-compatible-responses.ts` | Usable for deployments that implement the OpenAI Responses wire protocol.                                                                                                | No named family profiles or recorded deployment coverage yet.                                                                                                                                                                                             |
-| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                 | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base; MiniMax M3 has recorded text and tool-loop coverage.       | No named compatible family profiles yet.                                                                                                                                                                                                                  |
+| Anthropic-compatible Messages      | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic-compatible.ts`                 | Usable for deployments that implement the Anthropic Messages wire protocol. Named Anthropic composes this base.                                                          | No named compatible family profiles or recorded deployment coverage yet.                                                                                                                                                                                  |
 | Anthropic Messages                 | `src/protocols/anthropic-messages.ts`, `src/providers/anthropic.ts`                            | Usable. Supports tools, thinking, cache control, images, server-hosted tool events, and usage.                                                                           | Provider option surface is small. Beta/header handling, metadata, and newer Messages fields need a typed parity pass.                                                                                                                                     |
 | Gemini Developer API               | `src/protocols/gemini.ts`, `src/providers/google.ts`                                           | Usable for Google API key flow. Supports text, images, tools, thinking signatures, and cache usage.                                                                      | This is not Vertex. Typed provider options are narrow; many Gemini request fields currently require raw `http.body` overlays.                                                                                                                             |
 | Vertex Gemini                      | `src/protocols/gemini.ts`, `src/providers/google-vertex.ts`                                    | Usable through API-key express mode, explicit OAuth tokens, or ADC with project/location endpoint derivation, including tuned `endpoints/...` deployments.               | Core runner/catalog mapping and recorded provider coverage are missing.                                                                                                                                                                                   |
@@ -161,18 +161,6 @@ const PROVIDERS: ReadonlyArray<Provider> = [
    vars: [{ name: "TOGETHER_AI_API_KEY" }],
    validate: (env) => validateBearer("https://api.together.xyz/v1/models", Redacted.make(env.TOGETHER_AI_API_KEY)),
  },
-  {
-    id: "minimax",
-    label: "MiniMax",
-    tier: "compatible",
-    note: "Anthropic-compatible Messages text/tool recorded tests",
-    vars: [{ name: "MINIMAX_API_KEY" }],
-    validate: (env) =>
-      HttpClientRequest.get("https://api.minimax.io/anthropic/v1/models").pipe(
-        HttpClientRequest.setHeader("x-api-key", Redacted.value(Redacted.make(env.MINIMAX_API_KEY))),
-        executeRequest,
-      ),
-  },
  {
    id: "mistral",
    label: "Mistral",
@@ -703,14 +703,7 @@ const onContentBlockStart = (state: ParserState, event: AnthropicEvent): StepRes
          providerExecuted: block.type === "server_tool_use",
        }),
      },
-      [
-        ...events,
-        LLMEvent.toolInputStart({
-          id: block.id ?? String(event.index),
-          name: block.name ?? "",
-          providerExecuted: block.type === "server_tool_use" ? true : undefined,
-        }),
-      ],
+      [...events, LLMEvent.toolInputStart({ id: block.id ?? String(event.index), name: block.name ?? "" })],
    ]
  }

@@ -561,9 +561,7 @@ const step = (state: ParserState, event: BedrockEvent) =>
      return [
        {
          ...state,
-          hasToolCalls:
-            resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-            state.hasToolCalls,
+          hasToolCalls: resultEvents.some(LLMEvent.is.toolCall) ? true : state.hasToolCalls,
          lifecycle,
          tools: result.tools,
          reasoningSignatures: Object.fromEntries(
@@ -75,8 +75,6 @@ const OpenAIChatMessage = Schema.Union([
    content: Schema.NullOr(Schema.String),
    tool_calls: optionalArray(OpenAIChatAssistantToolCall),
    reasoning_content: Schema.optional(Schema.String),
-    reasoning: Schema.optional(Schema.String),
-    reasoning_text: Schema.optional(Schema.String),
  }),
  Schema.Struct({ role: Schema.Literal("tool"), tool_call_id: Schema.String, content: Schema.String }),
 ]).pipe(Schema.toTaggedUnion("role"))
@@ -147,8 +145,6 @@ type OpenAIChatToolCallDelta = Schema.Schema.Type<typeof OpenAIChatToolCallDelta
 const OpenAIChatDelta = Schema.Struct({
  content: optionalNull(Schema.String),
  reasoning_content: optionalNull(Schema.String),
-  reasoning: optionalNull(Schema.String),
-  reasoning_text: optionalNull(Schema.String),
  tool_calls: optionalNull(Schema.Array(OpenAIChatToolCallDelta)),
 })

@@ -170,7 +166,6 @@ export interface ParserState {
  readonly usage?: Usage
  readonly finishReason?: FinishReason
  readonly lifecycle: Lifecycle.State
-  readonly reasoningField?: "reasoning" | "reasoning_content" | "reasoning_text"
 }

 // =============================================================================
@@ -213,12 +208,6 @@ const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part: MediaPart
 const openAICompatibleReasoningContent = (native: unknown) =>
  isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined

-const reasoningField = (part: ReasoningPart) => {
-  const field = part.providerMetadata?.openai?.reasoningField
-  if (field === "reasoning" || field === "reasoning_content" || field === "reasoning_text") return field
-  return "reasoning_content"
-}
-
 const lowerUserMessage = Effect.fn("OpenAIChat.lowerUserMessage")(function* (message: OpenAIChatRequestMessage) {
  const content: Array<Schema.Schema.Type<typeof OpenAIChatUserContent>> = []
  for (const part of message.content) {
@@ -259,20 +248,14 @@ const lowerAssistantMessage = Effect.fn("OpenAIChat.lowerAssistantMessage")(func
      continue
    }
  }
-  const text = reasoning.map((part) => part.text).join("")
-  const field = reasoning[0] ? reasoningField(reasoning[0]) : "reasoning_content"
  return {
    role: "assistant" as const,
    content: content.length === 0 ? null : ProviderShared.joinText(content),
    tool_calls: toolCalls.length === 0 ? undefined : toolCalls,
    reasoning_content:
-      reasoning.length === 0
-        ? openAICompatibleReasoningContent(message.native?.openaiCompatible)
-        : field === "reasoning_content"
-          ? text
-          : undefined,
-    reasoning: reasoning.length > 0 && field === "reasoning" ? text : undefined,
-    reasoning_text: reasoning.length > 0 && field === "reasoning_text" ? text : undefined,
+      reasoning.length > 0
+        ? reasoning.map((part) => part.text).join("")
+        : openAICompatibleReasoningContent(message.native?.openaiCompatible),
  }
 })

@@ -417,12 +400,6 @@ const mapUsage = (usage: OpenAIChatEvent["usage"]): Usage | undefined => {
  })
 }

-const reasoningDelta = (delta: Schema.Schema.Type<typeof OpenAIChatDelta> | null | undefined) => {
-  if (delta?.reasoning_content) return { field: "reasoning_content", text: delta.reasoning_content } as const
-  if (delta?.reasoning) return { field: "reasoning", text: delta.reasoning } as const
-  if (delta?.reasoning_text) return { field: "reasoning_text", text: delta.reasoning_text } as const
-}
-
 const step = (state: ParserState, event: OpenAIChatEvent) =>
  Effect.gen(function* () {
    const events: LLMEvent[] = []
@@ -435,12 +412,8 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>

    let lifecycle = state.lifecycle

-    const reasoning = reasoningDelta(delta)
-    const reasoningField = state.reasoningField ?? reasoning?.field
-    if (reasoning)
-      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", reasoning.text, {
-        openai: { reasoningField: reasoningField ?? reasoning.field },
-      })
+    if (delta?.reasoning_content)
+      lifecycle = Lifecycle.reasoningDelta(lifecycle, events, "reasoning-0", delta.reasoning_content)

    if (delta?.content) {
      lifecycle = Lifecycle.reasoningEnd(lifecycle, events, "reasoning-0")
@@ -464,7 +437,7 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
    }

    // Finalize accumulated tool inputs eagerly when finish_reason arrives so
-    // valid calls and malformed local calls settle independently.
+    // JSON parse failures fail the stream at the boundary rather than at halt.
    const finished =
      finishReason !== undefined && state.finishReason === undefined && Object.keys(tools).length > 0
        ? yield* ToolStream.finishAll(ADAPTER, tools)
@@ -477,7 +450,6 @@ const step = (state: ParserState, event: OpenAIChatEvent) =>
        usage,
        finishReason,
        lifecycle,
-        reasoningField,
      },
      events,
    ] as const
@@ -510,12 +482,7 @@ export const protocol = Protocol.make({
  },
  stream: {
    event: Protocol.jsonEvent(OpenAIChatEvent),
-    initial: () => ({
-      tools: ToolStream.empty<number>(),
-      toolCallEvents: [],
-      lifecycle: Lifecycle.initial(),
-      reasoningField: undefined,
-    }),
+    initial: () => ({ tools: ToolStream.empty<number>(), toolCallEvents: [], lifecycle: Lifecycle.initial() }),
    step,
    onHalt: finishEvents,
  },
@@ -835,9 +835,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
      {
        ...state,
        lifecycle,
-        hasFunctionCall:
-          resultEvents.some((event) => LLMEvent.is.toolCall(event) || LLMEvent.is.toolInputError(event)) ||
-          state.hasFunctionCall,
+        hasFunctionCall: resultEvents.some(LLMEvent.is.toolCall) ? true : state.hasFunctionCall,
        tools: result.tools,
      },
      events,
@@ -1,5 +1,5 @@
 import { Effect } from "effect"
-import { LLMError, LLMEvent, type ProviderMetadata, type ToolCall, type ToolInputError } from "../../schema"
+import { LLMError, LLMEvent, type ProviderMetadata, type ToolCall } from "../../schema"
 import { eventError, parseToolInput, type ToolAccumulator } from "../shared"

 type StreamKey = string | number
@@ -53,7 +53,6 @@ const inputStart = (tool: PendingTool) =>
  LLMEvent.toolInputStart({
    id: tool.id,
    name: tool.name,
-    providerExecuted: tool.providerExecuted ? true : undefined,
    providerMetadata: tool.providerMetadata,
  })

@@ -64,36 +63,19 @@ const inputDelta = (tool: PendingTool, text: string) =>
    text,
  })

-const toolCall = (route: string, tool: PendingTool, inputOverride?: string) => {
-  const raw = inputOverride ?? tool.input
-  return parseToolInput(route, tool.name, raw).pipe(
-    Effect.map((input): ToolCall | ToolInputError =>
-      LLMEvent.toolCall({
-        id: tool.id,
-        name: tool.name,
-        input,
-        providerExecuted: tool.providerExecuted ? true : undefined,
-        providerMetadata: tool.providerMetadata,
-      }),
-    ),
-    Effect.catch((error) =>
-      tool.providerExecuted
-        ? Effect.fail(error)
-        : Effect.succeed(
-            LLMEvent.toolInputError({
-              id: tool.id,
-              name: tool.name,
-              raw,
-            }),
-          ),
+const toolCall = (route: string, tool: PendingTool, inputOverride?: string) =>
+  parseToolInput(route, tool.name, inputOverride ?? tool.input).pipe(
+    Effect.map(
+      (input): ToolCall =>
+        LLMEvent.toolCall({
+          id: tool.id,
+          name: tool.name,
+          input,
+          providerExecuted: tool.providerExecuted ? true : undefined,
+          providerMetadata: tool.providerMetadata,
+        }),
    ),
  )
-}
-
-const finishEvents = (tool: PendingTool, event: ToolCall | ToolInputError): ReadonlyArray<LLMEvent> =>
-  event.type === "tool-input-error"
-    ? [event]
-    : [LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }), event]

 /** Store the updated tool and produce the optional public delta event. */
 const appendTool = <K extends StreamKey>(
@@ -176,9 +158,8 @@ export const appendExisting = <K extends StreamKey>(

 /**
 * Finalize one pending tool call: parse the accumulated raw JSON, remove it
- * from state, and return either a call or a non-executable local input error.
- * Missing keys are a no-op because some providers emit stop events for
- * non-tool content blocks.
+ * from state, and return the optional public `tool-call` event. Missing keys are
+ * a no-op because some providers emit stop events for non-tool content blocks.
 */
 export const finish = <K extends StreamKey>(route: string, tools: State<K>, key: K) =>
  Effect.gen(function* () {
@@ -186,7 +167,10 @@ export const finish = <K extends StreamKey>(route: string, tools: State<K>, key:
    if (!tool) return { tools }
    return {
      tools: withoutTool(tools, key),
-      events: finishEvents(tool, yield* toolCall(route, tool)),
+      events: [
+        LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+        yield* toolCall(route, tool),
+      ],
    }
  })

@@ -201,14 +185,17 @@ export const finishWithInput = <K extends StreamKey>(route: string, tools: State
    if (!tool) return { tools }
    return {
      tools: withoutTool(tools, key),
-      events: finishEvents(tool, yield* toolCall(route, tool, input)),
+      events: [
+        LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+        yield* toolCall(route, tool, input),
+      ],
    }
  })

 /**
 * Finalize every pending tool call at once. OpenAI Chat has this shape: it does
- * not emit per-tool stop events, so all accumulated calls finish independently
- * when the choice receives a terminal `finish_reason`.
+ * not emit per-tool stop events, so all accumulated calls finish when the choice
+ * receives a terminal `finish_reason`.
 */
 export const finishAll = <K extends StreamKey>(route: string, tools: State<K>) =>
  Effect.gen(function* () {
@@ -218,7 +205,12 @@ export const finishAll = <K extends StreamKey>(route: string, tools: State<K>) =
    return {
      tools: empty<K>(),
      events: yield* Effect.forEach(pending, (tool) =>
-        toolCall(route, tool).pipe(Effect.map((event) => finishEvents(tool, event))),
+        toolCall(route, tool).pipe(
+          Effect.map((call) => [
+            LLMEvent.toolInputEnd({ id: tool.id, name: tool.name, providerMetadata: tool.providerMetadata }),
+            call,
+          ]),
+        ),
      ).pipe(Effect.map((events) => events.flat())),
    }
  })
@@ -129,7 +129,6 @@ export const ToolInputStart = Schema.Struct({
  type: Schema.tag("tool-input-start"),
  id: ToolCallID,
  name: Schema.String,
-  providerExecuted: Schema.optional(Schema.Boolean),
  providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "LLM.Event.ToolInputStart" })
 export type ToolInputStart = Schema.Schema.Type<typeof ToolInputStart>
@@ -150,15 +149,6 @@ export const ToolInputEnd = Schema.Struct({
 }).annotate({ identifier: "LLM.Event.ToolInputEnd" })
 export type ToolInputEnd = Schema.Schema.Type<typeof ToolInputEnd>

-/** A local tool call whose final input could not be decoded. */
-export const ToolInputError = Schema.Struct({
-  type: Schema.tag("tool-input-error"),
-  id: ToolCallID,
-  name: Schema.String,
-  raw: Schema.String,
-}).annotate({ identifier: "LLM.Event.ToolInputError" })
-export type ToolInputError = Schema.Schema.Type<typeof ToolInputError>
-
 export const ToolCall = Schema.Struct({
  type: Schema.tag("tool-call"),
  id: ToolCallID,
@@ -226,7 +216,6 @@ const llmEventTagged = Schema.Union([
  ToolInputStart,
  ToolInputDelta,
  ToolInputEnd,
-  ToolInputError,
  ToolCall,
  ToolResult,
  ToolError,
@@ -264,8 +253,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
  toolInputDelta: (input: WithID<ToolInputDelta, ToolCallID>) =>
    ToolInputDelta.make({ ...input, id: toolCallID(input.id) }),
  toolInputEnd: (input: WithID<ToolInputEnd, ToolCallID>) => ToolInputEnd.make({ ...input, id: toolCallID(input.id) }),
-  toolInputError: (input: WithID<ToolInputError, ToolCallID>) =>
-    ToolInputError.make({ ...input, id: toolCallID(input.id) }),
  toolCall: (input: WithID<ToolCall, ToolCallID>) => ToolCall.make({ ...input, id: toolCallID(input.id) }),
  toolResult: (input: WithID<ToolResult, ToolCallID>) =>
    ToolResult.make({
@@ -296,7 +283,6 @@ export const LLMEvent = Object.assign(llmEventTagged, {
    toolInputStart: llmEventTagged.guards["tool-input-start"],
    toolInputDelta: llmEventTagged.guards["tool-input-delta"],
    toolInputEnd: llmEventTagged.guards["tool-input-end"],
-    toolInputError: llmEventTagged.guards["tool-input-error"],
    toolCall: llmEventTagged.guards["tool-call"],
    toolResult: llmEventTagged.guards["tool-result"],
    toolError: llmEventTagged.guards["tool-error"],
@@ -562,10 +548,6 @@ const reduceResponseState = (state: ResponseState, event: LLMEvent): ResponseSta
      return reduceToolInputDelta(next, event)
    case "tool-input-end":
      return reduceToolInputEnd(next, event)
-    case "tool-input-error": {
-      const { [event.id]: _finished, ...toolInputs } = next.toolInputs
-      return { ...next, toolInputs }
-    }
    case "tool-call":
      return reduceToolCall(next, event)
    case "tool-result":
@@ -1,40 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "text",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-text",
-    "recordedAt": "2026-07-18T03:42:22.893Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"You are concise.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Reply exactly with: Hello!\"}]}],\"stream\":true,\"max_tokens\":40,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"1a0b363d0882af316faebcec4d4855a8\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":53,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Hello\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"!\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":53,\"output_tokens\":2,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,41 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-call",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-call",
-    "recordedAt": "2026-07-18T03:42:23.876Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Call tools exactly as requested.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Call get_weather with city exactly Paris.\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"tool_choice\":{\"type\":\"tool\",\"name\":\"get_weather\"},\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"6731ecc323233459d1792df9a733dd98\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":404,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_vkxtif4epmvm_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":290,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,60 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "minimax",
-    "protocol": "anthropic-messages",
-    "route": "anthropic-messages",
-    "transport": "http",
-    "model": "MiniMax-M3",
-    "tags": [
-      "prefix:anthropic-compatible-messages",
-      "provider:minimax",
-      "protocol:anthropic-messages",
-      "tool",
-      "tool-loop",
-      "golden"
-    ],
-    "name": "anthropic-compatible-messages/minimax-m3-anthropic-compatible-tool-loop",
-    "recordedAt": "2026-07-18T03:42:25.248Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"3807fa12f9ecb9357df511e099da6da0\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":0,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":417,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{}}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"{\\\"city\\\": \\\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"input_json_delta\",\"partial_json\":\"\\\"}\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"tool_use\"},\"usage\":{\"input_tokens\":303,\"output_tokens\":27,\"cache_read_input_tokens\":114,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    },
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://api.minimax.io/anthropic/v1/messages",
-        "headers": {
-          "anthropic-version": "2023-06-01",
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"MiniMax-M3\",\"system\":[{\"type\":\"text\",\"text\":\"Use the get_weather tool exactly once. After the tool result, reply exactly: Paris is sunny.\"}],\"messages\":[{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"What is the weather in Paris?\"}]},{\"role\":\"assistant\",\"content\":[{\"type\":\"tool_use\",\"id\":\"call_function_yr64rwmre4gr_1\",\"name\":\"get_weather\",\"input\":{\"city\":\"Paris\"}}]},{\"role\":\"user\",\"content\":[{\"type\":\"tool_result\",\"tool_use_id\":\"call_function_yr64rwmre4gr_1\",\"content\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}]}],\"tools\":[{\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false}}],\"stream\":true,\"max_tokens\":80,\"temperature\":0}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream; charset=utf-8"
-        },
-        "body": "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"92f8a1e86f29946eb2699d40a088fc08\",\"type\":\"message\",\"role\":\"assistant\",\"content\":[],\"model\":\"MiniMax-M3\",\"stop_reason\":null,\"stop_sequence\":null,\"usage\":{\"input_tokens\":41,\"output_tokens\":0,\"cache_creation_input_tokens\":0,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"},\"service_tier\":\"standard\"}}\n\nevent: ping\ndata: {\"type\":\"ping\"}\n\nevent: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"text\",\"text\":\"\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\"Paris\"}}\n\nevent: content_block_delta\ndata: {\"type\":\"content_block_delta\",\"index\":0,\"delta\":{\"type\":\"text_delta\",\"text\":\" is sunny.\"}}\n\nevent: content_block_stop\ndata: {\"type\":\"content_block_stop\",\"index\":0}\n\nevent: message_delta\ndata: {\"type\":\"message_delta\",\"delta\":{\"stop_reason\":\"end_turn\"},\"usage\":{\"input_tokens\":41,\"output_tokens\":4,\"cache_read_input_tokens\":430,\"service_tier\":\"standard\"}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n"
-      }
-    }
-  ]
-}
@@ -1,34 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "model": "anthropic/claude-sonnet-4.6",
-    "tags": [
-      "prefix:openai-compatible-chat",
-      "provider:openrouter",
-      "protocol:openai-chat",
-      "reasoning"
-    ],
-    "name": "openrouter-reasoning",
-    "recordedAt": "2026-07-18T11:28:39.267Z"
-  },
-  "interactions": [
-    {
-      "transport": "http",
-      "request": {
-        "method": "POST",
-        "url": "https://openrouter.ai/api/v1/chat/completions",
-        "headers": {
-          "content-type": "application/json"
-        },
-        "body": "{\"model\":\"anthropic/claude-sonnet-4.6\",\"messages\":[{\"role\":\"system\",\"content\":\"Think through the arithmetic, then reply with only the final integer.\"},{\"role\":\"user\",\"content\":\"What is 173 multiplied by 219?\"}],\"stream\":true,\"stream_options\":{\"include_usage\":true},\"max_tokens\":1536,\"temperature\":0,\"reasoning\":{\"max_tokens\":1024}}"
-      },
-      "response": {
-        "status": 200,
-        "headers": {
-          "content-type": "text/event-stream"
-        },
-        "body": ": OPENROUTER PROCESSING\n\n: OPENROUTER PROCESSING\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\"173\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"173\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\n: OPENROUTER PROCESSING\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\" × 219\\n\\n173 × 200 = 34,600\\n173 × 19 = 173 × 20 - 173 = 3,460 - 173 = 3,287\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\" × 219\\n\\n173 × 200 = 34,600\\n173 × 19 = 173 × 20 - 173 = 3,460 - 173 = 3,287\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":\"\\n\\n34,600 + 3,287 = 37,887\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"text\":\"\\n\\n34,600 + 3,287 = 37,887\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning_details\":[{\"type\":\"reasoning.text\",\"signature\":\"EtgCCosBCA8YAipA0W4viH3kgBs43Cl5ewwVBPXTQElvzfbA2TLF4iSbKy9ZZDCSDjjAlF3Bs4ELEnP3vrrTuTioC6OB380lXQdyIDIRY2xhdWRlLXNvbm5ldC00LTY4AEIIdGhpbmtpbmdaJDRjMGYwNDZmLTI1ZmQtNDVmYi1iZmIzLWEwOGE4ZTI0OWNhNxIMMiUlJC3x/5p5PuTwGgwlc8eipZyoM94BHwMiMO45uQx/ymeOjbugi7RDVPZ4jZXSIiEbVi2CD7zPjAK5fFQoVGP1HD55v9CER823JCp6Dg5Xb7Lrk6NUd1XN2KTKrttK7mATE+IBrDTFmor/1cNeg+9gjIbxM/jn/6L5HPmh3/esEVu24Q0IGLZVoE7cTgGgxsrceKMD71Jp2XQgIWD8ltsPfWw3gSc4p+z18UuPN6LuR0mHHENTnClHrAPnOrxbDIl4ZwZgMX8YAQ==\",\"format\":\"anthropic-claude-v1\",\"index\":0}]},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"37887\",\"role\":\"assistant\"},\"finish_reason\":null,\"native_finish_reason\":null}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\",\"reasoning\":null},\"finish_reason\":\"stop\",\"native_finish_reason\":\"end_turn\"}]}\n\ndata: {\"id\":\"gen-1784374117-AXXPsQRoclZeQGx2uHeK\",\"object\":\"chat.completion.chunk\",\"created\":1784374117,\"model\":\"anthropic/claude-sonnet-4.6\",\"provider\":\"Anthropic\",\"service_tier\":\"default\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"\",\"role\":\"assistant\"},\"finish_reason\":\"stop\",\"native_finish_reason\":\"end_turn\"}],\"usage\":{\"prompt_tokens\":61,\"completion_tokens\":80,\"total_tokens\":141,\"cost\":0.001383,\"is_byok\":false,\"prompt_tokens_details\":{\"cached_tokens\":0,\"cache_write_tokens\":0,\"audio_tokens\":0,\"video_tokens\":0},\"cache_creation\":{\"ephemeral_5m_input_tokens\":0,\"ephemeral_1h_input_tokens\":0},\"cost_details\":{\"upstream_inference_cost\":0.001383,\"upstream_inference_prompt_cost\":0.000183,\"upstream_inference_completions_cost\":0.0012},\"completion_tokens_details\":{\"reasoning_tokens\":29,\"image_tokens\":0,\"audio_tokens\":0}}}\n\ndata: [DONE]\n\n"
-      }
-    }
-  ]
-}
@@ -484,30 +484,6 @@ describe("Anthropic Messages route", () => {
    }),
  )

-  it.effect("keeps malformed server tool input terminal", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        { type: "message_start", message: { usage: { input_tokens: 5 } } },
-        {
-          type: "content_block_start",
-          index: 0,
-          content_block: { type: "server_tool_use", id: "call_1", name: "web_search" },
-        },
-        {
-          type: "content_block_delta",
-          index: 0,
-          delta: { type: "input_json_delta", partial_json: '{"query":"partial' },
-        },
-        { type: "content_block_stop", index: 0 },
-      )
-
-      const error = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)), Effect.flip)
-
-      expect(error).toBeInstanceOf(LLMError)
-      expect(error.message).toContain("Invalid JSON input for anthropic-messages tool call web_search")
-    }),
-  )
-
  it.effect("fails with a typed provider error for stream error frames", () =>
    Effect.gen(function* () {
      const error = yield* LLMClient.generate(request).pipe(
@@ -303,32 +303,6 @@ describe("Bedrock Converse route", () => {
    }),
  )

-  it.effect("emits malformed tool input as an unexecuted tool error", () =>
-    Effect.gen(function* () {
-      const body = eventStreamBody(
-        ["messageStart", { role: "assistant" }],
-        [
-          "contentBlockStart",
-          {
-            contentBlockIndex: 0,
-            start: { toolUse: { toolUseId: "tool_1", name: "lookup" } },
-          },
-        ],
-        ["contentBlockDelta", { contentBlockIndex: 0, delta: { toolUse: { input: '{"query":"partial' } } }],
-        ["contentBlockStop", { contentBlockIndex: 0 }],
-        ["messageStop", { stopReason: "end_turn" }],
-      )
-      const response = yield* LLMClient.generate(baseRequest).pipe(Effect.provide(fixedBytes(body)))
-
-      expect(response.events.find((event) => event.type === "tool-input-error")).toMatchObject({
-        id: "tool_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-    }),
-  )
-
  it.effect("decodes reasoning deltas", () =>
    Effect.gen(function* () {
      const body = eventStreamBody(
@@ -1,5 +1,4 @@
 import * as Anthropic from "../../src/providers/anthropic"
-import * as AnthropicCompatible from "../../src/providers/anthropic-compatible"
 import { CloudflareAIGateway, CloudflareWorkersAI } from "../../src/providers/cloudflare"
 import * as Google from "../../src/providers/google"
 import * as OpenAI from "../../src/providers/openai"
@@ -18,11 +17,6 @@ const anthropic = Anthropic.configure({
 })
 const anthropicHaiku = anthropic.model("claude-haiku-4-5-20251001")
 const anthropicOpus = anthropic.model("claude-opus-4-7")
-const minimax = AnthropicCompatible.configure({
-  apiKey: process.env.MINIMAX_API_KEY ?? "fixture",
-  baseURL: "https://api.minimax.io/anthropic/v1",
-  provider: "minimax",
-}).model("MiniMax-M3")
 const google = Google.configure({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY ?? "fixture" })
 const gemini = google.model("gemini-2.5-flash")
 const xai = XAI.configure({ apiKey: process.env.XAI_API_KEY ?? "fixture" })
@@ -114,15 +108,6 @@ describeRecordedGoldenScenarios([
      { id: "image-tool-result", temperature: false, maxTokens: 40 },
    ],
  },
-  {
-    name: "MiniMax M3 Anthropic-compatible",
-    prefix: "anthropic-compatible-messages",
-    protocol: "anthropic-messages",
-    model: minimax,
-    requires: ["MINIMAX_API_KEY"],
-    options: { redact: { allowRequestHeaders: ["anthropic-version"] } },
-    scenarios: ["text", "tool-call", "tool-loop"],
-  },
  {
    name: "Gemini 2.5 Flash",
    prefix: "gemini",
@@ -1,67 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect } from "effect"
-import { LLM, LLMEvent } from "../../src"
-import * as OpenAICompatible from "../../src/providers/openai-compatible"
-import * as OpenRouter from "../../src/providers/openrouter"
-import { LLMClient } from "../../src/route"
-import { recordedTests } from "../recorded-test"
-
-const cases = [
-  {
-    name: "OpenRouter",
-    model: OpenRouter.configure({
-      apiKey: process.env.OPENROUTER_API_KEY ?? "fixture",
-      providerOptions: { openrouter: { reasoning: { max_tokens: 1024 } } },
-    }).model("anthropic/claude-sonnet-4.6"),
-    requires: ["OPENROUTER_API_KEY"],
-    cassette: "openrouter-reasoning",
-  },
-  {
-    name: "Vercel AI Gateway",
-    model: OpenAICompatible.configure({
-      provider: "vercel-ai-gateway",
-      baseURL: "https://ai-gateway.vercel.sh/v1",
-      apiKey: process.env.AI_GATEWAY_API_KEY ?? "fixture",
-      http: { body: { reasoning: { enabled: true, max_tokens: 1024 } } },
-    }).model("anthropic/claude-sonnet-4.6"),
-    requires: ["AI_GATEWAY_API_KEY"],
-    cassette: "vercel-ai-gateway-reasoning",
-  },
-] as const
-
-for (const item of cases) {
-  const recorded = recordedTests({
-    prefix: "openai-compatible-chat",
-    provider: item.model.provider,
-    protocol: "openai-chat",
-    requires: item.requires,
-    tags: ["reasoning"],
-    metadata: { model: item.model.id },
-  })
-
-  describe(`${item.name} reasoning recorded`, () => {
-    recorded.effect.with(
-      "streams scalar reasoning",
-      { cassette: item.cassette },
-      () =>
-        Effect.gen(function* () {
-          const response = yield* LLMClient.generate(
-            LLM.request({
-              model: item.model,
-              system: "Think through the arithmetic, then reply with only the final integer.",
-              prompt: "What is 173 multiplied by 219?",
-              generation: { maxTokens: 1536, temperature: 0 },
-            }),
-          )
-
-          expect(response.text.replaceAll(",", "").trim()).toBe("37887")
-          expect(response.reasoning.length).toBeGreaterThan(0)
-          expect(response.events.some(LLMEvent.is.reasoningDelta)).toBe(true)
-          expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-            openai: { reasoningField: "reasoning" },
-          })
-        }),
-      30_000,
-    )
-  })
-}
@@ -540,33 +540,29 @@ describe("OpenAI Chat route", () => {
    }),
  )

-  it.effect("parses and replays OpenAI-compatible reasoning fields", () =>
+  it.effect("parses OpenAI-compatible reasoning content deltas", () =>
    Effect.gen(function* () {
-      const fields = ["reasoning_content", "reasoning", "reasoning_text"] as const
-      for (const field of fields) {
-        const response = yield* LLMClient.generate(request).pipe(
-          Effect.provide(
-            fixedResponse(
-              sseEvents(
-                { choices: [{ delta: { [field]: "thinking" } }] },
-                { choices: [{ delta: { content: "Hello" } }] },
-                { choices: [{ delta: {}, finish_reason: "stop" }] },
-              ),
-            ),
-          ),
-        )
+      const body = sseEvents(
+        { choices: [{ delta: { reasoning_content: "thinking" } }] },
+        { choices: [{ delta: { content: "Hello" } }] },
+        { choices: [{ delta: {}, finish_reason: "stop" }] },
+      )

-        expect(response.reasoning).toBe("thinking")
-        expect(response.text).toBe("Hello")
-        expect(response.message.content.find((part) => part.type === "reasoning")?.providerMetadata).toEqual({
-          openai: { reasoningField: field },
-        })
+      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))

-        const replay = yield* LLMClient.prepare<OpenAIChat.OpenAIChatBody>(
-          LLM.request({ model, messages: [response.message] }),
-        )
-        expect(replay.body.messages).toEqual([{ role: "assistant", content: "Hello", [field]: "thinking" }])
-      }
+      expect(response.reasoning).toBe("thinking")
+      expect(response.text).toBe("Hello")
+      expect(response.events).toMatchObject([
+        { type: "step-start", index: 0 },
+        { type: "reasoning-start", id: "reasoning-0" },
+        { type: "reasoning-delta", id: "reasoning-0", text: "thinking" },
+        { type: "reasoning-end", id: "reasoning-0" },
+        { type: "text-start", id: "text-0" },
+        { type: "text-delta", id: "text-0", text: "Hello" },
+        { type: "text-end", id: "text-0" },
+        { type: "step-finish", index: 0, reason: "stop" },
+        { type: "finish", reason: "stop" },
+      ])
    }),
  )

@@ -1,7 +1,7 @@
 import { describe, expect } from "bun:test"
 import { ConfigProvider, Effect, Layer, Stream } from "effect"
 import { Headers, HttpClientRequest } from "effect/unstable/http"
-import { LLM, LLMError, LLMEvent, Message, Model, ToolCallPart, Usage } from "../../src"
+import { LLM, LLMError, Message, Model, ToolCallPart, Usage } from "../../src"
 import { Auth, LLMClient, RequestExecutor, WebSocketExecutor } from "../../src/route"
 import * as Azure from "../../src/providers/azure"
 import * as OpenAI from "../../src/providers/openai"
@@ -1259,69 +1259,6 @@ describe("OpenAI Responses route", () => {
    }),
  )

-  it.effect("emits malformed final function arguments as an unexecuted tool error", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.added",
-          item: { type: "function_call", id: "item_1", call_id: "call_1", name: "lookup", arguments: "" },
-        },
-        { type: "response.function_call_arguments.delta", item_id: "item_1", delta: '{"query":"streamed"}' },
-        {
-          type: "response.output_item.done",
-          item: {
-            type: "function_call",
-            id: "item_1",
-            call_id: "call_1",
-            name: "lookup",
-            arguments: '{"query":"partial',
-          },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(
-        LLM.updateRequest(request, {
-          tools: [{ name: "lookup", description: "Lookup data", inputSchema: { type: "object" } }],
-        }),
-      ).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find(LLMEvent.is.toolInputError)).toEqual({
-        type: "tool-input-error",
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-      expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
-    }),
-  )
-
-  it.effect("settles malformed function arguments when output_item.added is absent", () =>
-    Effect.gen(function* () {
-      const body = sseEvents(
-        {
-          type: "response.output_item.done",
-          item: {
-            type: "function_call",
-            id: "item_1",
-            call_id: "call_1",
-            name: "lookup",
-            arguments: '{"query":"partial',
-          },
-        },
-        { type: "response.completed", response: { usage: { input_tokens: 5, output_tokens: 1 } } },
-      )
-      const response = yield* LLMClient.generate(request).pipe(Effect.provide(fixedResponse(body)))
-
-      expect(response.events.find(LLMEvent.is.toolInputError)).toMatchObject({
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      })
-      expect(response.finishReason).toBe("tool-calls")
-    }),
-  )
-
  it.effect("decodes web_search_call as provider-executed tool-call + tool-result", () =>
    Effect.gen(function* () {
      const item = {
@@ -95,19 +95,4 @@ describe("LLMResponse reducer", () => {
      { type: "tool-call", id: "call_1", name: "lookup", input: { query: "weather" } },
    ])
  })
-
-  test("clears malformed tool input without appending an executable call", () => {
-    const state = reduce([
-      LLMEvent.toolInputStart({ id: "call_1", name: "lookup" }),
-      LLMEvent.toolInputDelta({ id: "call_1", name: "lookup", text: '{"query":"partial' }),
-      LLMEvent.toolInputError({
-        id: "call_1",
-        name: "lookup",
-        raw: '{"query":"partial',
-      }),
-    ])
-
-    expect(state.toolInputs).toEqual({})
-    expect(state.message.content).toEqual([])
-  })
 })
@@ -64,73 +64,6 @@ describe("ToolStream", () => {
    }),
  )

-  it.effect("finalizes malformed local input as a non-executable tool error", () =>
-    Effect.gen(function* () {
-      const tools = ToolStream.start(ToolStream.empty<string>(), "item_1", {
-        id: "call_1",
-        name: "lookup",
-        input: '{"query":"partial',
-      })
-      const finished = yield* ToolStream.finish(ADAPTER, tools, "item_1")
-
-      expect(finished).toEqual({
-        tools: {},
-        events: [
-          {
-            type: "tool-input-error",
-            id: "call_1",
-            name: "lookup",
-            raw: '{"query":"partial',
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("preserves valid siblings when one parallel input is malformed", () =>
-    Effect.gen(function* () {
-      const valid = ToolStream.start(ToolStream.empty<number>(), 0, {
-        id: "call_valid",
-        name: "lookup",
-        input: '{"query":"weather"}',
-      })
-      const tools = ToolStream.start(valid, 1, {
-        id: "call_invalid",
-        name: "lookup",
-        input: '{"query":"partial',
-      })
-      const finished = yield* ToolStream.finishAll(ADAPTER, tools)
-
-      expect(finished).toEqual({
-        tools: {},
-        events: [
-          { type: "tool-input-end", id: "call_valid", name: "lookup" },
-          { type: "tool-call", id: "call_valid", name: "lookup", input: { query: "weather" } },
-          {
-            type: "tool-input-error",
-            id: "call_invalid",
-            name: "lookup",
-            raw: '{"query":"partial',
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("keeps malformed provider-executed input terminal", () =>
-    Effect.gen(function* () {
-      const tools = ToolStream.start(ToolStream.empty<string>(), "item_1", {
-        id: "call_1",
-        name: "web_search",
-        input: '{"query":"partial',
-        providerExecuted: true,
-      })
-      const result = yield* Effect.exit(ToolStream.finish(ADAPTER, tools, "item_1"))
-
-      expect(result._tag).toBe("Failure")
-    }),
-  )
-
  it.effect("preserves providerExecuted and clears all tools", () =>
    Effect.gen(function* () {
      const first: ToolStream.State<number> = ToolStream.start(ToolStream.empty<number>(), 0, {
@@ -1,161 +0,0 @@
-#!/usr/bin/env node
-
-import childProcess from "node:child_process"
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
-import { createRequire } from "node:module"
-import { fileURLToPath } from "node:url"
-
-const directory = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-const packageJson = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"))
-const command = Object.keys(packageJson.bin ?? {})[0]
-if (!command) throw new Error("OpenCode package does not declare a binary")
-
-const platform = { darwin: "darwin", linux: "linux", win32: "windows" }[os.platform()] ?? os.platform()
-const arch = { x64: "x64", arm64: "arm64", arm: "arm" }[os.arch()] ?? os.arch()
-const sourceBinary = platform === "windows" ? `${command}.exe` : command
-const targetBinary = path.resolve(directory, packageJson.bin[command])
-const dependencies = packageJson.optionalDependencies ?? {}
-const base = Object.keys(dependencies).find((name) => name.endsWith(`-${platform}-${arch}`))
-if (!base) throw new Error(`OpenCode does not provide a binary for ${platform}-${arch}`)
-
-function supportsAvx2() {
-  if (arch !== "x64") return false
-  if (platform === "linux") {
-    try {
-      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
-    } catch {
-      return false
-    }
-  }
-  if (platform === "darwin") {
-    try {
-      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
-        encoding: "utf8",
-        timeout: 1500,
-      })
-      return result.status === 0 && (result.stdout || "").trim() === "1"
-    } catch {
-      return false
-    }
-  }
-  if (platform === "windows") {
-    const script =
-      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
-    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", script], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const output = (result.stdout || "").trim().toLowerCase()
-        if (output === "true" || output === "1") return true
-        if (output === "false" || output === "0") return false
-      } catch {
-        continue
-      }
-    }
-  }
-  return false
-}
-
-function isMusl() {
-  if (platform !== "linux") return false
-  try {
-    if (fs.existsSync("/etc/alpine-release")) return true
-    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
-  } catch {
-    return false
-  }
-}
-
-function packageNames() {
-  const baseline = arch === "x64" && !supportsAvx2()
-  const names =
-    platform === "linux"
-      ? isMusl()
-        ? arch === "x64"
-          ? baseline
-            ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-            : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-          : [`${base}-musl`, base]
-        : arch === "x64"
-          ? baseline
-            ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-            : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-          : [base, `${base}-musl`]
-      : arch === "x64"
-        ? baseline
-          ? [`${base}-baseline`, base]
-          : [base, `${base}-baseline`]
-        : [base]
-  return names.filter((name) => dependencies[name])
-}
-
-function copyBinary(source) {
-  if (!fs.existsSync(source)) throw new Error(`Binary not found at ${source}`)
-  fs.mkdirSync(path.dirname(targetBinary), { recursive: true })
-  if (fs.existsSync(targetBinary)) fs.unlinkSync(targetBinary)
-  try {
-    fs.linkSync(source, targetBinary)
-  } catch {
-    fs.copyFileSync(source, targetBinary)
-  }
-  fs.chmodSync(targetBinary, 0o755)
-}
-
-function resolveBinary(name) {
-  const packagePath = require.resolve(`${name}/package.json`)
-  return path.join(path.dirname(packagePath), "bin", sourceBinary)
-}
-
-function installPackage(name) {
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "opencode-install-"))
-  try {
-    const result = childProcess.spawnSync(
-      "npm",
-      ["install", "--ignore-scripts", "--no-save", "--loglevel=error", "--prefix", temp, `${name}@${dependencies[name]}`],
-      { stdio: "inherit", windowsHide: true },
-    )
-    if (result.status !== 0) return false
-    copyBinary(path.join(temp, "node_modules", name, "bin", sourceBinary))
-    return true
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true })
-  }
-}
-
-function verifyBinary() {
-  return (
-    childProcess.spawnSync(targetBinary, ["--version"], {
-      stdio: "ignore",
-      windowsHide: true,
-    }).status === 0
-  )
-}
-
-function main() {
-  const names = packageNames()
-  for (const name of names) {
-    try {
-      copyBinary(resolveBinary(name))
-      if (verifyBinary()) return
-    } catch {
-      if (installPackage(name) && verifyBinary()) return
-    }
-  }
-
-  throw new Error(`Failed to install OpenCode. Try manually installing ${names.map((name) => JSON.stringify(name)).join(" or ")}.`)
-}
-
-try {
-  main()
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error))
-  process.exit(1)
-}
@@ -32,23 +32,12 @@ async function publishDistribution(input: { root: string; name: string; binary:
  if (!version) throw new Error(`No binary packages found for ${input.name}`)

  await $`mkdir -p ${input.root}/${input.name}/bin`
-  await $`cp ./script/postinstall.mjs ${input.root}/${input.name}/postinstall.mjs`
-  await Bun.file(`${input.root}/${input.name}/bin/${input.binary}.exe`).write(
-    [
-      `echo "Error: ${input.name}'s postinstall script was not run." >&2`,
-      'echo "" >&2',
-      'echo "This occurs when installation scripts are disabled." >&2',
-      'echo "Run the package postinstall script or reinstall with scripts enabled." >&2',
-      "exit 1",
-      "",
-    ].join("\n"),
-  )
+  await $`cp ./bin/opencode2.cjs ${input.root}/${input.name}/bin/${input.binary}`
  await Bun.file(`${input.root}/${input.name}/package.json`).write(
    JSON.stringify(
      {
        name: input.name,
-        bin: { [input.binary]: `./bin/${input.binary}.exe` },
-        scripts: { postinstall: "node ./postinstall.mjs" },
+        bin: { [input.binary]: `./bin/${input.binary}` },
        version,
        license: pkg.license,
        repository: { type: "git", url: "git+https://github.com/anomalyco/opencode.git" },
@@ -114,10 +114,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
        }),
      ],
    }),
-    Spec.make("plugin", {
-      description: "Manage plugins",
-      commands: [Spec.make("list", { description: "List active plugins" })],
-    }),
    Spec.make("migrate", { description: "Migrate v1 data to v2" }),
    Spec.make("mini", {
      description: "Start the minimal interactive interface",
@@ -1,4 +1,4 @@
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Global } from "@opencode-ai/core/global"
 import { run } from "@opencode-ai/tui"
 import { Commands } from "../commands"
@@ -75,6 +75,6 @@ export default Runtime.handler(Commands, (input) =>
                : Effect.logInfo(message, tags)
        runFork(effect)
      },
-    }).pipe(Effect.provide(LayerNode.compile(Global.node)))
+    }).pipe(Effect.provide(AppNodeBuilder.build(Global.node)))
  }),
 )
@@ -1,24 +0,0 @@
-import { EOL } from "node:os"
-import { Effect } from "effect"
-import { OpenCode } from "@opencode-ai/client"
-import { Service } from "@opencode-ai/client/effect/service"
-import { Commands } from "../../commands"
-import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
-
-export default Runtime.handler(
-  Commands.commands.plugin.commands.list,
-  Effect.fn("cli.plugin.list")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const endpoint = found ?? (yield* Service.ensure(options))
-    const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
-    const response = yield* Effect.promise(() => client.plugin.list({ location: { directory: process.cwd() } }))
-    const plugins = response.data.toSorted((a, b) => a.id.localeCompare(b.id))
-    if (plugins.length === 0) {
-      process.stdout.write("No plugins loaded" + EOL)
-      return
-    }
-    process.stdout.write(plugins.map((plugin) => plugin.id).join(EOL) + EOL)
-  }),
-)
@@ -7,6 +7,7 @@ import { Runtime } from "./framework/runtime"
 import { Observability } from "@opencode-ai/core/observability"
 import { Updater } from "./services/updater"
 import { InstallationChannel, InstallationVersion, InstallationLocal } from "@opencode-ai/core/installation/version"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { AppProcess } from "@opencode-ai/core/process"
@@ -31,9 +32,6 @@ const Handlers = Runtime.handlers(Commands, {
    auth: () => import("./commands/handlers/mcp/auth"),
    logout: () => import("./commands/handlers/mcp/logout"),
  },
-  plugin: {
-    list: () => import("./commands/handlers/plugin/list"),
-  },
  migrate: () => import("./commands/handlers/migrate"),
  mini: () => import("./commands/handlers/mini"),
  run: () => import("./commands/handlers/run"),
@@ -60,7 +58,7 @@ Effect.logInfo("cli starting", {
  Effect.annotateLogs({ role: "cli" }),
  Effect.provide(Config.layer),
  Effect.provide(Updater.layer),
-  Effect.provide(LayerNode.compile(LayerNode.group([Global.node, AppProcess.node, Npm.node]))),
+  Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node, Npm.node]))),
  Effect.provide(Observability.layer),
  Effect.provide(NodeServices.layer),
  Effect.scoped,
@@ -7,8 +7,8 @@
 // none block each other.
 import { Context, Effect, Layer } from "effect"
 import { resolve } from "@opencode-ai/tui/config/v1"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { makeRuntime } from "@opencode-ai/core/effect/runtime"
 import { loadRunProviders } from "./catalog.shared"
 import { resolveCurrentSession, sessionHistory } from "./session.shared"
@@ -130,7 +130,7 @@ const layer = Layer.effect(
 )

 const node = makeGlobalNode({ service: Service, layer, deps: [] })
-const runtime = makeRuntime(Service, LayerNode.compile(node))
+const runtime = makeRuntime(Service, AppNodeBuilder.build(node))

 // Fetches available variants and context limits for every provider/model pair.
 export async function resolveModelInfo(
@@ -8,6 +8,7 @@
 // variant and the persisted file.
 import path from "path"
 import { FSUtil } from "@opencode-ai/core/fs-util"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Context, Effect, Layer } from "effect"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { makeGlobalNode } from "@opencode-ai/core/effect/app-node"
@@ -202,7 +203,7 @@ const node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node] })

 /** @internal Exported for testing. */
 export function createVariantRuntime(replacements?: readonly LayerNode.Replacement[]): VariantRuntime {
-  const runtime = makeRuntime(Service, LayerNode.compile(node, replacements))
+  const runtime = makeRuntime(Service, AppNodeBuilder.build(node, replacements))
  return {
    resolveSavedVariant: (model) => runtime.runPromise((svc) => svc.resolveSavedVariant(model)).catch(() => undefined),
    saveVariant: (model, variant) => runtime.runPromise((svc) => svc.saveVariant(model, variant)).catch(() => {}),
@@ -1,11 +1,13 @@
 export * as ServerProcess from "./server-process"

 import { NodeServices } from "@effect/platform-node"
-import { Service, type DiscoverOptions, type Info } from "@opencode-ai/client/effect/service"
+import { Service } from "@opencode-ai/client/effect/service"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { AppProcess } from "@opencode-ai/core/process"
+import { ProcessLock } from "@opencode-ai/core/util/process-lock"
 import { randomBytes, randomUUID } from "node:crypto"
 import path from "node:path"
 import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
@@ -26,7 +28,7 @@ export type Options = {
 export const run = Effect.fnUntraced(function* (options: Options) {
  return yield* processEffect(options).pipe(
    Effect.provide(Updater.layer),
-    Effect.provide(LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]))),
+    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
    Effect.provide(NodeServices.layer),
  )
 })
@@ -36,15 +38,14 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
  return yield* Effect.scoped(
    Effect.gen(function* () {
      const serviceOptions = options.mode === "service" ? yield* ServiceConfig.options() : undefined
-      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
-      const hostname = options.hostname ?? config.hostname ?? "127.0.0.1"
-      const port = options.port ?? config.port ?? (options.mode === "service" ? ServiceConfig.defaultPort() : undefined)
-      if (
-        serviceOptions !== undefined &&
-        port !== undefined &&
-        (yield* Service.incumbent({ ...serviceOptions, url: serviceURL(hostname, port) })) !== undefined
-      )
-        return
+      if (serviceOptions !== undefined) {
+        const acquired = yield* ProcessLock.acquire(serviceOptions.file + ".lock").pipe(
+          Effect.as(true),
+          Effect.catchTag("ProcessLockHeldError", () => Effect.succeed(false)),
+        )
+        if (!acquired) return yield* Effect.void
+        if ((yield* Service.discover(serviceOptions)) !== undefined) return yield* Effect.void
+      }
      const { start } = yield* Effect.promise(() => import("@opencode-ai/server/process"))
      const environmentPassword = yield* Env.password
      // Keep the lease credential out of the environment inherited by tools.
@@ -52,49 +53,25 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
        delete process.env.OPENCODE_PASSWORD
        delete process.env.OPENCODE_SERVER_PASSWORD
      }
+      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
      const password =
        options.mode === "service"
-          ? config.password || randomBytes(32).toString("base64url")
+          ? yield* ServiceConfig.password()
          : environmentPassword
            ? Redacted.value(environmentPassword)
            : randomBytes(32).toString("base64url")
      if (!password) return yield* Effect.fail(new Error("Missing server password"))
      const instanceID = randomUUID()
      const server = yield* start({
-        hostname,
-        port: Option.fromNullishOr(port),
+        hostname: options.hostname ?? config.hostname ?? "127.0.0.1",
+        port: Option.fromNullishOr(options.port ?? config.port),
        password,
        instanceID,
        service:
          serviceOptions === undefined
            ? undefined
-            : {
-                onListen: (address, shutdown) =>
-                  Effect.gen(function* () {
-                    if (!config.password) yield* ServiceConfig.password(password)
-                    return yield* register(address, password, instanceID, serviceOptions.file, shutdown)
-                  }),
-              },
-      }).pipe(
-        Effect.provide(Logger.layer([], { mergeWithExisting: false })),
-        Effect.catch((error) => {
-          if (serviceOptions === undefined || port === undefined || !addressInUse(error)) return Effect.fail(error)
-          return recognizeIncumbent(serviceOptions, hostname, port).pipe(
-            Effect.flatMap((found) =>
-              found
-                ? Effect.void
-                : Effect.fail(
-                    new Error(
-                      `Managed service port ${port} on ${hostname} is already in use by another process. ` +
-                        "Configure another port with `opencode service set port <port>` and start the service again.",
-                      { cause: error },
-                    ),
-                  ),
-            ),
-          )
-        }),
-      )
-      if (server === undefined) return
+            : { onListen: (address) => register(address, password, instanceID, serviceOptions.file) },
+      }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
      const url = HttpServer.formatAddress(server.address)
      console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
      if (options.mode === "default" && !environmentPassword) console.log(`server password ${password}`)
@@ -118,7 +95,6 @@ const register = Effect.fnUntraced(function* (
  password: string,
  id: string,
  file: string,
-  shutdown: Effect.Effect<void>,
 ) {
  const fs = yield* FileSystem.FileSystem
  const temp = file + "." + id + ".tmp"
@@ -131,49 +107,38 @@ const register = Effect.fnUntraced(function* (
    password,
  }
  const encoded = yield* encodeInfo(info)
+  const publish = fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
+  yield* publish
  const current = fs.readFileString(file).pipe(
    Effect.flatMap(decodeInfo),
    Effect.orElseSucceed(() => undefined),
  )
-  const owns = (found: Info | undefined) =>
-    found?.id === info.id &&
-    found.version === info.version &&
-    found.url === info.url &&
-    found.pid === info.pid &&
-    found.password === info.password
-  yield* fs.writeFileString(temp, encoded, { mode: 0o600 }).pipe(Effect.andThen(fs.rename(temp, file)))
-  yield* current.pipe(
-    Effect.filterOrFail(owns),
+  const assertRegistration = Effect.gen(function* () {
+    const found = yield* current
+    if (
+      found !== undefined &&
+      found.id === info.id &&
+      found.version === info.version &&
+      found.url === info.url &&
+      found.pid === info.pid &&
+      found.password === info.password
+    )
+      return
+    yield* publish
+  })
+  yield* Effect.addFinalizer(() =>
+    current.pipe(
+      Effect.flatMap((current) => (current?.id === id ? fs.remove(file) : Effect.void)),
+      Effect.ignore,
+    ),
+  )
+  yield* assertRegistration.pipe(
+    Effect.catchCause((cause) => Effect.logWarning("failed to reassert service registration", { cause })),
    Effect.repeat(Schedule.spaced("5 seconds")),
-    Effect.ignore,
-    Effect.andThen(shutdown),
    Effect.forkScoped,
  )
-  return current.pipe(
-    Effect.flatMap((found) => (owns(found) ? fs.remove(file) : Effect.void)),
-    Effect.ignore,
-  )
 })

-const recognizeIncumbent = Effect.fnUntraced(function* (options: DiscoverOptions, hostname: string, port: number) {
-  const found = yield* Service.incumbent({ ...options, url: serviceURL(hostname, port) }).pipe(
-    Effect.filterOrFail((value) => value !== undefined),
-    Effect.retry(Schedule.spaced("100 millis")),
-    Effect.timeoutOption("15 seconds"),
-  )
-  return Option.isSome(found)
-})
-
-function serviceURL(hostname: string, port: number) {
-  return `http://${hostname.includes(":") ? `[${hostname}]` : hostname}:${port}`
-}
-
-function addressInUse(error: unknown): boolean {
-  if (typeof error !== "object" || error === null) return false
-  if ("code" in error && error.code === "EADDRINUSE") return true
-  return "cause" in error && addressInUse(error.cause)
-}
-
 function waitForStdinClose() {
  return Effect.callback<void>((resume) => {
    const close = () => resume(Effect.void)
@@ -30,12 +30,6 @@ export function filename(channel = InstallationChannel) {
  return `service-${Hash.fast(channel)}.json`
 }

-export function defaultPort(channel = InstallationChannel) {
-  if (channel === "latest") return 0xc0de
-  if (channel === "local") return 0xc0df
-  return 10_000 + (Number.parseInt(Hash.fast(channel).slice(0, 8), 16) % 50_000)
-}
-
 export function versionBelongsToChannel(
  version: string | undefined,
  channel = InstallationChannel,
@@ -1,6 +1,6 @@
 import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
 import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Deferred, Effect, Schema, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
 import { randomBytes } from "node:crypto"
@@ -53,7 +53,7 @@ const makeEndpoint = Effect.fn("cli.standalone.endpoint")(
      pid: proc.pid,
    } satisfies Endpoint & { readonly pid: number }
  },
-  Effect.provide(LayerNode.compile(CrossSpawnSpawner.node)),
+  Effect.provide(AppNodeBuilder.build(CrossSpawnSpawner.node)),
 )

 export function start(options: Options = {}) {
@@ -1,10 +1,9 @@
 import { NodeFileSystem } from "@effect/platform-node"
-import { Service, type Info } from "@opencode-ai/client/effect/service"
+import { Service } from "@opencode-ai/client/effect/service"
 import { Database } from "@opencode-ai/core/database/database"
 import { EventV2 } from "@opencode-ai/core/event"
 import { EventTable } from "@opencode-ai/core/event/sql"
 import { Global } from "@opencode-ai/core/global"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { AbsolutePath } from "@opencode-ai/core/schema"
@@ -18,13 +17,6 @@ import os from "node:os"
 import path from "node:path"
 import { ServiceConfig } from "../src/services/service-config"

-test("managed service ports are stable per installation channel", () => {
-  expect(ServiceConfig.defaultPort("latest")).toBe(0xc0de)
-  expect(ServiceConfig.defaultPort("local")).toBe(0xc0df)
-  expect(ServiceConfig.defaultPort("preview-a")).toBe(ServiceConfig.defaultPort("preview-a"))
-  expect(ServiceConfig.defaultPort("preview-a")).not.toBe(ServiceConfig.defaultPort("preview-b"))
-})
-
 test("local channel stores service config with the local service filename", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
  try {
@@ -98,80 +90,6 @@ test("preview registration migration never moves stable discovery", async () =>
  }
 })

-test("managed service writes its registration once", async () => {
-  const service = await startManagedService("opencode-service-once-")
-  try {
-    const before = await fs.stat(service.registration)
-    await Bun.sleep(6_000)
-    const after = await fs.stat(service.registration)
-    expect(after.ino).toBe(before.ino)
-    expect(after.mtimeMs).toBe(before.mtimeMs)
-    expect(await Bun.file(service.registration).json()).toEqual(service.info)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("deleting a managed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-delete-")
-  try {
-    await fs.rm(service.registration)
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).exists()).toBe(false)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("deleting a failed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-failed-delete-", true)
-  try {
-    await waitForFailed(service.info)
-    await fs.rm(service.registration)
-    expect(await waitForExit(service.owner)).toBe(true)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("corrupting a managed service registration stops its owner", async () => {
-  const service = await startManagedService("opencode-service-corrupt-")
-  try {
-    await fs.writeFile(service.registration, "not-json")
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).text()).toBe("not-json")
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("replacing a managed service registration stops its owner and preserves the foreign owner", async () => {
-  const service = await startManagedService("opencode-service-foreign-")
-  const foreign = { ...service.info, id: "foreign-owner", pid: process.pid }
-  try {
-    await fs.writeFile(service.registration, JSON.stringify(foreign))
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).json()).toEqual(foreign)
-    await expectPortAvailable(service.port)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
-test("clean managed service shutdown removes its registration", async () => {
-  const service = await startManagedService("opencode-service-clean-")
-  try {
-    await Effect.runPromise(Service.stop({ file: service.registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    expect(await waitForExit(service.owner)).toBe(true)
-    expect(await Bun.file(service.registration).exists()).toBe(false)
-  } finally {
-    await stopManagedService(service)
-  }
-}, 30_000)
-
 test("concurrent service processes elect one server", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-election-"))
  const database = path.join(root, "opencode.db")
@@ -212,34 +130,18 @@ test("concurrent service processes elect one server", async () => {
  )
  const command = [process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"]
  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const port = await availablePort()
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port }))
-  const processes = Array.from({ length: 10 }, () => Bun.spawn(command, { env, stderr: "pipe", stdout: "pipe" }))
+  const processes = Array.from({ length: 10 }, () => Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" }))

  try {
    const info = await waitForInfo(registration)
    const winner = processes.find((process) => process.pid === info.pid)
    const losers = processes.filter((process) => process.pid !== info.pid)
    const exited = await Promise.all(
-      losers.map((process) => Promise.race([process.exited.then(() => true), Bun.sleep(60_000).then(() => false)])),
+      losers.map((process) => Promise.race([process.exited.then(() => true), Bun.sleep(10_000).then(() => false)])),
    )

    expect(exited).toEqual(losers.map(() => true))
-    const errors = await Promise.all(
-      losers.map(
-        async (process) => (await new Response(process.stdout).text()) + (await new Response(process.stderr).text()),
-      ),
-    )
-    expect(
-      losers.map((process) => process.exitCode),
-      errors.filter(Boolean).join("\n"),
-    ).toEqual(losers.map(() => 0))
    expect(winner?.exitCode).toBe(null)
-    expect(new URL(info.url).port).toBe(String(port))
-    expect((await Bun.file(config).json()).password).toBe(info.password)
-    expect(await Bun.file(registration + ".lock").exists()).toBe(false)
    expect(
      await fetch(new URL("/api/health", info.url), {
        headers: { authorization: "Basic " + btoa(`opencode:${info.password}`) },
@@ -249,6 +151,20 @@ test("concurrent service processes elect one server", async () => {
      version: info.version,
      pid: info.pid,
    })
+    const blockedTemp = registration + "." + info.id + ".tmp"
+    await fs.mkdir(blockedTemp)
+    await fs.rm(registration)
+    await Bun.sleep(6_000)
+    expect(await Bun.file(registration).exists()).toBe(false)
+    await fs.rm(blockedTemp, { recursive: true })
+    const restored = await waitForInfo(registration)
+    expect(restored.id).toBe(info.id)
+    expect(restored.pid).toBe(info.pid)
+    await fs.writeFile(registration, "not-json")
+    const repaired = await waitForInfo(registration)
+    expect(repaired.id).toBe(info.id)
+    expect(repaired.pid).toBe(info.pid)
+
    const contender = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
    try {
      const contenderExited = await Promise.race([
@@ -256,7 +172,6 @@ test("concurrent service processes elect one server", async () => {
        Bun.sleep(10_000).then(() => false),
      ])
      expect(contenderExited).toBe(true)
-      expect(contender.exitCode).toBe(0)
      expect((await waitForInfo(registration)).id).toBe(info.id)
    } finally {
      contender.kill("SIGTERM")
@@ -278,200 +193,18 @@ test("concurrent service processes elect one server", async () => {
    expect(await waitForExecutionStart(database, sessionID)).toBe(1)
    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
    await winner?.exited
-    expect(await Bun.file(registration).exists()).toBe(false)
  } finally {
    processes.forEach((process) => process.kill("SIGTERM"))
    await Promise.all(processes.map((process) => process.exited))
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 120_000)
-
-test("configured managed service port overrides the channel default", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-port-"))
-  const port = await availablePort()
-  const env = serviceEnv(root)
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port, password: "" }))
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env,
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  try {
-    const info = await waitForInfo(registration)
-    expect(new URL(info.url).port).toBe(String(port))
-    expect(info.password).not.toBe("")
-    expect((await Bun.file(config).json()).password).toBe(info.password)
-    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    await owner.exited
-  } finally {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("unrelated managed port occupancy reports an actionable conflict", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-conflict-"))
-  const listener = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unrelated") })
-  const port = listener.port
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "pipe",
-  })
-  try {
-    expect(await contender.exited).not.toBe(0)
-    const output = (await new Response(contender.stdout).text()) + (await new Response(contender.stderr).text())
-    expect(output).toContain(`Managed service port ${port} on 127.0.0.1 is already in use by another process`)
-    expect(output).toContain("opencode service set port <port>")
-    expect(await Bun.file(registration).exists()).toBe(false)
-  } finally {
-    listener.stop(true)
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("unresponsive managed port occupancy reports a bounded conflict", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-unresponsive-conflict-"))
-  const recognizing = Promise.withResolvers<void>()
-  const requests = { count: 0 }
-  using listener = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    fetch() {
-      requests.count += 1
-      if (requests.count === 2) recognizing.resolve()
-      return new Promise<Response>(() => {})
-    },
-  })
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(
-    path.join(root, "config", "opencode", "service-local.json"),
-    JSON.stringify({ port: listener.port }),
-  )
-  const stale = {
-    id: "stale",
-    version: InstallationVersion,
-    url: "http://127.0.0.1:1",
-    pid: process.pid,
-    password: "stale",
-  }
-  await fs.writeFile(registration, JSON.stringify(stale))
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "pipe",
-  })
-
-  try {
-    expect(await Promise.race([recognizing.promise.then(() => true), Bun.sleep(20_000).then(() => false)])).toBe(true)
-    const exitCode = await Promise.race([contender.exited, Bun.sleep(20_000).then(() => undefined)])
-    expect(exitCode).toBe(1)
-    const output = (await new Response(contender.stdout).text()) + (await new Response(contender.stderr).text())
-    expect(output).toContain(`Managed service port ${listener.port} on 127.0.0.1 is already in use by another process`)
-    expect(await Bun.file(registration).json()).toEqual(stale)
-  } finally {
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 45_000)
-
-test("port contender recognizes an incumbent registered during the bind race", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-bind-race-"))
-  const recognizing = Promise.withResolvers<void>()
-  const requests = { count: 0 }
-  using listener = Bun.serve({
-    hostname: "127.0.0.1",
-    port: 0,
-    fetch() {
-      requests.count += 1
-      if (requests.count === 2) recognizing.resolve()
-      return Response.json({ healthy: true, version: InstallationVersion, pid: process.pid }, { status: 503 })
-    },
-  })
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  const config = path.join(root, "config", "opencode", "service-local.json")
-  await fs.mkdir(path.dirname(config), { recursive: true })
-  await fs.writeFile(config, JSON.stringify({ port: listener.port }))
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(
-    registration,
-    JSON.stringify({
-      id: "stale",
-      version: InstallationVersion,
-      url: "http://127.0.0.1:1",
-      pid: 2_147_483_647,
-      password: "stale",
-    }),
-  )
-  const contender = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-
-  try {
-    expect(await Promise.race([recognizing.promise.then(() => true), Bun.sleep(20_000).then(() => false)])).toBe(true)
-    await Bun.sleep(8_000)
-    const info = {
-      id: "incumbent",
-      version: InstallationVersion,
-      url: `http://127.0.0.1:${listener.port}`,
-      pid: process.pid,
-      password: "incumbent",
+    try {
+      expect(await Bun.file(registration).exists()).toBe(false)
+    } finally {
+      await fs.rm(root, { recursive: true, force: true })
    }
-    await fs.writeFile(registration, JSON.stringify(info))
-
-    expect(await Promise.race([contender.exited, Bun.sleep(20_000).then(() => undefined)])).toBe(0)
-    expect(await Bun.file(registration).json()).toEqual(info)
-  } finally {
-    contender.kill("SIGTERM")
-    await contender.exited
-    await fs.rm(root, { recursive: true, force: true })
  }
-}, 45_000)
+}, 60_000)

-test("stale dead registration is replaced after binding the selected port", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-stale-"))
-  const port = await availablePort()
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  await fs.mkdir(path.dirname(registration), { recursive: true })
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  await fs.writeFile(
-    registration,
-    JSON.stringify({ id: "dead", version: "dead", url: `http://127.0.0.1:${port}`, pid: 2_147_483_647 }),
-  )
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  try {
-    const info = await waitForInfo(registration, (value) => value.id !== "dead")
-    expect(new URL(info.url).port).toBe(String(port))
-    expect(info.pid).toBe(owner.pid)
-    await Effect.runPromise(Service.stop({ file: registration }).pipe(Effect.provide(NodeFileSystem.layer)))
-    await owner.exited
-  } finally {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-  }
-}, 30_000)
-
-test("a failed service stays registered and owns the selected port until stopped", async () => {
+test("a failed service stays registered and owns the lock until stopped", async () => {
  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-failed-"))
  const database = path.join(root, "database")
  await fs.mkdir(database)
@@ -491,12 +224,10 @@ test("a failed service stays registered and owns the selected port until stopped

  try {
    const info = await waitForInfo(registration)
-    await waitForFailed(info)
    expect(owner.exitCode).toBe(null)

    const contender = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
    expect(await Promise.race([contender.exited.then(() => true), Bun.sleep(10_000).then(() => false)])).toBe(true)
-    expect(contender.exitCode).toBe(0)
    expect((await waitForInfo(registration)).id).toBe(info.id)
    expect(owner.exitCode).toBe(null)

@@ -544,86 +275,13 @@ function waitForExecutionStart(file: string, sessionID: SessionV2.ID) {
  )
 }

-async function waitForInfo(file: string, accept: (info: Info) => boolean = () => true) {
+async function waitForInfo(file: string) {
  for (let attempt = 0; attempt < 400; attempt++) {
    const value = await Bun.file(file)
      .json()
      .catch(() => undefined)
-    if (value !== undefined) {
-      const info = await Schema.decodeUnknownPromise(Service.Info)(value)
-      if (accept(info)) return info
-    }
+    if (value !== undefined) return Schema.decodeUnknownPromise(Service.Info)(value)
    await Bun.sleep(50)
  }
  throw new Error("Timed out waiting for service registration")
 }
-
-async function waitForFailed(info: Info) {
-  for (let attempt = 0; attempt < 400; attempt++) {
-    const status = await fetch(new URL("/api/health", info.url), {
-      headers: { authorization: "Basic " + btoa(`opencode:${info.password}`) },
-    })
-      .then((response) => response.status)
-      .catch(() => undefined)
-    if (status === 500) return
-    await Bun.sleep(50)
-  }
-  throw new Error("Timed out waiting for service boot failure")
-}
-
-async function availablePort() {
-  const server = Bun.serve({ port: 0, fetch: () => new Response() })
-  const port = server.port
-  await server.stop(true)
-  if (port === undefined) throw new Error("Server did not bind a port")
-  return port
-}
-
-function serviceEnv(root: string) {
-  return {
-    ...process.env,
-    HOME: root,
-    OPENCODE_DB: path.join(root, "opencode.db"),
-    OPENCODE_TEST_HOME: root,
-    XDG_CACHE_HOME: path.join(root, "cache"),
-    XDG_CONFIG_HOME: path.join(root, "config"),
-    XDG_DATA_HOME: path.join(root, "data"),
-    XDG_STATE_HOME: path.join(root, "state"),
-  }
-}
-
-async function startManagedService(prefix: string, failBoot = false) {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix))
-  const port = await availablePort()
-  const registration = path.join(root, "state", "opencode", "service-local.json")
-  await fs.mkdir(path.join(root, "config", "opencode"), { recursive: true })
-  if (failBoot) await fs.mkdir(path.join(root, "database"))
-  await fs.writeFile(path.join(root, "config", "opencode", "service-local.json"), JSON.stringify({ port }))
-  const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"], {
-    env: failBoot ? { ...serviceEnv(root), OPENCODE_DB: path.join(root, "database") } : serviceEnv(root),
-    stderr: "pipe",
-    stdout: "ignore",
-  })
-  const info = await waitForInfo(registration).catch(async (cause) => {
-    owner.kill("SIGTERM")
-    await owner.exited
-    await fs.rm(root, { recursive: true, force: true })
-    throw cause
-  })
-  return { root, port, registration, owner, info }
-}
-
-async function stopManagedService(service: Awaited<ReturnType<typeof startManagedService>>) {
-  service.owner.kill("SIGTERM")
-  await service.owner.exited
-  await fs.rm(service.root, { recursive: true, force: true })
-}
-
-function waitForExit(process: Bun.Subprocess, timeout = 10_000) {
-  return Promise.race([process.exited.then(() => true), Bun.sleep(timeout).then(() => false)])
-}
-
-async function expectPortAvailable(port: number) {
-  const server = Bun.serve({ hostname: "127.0.0.1", port, fetch: () => new Response() })
-  await server.stop(true)
-}
@@ -29,17 +29,6 @@ export const discover = Effect.fn("service.discover")(function* (options: Discov
  return (yield* discoverLocal(options))?.endpoint
 })

-/** Recognize an authenticated compatible service bound to an expected URL, including while it starts or fails. */
-export const incumbent = Effect.fn("service.incumbent")(function* (
-  options: DiscoverOptions & { readonly url: string },
-) {
-  const info = yield* read(options.file)
-  const found = info === undefined ? undefined : yield* probe({ ...info, url: options.url })
-  if (found === undefined || found.legacy) return undefined
-  if (options.version !== undefined && found.version !== options.version) return undefined
-  return { endpoint: found.endpoint, state: found.state }
-})
-
 const discoverLocal = Effect.fnUntraced(function* (options: DiscoverOptions) {
  const found = (yield* registered(options.file)).service
  if (found?.state !== "ready") return undefined
@@ -112,15 +101,8 @@ export const ensure = Effect.fn("service.ensure")(function* (options: EnsureOpti
      lastSpawn = Date.now()
    }
    return Option.none<LocalService>()
-  }).pipe(
-    Effect.repeat({
-      until: Option.isSome,
-      schedule: Schedule.max([Schedule.spaced("1 second"), Schedule.recurs(120)]),
-    }),
-  )
-  if (Option.isNone(found))
-    return yield* Effect.fail(new Error("Timed out waiting for the background service to start"))
-  return found.value.endpoint
+  }).pipe(Effect.repeat({ until: Option.isSome, schedule: Schedule.spaced("1 second") }))
+  return Option.getOrThrow(found).endpoint
 })

 function contenderFailure(contender: Contender) {
@@ -291,4 +273,4 @@ const requestStop = Effect.fnUntraced(function* (service: LocalService) {
 })

 /** Effect-based local service lifecycle operations. */
-export const Service = { discover, incumbent, ensure, stop, headers, Info }
+export const Service = { discover, ensure, stop, headers, Info }
@@ -1276,8 +1276,6 @@ export type SessionStepFailed = {
    error: SessionStructuredError
    cost?: MoneyUSD
    tokens?: TokenUsageInfo
-    snapshot?: string
-    files?: Array<string>
  }
 }

@@ -2,7 +2,13 @@ import { readFile } from "node:fs/promises"
 import { spawn, type ChildProcess } from "node:child_process"
 import { homedir } from "node:os"
 import { join } from "node:path"
-import type { DiscoverOptions, Endpoint, Info, EnsureOptions, StopOptions } from "../service.js"
+import type {
+  DiscoverOptions,
+  Endpoint,
+  Info,
+  EnsureOptions,
+  StopOptions,
+} from "../service.js"
 import type { ServiceHealth, ServiceStopResponse } from "./generated/types.js"

 export * from "../service.js"
@@ -32,7 +38,6 @@ async function discoverLocal(options: DiscoverOptions) {

 /** Ensure a healthy, compatible local service is running. */
 export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
-  const deadline = Date.now() + 120_000
  const contenders = new Set<Contender>()
  let announced = false
  let lastSpawn = 0
@@ -61,7 +66,6 @@ export async function ensure(options: EnsureOptions = {}): Promise<Endpoint> {
  }

  while (true) {
-    if (Date.now() >= deadline) throw new Error("Timed out waiting for the background service to start")
    const registration = await registered(options.file, true)

    if (registration.service !== undefined) {
@@ -124,9 +128,7 @@ function fallback() {
 /** Create HTTP authentication headers for a service endpoint. */
 export function headers(endpoint: Endpoint) {
  if (endpoint.auth === undefined) return undefined
-  return {
-    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64"),
-  }
+  return { authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64") }
 }

 async function read(file?: string) {
@@ -225,8 +227,7 @@ async function kill(service: LocalService, options: { readonly file?: string })
  const latest = await find(options)
  if (latest === undefined || !same(latest.info, service.info)) return
  signal(service.info.pid, "SIGKILL")
-  if (!(await waitUntilStopped(service.info.pid)))
-    throw new Error(`Server process ${service.info.pid} is still running`)
+  if (!(await waitUntilStopped(service.info.pid))) throw new Error(`Server process ${service.info.pid} is still running`)
 }

 async function requestStop(service: LocalService) {
@@ -108,9 +108,7 @@ const runtime = CodeMode.make({ tools: { opencode: api.tools } })

 It is synchronous and returns `{ tools, skipped }`: operations with unsupported encodings, non-JSON bodies, binary
 responses, or streaming land in `skipped` instead of producing broken tools. Auth is resolved host-side and never
-model-visible; generated tools require `HttpClient.HttpClient` in the environment. `readOnly` properties are omitted
-from request signatures and `writeOnly` properties from response signatures. These JSON Schemas are model-facing, not
-runtime filters: nested value bodies and server responses pass through unchanged. See the option docstrings in
+model-visible; generated tools require `HttpClient.HttpClient` in the environment. See the option docstrings in
 `src/openapi/types.ts` for full semantics.

 ## Outputs
@@ -19,7 +19,7 @@ ultimate source of truth.
 - [x] Top-level `await` and `return` through the program's implicit async-function scope.
 - [x] Explicit `return`, final top-level expression as a REPL-style result, and `null` when no value is produced.
 - [x] Program results use JSON-like boundaries, with `undefined` and non-finite numbers normalized to `null`. Tool
-      arguments follow JSON serialization semantics before their schema applies (see the tools section).
+      arguments remain subject to their schema and the outbound-handling gap listed below.
 - [x] Live Date, RegExp, Map, Set, URL, and URLSearchParams values inside CodeMode.
 - [x] Tool calls through the host-provided `tools` tree only.
 - [x] The global `search(...)` built-in: synchronous tool discovery that counts as an admitted tool call and is
@@ -80,7 +80,7 @@ ultimate source of truth.
 - [x] Expression and block function bodies.
 - [x] User callbacks for the supported Array, Map, Set, URLSearchParams, sort, string-replacement, and `Array.from`
      mapper APIs, with one shared acceptance rule everywhere including promise reactions.
- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, `isFinite`, `isNaN`, and URI helpers as callbacks.
+- [x] `Boolean`, `Number`, `String`, `parseInt`, `parseFloat`, and URI helpers as callbacks.
 - [x] Built-in method references as callbacks, such as `values.map(Math.abs)`, `records.map(JSON.stringify)`,
      `items.forEach(console.log)`, and `Promise.resolve(-1).then(Math.abs)`. Extra callback arguments a built-in
      does not consume are ignored, like JS; consumed arguments stay strictly validated (`Math.floor` still rejects a
@@ -157,11 +157,8 @@ ultimate source of truth.
 - [x] Dotted tool names are canonicalized into namespace paths; a path can be both callable and a namespace, and the
      last definition supplied for a canonical path wins.
 - [x] Tool path segments may be named `constructor`, `prototype`, or `__proto__` because paths use inert Map keys.
- [x] Outbound tool arguments follow JSON serialization semantics, like `JSON.stringify`: object properties with
-      `undefined` values are dropped, `undefined` array elements and non-finite numbers become `null`, and sparse
-      arrays densify. Tools never receive `undefined` inside their input object, though a bare `tools.t(undefined)`
-      argument still reaches schema decoding as `undefined`. Program results keep the stricter
-      normalization where every `undefined` becomes `null`.
+- [ ] Reject `undefined` and non-finite numbers in outbound tool arguments before render-only and OpenAPI tools run;
+      retain null normalization for program results and JSON serialization.
 - [ ] Tokenize and case-fold non-ASCII tool paths, descriptions, and queries for tool search.

 ## Objects and properties
@@ -213,12 +210,9 @@ ultimate source of truth.
 - [x] `localeCompare`; locale and options arguments are currently ignored.
 - [x] `toString`, `length`, numeric indexing, spread, and `for...of` by Unicode code point.
 - [x] Static `String.fromCharCode` and `String.fromCodePoint`.
- [x] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` coerce like
-      native JS, `split(undefined)` returns the whole string, and `includes`/`startsWith`/`endsWith` reject regular
-      expressions with a native-style `TypeError`. Opaque runtime references still reject as data errors, and
-      `repeat` still requires a finite non-negative count.
- [x] Native no-argument parity for `match()`, `matchAll()`, and `search()`; all behave as an empty pattern. Present
-      arguments must still be a regular expression or string pattern.
+- [ ] Native argument coercion for supported String methods; for example, `includes(1)` and `slice("1")` currently
+      reject instead of coercing.
+- [ ] Native no-argument parity for `match()` and `search()`.

 ## Numbers and Math

@@ -232,16 +226,13 @@ ultimate source of truth.
 - [x] Math methods: `random`, `max`, `min`, `abs`, `acos`, `acosh`, `asin`, `asinh`, `atan`, `atan2`, `atanh`,
      `floor`, `ceil`, `round`, `trunc`, `sign`, `sqrt`, `cbrt`, `pow`, `hypot`, `cos`, `cosh`, `sin`, `sinh`,
      `tan`, `tanh`, `log`, `log2`, `log10`, `log1p`, `exp`, `expm1`, `f16round`, `fround`, `clz32`, and `imul`.
- [x] Native zero-argument behavior for `Number()` and `String()`: they produce `0` and `""`, while
-      `Number(undefined)` stays `NaN` and `String(undefined)` stays `"undefined"`.
- [x] `++` and `--` use CodeMode numeric coercion (numeric strings increment, plain data objects become `NaN`, Dates
-      use their epoch time) and reject opaque runtime references as data errors.
- [x] Unknown static members on global namespaces and on `Number`/`String`/the coercion functions read as `undefined`
-      for feature detection. Calling any undefined value reports a native-style `TypeError` naming the callee, for
-      example `Math.sumPrecise is not a function.` Blocked members (`constructor`, `__proto__`, ...) still throw,
-      and unknown `Promise` statics keep their descriptive error.
+- [ ] Native zero-argument behavior for `Number()` and `String()`; they currently do not produce `0` and `""`.
+- [ ] `++` and `--` must use CodeMode numeric coercion and reject opaque runtime references; they currently call host
+      `Number(...)` directly.
+- [ ] Unknown static members must read as `undefined` for feature detection; some currently appear callable or throw
+      during property access.
 - [ ] `Math.sumPrecise`.
- [x] Global coercing `isFinite` and `isNaN`; opaque runtime references reject as data errors, like `Number(...)`.
+- [ ] Global coercing `isFinite` and `isNaN`.

 ## JSON and console

@@ -44,7 +44,7 @@ export const normalizeError = (error: unknown): Diagnostic => {
      message = (value as { message: string }).message
    } else {
      try {
-        message = JSON.stringify(copyOut(value, "json")) ?? String(value)
+        message = JSON.stringify(copyOut(value)) ?? String(value)
      } catch {
        message = String(value)
      }
@@ -52,7 +52,7 @@ export const executeWithLimits = <const Provided extends Record<string, unknown>
            logs,
          )
          const value = yield* interpreter.run(program)
-          const result = copyOut(copyIn(value, "Execution result"), "nullify") as DataValue
+          const result = copyOut(copyIn(value, "Execution result"), true) as DataValue
          returned = { value: result, promises }
          const warnings = yield* promises.interrupt()
          return {
@@ -12,7 +12,7 @@ import {
  PromiseNamespace,
  UriFunction,
 } from "./model.js"
-import { containsOpaqueReference, rejectCircularInsertion, typeofValue } from "./references.js"
+import { rejectCircularInsertion, typeofValue } from "./references.js"
 import { isBlockedMember, type SafeObject } from "../tool-runtime.js"
 import {
  CodeModeDate,
@@ -137,31 +137,21 @@ export const invokeGlobalMethod = (ref: GlobalMethodReference, args: Array<unkno
  return invokeJsonMethod(ref.name, args, node)
 }

-const requireDataArgument = (name: string, index: number, arg: unknown, node: AstNode): unknown => {
-  if (containsOpaqueReference(arg)) {
-    throw new InterpreterRuntimeError(
-      `String.${name} expects argument ${index + 1} to be a data value.`,
-      node,
-      "InvalidDataValue",
-    )
-  }
-  return arg
-}
-
 const invokeStringMethod = (value: string, name: string, args: Array<unknown>, node: AstNode): unknown => {
-  // Coerce arguments like native JS; opaque runtime references still reject.
-  const str = (index: number): string => coerceToString(requireDataArgument(name, index, args[index], node))
-  const num = (index: number): number => coerceToNumber(requireDataArgument(name, index, args[index], node))
+  const str = (index: number): string => {
+    const arg = args[index]
+    if (typeof arg !== "string")
+      throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a string.`, node)
+    return arg
+  }
+  const num = (index: number): number => {
+    const arg = args[index]
+    if (typeof arg !== "number")
+      throw new InterpreterRuntimeError(`String.${name} expects argument ${index + 1} to be a number.`, node)
+    return arg
+  }
  const optNum = (index: number): number | undefined => (args[index] === undefined ? undefined : num(index))
  const optStr = (index: number): string | undefined => (args[index] === undefined ? undefined : str(index))
-  const rejectRegex = (): void => {
-    if (args[0] instanceof CodeModeRegExp) {
-      throw new InterpreterRuntimeError(
-        `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`,
-        node,
-      ).as("TypeError")
-    }
-  }

  let result: unknown
  switch (name) {
@@ -197,11 +187,8 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
      break
    }
    case "split": {
-      // Native: an undefined separator returns the whole string, not a split on "undefined",
-      // unless the limit truncates to zero.
-      if (args[0] === undefined) {
-        const requestedLimit = optNum(1)
-        result = requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]
+      if (args.length === 0) {
+        result = [value]
        break
      }
      if (args[0] instanceof CodeModeRegExp) {
@@ -216,15 +203,12 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
      result = value.slice(optNum(0), optNum(1))
      break
    case "includes":
-      rejectRegex()
      result = value.includes(str(0), optNum(1))
      break
    case "startsWith":
-      rejectRegex()
      result = value.startsWith(str(0), optNum(1))
      break
    case "endsWith":
-      rejectRegex()
      result = value.endsWith(str(0), optNum(1))
      break
    case "indexOf":
@@ -279,7 +263,7 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
    case "repeat": {
      const count = num(0)
      if (!Number.isFinite(count) || count < 0)
-        throw new InterpreterRuntimeError("String.repeat expects a finite non-negative count.", node).as("RangeError")
+        throw new InterpreterRuntimeError("String.repeat expects a finite non-negative count.", node)
      result = value.repeat(count)
      break
    }
@@ -317,8 +301,6 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
  return boundedData(result, `String.${name} result`)
 }

-export const arrayStatics = new Set(["isArray", "of", "from"])
-
 const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  switch (name) {
    case "isArray":
@@ -418,9 +400,11 @@ const invokeStringReplacer = <R>(
    if (name === "replace") value.replace(pattern.regex, collect)
    else value.replaceAll(pattern.regex, collect)
  } else {
-    const search = coerceToString(requireDataArgument(name, 0, pattern, node))
-    if (name === "replace") value.replace(search, collect)
-    else value.replaceAll(search, collect)
+    if (typeof pattern !== "string") {
+      throw new InterpreterRuntimeError(`String.${name} expects argument 1 to be a string.`, node)
+    }
+    if (name === "replace") value.replace(pattern, collect)
+    else value.replaceAll(pattern, collect)
  }

  return Effect.gen(function* () {
@@ -105,7 +105,7 @@ export class GlobalMethodReference {
 }

 export class CoercionFunction {
-  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat" | "isFinite" | "isNaN") {}
+  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat") {}
 }

 export class UriFunction {
@@ -10,7 +10,6 @@ import {
  ErrorConstructorReference,
  GlobalMethodReference,
  GlobalNamespace,
-  type GlobalNamespaceName,
  getArray,
  getBoolean,
  getNode,
@@ -35,7 +34,7 @@ import {
  UriFunction,
 } from "./model.js"
 import { caughtErrorValue, constructErrorValue } from "./errors.js"
-import { arrayStatics, type CallbackRunner, invokeArrayFrom, invokeGlobalMethod, invokeIntrinsic } from "./methods.js"
+import { type CallbackRunner, invokeArrayFrom, invokeGlobalMethod, invokeIntrinsic } from "./methods.js"
 import {
  constructPromise,
  invokePromiseInstanceMethod,
@@ -47,11 +46,10 @@ import { containsOpaqueReference, isRuntimeReference, rejectCircularInsertion, t
 import { ScopeStack } from "./scope.js"
 import { arrayMethods, mapMethods, setMethods, spreadItems } from "../stdlib/collections.js"
 import { consoleMethods, formatConsoleMessage } from "../stdlib/console.js"
-import { dateMethods, dateStatics } from "../stdlib/date.js"
-import { jsonStatics } from "../stdlib/json.js"
-import { mathConstants, mathMethods } from "../stdlib/math.js"
+import { dateMethods } from "../stdlib/date.js"
+import { mathConstants } from "../stdlib/math.js"
 import { numberConstants, numberMethods, numberStatics } from "../stdlib/number.js"
-import { objectMethodsPreservingIdentity, objectStatics } from "../stdlib/object.js"
+import { objectMethodsPreservingIdentity } from "../stdlib/object.js"
 import { promiseStatics } from "../stdlib/promise.js"
 import { escapeRegexHint, regexpMethods, regexpProperties, regexFailureReason } from "../stdlib/regexp.js"
 import { stringMethods, stringStatics } from "../stdlib/string.js"
@@ -59,7 +57,6 @@ import {
  urlMethods,
  urlProperties,
  urlSearchParamsMethods,
-  urlStatics,
  urlWritableProperties,
  invokeUriFunction,
  uriArgument,
@@ -86,32 +83,6 @@ import {
  CodeModeURLSearchParams,
 } from "../values.js"

-const globalStaticMembers: Partial<Record<GlobalNamespaceName, Set<string>>> = {
-  Object: objectStatics,
-  Math: mathMethods,
-  JSON: jsonStatics,
-  Array: arrayStatics,
-  console: consoleMethods,
-  Date: dateStatics,
-  URL: urlStatics,
-}
-
-const calleeDescription = (callee: AstNode): string => {
-  if (callee.type === "Identifier") return getString(callee, "name")
-  if (callee.type === "MemberExpression") {
-    const object = getNode(callee, "object")
-    const property = getNode(callee, "property")
-    const key =
-      callee.computed !== true && property.type === "Identifier"
-        ? getString(property, "name")
-        : property.type === "Literal" && typeof property.value === "string"
-          ? property.value
-          : undefined
-    if (object.type === "Identifier" && key !== undefined) return `${getString(object, "name")}.${key}`
-  }
-  return "The called value"
-}
-
 const instanceofValue = (lhs: unknown, rhs: unknown, node: AstNode): boolean => {
  if (rhs instanceof ErrorConstructorReference) {
    const brand = errorBrandName(lhs)
@@ -228,8 +199,6 @@ export class Interpreter<R> {
    globalScope.set("console", { mutable: false, value: new GlobalNamespace("console") })
    globalScope.set("parseInt", { mutable: false, value: new CoercionFunction("parseInt") })
    globalScope.set("parseFloat", { mutable: false, value: new CoercionFunction("parseFloat") })
-    globalScope.set("isFinite", { mutable: false, value: new CoercionFunction("isFinite") })
-    globalScope.set("isNaN", { mutable: false, value: new CoercionFunction("isNaN") })
    globalScope.set("Date", { mutable: false, value: new GlobalNamespace("Date") })
    globalScope.set("RegExp", { mutable: false, value: new GlobalNamespace("RegExp") })
    globalScope.set("Map", { mutable: false, value: new GlobalNamespace("Map") })
@@ -1485,23 +1454,10 @@ export class Interpreter<R> {
      throw new InterpreterRuntimeError(`Unsupported update operator '${operator}'.`, node)
    }

-    // CodeMode numeric coercion, not host Number(): null-prototype data objects would make
-    // the host throw during ToPrimitive, and opaque runtime references must reject clearly.
-    const operand = (current: unknown): number => {
-      if (containsOpaqueReference(current)) {
-        throw new InterpreterRuntimeError(
-          `'${operator}' requires a data value in CodeMode.`,
-          argument,
-          "InvalidDataValue",
-        )
-      }
-      return coerceToNumber(current)
-    }
-
    if (argument.type === "Identifier") {
      return Effect.sync(() => {
        const name = getString(argument, "name")
-        const current = operand(this.scopes.get(name, argument))
+        const current = Number(this.scopes.get(name, argument))
        const next = current + increment
        this.scopes.set(name, next, argument)
        return prefix ? next : current
@@ -1510,7 +1466,7 @@ export class Interpreter<R> {

    if (argument.type === "MemberExpression") {
      return this.modifyMember(argument, (current) => {
-        const value = operand(current)
+        const value = Number(current)
        const next = value + increment
        return Effect.succeed({ write: true, next, result: prefix ? next : value })
      })
@@ -1607,9 +1563,6 @@ export class Interpreter<R> {
        callable.settle(args[0])
        return undefined
      }
-      if (callable === undefined || callable === null) {
-        throw new InterpreterRuntimeError(`${calleeDescription(callee)} is not a function.`, callee).as("TypeError")
-      }
      throw new InterpreterRuntimeError("Only tools are callable in CodeMode.", callee)
    })
  }
@@ -1880,18 +1833,16 @@ export class Interpreter<R> {
      }

      if (objectValue instanceof GlobalNamespace) {
-        if (typeof key === "string" && isBlockedMember(key)) {
-          throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available in CodeMode.`, propertyNode)
+        if (typeof key !== "string" || isBlockedMember(key)) {
+          throw new InterpreterRuntimeError(
+            `${objectValue.name}.${String(key)} is not available in CodeMode.`,
+            propertyNode,
+          )
        }
-        if (typeof key !== "string") return new ComputedValue(undefined)
        if (objectValue.name === "Math" && mathConstants.has(key)) {
          return new ComputedValue((Math as unknown as Record<string, number>)[key])
        }
-        if (globalStaticMembers[objectValue.name]?.has(key)) {
-          return new GlobalMethodReference(objectValue.name, key)
-        }
-        // Unknown static members read as undefined so feature detection works like native JS.
-        return new ComputedValue(undefined)
+        return new GlobalMethodReference(objectValue.name, key)
      }

      if (typeof objectValue === "string") {
@@ -1907,21 +1858,12 @@ export class Interpreter<R> {
        return new ComputedValue(undefined)
      }

-      if (objectValue instanceof CoercionFunction) {
-        if (typeof key === "string" && isBlockedMember(key)) {
-          throw new InterpreterRuntimeError(`${objectValue.name}.${key} is not available in CodeMode.`, propertyNode)
-        }
-        if (typeof key !== "string") return new ComputedValue(undefined)
+      if (objectValue instanceof CoercionFunction && typeof key === "string" && !isBlockedMember(key)) {
        if (objectValue.name === "Number" && numberConstants.has(key)) {
          return new ComputedValue((Number as unknown as Record<string, number>)[key])
        }
-        if (objectValue.name === "Number" && numberStatics.has(key)) {
-          return new GlobalMethodReference("Number", key)
-        }
-        if (objectValue.name === "String" && stringStatics.has(key)) {
-          return new GlobalMethodReference("String", key)
-        }
-        return new ComputedValue(undefined)
+        if (objectValue.name === "Number" && numberStatics.has(key)) return new GlobalMethodReference("Number", key)
+        if (objectValue.name === "String" && stringStatics.has(key)) return new GlobalMethodReference("String", key)
      }

      if (objectValue instanceof CodeModeDate) {
@@ -5,15 +5,11 @@ The initial adapter intentionally skips operations it cannot execute correctly.
 - Cookie parameters, authentication, and cookie-header merging.
 - Matrix, label, space-delimited, pipe-delimited, `allowReserved`, and parameter `content` serialization.
 - External references and complete nested `$defs` support.
- `$anchor` and nested `$id` resource resolution in directional (`readOnly`/`writeOnly`) projection.
- Use-site cleanup for `allOf` branches that reference shared component schemas: per-direction component definitions are projected globally, so a directional annotation declared only at one use site cannot remove the property from a referenced component's definition.
- Hidden-name cleanup inside `then`/`else`/`dependentSchemas`/`dependentRequired`, which constrain the same instance as `allOf`; a hidden property may remain named in those keywords.
- Projection inside `not`/`if`/`contains`, whose semantics would invert or shift if constraints were removed; those subschemas pass through unchanged, and a `$ref` from such a context to a projected `$defs` or component definition still observes hiding.
- Iterative traversal for pathologically deep schema nesting: the directional scan and projection recurse per level and overflow the stack around ten thousand levels, below the pre-existing converter limit of roughly fifty thousand; `fromSpec` throws a catchable `RangeError` either way.
 - Relative or templated server URLs and server variables.
 - Base URLs containing query strings or fragments.
 - Runtime response-schema validation and full content negotiation.
 - Binary response values and explicit byte-oriented return types.
+- Request/response projection for `readOnly` and `writeOnly` properties.
 - SSE, WebSocket, and other streaming transports.
 - Recovery of responses rejected by a status-filtering `HttpClient`.
 - Configurable request and response size limits.
@@ -3,7 +3,6 @@ import { make, type Definition } from "../tool.js"
 import { invoke } from "./runtime.js"
 import {
  componentDefinitions,
-  hasDirectionalSchemas,
  inputSchema,
  isRecord,
  methods,
@@ -39,10 +38,7 @@ export const fromSpec = (options: Options): Result => {
  const document = options.spec
  const schemes = securitySchemes(document)
  const defaultSecurity = securityRequirements(document.security)
-  const requestDefinitions = componentDefinitions(document, "request")
-  const responseDefinitions = hasDirectionalSchemas(document)
-    ? componentDefinitions(document, "response")
-    : requestDefinitions
+  const definitions = componentDefinitions(document)
  const paths = isRecord(document.paths) ? document.paths : {}
  const used = new Set<string>()
  const namespaces = new Set<string>()
@@ -61,7 +57,7 @@ export const fromSpec = (options: Options): Result => {
        summary: nonEmptyString(operationValue.summary),
        description: nonEmptyString(operationValue.description),
      }
-      const output = operationOutput(document, operationValue, responseDefinitions)
+      const output = operationOutput(document, operationValue, definitions)
      if (!output.ok) {
        skipped.push({ method: operation.method, path, reason: output.reason })
        continue
@@ -106,7 +102,7 @@ export const fromSpec = (options: Options): Result => {
        segments,
        make({
          description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
-          input: inputSchema(input.fields, requestDefinitions),
+          input: inputSchema(input.fields, definitions),
          output: output.value,
          run: (input) => invoke(plan, input),
        }),
@@ -27,225 +27,22 @@ export const nonEmptyString = (value: unknown): string | undefined =>
 export const own = <T>(record: Readonly<Record<string, T>>, key: string): T | undefined =>
  Object.hasOwn(record, key) ? record[key] : undefined

-const resolvePointer = (root: unknown, ref: string): unknown =>
-  ref
-    .slice(2)
-    .split("/")
-    .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-    .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), root)
-
 export const resolve = (document: Document, value: unknown): unknown => {
  const next = (current: unknown, seen: ReadonlySet<string>): unknown => {
    if (!isRecord(current)) return current
-    const ref = nonEmptyString(own(current, "$ref"))
+    const ref = nonEmptyString(current.$ref)
    if (ref === undefined || !ref.startsWith("#/") || seen.has(ref)) return current
-    const target = resolvePointer(document, ref)
+    const target = ref
+      .slice(2)
+      .split("/")
+      .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
+      .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), document)
    return target === undefined ? current : next(target, new Set([...seen, ref]))
  }
  return next(value, new Set())
 }

-// Model-facing directional projection: request schemas omit `readOnly` properties,
-// response schemas omit `writeOnly` properties, and `required` stays consistent.
-// Runtime values pass through unchanged.
-type SchemaDirection = "request" | "response"
-type SchemaResource = { readonly value: unknown; readonly root: unknown }
-
-const hiddenKeyword = { request: "readOnly", response: "writeOnly" } as const
-
-// Resolves one `$ref` hop so every link of a chain has its own sibling declarations
-// inspected; cycles terminate in the callers' cycle solver. Local `$defs`/`definitions`
-// pointers resolve against the schema being projected, other pointers rebase onto the target.
-const resolveResource = (document: Document, resource: SchemaResource): SchemaResource => {
-  if (!isRecord(resource.value)) return resource
-  const ref = nonEmptyString(own(resource.value, "$ref"))
-  if (ref === undefined || !ref.startsWith("#/")) return resource
-  const local = ref.startsWith("#/$defs/") || ref.startsWith("#/definitions/")
-  const target = resolvePointer(local ? resource.root : document, ref)
-  if (target === undefined) return resource
-  return { value: target, root: local ? resource.root : target }
-}
-
-// Hidden-ness and hidden names are memoized per schema object and direction so
-// diamond-shaped reference graphs stay linear. Documents are assumed immutable once
-// projected; a schema reachable under multiple resolution roots reuses the first result.
-type Solver<T> = {
-  readonly values: Map<unknown, T>
-  // Discovery index per schema whose strongly connected component is unresolved.
-  readonly pending: Map<unknown, number>
-  readonly stack: Array<unknown>
-}
-type DirectionCache = {
-  readonly hidden: Solver<boolean>
-  readonly names: Solver<ReadonlySet<string>>
-}
-
-const emptyCache = (): DirectionCache => ({
-  hidden: { values: new Map(), pending: new Map(), stack: [] },
-  names: { values: new Map(), pending: new Map(), stack: [] },
-})
-
-const projectionCaches = new WeakMap<Document, Record<SchemaDirection, DirectionCache>>()
-
-const projectionCache = (document: Document, direction: SchemaDirection): DirectionCache => {
-  const existing = projectionCaches.get(document)
-  if (existing !== undefined) return existing[direction]
-  const created = { request: emptyCache(), response: emptyCache() }
-  projectionCaches.set(document, created)
-  return created[direction]
-}
-
-// Tarjan's strongly connected components: cycle members all reach the same
-// declarations, so the component root's value is final for every member. Only resolved
-// components are cached, keeping results independent of traversal order.
-type CycleScope = { lowlink: number }
-
-const solveCycles = <T>(
-  solver: Solver<T>,
-  key: unknown,
-  provisional: T,
-  scope: CycleScope,
-  compute: (inner: CycleScope) => T,
-): T => {
-  const cached = solver.values.get(key)
-  if (cached !== undefined) return cached
-  const pending = solver.pending.get(key)
-  if (pending !== undefined) {
-    scope.lowlink = Math.min(scope.lowlink, pending)
-    return provisional
-  }
-  // Components pop as contiguous stack suffixes, so pending indices stay 0..size-1.
-  const index = solver.pending.size
-  const base = solver.stack.length
-  solver.pending.set(key, index)
-  solver.stack.push(key)
-  const inner: CycleScope = { lowlink: Infinity }
-  const value = compute(inner)
-  if (inner.lowlink < index) {
-    scope.lowlink = Math.min(scope.lowlink, inner.lowlink)
-    return value
-  }
-  for (const member of solver.stack.splice(base)) {
-    solver.pending.delete(member)
-    solver.values.set(member, value)
-  }
-  return value
-}
-
-// Most documents have no directional keywords; one cached scan skips projection entirely.
-const directionalDocuments = new WeakMap<Document, boolean>()
-
-export const hasDirectionalSchemas = (document: Document): boolean => {
-  const cached = directionalDocuments.get(document)
-  if (cached !== undefined) return cached
-  const contains = (value: unknown): boolean => {
-    if (Array.isArray(value)) return value.some(contains)
-    if (!isRecord(value)) return false
-    if (own(value, "readOnly") === true || own(value, "writeOnly") === true) return true
-    return Object.values(value).some(contains)
-  }
-  const result = contains(document)
-  directionalDocuments.set(document, result)
-  return result
-}
-
-// OpenAPI 3.1 allows keywords as siblings of `$ref`, so a schema's own declarations
-// are inspected before following the reference.
-const isHidden = (
-  document: Document,
-  resource: SchemaResource,
-  direction: SchemaDirection,
-  scope: CycleScope = { lowlink: Infinity },
-): boolean => {
-  const value = resource.value
-  if (!isRecord(value)) return false
-  if (own(value, hiddenKeyword[direction]) === true) return true
-  return solveCycles(projectionCache(document, direction).hidden, value, false, scope, (inner) => {
-    const target = resolveResource(document, resource)
-    return (
-      asArray(own(value, "allOf")).some((item) => isHidden(document, { ...resource, value: item }, direction, inner)) ||
-      (target.value !== value && isHidden(document, target, direction, inner))
-    )
-  })
-}
-
-// Hidden property names declared by a schema itself or inherited through `$ref` and
-// `allOf` composition, so sibling `required` lists stay consistent after projection.
-const hiddenNames = (
-  document: Document,
-  resource: SchemaResource,
-  direction: SchemaDirection,
-  scope: CycleScope = { lowlink: Infinity },
-): ReadonlySet<string> => {
-  const value = resource.value
-  if (!isRecord(value)) return new Set()
-  return solveCycles(projectionCache(document, direction).names, value, new Set(), scope, (inner) => {
-    const properties = own(value, "properties")
-    const declared = isRecord(properties)
-      ? Object.entries(properties)
-          .filter(([, property]) => isHidden(document, { ...resource, value: property }, direction))
-          .map(([name]) => name)
-      : []
-    const composed = asArray(own(value, "allOf")).flatMap((item) => [
-      ...hiddenNames(document, { ...resource, value: item }, direction, inner),
-    ])
-    const target = resolveResource(document, resource)
-    const referenced = target.value === value ? [] : hiddenNames(document, target, direction, inner)
-    return new Set([...declared, ...composed, ...referenced])
-  })
-}
-
-// `not`/`if`/`contains` subschemas pass through unprojected: they negate or select
-// rather than assert, so removing hidden properties would invert their semantics.
-const nestedSchemas = new Set([
-  "items",
-  "additionalProperties",
-  "unevaluatedProperties",
-  "propertyNames",
-  "then",
-  "else",
-])
-const nestedSchemaLists = new Set(["anyOf", "oneOf", "prefixItems"])
-const nestedSchemaMaps = new Set(["patternProperties", "dependentSchemas", "$defs", "definitions"])
-
-const directionalSchema = (
-  document: Document,
-  resource: SchemaResource,
-  direction: SchemaDirection,
-  excluded: ReadonlySet<string> = new Set(),
-): unknown => {
-  if (!isRecord(resource.value)) return resource.value
-  const hidden = new Set([...excluded, ...hiddenNames(document, resource, direction)])
-  const project = (item: unknown, inherited: ReadonlySet<string> = new Set()): unknown =>
-    directionalSchema(document, { ...resource, value: item }, direction, inherited)
-  return Object.fromEntries(
-    Object.entries(resource.value).map(([key, item]) => {
-      if (key === "properties" && isRecord(item)) {
-        return [
-          key,
-          Object.fromEntries(
-            Object.entries(item)
-              .filter(([name]) => !hidden.has(name))
-              .map(([name, property]) => [name, project(property)]),
-          ),
-        ]
-      }
-      if (key === "required" && Array.isArray(item)) {
-        return [key, item.filter((name) => typeof name !== "string" || !hidden.has(name))]
-      }
-      // allOf branches share one object; hidden names apply across every branch.
-      if (key === "allOf" && Array.isArray(item)) return [key, item.map((entry) => project(entry, hidden))]
-      if (nestedSchemas.has(key)) return [key, project(item)]
-      if (nestedSchemaLists.has(key) && Array.isArray(item)) return [key, item.map((entry) => project(entry))]
-      if (nestedSchemaMaps.has(key) && isRecord(item)) {
-        return [key, Object.fromEntries(Object.entries(item).map(([name, entry]) => [name, project(entry)]))]
-      }
-      return [key, item]
-    }),
-  )
-}
-
-const normalizeSchema = (document: Document, value: unknown): JsonSchema => {
+const projectSchema = (document: Document, value: unknown): JsonSchema => {
  if (!isRecord(value)) return {}
  const normalized = nonEmptyString(document.openapi)?.startsWith("3.0")
    ? fromSchemaOpenApi3_0(value)
@@ -255,21 +52,10 @@ const normalizeSchema = (document: Document, value: unknown): JsonSchema => {
    : { ...normalized.schema, $defs: normalized.definitions }
 }

-const projectSchema = (document: Document, value: unknown, direction: SchemaDirection): JsonSchema =>
-  normalizeSchema(
-    document,
-    hasDirectionalSchemas(document) ? directionalSchema(document, { value, root: value }, direction) : value,
-  )
-
-export const componentDefinitions = (
-  document: Document,
-  direction: SchemaDirection,
-): Readonly<Record<string, JsonSchema>> => {
+export const componentDefinitions = (document: Document): Readonly<Record<string, JsonSchema>> => {
  const components = isRecord(document.components) ? document.components : {}
  const schemas = isRecord(components.schemas) ? components.schemas : {}
-  return Object.fromEntries(
-    Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value, direction)]),
-  )
+  return Object.fromEntries(Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value)]))
 }

 const withDefinitions = (schema: JsonSchema, definitions: Readonly<Record<string, JsonSchema>>): JsonSchema => {
@@ -371,7 +157,7 @@ const operationParameters = (
    if (style === "deepObject" && !explode) {
      return { ok: false, reason: `query parameter '${name}' uses deepObject with explode=false` }
    }
-    const base = projectSchema(document, resolved.schema, "request")
+    const base = projectSchema(document, resolved.schema)
    const description = nonEmptyString(resolved.description)
    unordered.push({
      name,
@@ -405,10 +191,7 @@ const operationBody = (
      reason: `request body has no JSON content (declared: ${Object.keys(content).join(", ") || "none"})`,
    }
  }
-  const resolvedSchema = resolve(document, selected.schema)
-  const schema = hasDirectionalSchemas(document)
-    ? directionalSchema(document, { value: resolvedSchema, root: resolvedSchema }, "request")
-    : resolvedSchema
+  const schema = resolve(document, selected.schema)
  const required = resolved.required === true
  if (!isFlattenableObjectBody(schema, required)) {
    return {
@@ -419,7 +202,7 @@ const operationBody = (
            name: "body",
            location: "body",
            required,
-            schema: projectSchema(document, selected.schema, "request"),
+            schema: projectSchema(document, selected.schema),
            style: undefined,
            explode: undefined,
          },
@@ -434,13 +217,11 @@ const operationBody = (
  return {
    ok: true,
    value: {
-      // Field schemas were already projected with the body as resolution root; a second
-      // directional pass rooted at the field would misresolve shadowed local $defs.
      fields: Object.entries(schema.properties).map(([name, value]) => ({
        name,
        location: "body" as const,
        required: required && requiredProperties.has(name),
-        schema: normalizeSchema(document, value),
+        schema: projectSchema(document, value),
        style: undefined,
        explode: undefined,
      })),
@@ -558,7 +339,7 @@ export const operationOutput = (
        continue
      }
      if (!isRecord(value) || value.schema === undefined) return { ok: true, value: undefined }
-      outcomes.push(projectSchema(document, value.schema, "response"))
+      outcomes.push(projectSchema(document, value.schema))
    }
  }
  if (outcomes.length === 0) return { ok: true, value: undefined }
@@ -89,7 +89,7 @@ const formatConsoleTable = (value: unknown, columnsArgument: unknown): string =>
 const consoleTableColumns = (value: unknown): ReadonlyArray<string> | undefined => {
  if (value === undefined) return undefined
  if (containsRuntimeReference(value)) return undefined
-  const columns = copyOut(copyIn(value, "console.table columns"), "nullify")
+  const columns = copyOut(copyIn(value, "console.table columns"), true)
  return Array.isArray(columns) ? columns.map((column) => String(column)) : undefined
 }

@@ -23,8 +23,6 @@ export const dateMethods = new Set([
  "getTimezoneOffset",
 ])

-export const dateStatics = new Set(["now", "parse", "UTC"])
-
 export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
  switch (name) {
    case "now":
@@ -2,8 +2,6 @@ import { type AstNode, InterpreterRuntimeError, supportedSyntaxMessage } from ".
 import { typeofValue } from "../interpreter/references.js"
 import { copyIn, copyOut } from "../tool-runtime.js"

-export const jsonStatics = new Set(["parse", "stringify"])
-
 export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  switch (name) {
    case "stringify": {
@@ -18,7 +16,7 @@ export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNo
      }
      const space = args[2]
      const indent = typeof space === "number" || typeof space === "string" ? space : undefined
-      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value"), "json"), null, indent)
+      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value")), null, indent)
    }
    case "parse": {
      const text = args[0]
@@ -6,8 +6,6 @@ import { boundedData, coerceToString } from "./value.js"

 export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"])

-export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "is", "assign", "fromEntries"])
-
 export const invokeObjectMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
  const requireObject = (): Record<string, unknown> => {
    const input = args[0]
@@ -19,8 +19,6 @@ export const escapeRegexHint =
  'To match special characters like ( ) [ ] { } + * ? . literally, escape them with a backslash (e.g. "\\\\(") or test for them with String.includes instead.'

 export const toHostRegex = (arg: unknown, method: string, node: AstNode, extraFlags = ""): RegExp => {
-  // Native parity: an undefined pattern behaves as an empty pattern.
-  if (arg === undefined) return new RegExp("", extraFlags)
  if (arg instanceof CodeModeRegExp) return arg.regex
  if (typeof arg === "string") {
    try {
@@ -61,19 +61,10 @@ export const coerceToString = (value: unknown): string => {
 export const coerceToNumber = (value: unknown): number => {
  if (value instanceof CodeModeDate) return value.time
  if (isCodeModeValue(value)) return Number.NaN
-  // Arrays coerce through our own string coercion: host Number(array) joins with host
-  // ToPrimitive, which throws on the null-prototype objects the interpreter produces.
-  if (Array.isArray(value)) return Number(coerceToString(value))
-  return value !== null && typeof value === "object" ? Number.NaN : Number(value)
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? Number.NaN : Number(value)
 }

 export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node: AstNode): unknown => {
-  // Native: Number() is 0 and String() is "", unlike their undefined-argument forms; the
-  // other coercers match native through the undefined-argument path below.
-  if (args.length === 0) {
-    if (ref.name === "Number") return 0
-    if (ref.name === "String") return ""
-  }
  const raw = args[0]
  // Error values are plain SafeObjects; the boundedData path below would strip their brand.
  if (ref.name === "String" && errorBrandName(raw) !== undefined) return coerceToString(raw)
@@ -81,16 +72,12 @@ export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node
    if (ref.name === "Boolean") return true
    if (ref.name === "Number") return coerceToNumber(raw)
    if (ref.name === "String") return coerceToString(raw)
-    if (ref.name === "isFinite") return Number.isFinite(coerceToNumber(raw))
-    if (ref.name === "isNaN") return Number.isNaN(coerceToNumber(raw))
    if (ref.name === "parseInt") return parseInt(coerceToString(raw))
    return parseFloat(coerceToString(raw))
  }
  const value = boundedData(raw, `${ref.name} input`)
  if (ref.name === "Number") return coerceToNumber(value)
  if (ref.name === "Boolean") return Boolean(value)
-  if (ref.name === "isFinite") return Number.isFinite(coerceToNumber(value))
-  if (ref.name === "isNaN") return Number.isNaN(coerceToNumber(value))
  if (ref.name === "parseInt") {
    const radix = args[1]
    if (radix !== undefined && typeof radix !== "number") {
@@ -118,7 +118,8 @@ export class ToolRuntimeError extends Error {
  }
 }

-const isDefinition = <R>(value: Definition<R> | Tools<R>): value is Definition<R> => isToolDefinition<R>(value)
+const isDefinition = <R>(value: Definition<R> | Tools<R>): value is Definition<R> =>
+  isToolDefinition<R>(value)

 const runHost = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, ToolError, R> =>
  effect.pipe(
@@ -256,31 +257,18 @@ const copyBounded = (
  return copied
 }

-// "json" mirrors JSON.stringify (undefined object values drop, undefined array elements become
-// null, a bare undefined passes through): use it wherever data leaves as JSON, like tool
-// arguments and stringify-style formatting. "nullify" turns every undefined, including a bare
-// one, into null: use it for program results, where the consumer must never see undefined.
-export type CopyOutMode = "json" | "nullify"
-
-export const copyOut = (value: unknown, mode: CopyOutMode): unknown => {
-  if (value === undefined && mode === "nullify") return null
+export const copyOut = (value: unknown, undefinedAsNull = false): unknown => {
+  if (value === undefined && undefinedAsNull) return null
  if (typeof value === "number" && !Number.isFinite(value)) {
    return null
  }
  if (Array.isArray(value)) {
    // Array.from densifies holes so sparse arrays normalize at the boundary like JSON does.
-    return Array.from(value, (item) => {
-      const copied = copyOut(item, mode)
-      return copied === undefined && mode === "json" ? null : copied
-    })
+    return Array.from(value, (item) => copyOut(item, undefinedAsNull))
  }

  if (value !== null && typeof value === "object" && !(value instanceof ToolReference)) {
-    return Object.fromEntries(
-      Object.entries(value)
-        .map(([key, item]) => [key, copyOut(item, mode)] as const)
-        .filter(([, item]) => !(item === undefined && mode === "json")),
-    )
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copyOut(item, undefinedAsNull)]))
  }

  return value
@@ -708,13 +696,13 @@ export const make = <R>(
        invokeDefinition(
          "search",
          searchTool,
-          args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"), "json")),
+          args.map((arg) => copyOut(copyIn(arg, "Arguments for tool 'search'"))),
        ),
      ),
    invoke: (path, args) =>
      Effect.gen(function* () {
        const name = canonicalSegments(path).join(".")
-        const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`), "json"))
+        const externalArgs = args.map((arg) => copyOut(copyIn(arg, `Arguments for tool '${name}'`)))
        const tool = resolve(root, path)
        return yield* invokeDefinition(name, tool, externalArgs)
      }),
@@ -453,56 +453,6 @@ describe("CodeMode schema flexibility", () => {
    expect(observed).toStrictEqual([{ id: 42 }])
  })

-  test("outbound tool arguments follow JSON serialization semantics", async () => {
-    const observed: Array<unknown> = []
-    const call = Tool.make({
-      description: "Observe raw input",
-      input: { type: "object" },
-      run: (input) =>
-        Effect.sync(() => {
-          observed.push(input)
-          return "ok"
-        }),
-    })
-    const runtime = CodeMode.make({ tools: { adapter: { call } } })
-
-    const result = await Effect.runPromise(
-      runtime.execute(
-        `return await tools.adapter.call({ q: undefined, limit: 0 / 0, rate: 1 / 0, items: [1, undefined, 2], holes: [1, , 3] })`,
-      ),
-    )
-    expect(result.ok).toBe(true)
-    const received = observed[0] as Record<string, unknown>
-    expect(received).toStrictEqual({ limit: null, rate: null, items: [1, null, 2], holes: [1, null, 3] })
-    // The undefined-valued property is dropped like JSON.stringify, not delivered as undefined.
-    expect(Object.hasOwn(received, "q")).toBe(false)
-  })
-
-  test("dropping undefined values lets optionalKey schemas accept conditional arguments", async () => {
-    const observed: Array<unknown> = []
-    const find = Tool.make({
-      description: "Find things",
-      input: Schema.Struct({ query: Schema.optionalKey(Schema.String), limit: Schema.optionalKey(Schema.Number) }),
-      run: (input) =>
-        Effect.sync(() => {
-          observed.push(input)
-          return "ok"
-        }),
-    })
-    const runtime = CodeMode.make({ tools: { things: { find } } })
-
-    // The `cond ? value : undefined` idiom: optionalKey rejects a present undefined, so the
-    // JSON boundary must drop the key before the schema decodes.
-    const result = await Effect.runPromise(
-      runtime.execute(`return await tools.things.find({ query: undefined, limit: 5 })`),
-    )
-    expect(result.ok).toBe(true)
-    expect(observed).toStrictEqual([{ limit: 5 }])
-
-    const search = await Effect.runPromise(runtime.execute(`return (await search({ query: undefined })).items.length`))
-    expect(search.ok).toBe(true)
-  })
-
  test("renders JSON Schema outputs and $defs references", async () => {
    const lookup = Tool.make({
      description: "Look up a user",
@@ -59,53 +59,6 @@ const singleOperation = (operation: Record<string, unknown>, method = "get"): Do
  },
 })

-const directionalSpec = (openapi: string): Document => ({
-  openapi,
-  paths: {
-    "/users": {
-      post: {
-        operationId: "users.create",
-        requestBody: {
-          required: true,
-          content: { "application/json": { schema: { $ref: "#/components/schemas/User" } } },
-        },
-        responses: {
-          200: {
-            description: "Created",
-            content: { "application/json": { schema: { $ref: "#/components/schemas/User" } } },
-          },
-        },
-      },
-    },
-  },
-  components: {
-    schemas: {
-      ReadOnlyID: { type: "string", readOnly: true },
-      User: {
-        type: "object",
-        additionalProperties: false,
-        required: ["id", "name", "password", "profile", "generated"],
-        properties: {
-          id: { type: "string", readOnly: true },
-          name: { type: "string" },
-          password: { type: "string", writeOnly: true },
-          profile: {
-            type: "object",
-            additionalProperties: false,
-            required: ["createdAt", "secret", "label"],
-            properties: {
-              createdAt: { type: "string", readOnly: true },
-              secret: { type: "string", writeOnly: true },
-              label: { type: "string" },
-            },
-          },
-          generated: { $ref: "#/components/schemas/ReadOnlyID" },
-        },
-      },
-    },
-  },
-})
-
 describe("OpenAPI.fromSpec", () => {
  test("covers a representative API from generation through execution", async () => {
    const resolutions: Array<string> = []
@@ -401,550 +354,6 @@ describe("OpenAPI.fromSpec", () => {
    expect(tool.output.$defs).toMatchObject({ Local: { type: "string" }, Global: { type: "number" } })
  })

-  test("projects read-only and write-only properties by schema direction", () => {
-    for (const version of ["3.0.3", "3.1.0"]) {
-      const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec: directionalSpec(version) }).tools, "users.create")
-      if (!Tool.isDefinition(tool) || !isRecord(tool.input) || !isRecord(tool.output)) {
-        throw new Error(`users.create was not generated for OpenAPI ${version}`)
-      }
-
-      expect(inputTypeScript(tool)).toBe(
-        "{ name: string; password: string; profile: { secret: string; label: string } }",
-      )
-      expect(outputTypeScript(tool)).toBe(
-        "{ id: string; name: string; profile: { createdAt: string; label: string }; generated: string }",
-      )
-
-      const requestDefinitions = isRecord(tool.input.$defs) ? tool.input.$defs : {}
-      const responseDefinitions = isRecord(tool.output.$defs) ? tool.output.$defs : {}
-      const requestUser = isRecord(requestDefinitions.User) ? requestDefinitions.User : {}
-      const responseUser = isRecord(responseDefinitions.User) ? responseDefinitions.User : {}
-      expect(Object.keys(isRecord(requestUser.properties) ? requestUser.properties : {})).toEqual([
-        "name",
-        "password",
-        "profile",
-      ])
-      expect(requestUser.required).toEqual(["name", "password", "profile"])
-      expect(Object.keys(isRecord(responseUser.properties) ? responseUser.properties : {})).toEqual([
-        "id",
-        "name",
-        "profile",
-        "generated",
-      ])
-      expect(responseUser.required).toEqual(["id", "name", "profile", "generated"])
-    }
-  })
-
-  test("projects directional annotations through local refs and allOf composition", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["local", "composed", "name"],
-                    properties: {
-                      local: { $ref: "#/$defs/ReadOnlyValue" },
-                      composed: { allOf: [{ $ref: "#/$defs/ReadOnlyValue" }] },
-                      name: { type: "string" },
-                    },
-                    $defs: {
-                      ReadOnlyValue: { type: "string", readOnly: true },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    expect(inputTypeScript(tool)).toBe("{ name: string }")
-  })
-
-  test("honors declarations that are siblings of a $ref", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              post: {
-                operationId: "test",
-                responses: { 200: { description: "Success" } },
-                requestBody: {
-                  required: true,
-                  content: {
-                    "application/json": {
-                      schema: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["record"],
-                        properties: {
-                          record: {
-                            $ref: "#/components/schemas/Base",
-                            properties: { extra: { type: "string", readOnly: true }, note: { type: "string" } },
-                            required: ["extra", "note", "id"],
-                          },
-                        },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          components: {
-            schemas: {
-              Base: {
-                type: "object",
-                required: ["id", "name"],
-                properties: { id: { type: "string", readOnly: true }, name: { type: "string" } },
-              },
-            },
-          },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const properties = isRecord(tool.input.properties) ? tool.input.properties : {}
-    const record = isRecord(properties.record) ? properties.record : {}
-    const definitions = isRecord(tool.input.$defs) ? tool.input.$defs : {}
-    const base = isRecord(definitions.Base) ? definitions.Base : {}
-
-    expect(Object.keys(isRecord(record.properties) ? record.properties : {})).toEqual(["note"])
-    expect(record.required).toEqual(["note"])
-    expect(Object.keys(isRecord(base.properties) ? base.properties : {})).toEqual(["name"])
-    expect(base.required).toEqual(["name"])
-  })
-
-  test("honors directional declarations on intermediate reference hops", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          ...singleOperation(
-            {
-              requestBody: {
-                required: true,
-                content: {
-                  "application/json": {
-                    schema: {
-                      type: "object",
-                      additionalProperties: false,
-                      required: ["secret", "name"],
-                      properties: {
-                        // Hidden only by the sibling declaration on the middle hop.
-                        secret: { $ref: "#/components/schemas/Middle" },
-                        name: { type: "string" },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-            "post",
-          ),
-          components: {
-            schemas: {
-              Middle: { $ref: "#/components/schemas/Plain", readOnly: true },
-              Plain: { type: "string" },
-            },
-          },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    expect(inputTypeScript(tool)).toBe("{ name: string }")
-  })
-
-  test("projects cyclic component references without hanging", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              post: {
-                operationId: "test",
-                responses: { 200: { description: "Success" } },
-                requestBody: {
-                  required: true,
-                  content: { "application/json": { schema: { $ref: "#/components/schemas/Node" } } },
-                },
-              },
-            },
-          },
-          components: {
-            schemas: {
-              Node: {
-                type: "object",
-                required: ["id", "name", "child"],
-                properties: {
-                  id: { type: "string", readOnly: true },
-                  name: { type: "string" },
-                  child: { $ref: "#/components/schemas/Node" },
-                },
-              },
-            },
-          },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const definitions = isRecord(tool.input.$defs) ? tool.input.$defs : {}
-    const node = isRecord(definitions.Node) ? definitions.Node : {}
-
-    expect(Object.keys(isRecord(node.properties) ? node.properties : {})).toEqual(["name", "child"])
-    expect(node.required).toEqual(["name", "child"])
-  })
-
-  test("projects diamond-shaped reference graphs in linear time", () => {
-    // Each component references the next twice; without memoized hidden-ness this is 2^30 work.
-    const depth = 30
-    const schemas = Object.fromEntries(
-      Array.from({ length: depth }, (_, index) => [
-        `C${index}`,
-        index === depth - 1
-          ? { type: "object", properties: { id: { type: "string", readOnly: true }, name: { type: "string" } } }
-          : { allOf: [{ $ref: `#/components/schemas/C${index + 1}` }, { $ref: `#/components/schemas/C${index + 1}` }] },
-      ]),
-    )
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: {
-          openapi: "3.1.0",
-          paths: {
-            "/test": {
-              post: {
-                operationId: "test",
-                responses: { 200: { description: "Success" } },
-                requestBody: {
-                  required: true,
-                  content: { "application/json": { schema: { $ref: "#/components/schemas/C0" } } },
-                },
-              },
-            },
-          },
-          components: { schemas },
-        },
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const definitions = isRecord(tool.input.$defs) ? tool.input.$defs : {}
-    const leaf = isRecord(definitions[`C${depth - 1}`]) ? definitions[`C${depth - 1}`] : {}
-
-    expect(Object.keys(isRecord(leaf.properties) ? leaf.properties : {})).toEqual(["name"])
-  })
-
-  test("resolves hiding through reference cycles regardless of evaluation order", () => {
-    // `Wrap` is hidden only through the cycle member `Loop`; evaluating a property that
-    // enters the cycle at `Loop` first must not freeze a provisional result for `Wrap`.
-    const schemas = {
-      Wrap: { allOf: [{ $ref: "#/components/schemas/Loop" }] },
-      Loop: { allOf: [{ $ref: "#/components/schemas/Wrap" }, { readOnly: true }] },
-    }
-    const body = (properties: Record<string, unknown>) => ({
-      required: true,
-      content: {
-        "application/json": {
-          schema: {
-            type: "object",
-            additionalProperties: false,
-            required: [...Object.keys(properties), "name"],
-            properties: { ...properties, name: { type: "string" } },
-          },
-        },
-      },
-    })
-    for (const properties of [
-      { a: { $ref: "#/components/schemas/Loop" }, b: { $ref: "#/components/schemas/Wrap" } },
-      { a: { $ref: "#/components/schemas/Wrap" }, b: { $ref: "#/components/schemas/Loop" } },
-    ]) {
-      const tool = toolAt(
-        OpenAPI.fromSpec({
-          baseUrl,
-          spec: { ...singleOperation({ requestBody: body(properties) }, "post"), components: { schemas } },
-        }).tools,
-        "test",
-      )
-      if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-      expect(inputTypeScript(tool)).toBe("{ name: string }")
-    }
-  })
-
-  test("keeps not, if, and contains subschemas unprojected", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["record"],
-                    properties: {
-                      record: {
-                        type: "object",
-                        // Removing `secret` here would turn `not` unsatisfiable and
-                        // flip which branch of `if` applies; both must pass through.
-                        not: { required: ["secret"], properties: { secret: { type: "string", readOnly: true } } },
-                        if: { required: ["kind"], properties: { kind: { type: "string", readOnly: true } } },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const properties = isRecord(tool.input.properties) ? tool.input.properties : {}
-    const record: Record<string, unknown> = isRecord(properties.record) ? properties.record : {}
-
-    expect(record.not).toEqual({ required: ["secret"], properties: { secret: { type: "string", readOnly: true } } })
-    expect(record.if).toEqual({ required: ["kind"], properties: { kind: { type: "string", readOnly: true } } })
-  })
-
-  test("does not hide properties whose direction is declared only in anyOf or oneOf alternatives", () => {
-    // Deliberate scope bound: alternatives may apply, so a directional declaration on
-    // one alternative does not hide the property; the annotation is preserved as-is.
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["choice", "pick"],
-                    properties: {
-                      choice: { anyOf: [{ type: "string", readOnly: true }, { type: "number" }] },
-                      pick: { oneOf: [{ type: "string", readOnly: true }, { type: "number" }] },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const properties = isRecord(tool.input.properties) ? tool.input.properties : {}
-    const choice: Record<string, unknown> = isRecord(properties.choice) ? properties.choice : {}
-    const pick: Record<string, unknown> = isRecord(properties.pick) ? properties.pick : {}
-
-    expect(Object.keys(properties)).toEqual(["choice", "pick"])
-    expect(choice.anyOf).toEqual([{ type: "string", readOnly: true }, { type: "number" }])
-    expect(pick.oneOf).toEqual([{ type: "string", readOnly: true }, { type: "number" }])
-  })
-
-  test("does not misresolve shadowed local $defs when flattening body fields", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["record"],
-                    $defs: { Value: { type: "string" } },
-                    properties: {
-                      record: {
-                        type: "object",
-                        required: ["x"],
-                        properties: { x: { $ref: "#/$defs/Value" } },
-                        // Shadows the body-level Value; must not affect the body-rooted projection.
-                        $defs: { Value: { type: "string", readOnly: true } },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const properties = isRecord(tool.input.properties) ? tool.input.properties : {}
-    const record = isRecord(properties.record) ? properties.record : {}
-
-    expect(Object.keys(isRecord(record.properties) ? record.properties : {})).toEqual(["x"])
-    expect(record.required).toEqual(["x"])
-  })
-
-  test("projects directional annotations inside parameter schemas", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation({
-          parameters: [
-            {
-              name: "filter",
-              in: "query",
-              required: true,
-              schema: {
-                type: "object",
-                required: ["state", "id"],
-                properties: { state: { type: "string" }, id: { type: "string", readOnly: true } },
-              },
-            },
-          ],
-        }),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    expect(inputTypeScript(tool)).toBe("{ filter: { state: string } }")
-  })
-
-  test("ignores inherited directional annotations", () => {
-    const inherited: Record<string, unknown> = { type: "string" }
-    Object.setPrototypeOf(inherited, { readOnly: true })
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation({
-          parameters: [
-            {
-              name: "filter",
-              in: "query",
-              required: true,
-              schema: {
-                type: "object",
-                // The own annotation on `id` keeps projection active for the document,
-                // so `value` pins that prototype-inherited annotations are not read.
-                properties: { value: inherited, id: { type: "string", readOnly: true } },
-                required: ["value", "id"],
-              },
-            },
-          ],
-        }),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool)) throw new Error("test was not generated")
-
-    expect(inputTypeScript(tool)).toBe("{ filter: { value: string } }")
-  })
-
-  test("cleans required properties across allOf branches", () => {
-    const tool = toolAt(
-      OpenAPI.fromSpec({
-        baseUrl,
-        spec: singleOperation(
-          {
-            requestBody: {
-              required: true,
-              content: {
-                "application/json": {
-                  schema: {
-                    type: "object",
-                    required: ["id", "name"],
-                    allOf: [
-                      {
-                        type: "object",
-                        required: ["id", "name"],
-                        properties: { id: { type: "string", readOnly: true }, name: { type: "string" } },
-                      },
-                    ],
-                  },
-                },
-              },
-            },
-          },
-          "post",
-        ),
-      }).tools,
-      "test",
-    )
-    if (!Tool.isDefinition(tool) || !isRecord(tool.input)) throw new Error("test was not generated")
-    const properties = isRecord(tool.input.properties) ? tool.input.properties : {}
-    const body = isRecord(properties.body) ? properties.body : {}
-    const allOf = Array.isArray(body.allOf) ? body.allOf : []
-    const branch = isRecord(allOf[0]) ? allOf[0] : {}
-
-    expect(body.required).toEqual(["name"])
-    expect(branch.required).toEqual(["name"])
-    expect(Object.keys(isRecord(branch.properties) ? branch.properties : {})).toEqual(["name"])
-  })
-
-  test("keeps directional schemas model-facing while preserving runtime pass-through", async () => {
-    const client = recordingClient(() =>
-      json({
-        id: "server-id",
-        name: "Ada",
-        password: "returned-by-server",
-        profile: { createdAt: "today", secret: "returned-secret", label: "primary" },
-        generated: "generated-id",
-      }),
-    )
-    const tool = toolAt(OpenAPI.fromSpec({ baseUrl, spec: directionalSpec("3.1.0") }).tools, "users.create")
-    if (!Tool.isDefinition(tool)) throw new Error("users.create was not generated")
-
-    const result = await Effect.runPromise(
-      tool
-        .run({
-          id: "ignored-top-level",
-          generated: "ignored-generated",
-          name: "Ada",
-          password: "request-secret",
-          profile: { createdAt: "sent-nested", secret: "nested-secret", label: "primary" },
-        })
-        .pipe(Effect.provide(client.layer)),
-    )
-
-    expect(client.requests[0]?.body).toEqual({
-      name: "Ada",
-      password: "request-secret",
-      profile: { createdAt: "sent-nested", secret: "nested-secret", label: "primary" },
-    })
-    expect(result).toMatchObject({ password: "returned-by-server", profile: { secret: "returned-secret" } })
-  })
-
  test("documents that the opencode fixture is unauthenticated", async () => {
    const spec = await opencodeSpec()
    const components = isRecord(spec.components) ? spec.components : {}
@@ -1116,9 +525,9 @@ describe("OpenAPI.fromSpec", () => {
    expect(client.requests[0]?.url).toBe(
      `${baseUrl}/test?tags=first+value&tags=second%26value&state=open+now&page=2&location%5Bdirectory%5D=%2Ftmp%2Fa+b&location%5Bworkspace%5D=work%261`,
    )
-    await expect(Effect.runPromise(tool.run({ tags: [{}] }).pipe(Effect.provide(client.layer)))).rejects.toThrow(
-      "Parameter 'tags' contains an unsupported nested value.",
-    )
+    await expect(
+      Effect.runPromise(tool.run({ tags: [{}] }).pipe(Effect.provide(client.layer))),
+    ).rejects.toThrow("Parameter 'tags' contains an unsupported nested value.")
    await expect(
      Effect.runPromise(tool.run({ filter: { state: {} } }).pipe(Effect.provide(client.layer))),
    ).rejects.toThrow("Query parameter 'filter' contains an unsupported nested value.")
@@ -258,23 +258,11 @@ describe("H1: NaN/Infinity flow as intermediates and normalize to null at the bo

  test("copyOut normalizes non-finite numbers to null (the shared return + tool-arg boundary)", () => {
    // Tool-call arguments funnel through copyOut too, so this one function pins both boundaries.
-    expect(ToolRuntime.copyOut(NaN, "json")).toBeNull()
-    expect(ToolRuntime.copyOut(Infinity, "json")).toBeNull()
-    expect(ToolRuntime.copyOut(-Infinity, "nullify")).toBeNull()
-    expect(ToolRuntime.copyOut(42, "json")).toBe(42)
-    expect(ToolRuntime.copyOut({ a: NaN, b: [Infinity, 1] }, "json")).toEqual({ a: null, b: [null, 1] })
-  })
-})
-
-describe("copyOut undefined handling per boundary mode", () => {
-  test("json mode mirrors JSON.stringify for undefined", () => {
-    expect(ToolRuntime.copyOut({ q: undefined, keep: 1 }, "json")).toStrictEqual({ keep: 1 })
-    expect(ToolRuntime.copyOut([1, undefined, 2], "json")).toStrictEqual([1, null, 2])
-    expect(ToolRuntime.copyOut({ nested: { a: undefined, b: [undefined] } }, "json")).toStrictEqual({
-      nested: { b: [null] },
-    })
-    expect(ToolRuntime.copyOut(undefined, "json")).toBeUndefined()
-    expect(ToolRuntime.copyOut({ a: undefined }, "nullify")).toStrictEqual({ a: null })
+    expect(ToolRuntime.copyOut(NaN)).toBeNull()
+    expect(ToolRuntime.copyOut(Infinity)).toBeNull()
+    expect(ToolRuntime.copyOut(-Infinity)).toBeNull()
+    expect(ToolRuntime.copyOut(42)).toBe(42)
+    expect(ToolRuntime.copyOut({ a: NaN, b: [Infinity, 1] })).toEqual({ a: null, b: [null, 1] })
  })
 })

@@ -681,177 +669,3 @@ describe("destructuring assignment", () => {
    expect(err.message).toContain("Property key must be a string or number")
  })
 })
-
-describe("coercion parity: zero-argument coercion functions", () => {
-  test("Number() is 0 and String() is empty, unlike their undefined-argument forms", async () => {
-    expect(await value(`return Number()`)).toBe(0)
-    expect(await value(`return String()`)).toBe("")
-    expect(await value(`return Boolean()`)).toBe(false)
-    expect(await value(`return Number.isNaN(Number(undefined))`)).toBe(true)
-    expect(await value(`return String(undefined)`)).toBe("undefined")
-  })
-
-  test("parseInt() and parseFloat() stay NaN with no argument", async () => {
-    expect(await value(`return Number.isNaN(parseInt())`)).toBe(true)
-    expect(await value(`return Number.isNaN(parseFloat())`)).toBe(true)
-  })
-})
-
-describe("coercion parity: global isFinite and isNaN", () => {
-  test("coerce their argument like native JS, unlike the Number statics", async () => {
-    expect(await value(`return isFinite("42")`)).toBe(true)
-    expect(await value(`return Number.isFinite("42")`)).toBe(false)
-    expect(await value(`return isNaN("oops")`)).toBe(true)
-    expect(await value(`return isNaN("42")`)).toBe(false)
-    expect(await value(`return isFinite(Infinity)`)).toBe(false)
-    expect(await value(`return isNaN(null)`)).toBe(false)
-  })
-
-  test("zero-argument forms match native", async () => {
-    expect(await value(`return isFinite()`)).toBe(false)
-    expect(await value(`return isNaN()`)).toBe(true)
-  })
-
-  test("read as functions", async () => {
-    expect(await value(`return typeof isFinite`)).toBe("function")
-    expect(await value(`return typeof isNaN`)).toBe("function")
-  })
-
-  test("work as array callbacks", async () => {
-    expect(await value(`return [1, "2", "x", Infinity].filter(isFinite)`)).toEqual([1, "2"])
-    expect(await value(`return ["1", "x"].map(isNaN)`)).toEqual([false, true])
-  })
-})
-
-describe("coercion parity: arrays coerce to numbers through their string form", () => {
-  test("arrays with objects become NaN instead of crashing on host ToPrimitive", async () => {
-    expect(await value(`let x = [{}]; x++; return Number.isNaN(x)`)).toBe(true)
-    expect(await value(`return isFinite([{}])`)).toBe(false)
-    expect(await value(`return "abc".slice([{}])`)).toBe("abc")
-  })
-
-  test("single-element and empty arrays match native Number()", async () => {
-    expect(await value(`return Number([5])`)).toBe(5)
-    expect(await value(`return Number([])`)).toBe(0)
-    expect(await value(`return Number.isNaN(Number([1, 2]))`)).toBe(true)
-  })
-})
-
-describe("coercion parity: String method arguments coerce like native JS", () => {
-  test("includes and indexOf coerce numbers", async () => {
-    expect(await value(`return "v1.2".includes(1)`)).toBe(true)
-    expect(await value(`return "a2b".indexOf(2)`)).toBe(1)
-    expect(await value(`return "abc".includes("d")`)).toBe(false)
-  })
-
-  test("slice, repeat, and padStart coerce numeric strings", async () => {
-    expect(await value(`return "abc".slice("1")`)).toBe("bc")
-    expect(await value(`return "ab".repeat("2")`)).toBe("abab")
-    expect(await value(`return "7".padStart("3", 0)`)).toBe("007")
-  })
-
-  test("split coerces separators but treats undefined as absent", async () => {
-    expect(await value(`return "a1b".split(1)`)).toEqual(["a", "b"])
-    expect(await value(`return "a,b".split(undefined)`)).toEqual(["a,b"])
-    expect(await value(`return "a,b".split()`)).toEqual(["a,b"])
-    expect(await value(`return "a,b".split(undefined, 0)`)).toEqual([])
-    expect(await value(`return "a,b".split(undefined, 1)`)).toEqual(["a,b"])
-  })
-
-  test("replace coerces search and replacement values", async () => {
-    expect(await value(`return "a1b".replace(1, 2)`)).toBe("a2b")
-    expect(await value(`return "a1b".replace(1, () => "x")`)).toBe("axb")
-  })
-
-  test("repeat rejections carry the native RangeError name", async () => {
-    expect(await value(`try { "a".repeat(-1) } catch (e) { return e.name }`)).toBe("RangeError")
-  })
-
-  test("includes, startsWith, and endsWith reject regular expressions with a TypeError", async () => {
-    expect(await value(`try { "abc".includes(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-    expect(await value(`try { "abc".startsWith(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-    expect(await value(`try { "abc".endsWith(/a/) } catch (e) { return e.name }`)).toBe("TypeError")
-  })
-
-  test("opaque runtime references still reject as data errors", async () => {
-    const err = await error(`const f = () => 1; return "abc".includes(f)`)
-    expect(err.message).toContain("data value")
-    const replacerErr = await error(`const f = () => 1; return "a".replace(f, () => "x")`)
-    expect(replacerErr.message).toContain("data value")
-  })
-})
-
-describe("coercion parity: match() and search() with no argument", () => {
-  test("behave as an empty pattern like native JS", async () => {
-    expect(await value(`return "abc".search()`)).toBe(0)
-    expect(await value(`const m = "abc".match(); return { first: m[0], index: m.index }`)).toEqual({
-      first: "",
-      index: 0,
-    })
-  })
-})
-
-describe("coercion parity: ++ and -- use CodeMode numeric coercion", () => {
-  test("numeric strings increment like native JS", async () => {
-    expect(await value(`let x = "5"; x++; return x`)).toBe(6)
-    expect(await value(`let x = "5"; return ++x`)).toBe(6)
-    expect(await value(`const o = { n: "2" }; o.n--; return o.n`)).toBe(1)
-  })
-
-  test("dates increment through their epoch time", async () => {
-    expect(await value(`let d = new Date(5); d++; return d`)).toBe(6)
-  })
-
-  test("plain data objects become NaN instead of crashing", async () => {
-    expect(await value(`let x = {}; x++; return Number.isNaN(x)`)).toBe(true)
-    expect(await value(`const o = { a: {} }; o.a++; return Number.isNaN(o.a)`)).toBe(true)
-  })
-
-  test("opaque runtime references reject with a clear error", async () => {
-    const err = await error(`let f = () => 1; f++`)
-    expect(err.message).toContain("data value")
-  })
-})
-
-describe("coercion parity: unknown static members read as undefined", () => {
-  test("feature detection on missing statics works like native JS", async () => {
-    expect(await value(`return typeof Math.sumPrecise`)).toBe("undefined")
-    expect(await value(`return Object.groupBy === undefined`)).toBe(true)
-    expect(await value(`return RegExp.escape === undefined`)).toBe(true)
-    expect(await value(`return Number.range === undefined`)).toBe(true)
-    expect(await value(`return String.raw === undefined`)).toBe(true)
-    expect(await value(`return isFinite.something === undefined`)).toBe(true)
-    expect(await value(`return console.group === undefined`)).toBe(true)
-    expect(await value(`return Date.moment === undefined`)).toBe(true)
-    expect(await value(`return JSON.rawJSON === undefined`)).toBe(true)
-    expect(await value(`return URL.createObjectURL === undefined`)).toBe(true)
-    expect(await value(`return Map.groupBy === undefined`)).toBe(true)
-    expect(await value(`return Math.sumPrecise?.([1]) ?? "fallback"`)).toBe("fallback")
-  })
-
-  test("known statics still resolve and run", async () => {
-    expect(await value(`return typeof Math.max`)).toBe("function")
-    expect(await value(`return typeof console.log`)).toBe("function")
-    expect(await value(`return typeof Date.now`)).toBe("function")
-    expect(await value(`return Math.max(1, 2)`)).toBe(2)
-    expect(await value(`return URL.canParse("https://example.com")`)).toBe(true)
-    expect(await value(`return Number.isInteger(3)`)).toBe(true)
-    expect(await value(`return Number.MAX_SAFE_INTEGER`)).toBe(Number.MAX_SAFE_INTEGER)
-  })
-
-  test("calling an unknown static reports a native-style TypeError", async () => {
-    expect(await value(`try { Math.sumPrecise([1]) } catch (e) { return e.name + ": " + e.message }`)).toBe(
-      "TypeError: Math.sumPrecise is not a function.",
-    )
-    expect(await value(`try { Math["sumPrecise"]([1]) } catch (e) { return e.message }`)).toBe(
-      "Math.sumPrecise is not a function.",
-    )
-  })
-
-  test("blocked members still throw instead of reading as undefined", async () => {
-    const err = await error(`return Math.constructor`)
-    expect(err.message).toContain("not available")
-    const coercionErr = await error(`return Number.constructor`)
-    expect(coercionErr.message).toContain("Number.constructor is not available")
-  })
-})
@@ -30,7 +30,6 @@ import {
  type UsageInput,
 } from "@opencode-ai/ai"
 import { Auth, Endpoint, type AnyRoute } from "@opencode-ai/ai/route"
-import { ProviderShared } from "@opencode-ai/ai/protocols/shared"
 import { Cause, Context, Effect, Layer, Option, Schema, Scope, Stream } from "effect"
 import { ModelV2 } from "./model"
 import { ProviderV2 } from "./provider"
@@ -606,7 +605,6 @@ function streamPartEvents(
        LLMEvent.toolInputStart({
          id: event.id,
          name: event.toolName,
-          providerExecuted: event.providerExecuted,
          providerMetadata: providerMetadata(event.providerMetadata),
        }),
      ])
@@ -624,28 +622,15 @@ function streamPartEvents(
      ])
    case "tool-call":
      state.toolNames[event.toolCallId] = event.toolName
-      return ProviderShared.parseToolInput("aisdk", event.toolName, event.input).pipe(
-        Effect.map((input) => [
-          LLMEvent.toolCall({
-            id: event.toolCallId,
-            name: event.toolName,
-            input,
-            providerExecuted: event.providerExecuted,
-            providerMetadata: providerMetadata(event.providerMetadata),
-          }),
-        ]),
-        Effect.catch((error) =>
-          event.providerExecuted
-            ? Effect.fail(error)
-            : Effect.succeed([
-                LLMEvent.toolInputError({
-                  id: event.toolCallId,
-                  name: event.toolName,
-                  raw: event.input,
-                }),
-              ]),
-        ),
-      )
+      return Effect.succeed([
+        LLMEvent.toolCall({
+          id: event.toolCallId,
+          name: event.toolName,
+          input: parseToolInput(event.input),
+          providerExecuted: event.providerExecuted,
+          providerMetadata: providerMetadata(event.providerMetadata),
+        }),
+      ])
    case "tool-result":
      delete state.toolNames[event.toolCallId]
      return Effect.succeed([
@@ -700,6 +685,14 @@ function providerMetadata(value: unknown) {
  return Schema.is(ProviderMetadata)(value) ? value : undefined
 }

+function parseToolInput(value: string) {
+  try {
+    return JSON.parse(value) as unknown
+  } catch {
+    return value
+  }
+}
+
 function jsonObject(input: Record<string, unknown>) {
  return Object.fromEntries(Object.entries(input).map(([key, value]) => [key, jsonValue(value)]))
 }
@@ -23,9 +23,6 @@ export class Local extends Schema.Class<Local>("ConfigV2.MCP.Local")({
  }),
  environment: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
  disabled: Schema.Boolean.pipe(Schema.optional),
-  codemode: Schema.Boolean.pipe(Schema.optional).annotate({
-    description: "Expose this server's tools through Code Mode. Defaults to true.",
-  }),
  timeout: Timeout.pipe(Schema.optional),
 }) {}

@@ -43,9 +40,6 @@ export class Remote extends Schema.Class<Remote>("ConfigV2.MCP.Remote")({
  headers: Schema.Record(Schema.String, Schema.String).pipe(Schema.optional),
  oauth: Schema.Union([OAuth, Schema.Literal(false)]).pipe(Schema.optional),
  disabled: Schema.Boolean.pipe(Schema.optional),
-  codemode: Schema.Boolean.pipe(Schema.optional).annotate({
-    description: "Expose this server's tools through Code Mode. Defaults to true.",
-  }),
  timeout: Timeout.pipe(Schema.optional),
 }) {}

@@ -12,6 +12,7 @@ import { ConfigAgentV1 } from "../../v1/config/agent"
 import { ConfigMigrateV1 } from "../../v1/config/migrate"
 import { Global } from "../../global"
 import { PermissionV2 } from "../../permission"
+import { SHELL_OUTPUT_GLOB } from "../../permission/defaults"
 import type { LocationMutation } from "../../location-mutation"
 import type { ReadTool } from "../../tool/read"
 import type { EditTool } from "../../tool/edit"
@@ -112,6 +113,23 @@ export const Plugin = define({
          })
        }
      }
+
+      // Internal shell output remains readable through broad external-directory denials.
+      // An exact deny still lets users explicitly revoke access to these files.
+      for (const current of draft.list()) {
+        draft.update(current.id, (agent) => {
+          const denied = agent.permissions.some(
+            (rule) =>
+              rule.action === "external_directory" && rule.resource === SHELL_OUTPUT_GLOB && rule.effect === "deny",
+          )
+          if (
+            denied ||
+            PermissionV2.evaluate("external_directory", SHELL_OUTPUT_GLOB, agent.permissions).effect === "allow"
+          )
+            return
+          agent.permissions.push({ action: "external_directory", resource: SHELL_OUTPUT_GLOB, effect: "allow" })
+        })
+      }
    })
    yield* ctx.event.subscribe().pipe(
      Stream.filter((event) => event.type === "config.updated"),
@@ -9,6 +9,8 @@ import { Reference } from "../../reference"
 import { AbsolutePath } from "../../schema"
 import { Global } from "../../global"
 import { Location } from "../../location"
+import { allowExternalDirectories } from "../../permission/defaults"
+import { Repository } from "../../repository"

 export const Plugin = define({
  id: "opencode.config.reference",
@@ -18,35 +20,20 @@ export const Plugin = define({
    const global = yield* Global.Service
    const loaded = { entries: yield* config.entries() }
    yield* ctx.reference.transform((draft) => {
-      const entries = new Map<string, Reference.Source>()
-      for (const doc of loaded.entries.filter((entry): entry is Config.Document => entry.type === "document")) {
-        const directory = doc.path ? path.dirname(doc.path) : location.directory
-        for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
-          if (!validAlias(name)) continue
-          const description = typeof entry === "string" ? undefined : entry.description
-          const hidden = typeof entry === "string" ? undefined : entry.hidden
-          entries.set(
-            name,
-            local(entry)
-              ? Reference.LocalSource.make({
-                  type: "local",
-                  path: AbsolutePath.make(
-                    localPath(directory, global.home, typeof entry === "string" ? entry : entry.path),
-                  ),
-                  ...(description === undefined ? {} : { description }),
-                  ...(hidden === undefined ? {} : { hidden }),
-                })
-              : Reference.GitSource.make({
-                  type: "git",
-                  repository: typeof entry === "string" ? entry : entry.repository,
-                  ...(entry.branch === undefined ? {} : { branch: entry.branch }),
-                  ...(description === undefined ? {} : { description }),
-                  ...(hidden === undefined ? {} : { hidden }),
-                }),
-          )
-        }
+      for (const [name, source] of sources(loaded.entries, location.directory, global.home)) draft.add(name, source)
+    })
+    yield* ctx.agent.transform((draft) => {
+      const permissions = allowExternalDirectories(
+        Array.from(sources(loaded.entries, location.directory, global.home)).flatMap(([, source]) => {
+          if (source.type === "local") return [path.join(source.path, "*")]
+          const repository = Repository.parse(source.repository)
+          if (!repository || !Repository.isRemote(repository)) return []
+          return [path.join(Repository.cachePath(global.repos, repository), "*")]
+        }),
+      )
+      for (const current of draft.list()) {
+        draft.update(current.id, (agent) => agent.permissions.push(...permissions))
      }
-      for (const [name, source] of entries) draft.add(name, source)
    })
    yield* ctx.event.subscribe().pipe(
      Stream.filter((event) => event.type === "config.updated"),
@@ -54,6 +41,7 @@ export const Plugin = define({
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
          Effect.andThen(ctx.reference.reload()),
+          Effect.andThen(ctx.agent.reload()),
        ),
      ),
      Effect.forkScoped({ startImmediately: true }),
@@ -61,6 +49,36 @@ export const Plugin = define({
  }),
 })

+function sources(entries: readonly Config.Entry[], location: string, home: string) {
+  const result = new Map<string, Reference.Source>()
+  for (const doc of entries.filter((entry): entry is Config.Document => entry.type === "document")) {
+    const directory = doc.path ? path.dirname(doc.path) : location
+    for (const [name, entry] of Object.entries(doc.info.references ?? {})) {
+      if (!validAlias(name)) continue
+      const description = typeof entry === "string" ? undefined : entry.description
+      const hidden = typeof entry === "string" ? undefined : entry.hidden
+      result.set(
+        name,
+        local(entry)
+          ? Reference.LocalSource.make({
+              type: "local",
+              path: AbsolutePath.make(localPath(directory, home, typeof entry === "string" ? entry : entry.path)),
+              ...(description === undefined ? {} : { description }),
+              ...(hidden === undefined ? {} : { hidden }),
+            })
+          : Reference.GitSource.make({
+              type: "git",
+              repository: typeof entry === "string" ? entry : entry.repository,
+              ...(entry.branch === undefined ? {} : { branch: entry.branch }),
+              ...(description === undefined ? {} : { description }),
+              ...(hidden === undefined ? {} : { hidden }),
+            }),
+      )
+    }
+  }
+  return result
+}
+
 function validAlias(name: string) {
  return name.length > 0 && !/[\/\s`,]/.test(name)
 }
@@ -8,6 +8,8 @@ import { AbsolutePath } from "../../schema"
 import { SkillV2 } from "../../skill"
 import { Global } from "../../global"
 import { Location } from "../../location"
+import { SkillDiscovery } from "../../skill/discovery"
+import { allowExternalDirectories } from "../../permission/defaults"

 export const Plugin = define({
  id: "opencode.config.skill",
@@ -17,41 +19,19 @@ export const Plugin = define({
    const location = yield* Location.Service
    const loaded = { entries: yield* config.entries() }
    yield* ctx.skill.transform((draft) => {
-      const claude = loaded.entries.flatMap((entry) => (entry.type === "claude" ? [entry.path] : []))
-      const agents = loaded.entries.flatMap((entry) => (entry.type === "agents" ? [entry.path] : []))
-      const directories = loaded.entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
-      const items = loaded.entries.flatMap((entry) => (entry.type === "document" ? (entry.info.skills ?? []) : []))
-      for (const directory of [...claude, ...agents]) {
-        draft.source(
-          SkillV2.DirectorySource.make({
-            type: "directory",
-            path: AbsolutePath.make(path.join(directory, "skills")),
-          }),
-        )
-      }
-      for (const directory of directories) {
-        draft.source(
-          SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }),
-        )
-        draft.source(
-          SkillV2.DirectorySource.make({
-            type: "directory",
-            path: AbsolutePath.make(path.join(directory, "skills")),
-          }),
-        )
-      }
-      for (const item of items) {
-        if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
-          draft.source(SkillV2.UrlSource.make({ type: "url", url: item }))
-          continue
-        }
-        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item
-        draft.source(
-          SkillV2.DirectorySource.make({
-            type: "directory",
-            path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded)),
-          }),
-        )
+      for (const source of sources(loaded.entries, global.home, location.directory)) draft.source(source)
+    })
+    yield* ctx.agent.transform((draft) => {
+      const permissions = allowExternalDirectories(
+        sources(loaded.entries, global.home, location.directory).map((source) =>
+          path.join(
+            source.type === "directory" ? source.path : SkillDiscovery.cachePath(global.cache, source.url),
+            "*",
+          ),
+        ),
+      )
+      for (const current of draft.list()) {
+        draft.update(current.id, (agent) => agent.permissions.push(...permissions))
      }
    })
    yield* ctx.event.subscribe().pipe(
@@ -60,9 +40,44 @@ export const Plugin = define({
        config.entries().pipe(
          Effect.tap((entries) => Effect.sync(() => (loaded.entries = entries))),
          Effect.andThen(ctx.skill.reload()),
+          Effect.andThen(ctx.agent.reload()),
        ),
      ),
      Effect.forkScoped({ startImmediately: true }),
    )
  }),
 })
+
+function sources(entries: readonly Config.Entry[], home: string, directory: string) {
+  const result: Array<SkillV2.DirectorySource | SkillV2.UrlSource> = []
+  for (const entry of entries) {
+    if (entry.type === "claude" || entry.type === "agents") {
+      result.push(
+        SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(entry.path, "skills")) }),
+      )
+      continue
+    }
+    if (entry.type === "directory") {
+      result.push(
+        SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(entry.path, "skill")) }),
+        SkillV2.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(entry.path, "skills")) }),
+      )
+      continue
+    }
+    if (entry.type !== "document") continue
+    for (const item of entry.info.skills ?? []) {
+      if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
+        result.push(SkillV2.UrlSource.make({ type: "url", url: item }))
+        continue
+      }
+      const expanded = item.startsWith("~/") ? path.join(home, item.slice(2)) : item
+      result.push(
+        SkillV2.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(directory, expanded)),
+        }),
+      )
+    }
+  }
+  return result
+}
@@ -70,7 +70,6 @@ export type Inputs = Integration.Inputs
 export type OAuthAuthorization = {
  readonly url: string
  readonly instructions: string
-  readonly expiresAt?: number
 } & (
  | {
      readonly mode: "auto"
@@ -561,7 +560,7 @@ const layer = Layer.effect(
      )
      const id = AttemptID.create()
      const created = yield* Clock.currentTimeMillis
-      const time = { created, expires: authorization.expiresAt ?? created + attemptLifetime }
+      const time = { created, expires: created + attemptLifetime }
      yield* SynchronizedRef.update(attempts, (current) =>
        new Map(current).set(id, {
          status: "pending",
@@ -12,8 +12,8 @@ export const Kind = Schema.Literals(["file", "directory"])
 export type Kind = typeof Kind.Type

 /**
- * Mutation paths do not accept project references. Relative paths resolve
- * from the active Location. Paths outside it require separate
+ * Mutation paths do not accept project references. Relative paths must stay
+ * inside the active Location. Absolute paths outside it require separate
 * `external_directory` approval.
 */
 export const ResolveInput = Schema.Struct({
@@ -25,7 +25,7 @@ export type ResolveInput = typeof ResolveInput.Type

 export class PathError extends Schema.TaggedErrorClass<PathError>()("LocationMutation.PathError", {
  path: Schema.String,
-  reason: Schema.Literals(["location_escape", "non_directory_ancestor"]),
+  reason: Schema.Literals(["relative_escape", "location_escape", "non_directory_ancestor"]),
 }) {}

 export interface ExternalDirectoryAuthorization {
@@ -53,9 +53,9 @@ export interface Target {

 export interface Interface {
  /**
-   * Resolve a path and derive its permission resources. Relative paths resolve
-   * from the Location. Paths outside it require separate `external_directory`
-   * approval. This does not approve the mutation.
+   * Resolve a path and derive its permission resources. Relative paths must
+   * stay inside the Location. Absolute paths outside it require separate
+   * `external_directory` approval. This does not approve the mutation.
   */
  readonly resolve: (input: ResolveInput) => Effect.Effect<Target, PathError | FSUtil.Error>
 }
@@ -120,8 +120,10 @@ const layer = Layer.effect(
    })

    const resolve = Effect.fn("LocationMutation.resolve")(function* (input: ResolveInput) {
+      const relative = !path.isAbsolute(input.path)
      const absolute = path.resolve(location.directory, input.path)
      const lexicallyInternal = FSUtil.contains(location.directory, absolute)
+      if (relative && !lexicallyInternal) return yield* new PathError({ path: input.path, reason: "relative_escape" })

      const resolved = yield* resolvePath(absolute)
      if (lexicallyInternal && !FSUtil.contains(locationRoot, resolved.canonical)) {
@@ -144,7 +146,10 @@ const layer = Layer.effect(
              directory: externalDirectory,
              resource: externalResource,
              save: slash(
-                path.join((yield* Project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory, "*"),
+                path.join(
+                  (yield* Project.root(fs, AbsolutePath.make(externalDirectory))) ?? externalDirectory,
+                  "*",
+                ),
              ),
            }
          : undefined,
@@ -13,10 +13,8 @@ import { EventV2 } from "../event"
 import { Form } from "../form"
 import { Integration } from "../integration"
 import { IntegrationConnection } from "../integration/connection"
-import { KeyedMutex } from "../effect/keyed-mutex"
 import { Location } from "../location"
 import { waitForAbort } from "../process"
-import { State } from "../state"
 import { MCPClient } from "./client"
 import { MCPOAuth } from "./oauth"

@@ -42,7 +40,6 @@ export class ServerInstructions extends Schema.Class<ServerInstructions>("MCP.Se
 export class Tool extends Schema.Class<Tool>("MCP.Tool")({
  server: ServerName,
  name: Schema.String,
-  codemode: Schema.Boolean.pipe(Schema.optional),
  description: Schema.String.pipe(Schema.optional),
  inputSchema: Schema.Unknown.pipe(Schema.optional),
  outputSchema: Schema.Unknown.pipe(Schema.optional),
@@ -121,7 +118,6 @@ type ServerEntry = {
  prompts?: ReadonlyArray<Prompt>
  // Set when a remote server is registered as an OAuth integration; the credential lives in the global store.
  integrationID?: Integration.ID
-  registration?: State.Registration
 }

 // MCP elicitations are Location-scoped, not Session-scoped: the server cannot attribute them to a
@@ -131,10 +127,6 @@ const URL_ELICITATION_FIELD_KEY = "elicitation"

 export interface Interface {
  readonly servers: () => Effect.Effect<ServerInfo[]>
-  readonly add: (server: ServerName | string, config: typeof ConfigMCP.Server.Type) => Effect.Effect<void>
-  readonly connect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
-  readonly disconnect: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
-  readonly remove: (server: ServerName | string) => Effect.Effect<void, NotFoundError>
  readonly tools: () => Effect.Effect<Tool[]>
  readonly callTool: (input: {
    readonly server: ServerName | string
@@ -178,9 +170,6 @@ export const layer = Layer.effect(
    )
    // Later config files win for duplicate server names; per-server timeout overrides globals.
    const runtime = new Map<ServerName, ServerEntry>()
-    // Serializes lifecycle operations per server. Anything taking this lock from a connection
-    // callback must stay forked: lifecycle operations close scopes while holding it, firing onClose.
-    const locks = KeyedMutex.makeUnsafe<ServerName>()
    const urlElicitations = new Map<string, Form.ID>()
    for (const entry of documents) {
      for (const [name, server] of Object.entries(entry.info.mcp?.servers ?? {})) {
@@ -194,9 +183,14 @@ export const layer = Layer.effect(

    // Register every remote server as an OAuth integration so credentials live in the global store
    // rather than in committed config. Servers that connect anonymously simply never use the method.
-    const owned = new Set<Integration.ID>()
-    const register = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
-      if (entry.config.type !== "remote" || entry.config.oauth === false) return
+    const registrations: Array<{
+      readonly name: ServerName
+      readonly remote: typeof ConfigMCP.Remote.Type
+      readonly integrationID: Integration.ID
+      readonly methodID: Integration.MethodID
+    }> = []
+    for (const [name, entry] of runtime) {
+      if (entry.config.type !== "remote" || entry.config.oauth === false) continue
      const remote = entry.config
      // Key identity on name + url, not url alone: two configs for the same url under different names are
      // distinct logical servers that may hold different accounts, so they must not share a credential row.
@@ -206,29 +200,27 @@ export const layer = Layer.effect(
          .update(name + "\u0000" + remote.url)
          .digest("hex")
          .slice(0, 16)
-      const integrationID = Integration.ID.make(suffix)
-      entry.integrationID = integrationID
-      owned.add(integrationID)
-      const methodID = Integration.MethodID.make(suffix)
-      // Each registration gets its own child scope so disposal detaches it from the root scope
-      // entirely; registering directly on root would accumulate a dead finalizer per replaced or
-      // removed server for the lifetime of the layer.
-      const scope = yield* Scope.fork(root)
-      entry.registration = { dispose: Scope.close(scope, Exit.void) }
-      yield* integration
-        .transform((draft) => {
-          draft.update(integrationID, (ref) => {
-            ref.name = name
+      entry.integrationID = Integration.ID.make(suffix)
+      registrations.push({
+        name,
+        remote,
+        integrationID: entry.integrationID,
+        methodID: Integration.MethodID.make(suffix),
+      })
+    }
+    if (registrations.length > 0)
+      yield* integration.transform((draft) => {
+        for (const reg of registrations) {
+          draft.update(reg.integrationID, (ref) => {
+            ref.name = reg.name
          })
          draft.method.update({
-            integrationID,
-            method: { id: methodID, type: "oauth", label: name },
-            authorize: () => MCPOAuth.authorize({ name, config: remote, methodID }),
+            integrationID: reg.integrationID,
+            method: { id: reg.methodID, type: "oauth", label: reg.name },
+            authorize: () => MCPOAuth.authorize({ name: reg.name, config: reg.remote, methodID: reg.methodID }),
          })
-        })
-        .pipe(Scope.provide(scope))
-    })
-    yield* Effect.forEach(runtime, ([name, entry]) => register(name, entry), { discard: true })
+        }
+      })

    const requireServer = Effect.fnUntraced(function* (server: ServerName | string) {
      const name = ServerName.make(server)
@@ -368,11 +360,10 @@ export const layer = Layer.effect(
        }),
    } satisfies MCPClient.ElicitationHandler

-    const toTool = (server: ServerName, entry: ServerEntry, def: MCPClient.ToolDefinition) =>
+    const toTool = (server: ServerName, def: MCPClient.ToolDefinition) =>
      new Tool({
        server,
        name: def.name,
-        codemode: entry.config.codemode,
        description: def.description,
        inputSchema: def.inputSchema,
        outputSchema: def.outputSchema,
@@ -414,7 +405,7 @@ export const layer = Layer.effect(
    const refreshTools = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
      connection.tools().pipe(
        Effect.map((defs) => {
-          entry.tools = defs.map((def) => toTool(name, entry, def))
+          entry.tools = defs.map((def) => toTool(name, def))
        }),
      )

@@ -429,44 +420,36 @@ export const layer = Layer.effect(
        ),
      )

-    // Runs a connection callback under the server lock, dropping it if the connection is no longer
-    // the entry's live client, so late SDK callbacks cannot commit obsolete state.
-    const whenLive =
-      (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) =>
-      <E>(effect: Effect.Effect<void, E>) =>
+    const watch = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) => {
+      connection.onClose(() => {
+        // A reconnect closes the previous scope, but the SDK may fire this onclose after the new
+        // connection is already assigned; ignore the stale close so it can't null out the live client.
+        if (entry.client !== connection) return
+        entry.client = undefined
+        entry.tools = undefined
+        entry.prompts = undefined
+        entry.status = { status: "failed", error: "Connection closed" }
+        fork(events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore))
+        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
+        fork(events.publish(Command.Event.Updated, {}).pipe(Effect.ignore))
+        fork(events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore))
+      })
+      connection.onLog((message) => fork(serverLog(name, message).pipe(Effect.ignore)))
+      connection.onToolsChanged(() => {
        fork(
-          Effect.suspend(() => (entry.client === connection ? effect : Effect.void)).pipe(
-            locks.withLock(name),
+          refreshTools(name, entry, connection).pipe(
+            Effect.andThen(events.publish(McpEvent.ToolsChanged, { server: name })),
            Effect.ignore,
          ),
        )
-
-    const watch = (name: ServerName, entry: ServerEntry, connection: MCPClient.Connection) => {
-      const live = whenLive(name, entry, connection)
-      connection.onClose(() =>
-        live(
-          Effect.gen(function* () {
-            entry.client = undefined
-            entry.tools = undefined
-            entry.prompts = undefined
-            entry.status = { status: "failed", error: "Connection closed" }
-            yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-            yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-            yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
-            yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-          }),
-        ),
-      )
-      connection.onLog((message) => fork(serverLog(name, message).pipe(Effect.ignore)))
-      connection.onToolsChanged(() =>
-        live(
-          refreshTools(name, entry, connection).pipe(
-            Effect.andThen(events.publish(McpEvent.ToolsChanged, { server: name })),
-          ),
-        ),
-      )
-      connection.onPromptsChanged(() => live(refreshPrompts(name, entry, connection)))
-      connection.onResourcesChanged(() => live(events.publish(McpEvent.ResourcesChanged, { server: name })))
+      })
+      connection.onPromptsChanged(() => {
+        fork(refreshPrompts(name, entry, connection).pipe(Effect.ignore))
+      })
+      connection.onResourcesChanged(() => {
+        if (entry.client !== connection) return
+        fork(events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore))
+      })
    }

    const serverLog = (server: ServerName, message: MCPClient.LogMessage) => {
@@ -489,10 +472,6 @@ export const layer = Layer.effect(

    const startServer = (name: ServerName, entry: ServerEntry) =>
      Effect.gen(function* () {
-        // Announce the handshake so connect() and credential reconnects don't show a stale
-        // disabled/failed status for the duration of the connection attempt.
-        entry.status = { status: "pending" }
-        yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
        const scope = yield* Scope.fork(root)
        entry.scope = scope
        const authProvider = yield* connectProvider(entry)
@@ -505,7 +484,7 @@ export const layer = Layer.effect(
        )
        if (Exit.isSuccess(result)) {
          entry.client = result.value.connection
-          entry.tools = result.value.tools.map((def) => toTool(name, entry, def))
+          entry.tools = result.value.tools.map((def) => toTool(name, def))
          entry.prompts = []
          entry.status = { status: "connected" }
          watch(name, entry, result.value.connection)
@@ -516,7 +495,7 @@ export const layer = Layer.effect(
          yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
          yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-          whenLive(name, entry, result.value.connection)(refreshPrompts(name, entry, result.value.connection))
+          fork(refreshPrompts(name, entry, result.value.connection).pipe(Effect.ignore))
          return
        }
        yield* Scope.close(scope, Exit.void)
@@ -530,19 +509,6 @@ export const layer = Layer.effect(
        yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
      }).pipe(Effect.ensuring(Deferred.succeed(entry.startup, undefined)))

-    const stopServer = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
-      const scope = entry.scope
-      if (!scope) return
-      entry.scope = undefined
-      entry.client = undefined
-      entry.tools = undefined
-      entry.prompts = undefined
-      yield* Scope.close(scope, Exit.void)
-      yield* events.publish(McpEvent.ToolsChanged, { server: name }).pipe(Effect.ignore)
-      yield* events.publish(McpEvent.ResourcesChanged, { server: name }).pipe(Effect.ignore)
-      yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
-    })
-
    // Disabled servers settle their startup immediately so queries never block on them.
    for (const [name, entry] of runtime) {
      if (entry.config.disabled) {
@@ -550,24 +516,27 @@ export const layer = Layer.effect(
        Deferred.doneUnsafe(entry.startup, Exit.void)
        continue
      }
-      fork(startServer(name, entry).pipe(locks.withLock(name)))
+      fork(startServer(name, entry))
    }

    // Bring a server online (or back to needs_auth) when its integration's credential changes, so an
    // OAuth login takes effect without a restart. Only fires for the integrations we registered.
+    const owned = new Set(registrations.map((reg) => reg.integrationID))
    const reconnect = (integrationID: Integration.ID) =>
      Effect.gen(function* () {
        const match = Array.from(runtime).find(([, entry]) => entry.integrationID === integrationID)
        if (!match) return
-        const name = match[0]
-        yield* Effect.gen(function* () {
-          // add() or remove() may have replaced or deleted the entry while we waited for the lock.
-          const entry = runtime.get(name)
-          if (!entry || entry.integrationID !== integrationID) return
-          if (entry.status.status === "disabled") return
-          yield* stopServer(name, entry)
-          yield* startServer(name, entry)
-        }).pipe(locks.withLock(name))
+        const [name, entry] = match
+        if (entry.config.disabled) return
+        if (entry.scope) {
+          yield* Scope.close(entry.scope, Exit.void)
+          entry.scope = undefined
+          entry.client = undefined
+          entry.tools = undefined
+          entry.prompts = undefined
+          yield* events.publish(Command.Event.Updated, {}).pipe(Effect.ignore)
+        }
+        yield* startServer(name, entry)
      })
    fork(
      events.subscribe(Integration.Event.ConnectionUpdated).pipe(
@@ -577,13 +546,10 @@ export const layer = Layer.effect(
      ),
    )

-    // Suspend so each await sees current entries; a bare Map iterator is exhausted after one run.
-    const whenAllReady = Effect.suspend(() =>
-      Effect.forEach(Array.from(runtime.values()), (entry) => Deferred.await(entry.startup), {
-        concurrency: "unbounded",
-        discard: true,
-      }),
-    )
+    const whenAllReady = Effect.forEach(runtime.values(), (entry) => Deferred.await(entry.startup), {
+      concurrency: "unbounded",
+      discard: true,
+    })
    return Service.of({
      servers: Effect.fn("MCP.servers")(function* () {
        const entries = Array.from(runtime).toSorted(([a], [b]) => a.localeCompare(b))
@@ -596,66 +562,6 @@ export const layer = Layer.effect(
          }),
        )
      }),
-      add: Effect.fn("MCP.add")(function* (server, config) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const previous = runtime.get(name)
-          if (previous) {
-            yield* stopServer(name, previous)
-            if (previous.integrationID) owned.delete(previous.integrationID)
-            if (previous.registration) yield* previous.registration.dispose
-          }
-          const entry: ServerEntry = {
-            config: { ...config, timeout: { ...timeout, ...config.timeout } },
-            status: { status: "pending" },
-            startup: Deferred.makeUnsafe<void>(),
-          }
-          runtime.set(name, entry)
-          yield* Effect.gen(function* () {
-            yield* register(name, entry)
-            if (config.disabled) {
-              entry.status = { status: "disabled" }
-              yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-              return
-            }
-            yield* startServer(name, entry)
-          }).pipe(
-            // Settle startup even when register fails or add is interrupted, so an entry that made it
-            // into runtime can never hang readers awaiting its startup.
-            Effect.ensuring(Effect.sync(() => Deferred.doneUnsafe(entry.startup, Exit.void))),
-          )
-        }).pipe(locks.withLock(name))
-      }),
-      connect: Effect.fn("MCP.connect")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          yield* startServer(name, target.entry)
-        }).pipe(locks.withLock(name))
-      }),
-      disconnect: Effect.fn("MCP.disconnect")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          target.entry.status = { status: "disabled" }
-          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-        }).pipe(locks.withLock(name))
-      }),
-      remove: Effect.fn("MCP.remove")(function* (server) {
-        const name = ServerName.make(server)
-        yield* Effect.gen(function* () {
-          const target = yield* requireServer(name)
-          yield* stopServer(name, target.entry)
-          if (target.entry.integrationID) owned.delete(target.entry.integrationID)
-          if (target.entry.registration) yield* target.entry.registration.dispose
-          // Credentials are kept: they are keyed by name + url, so re-adding the same server
-          // reuses them without forcing re-auth, matching add()'s replacement semantics.
-          runtime.delete(name)
-          yield* events.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-        }).pipe(locks.withLock(name))
-      }),
      tools: Effect.fn("MCP.tools")(function* () {
        yield* whenAllReady
        return Array.from(runtime.values())
@@ -23,7 +23,7 @@ export interface FileUpdate {
 }

 export function parse(patchText: string): ReadonlyArray<Hunk> {
-  const lines = stripHeredoc(patchText.replaceAll("\r\n", "\n").trim()).split("\n")
+  const lines = stripHeredoc(patchText.trim()).split("\n")
  const begin = lines.findIndex((line) => line.trim() === "*** Begin Patch")
  const end = lines.findIndex((line) => line.trim() === "*** End Patch")
  if (begin === -1 || end === -1 || begin >= end) throw new Error("Invalid patch format: missing Begin/End markers")
@@ -34,10 +34,7 @@ export function parse(patchText: string): ReadonlyArray<Hunk> {
    const line = lines[index]!
    if (line.startsWith("*** Add File:")) {
      const path = line.slice("*** Add File:".length).trim()
-      if (!path) {
-        index++
-        continue
-      }
+      if (!path) throw new Error("Invalid add file path")
      const parsed = parseAdd(lines, index + 1)
      hunks.push({ type: "add", path, contents: parsed.content })
      index = parsed.next
@@ -45,32 +42,28 @@ export function parse(patchText: string): ReadonlyArray<Hunk> {
    }
    if (line.startsWith("*** Delete File:")) {
      const path = line.slice("*** Delete File:".length).trim()
-      if (!path) {
-        index++
-        continue
-      }
+      if (!path) throw new Error("Invalid delete file path")
      hunks.push({ type: "delete", path })
      index++
      continue
    }
    if (line.startsWith("*** Update File:")) {
      const path = line.slice("*** Update File:".length).trim()
-      if (!path) {
-        index++
-        continue
-      }
+      if (!path) throw new Error("Invalid update file path")
      let next = index + 1
      let movePath: string | undefined
      if (lines[next]?.startsWith("*** Move to:")) {
-        movePath = lines[next]!.slice("*** Move to:".length).trim() || undefined
+        movePath = lines[next]!.slice("*** Move to:".length).trim()
+        if (!movePath) throw new Error("Invalid move file path")
        next++
      }
      const parsed = parseUpdate(lines, next)
+      if (parsed.chunks.length === 0) throw new Error(`Invalid update hunk for ${path}: expected at least one @@ chunk`)
      hunks.push({ type: "update", path, movePath, chunks: parsed.chunks })
      index = parsed.next
      continue
    }
-    index++
+    throw new Error(`Invalid patch line: ${line}`)
  }
  return hunks
 }
@@ -96,7 +89,8 @@ function parseAdd(lines: ReadonlyArray<string>, start: number) {
  const content: string[] = []
  let index = start
  while (index < lines.length && !lines[index]!.startsWith("***")) {
-    if (lines[index]!.startsWith("+")) content.push(lines[index]!.slice(1))
+    if (!lines[index]!.startsWith("+")) throw new Error(`Invalid add file line: ${lines[index]}`)
+    content.push(lines[index]!.slice(1))
    index++
  }
  return { content: content.join("\n"), next: index }
@@ -106,16 +100,14 @@ function parseUpdate(lines: ReadonlyArray<string>, start: number) {
  const chunks: UpdateFileChunk[] = []
  let index = start
  while (index < lines.length && !lines[index]!.startsWith("***")) {
-    const explicit = lines[index]!.startsWith("@@")
-    if (!explicit && (chunks.length > 0 || !/^[ +-]/.test(lines[index]!))) {
-      index++
-      continue
+    if (!lines[index]!.startsWith("@@")) {
+      throw new Error(`Invalid update file line: ${lines[index]}`)
    }
-    const changeContext = explicit ? lines[index]!.slice(2).trim() || undefined : undefined
+    const changeContext = lines[index]!.slice(2).trim() || undefined
    const oldLines: string[] = []
    const newLines: string[] = []
    let endOfFile = false
-    if (explicit) index++
+    index++
    while (index < lines.length && !lines[index]!.startsWith("@@")) {
      const line = lines[index]!
      if (line === "*** End of File") {
@@ -129,6 +121,7 @@ function parseUpdate(lines: ReadonlyArray<string>, start: number) {
        newLines.push(line.slice(1))
      } else if (line.startsWith("-")) oldLines.push(line.slice(1))
      else if (line.startsWith("+")) newLines.push(line.slice(1))
+      else throw new Error(`Invalid update chunk line: ${line}`)
      index++
    }
    chunks.push({ oldLines, newLines, changeContext, endOfFile: endOfFile || undefined })
@@ -6,8 +6,7 @@ import { Permission } from "@opencode-ai/schema/permission"
 import { EventV2 } from "./event"
 import { Location } from "./location"
 import { AgentV2 } from "./agent"
-import { SessionErrors } from "./session/error"
-import { SessionSchema } from "./session/schema"
+import { SessionV2 } from "./session"
 import { SessionStore } from "./session/store"
 import { Wildcard } from "./util/wildcard"
 import { PermissionSaved } from "./permission/saved"
@@ -99,11 +98,11 @@ export function merge(...rulesets: Permission.Ruleset[]): Permission.Ruleset {
 }

 export interface Interface {
-  readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionErrors.NotFoundError>
-  readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionErrors.NotFoundError>
+  readonly ask: (input: AssertInput) => Effect.Effect<AskResult, SessionV2.NotFoundError>
+  readonly assert: (input: AssertInput) => Effect.Effect<void, Error | SessionV2.NotFoundError>
  readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>
  readonly get: (id: ID) => Effect.Effect<Request | undefined>
-  readonly forSession: (sessionID: SessionSchema.ID) => Effect.Effect<ReadonlyArray<Request>>
+  readonly forSession: (sessionID: SessionV2.ID) => Effect.Effect<ReadonlyArray<Request>>
  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
 }

@@ -143,12 +142,9 @@ const layer = Layer.effect(
      )
    })

-    const configured = Effect.fn("PermissionV2.configured")(function* (
-      sessionID: SessionSchema.ID,
-      agentID?: AgentV2.ID,
-    ) {
+    const configured = Effect.fn("PermissionV2.configured")(function* (sessionID: SessionV2.ID, agentID?: AgentV2.ID) {
      const session = yield* sessions.get(sessionID)
-      if (!session) return yield* new SessionErrors.NotFoundError({ sessionID })
+      if (!session) return yield* new SessionV2.NotFoundError({ sessionID })
      const agent = yield* agents.resolve(agentID ?? session.agent)
      return agent?.permissions ?? missingAgentPermissions
    })
@@ -305,7 +301,7 @@ const layer = Layer.effect(
      return pending.get(id)?.request
    })

-    const forSession = Effect.fn("PermissionV2.forSession")(function* (sessionID: SessionSchema.ID) {
+    const forSession = Effect.fn("PermissionV2.forSession")(function* (sessionID: SessionV2.ID) {
      return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID)
    })

@@ -0,0 +1,10 @@
+import path from "path"
+import { Global } from "../global"
+import { PermissionV2 } from "../permission"
+
+// Combined output files written by the Shell service, e.g. `<data>/shell/<projectID>/<shellID>.out`.
+export const SHELL_OUTPUT_GLOB = path.join(Global.Path.data, "shell", "*", "*")
+
+export function allowExternalDirectories(resources: readonly string[]): PermissionV2.Ruleset {
+  return resources.map((resource): PermissionV2.Rule => ({ action: "external_directory", resource, effect: "allow" }))
+}
@@ -7,10 +7,8 @@ import { AgentV2 } from "../agent"
 import { Global } from "../global"
 import { Location } from "../location"
 import { PermissionV2 } from "../permission"
+import { SHELL_OUTPUT_GLOB } from "../permission/defaults"

-// Combined output files written by the Shell service, e.g. `<data>/shell/<projectID>/<shellID>.out`.
-// Whitelisted so agents can read a command's full captured output without an external-directory prompt.
-const SHELL_OUTPUT_GLOB = path.join(Global.Path.data, "shell", "*", "*")
 const BUILD_SYSTEM =
  "You are an AI coding agent. Help the user accomplish software engineering tasks by inspecting the workspace, making targeted changes, and using tools according to the configured permissions."

@@ -147,9 +147,9 @@ const pre = [

 const post = [
  ConfigReferencePlugin.Plugin,
+  ConfigSkillPlugin.Plugin,
  ConfigAgentPlugin.Plugin,
  ConfigCommandPlugin.Plugin,
-  ConfigSkillPlugin.Plugin,
  ConfigProviderPlugin.Plugin,
  VariantPlugin.Plugin,
  ConfigPolicyPlugin.Plugin,
@@ -133,20 +133,12 @@ const device = {
      },
      Device,
    ).pipe(
-      Effect.flatMap((value) =>
-        Clock.currentTimeMillis.pipe(
-          Effect.map((created) => {
-            const lifetime = positiveSeconds(value.expires_in, 0)
-            return {
-              mode: "auto" as const,
-              url: value.verification_uri_complete ?? value.verification_uri,
-              instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
-              ...(lifetime ? { expiresAt: created + lifetime * 1000 } : {}),
-              callback: poll(value).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens))),
-            }
-          }),
-        ),
-      ),
+      Effect.map((value) => ({
+        mode: "auto" as const,
+        url: value.verification_uri_complete ?? value.verification_uri,
+        instructions: `Open ${value.verification_uri} on any device and enter code: ${value.user_code}`,
+        callback: poll(value).pipe(Effect.flatMap((tokens) => credential(deviceMethodID, tokens))),
+      })),
    ),
  refresh: (value) => refresh(deviceMethodID, Credential.OAuth.make({ ...value, methodID: deviceMethodID })),
 } satisfies IntegrationOAuthMethodRegistration
@@ -142,11 +142,7 @@ const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
      continue
    }

-    const plugin = yield* load(operation).pipe(
-      Effect.catchCause((cause) =>
-        Effect.logWarning("failed to load plugin", { target: operation.target, cause }).pipe(Effect.as(undefined)),
-      ),
-    )
+    const plugin = yield* load(operation).pipe(Effect.catchCause(() => Effect.succeed(undefined)))
    if (!plugin) continue
    const previous = packages.get(operation.target)
    if (previous) enabled.delete(previous.id)
@@ -5,7 +5,7 @@ You are an interactive CLI tool that helps users with software engineering tasks
 ## Editing constraints
 - Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
 - Only add comments if they are necessary to make a non-obvious block easier to understand.
- Try to use patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
+- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).

 ## Tool usage
 - Prefer specialized tools over shell for file operations:
@@ -24,8 +24,8 @@ If you notice unexpected changes in the worktree or staging area that you did no

 - Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
 - Add succinct code comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
- Always use patch for manual code edits. Do not use cat or any other commands when creating or editing files. Formatting commands or bulk edits don't need to be done with patch.
- Do not use Python to read/write files when a simple shell command or patch would suffice.
+- Always use apply_patch for manual code edits. Do not use cat or any other commands when creating or editing files. Formatting commands or bulk edits don't need to be done with apply_patch.
+- Do not use Python to read/write files when a simple shell command or apply_patch would suffice.
 - You may be in a dirty git worktree.
  * NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
  * If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
@@ -28,9 +28,9 @@ import { fromRow } from "./session/info"
 import { SessionRunner } from "./session/runner/index"
 import { SessionStore } from "./session/store"
 import { SessionExecution } from "./session/execution"
-import { MessageDecodeError, NotFoundError } from "./session/error"
 import { makeGlobalNode } from "./effect/app-node"
 import { LocationServiceMap } from "./location-service-map"
+import { MessageDecodeError } from "./session/error"
 import { SessionEvent } from "./session/event"
 import { SessionPending } from "./session/pending"
 import { SessionGenerate } from "./session/generate"
@@ -108,6 +108,10 @@ type ForkInput = {
  messageID?: SessionMessage.ID
 }

+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Session.NotFoundError", {
+  sessionID: SessionSchema.ID,
+}) {}
+
 export class OperationUnavailableError extends Schema.TaggedErrorClass<OperationUnavailableError>()(
  "Session.OperationUnavailableError",
  {
@@ -115,7 +119,7 @@ export class OperationUnavailableError extends Schema.TaggedErrorClass<Operation
  },
 ) {}

-export { MessageDecodeError, NotFoundError }
+export { MessageDecodeError } from "./session/error"

 export class PromptConflictError extends Schema.TaggedErrorClass<PromptConflictError>()("Session.PromptConflictError", {
  sessionID: SessionSchema.ID,
@@ -1,15 +1,9 @@
-export * as SessionErrors from "./error"
-
 import { Schema } from "effect"
 import { Agent } from "@opencode-ai/schema/agent"
 import { SessionMessage } from "./message"
 import { SessionSchema } from "./schema"
 import { SessionError } from "@opencode-ai/schema/session-error"

-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Session.NotFoundError", {
-  sessionID: SessionSchema.ID,
-}) {}
-
 export class MessageDecodeError extends Schema.TaggedErrorClass<MessageDecodeError>()("Session.MessageDecodeError", {
  sessionID: SessionSchema.ID,
  messageID: SessionMessage.ID,
@@ -297,12 +297,6 @@ export function update(adapter: Adapter, event: SessionEvent.Event) {
            draft.cost = event.data.cost
            draft.tokens = castDraft(event.data.tokens)
          }
-          if (event.data.snapshot || event.data.files)
-            draft.snapshot = {
-              ...draft.snapshot,
-              end: event.data.snapshot,
-              files: event.data.files ? Array.from(event.data.files) : undefined,
-            }
        })
      },
      "session.text.started": (event) => {
@@ -143,10 +143,6 @@ const layer = Layer.effect(
              }
            }
            yield* publish(event)
-            if (LLMEvent.is.toolInputError(event)) {
-              if (prepared.resolveToolCall(event.name).type === "settle") needsContinuation = true
-              return
-            }
            if (event.type !== "tool-call" || event.providerExecuted) return
            const tool = prepared.resolveToolCall(event.name)
            if (tool.type === "reject") {
@@ -199,27 +195,25 @@ const layer = Layer.effect(
        tokens: settlement.tokens,
      })

-      const captureStepEnd = Effect.fnUntraced(function* () {
-        const snapshot = yield* snapshots.capture()
-        const files =
-          startSnapshot && snapshot
-            ? yield* snapshots
-                .files({ from: startSnapshot, to: snapshot })
-                .pipe(Effect.catch(() => Effect.succeed(undefined)))
-            : undefined
-        return { snapshot, files }
-      })
-
+      // Captures the end snapshot, diffs it against the step's start, and durably ends the
+      // assistant step.
      const publishStepEnd = (settlement: NonNullable<ReturnType<typeof publisher.stepSettlement>>) =>
        Effect.gen(function* () {
-          const end = yield* captureStepEnd()
+          const endSnapshot = yield* snapshots.capture()
+          const files =
+            startSnapshot && endSnapshot
+              ? yield* snapshots
+                  .files({ from: startSnapshot, to: endSnapshot })
+                  .pipe(Effect.catch(() => Effect.succeed(undefined)))
+              : undefined
          yield* serialized(
            events.publish(SessionEvent.Step.Ended, {
              sessionID: session.id,
              assistantMessageID: yield* publisher.startAssistant(),
              finish: settlement.finish,
              ...stepUsage(settlement),
-              ...end,
+              snapshot: endSnapshot,
+              files,
            }),
          )
        })
@@ -330,15 +324,8 @@ const layer = Layer.effect(
          const stepFailure = publisher.stepFailure()
          const stepSettlement = publisher.stepSettlement()
          if (stepSettlement && !stepFailure) yield* publishStepEnd(stepSettlement)
-          if (stepFailure) {
-            const end = yield* captureStepEnd()
-            yield* serialized(
-              publisher.publishStepFailure({
-                ...(stepSettlement ? stepUsage(stepSettlement) : {}),
-                ...end,
-              }),
-            )
-          }
+          if (stepFailure)
+            yield* serialized(publisher.publishStepFailure(stepSettlement ? stepUsage(stepSettlement) : undefined))

          if (stream._tag === "Failure") return yield* Effect.failCause(stream.cause)
          if (userDeclined) return yield* Effect.interrupt
@@ -391,11 +378,7 @@ const layer = Layer.effect(
              .pipe(Effect.andThen(Effect.fail(error.cause)))
          }),
        )
-        if (attempt._tag === "Completed")
-          return {
-            needsContinuation: attempt.needsContinuation,
-            step: attempt.step,
-          }
+        if (attempt._tag === "Completed") return { needsContinuation: attempt.needsContinuation, step: attempt.step }
        if (attempt._tag === "RestartAfterOverflowCompaction") recoverOverflow = undefined
        yield* Effect.yieldNow
        currentPromotion = undefined
@@ -427,9 +410,7 @@ const layer = Layer.effect(
              yield* events.publish(SessionEvent.Compaction.Failed, {
                sessionID,
                reason: "manual",
-                error: Cause.hasInterruptsOnly(compacted.cause)
-                  ? { type: "aborted", message: "Compaction cancelled" }
-                  : { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
+                error: { type: "compaction.failed", message: Cause.pretty(compacted.cause) },
                inputID: unsettled.id,
              })
            return yield* Effect.failCause(compacted.cause)
@@ -9,7 +9,6 @@ import { SessionError } from "@opencode-ai/schema/session-error"
 import { Money } from "@opencode-ai/schema/money"
 import { AgentV2 } from "../../agent"
 import { Snapshot } from "../../snapshot"
-import { RelativePath } from "../../schema"
 import { SessionUsage } from "../usage"

 type Input = {
@@ -113,12 +112,12 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
        if (state !== undefined) current.state = { ...current.state, ...state }
        return Effect.succeed(current.ordinal)
      })
-    const end = Effect.fnUntraced(function* (id: string, state?: Record<string, unknown>, value?: string) {
+    const end = Effect.fnUntraced(function* (id: string, state?: Record<string, unknown>) {
      const current = chunks.get(id)
      if (!current) return yield* Effect.die(new Error(`${name} end before start: ${id}`))
      yield* ended(
        id,
-        value ?? current.values.join(""),
+        current.values.join(""),
        current.ordinal,
        state === undefined ? current.state : { ...current.state, ...state },
      )
@@ -176,11 +175,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
    yield* toolInput.flush()
  })

-  const startToolInput = Effect.fnUntraced(function* (event: {
-    readonly id: string
-    readonly name: string
-    readonly providerExecuted?: boolean
-  }) {
+  const startToolInput = Effect.fnUntraced(function* (event: { readonly id: string; readonly name: string }) {
    if (tools.has(event.id)) return yield* Effect.die(new Error(`Duplicate tool input start: ${event.id}`))
    const assistantMessageID = yield* startAssistant()
    tools.set(event.id, {
@@ -188,7 +183,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
      name: event.name,
      called: false,
      settled: false,
-      providerExecuted: event.providerExecuted === true,
+      providerExecuted: false,
    })
    yield* toolInput.start(event.id)
    yield* events.publish(SessionEvent.Tool.Input.Started, {
@@ -199,41 +194,13 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
    })
  })

-  const endToolInput = Effect.fnUntraced(function* (
-    event: { readonly id: string; readonly name: string },
-    value?: string,
-  ) {
+  const endToolInput = Effect.fnUntraced(function* (event: { readonly id: string; readonly name: string }) {
    const tool = tools.get(event.id)
    if (!tool) return yield* Effect.die(new Error(`Tool input end before start: ${event.id}`))
    if (tool.name !== event.name)
      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`))
    if (!toolInput.has(event.id)) return yield* Effect.die(new Error(`Duplicate tool input end: ${event.id}`))
-    yield* toolInput.end(event.id, undefined, value)
-  })
-
-  const failMalformedToolInput = Effect.fnUntraced(function* (event: {
-    readonly id: string
-    readonly name: string
-    readonly raw: string
-  }) {
-    if (!tools.has(event.id)) yield* startToolInput(event)
-    const tool = tools.get(event.id)
-    if (!tool || tool.called || tool.settled)
-      return yield* Effect.die(new Error(`Malformed tool input after call settlement: ${event.id}`))
-    if (tool.name !== event.name)
-      return yield* Effect.die(new Error(`Tool input name changed for ${event.id}: ${tool.name} -> ${event.name}`))
-    if (toolInput.has(event.id)) yield* endToolInput(event, event.raw)
-    tool.settled = true
-    yield* events.publish(SessionEvent.Tool.Failed, {
-      sessionID: input.sessionID,
-      assistantMessageID: tool.assistantMessageID,
-      callID: event.id,
-      error: {
-        type: "tool.input-json",
-        message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON.",
-      },
-      executed: false,
-    })
+    yield* toolInput.end(event.id)
  })

  const flush = Effect.fn("SessionRunner.flush")(function* () {
@@ -262,18 +229,16 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
    return failed
  })

-  const failAssistant = Effect.fnUntraced(function* (error: SessionError.Error) {
+  const failAssistant = Effect.fnUntraced(function* (error: SessionError.Error, replace = false) {
    yield* flush()
    yield* failTools(error, "uncalled")
    yield* startAssistant()
-    if (stepFailure === undefined) stepFailure = error
+    if (replace || stepFailure === undefined) stepFailure = error
  })

-  const publishStepFailure = Effect.fnUntraced(function* (details?: {
-    readonly cost?: Money.USD
-    readonly tokens?: ReturnType<typeof SessionUsage.tokens>
-    readonly snapshot?: Snapshot.ID
-    readonly files?: readonly RelativePath[]
+  const publishStepFailure = Effect.fnUntraced(function* (usage?: {
+    readonly cost: Money.USD
+    readonly tokens: ReturnType<typeof SessionUsage.tokens>
  }) {
    if (stepFailed || stepFailure === undefined) return
    const assistantMessageID = yield* startAssistant()
@@ -282,7 +247,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
      sessionID: input.sessionID,
      assistantMessageID,
      error: stepFailure,
-      ...details,
+      ...usage,
    })
  })

@@ -372,10 +337,6 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
      case "tool-input-end":
        yield* endToolInput(event)
        return
-      case "tool-input-error":
-        retryEvidence = true
-        yield* failMalformedToolInput(event)
-        return
      case "tool-call": {
        retryEvidence = true
        if (!tools.has(event.id)) yield* startToolInput(event)
@@ -458,7 +419,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
        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" })
+          yield* failAssistant({ type: "provider.content-filter", message: "Provider blocked the response" }, true)
          return
        }
        return
@@ -466,7 +427,7 @@ export const createLLMEventPublisher = (events: Pick<EventV2.Interface, "publish
        return
      case "provider-error":
        providerFailed = true
-        yield* failAssistant({ type: "provider.unknown", message: event.message })
+        yield* failAssistant({ type: "provider.unknown", message: event.message }, true)
        return
    }
  })
@@ -136,19 +136,14 @@ const assistant = (message: SessionMessage.Assistant, model: ModelV2.Ref, provid
        : item.text.length > 0
          ? [{ type: "text", text: item.text }]
          : []
-    const reuseToolProviderMetadata =
-      reuseProviderMetadata ||
-      (sameModel &&
-        item.executed === true &&
-        (item.state.status === "completed" || (item.state.status === "error" && item.state.result !== undefined)))
    const call = toolCall(
      item,
-      reuseToolProviderMetadata ? providerMetadata(providerMetadataKey, item.providerState) : undefined,
+      reuseProviderMetadata ? providerMetadata(providerMetadataKey, item.providerState) : undefined,
    )
    if (item.executed !== true) return [call]
    const result = toolResult(
      item,
-      reuseToolProviderMetadata
+      reuseProviderMetadata
        ? providerMetadata(providerMetadataKey, item.providerResultState ?? item.providerState)
        : undefined,
    )
@@ -69,6 +69,10 @@ export interface Interface {

 export class Service extends Context.Service<Service, Interface>()("@opencode/v2/SkillDiscovery") {}

+export function cachePath(cache: string, url: string) {
+  return path.resolve(cache, "skills", Hash.fast(url.endsWith("/") ? url : `${url}/`))
+}
+
 const layer = Layer.effect(
  Service,
  Effect.gen(function* () {
@@ -111,7 +115,7 @@ const layer = Layer.effect(
        )
        if (!data) return []

-        const sourceRoot = path.resolve(global.cache, "skills", Hash.fast(base))
+        const sourceRoot = cachePath(global.cache, base)
        return yield* Effect.forEach(
          data.skills.flatMap((skill) => {
            if (!isSafeSegment(skill.name)) {
@@ -16,7 +16,8 @@ import { ToolRegistry } from "./registry"
 * Registry namespace and permission action names for MCP tools.
 */
 export const namespace = (server: string) => server.replace(/[^a-zA-Z0-9_-]/g, "_")
-export const name = (server: string, tool: string) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`
+export const name = (server: string, tool: string) =>
+  `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`

 export const layer = Layer.effectDiscard(
  Effect.gen(function* () {
@@ -32,11 +33,11 @@ export const layer = Layer.effectDiscard(
    // registry never has a gap where MCP tools disappear mid-swap.
    const reconcile = lock.withPermit(
      Effect.gen(function* () {
-        const groups = new Map<string, { tools: Record<string, Tool.AnyTool>; codemode: boolean }>()
+        const groups = new Map<string, Record<string, Tool.AnyTool>>()
        for (const tool of yield* mcp.tools()) {
-          const group = groups.get(tool.server) ?? { tools: {}, codemode: tool.codemode !== false }
+          const group = groups.get(tool.server) ?? {}
          const schema = (tool.inputSchema ?? {}) as JsonSchema.JsonSchema
-          group.tools[tool.name] = Tool.withPermission(
+          group[tool.name] = Tool.withPermission(
            Tool.make({
              description: tool.description ?? "",
              jsonSchema: {
@@ -107,7 +108,7 @@ export const layer = Layer.effectDiscard(
        const next = yield* Scope.fork(scope)
        yield* Effect.forEach(
          groups,
-          ([server, group]) => tools.register(group.tools, { namespace: namespace(server), codemode: group.codemode }),
+          ([server, record]) => tools.register(record, { namespace: namespace(server) }),
          {
            discard: true,
          },
@@ -3,7 +3,7 @@ export * as PatchTool from "./patch"
 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 { formatPatch, structuredPatch } from "diff"
+import { createTwoFilesPatch, diffLines } from "diff"
 import { Effect, Schema } from "effect"
 import { FileMutation } from "../file-mutation"
 import { FSUtil } from "../fs-util"
@@ -11,7 +11,6 @@ import { LocationMutation } from "../location-mutation"
 import { Patch } from "../patch"
 import { PermissionV2 } from "../permission"
 import { Tool } from "./tool"
-import DESCRIPTION from "./patch.txt"

 export const name = "patch"

@@ -35,7 +34,7 @@ export type Output = typeof Output.Type

 export const toModelOutput = (output: Output) =>
  [
-    "Success. Updated the following files:",
+    "Applied patch sequentially:",
    ...output.applied.map(
      (item) => `${item.type === "add" ? "A" : item.type === "delete" ? "D" : "M"} ${item.resource}`,
    ),
@@ -53,7 +52,6 @@ type Prepared =
      readonly content: string
      readonly before: string
      readonly after: string
-      readonly moveTarget?: LocationMutation.Target
    })

 export const Plugin = {
@@ -70,7 +68,8 @@ export const Plugin = {
          name,
          Tool.withPermission(
            Tool.make({
-              description: DESCRIPTION,
+              description:
+                "Apply one patch containing add, update, and delete file operations. All targets are resolved and approved before target contents are read. Operations apply sequentially; if a later operation fails, earlier operations remain applied and the failure reports them explicitly. Moves and atomic rollback are not supported yet.",
              input: Input,
              output: Output,
              toModelOutput: ({ output }) => [{ type: "text", text: toModelOutput(output) }],
@@ -89,39 +88,22 @@ export const Plugin = {
                    messageID: context.messageID,
                    callID: context.callID,
                  }
-                  if (!input.patchText) return yield* new ToolFailure({ message: "patchText is required" })
+                  if (!input.patchText.trim()) return yield* new ToolFailure({ message: "patchText is required" })
                  const hunks = yield* Effect.try({
                    try: () => Patch.parse(input.patchText),
                    catch: (cause) => new ToolFailure({ message: `patch verification failed: ${String(cause)}` }),
                  })
-                  if (hunks.length === 0) {
-                    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 targets: Array<{
-                    readonly hunk: Patch.Hunk
-                    readonly target: LocationMutation.Target
-                    readonly moveTarget?: LocationMutation.Target
-                  }> = []
-                  for (const hunk of hunks) {
-                    targets.push({
-                      hunk,
-                      target: yield* mutation.resolve({ path: hunk.path, kind: "file" }),
-                      moveTarget:
-                        hunk.type === "update" && hunk.movePath
-                          ? yield* mutation.resolve({ path: hunk.movePath, kind: "file" })
-                          : undefined,
-                    })
-                  }
+                  if (hunks.length === 0) return yield* new ToolFailure({ message: "patch rejected: empty patch" })
+                  const move = hunks.find((hunk) => hunk.type === "update" && hunk.movePath !== undefined)
+                  if (move) return yield* new ToolFailure({ message: "patch moves are not supported yet" })
+
+                  const targets: Array<{ readonly hunk: Patch.Hunk; readonly target: LocationMutation.Target }> = []
+                  for (const hunk of hunks)
+                    targets.push({ hunk, target: yield* mutation.resolve({ path: hunk.path, kind: "file" }) })
                  const externalDirectories = new Map<string, LocationMutation.ExternalDirectoryAuthorization>()
-                  for (const target of targets) {
-                    for (const item of [target.target, target.moveTarget]) {
-                      const external = item?.externalDirectory
-                      if (external) externalDirectories.set(external.resource, external)
-                    }
+                  for (const { target } of targets) {
+                    const external = target.externalDirectory
+                    if (external) externalDirectories.set(external.resource, external)
                  }
                  for (const external of externalDirectories.values()) {
                    yield* permission.assert({
@@ -141,17 +123,15 @@ export const Plugin = {
                  })

                  const prepared: Prepared[] = []
-                  for (const { hunk, target, moveTarget } of targets) {
+                  for (const { hunk, target } of targets) {
                    yield* Effect.gen(function* () {
                      if (hunk.type === "add") {
                        prepared.push({
                          ...hunk,
                          target,
                          before: "",
-                          after: (hunk.contents.endsWith("\n") || hunk.contents === ""
-                            ? hunk.contents
-                            : `${hunk.contents}\n`
-                          ).replace(/^\uFEFF/, ""),
+                          after:
+                            hunk.contents.endsWith("\n") || hunk.contents === "" ? hunk.contents : `${hunk.contents}\n`,
                        })
                        return
                      }
@@ -163,11 +143,7 @@ export const Plugin = {
                        prepared.push({ ...hunk, target, before, after: "" })
                        return
                      }
-                      const update = yield* Effect.try({
-                        try: () => Patch.derive(hunk.path, hunk.chunks, original),
-                        catch: (error) =>
-                          new ToolFailure({ message: `patch verification failed: ${String(error)}` }),
-                      })
+                      const update = Patch.derive(hunk.path, hunk.chunks, original)
                      prepared.push({
                        ...hunk,
                        target,
@@ -175,9 +151,8 @@ export const Plugin = {
                        content: Patch.joinBom(update.content, update.bom),
                        before,
                        after: update.content,
-                        moveTarget,
                      })
-                    }).pipe(Effect.mapError((error) => (error instanceof ToolFailure ? error : fail(hunk.path, error))))
+                    }).pipe(Effect.mapError((error) => fail(hunk.path, error)))
                  }

                  const patchFiles = prepared.map(patchFile)
@@ -186,7 +161,7 @@ export const Plugin = {
                    (change) =>
                      Effect.gen(function* () {
                        if (change.type === "add") {
-                          const result = yield* files.write({
+                          const result = yield* files.create({
                            target: change.target,
                            content:
                              change.contents.endsWith("\n") || change.contents === ""
@@ -201,15 +176,6 @@ export const Plugin = {
                          applied.push({ type: change.type, resource: result.resource, target: result.target })
                          return
                        }
-                        if (change.moveTarget) {
-                          const result = yield* files.write({
-                            target: change.moveTarget,
-                            content: change.content,
-                          })
-                          yield* files.remove({ target: change.target })
-                          applied.push({ type: change.type, resource: result.resource, target: result.target })
-                          return
-                        }
                        const result = yield* files.writeIfUnchanged({
                          target: change.target,
                          expected: change.source,
@@ -233,7 +199,7 @@ export const Plugin = {
    yield* ctx.session.hook("context", (event) =>
      Effect.sync(() => {
        const usePatch =
-          event.model.id.includes("gpt-") && !event.model.id.includes("oss") && !event.model.id.includes("gpt-4")
+          event.model.providerID.toLowerCase() === "openai" || event.model.id.toLowerCase().includes("gpt")
        if (usePatch) {
          delete event.tools.edit
          delete event.tools.write
@@ -246,18 +212,16 @@ export const Plugin = {
 }

 function patchFile(change: Prepared): typeof FileDiff.Info.Type {
-  const target = (change.type === "update" ? change.moveTarget : undefined)?.resource ?? change.target.resource
-  const diff = structuredPatch(change.target.resource, target, change.before, change.after)
-  const counts = diff.hunks.flatMap((hunk) => hunk.lines).reduce(
-    (result, line) => ({
-      additions: result.additions + (line.startsWith("+") ? 1 : 0),
-      deletions: result.deletions + (line.startsWith("-") ? 1 : 0),
+  const counts = diffLines(change.before, change.after).reduce(
+    (result, item) => ({
+      additions: result.additions + (item.added ? (item.count ?? 0) : 0),
+      deletions: result.deletions + (item.removed ? (item.count ?? 0) : 0),
    }),
    { additions: 0, deletions: 0 },
  )
  return {
-    file: target,
-    patch: formatPatch(diff),
+    file: change.target.resource,
+    patch: createTwoFilesPatch(change.target.resource, change.target.resource, change.before, change.after),
    status: change.type === "add" ? "added" : change.type === "delete" ? "deleted" : "modified",
    ...counts,
  }
@@ -1,33 +0,0 @@
-Use the `patch` tool to edit files. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope:
-
-*** Begin Patch
-[ one or more file sections ]
-*** End Patch
-
-Within that envelope, you get a sequence of file operations.
-You MUST include a header to specify the action you are taking.
-Each operation starts with one of three headers:
-
-*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
-*** Delete File: <path> - remove an existing file. Nothing follows.
-*** Update File: <path> - patch an existing file in place (optionally with a rename).
-
-Example patch:
-
-```
-*** Begin Patch
-*** Add File: hello.txt
-+Hello world
-*** Update File: src/app.py
-*** Move to: src/main.py
-@@ def greet():
-print("Hi")
-+print("Hello, world!")
-*** Delete File: obsolete.txt
-*** End Patch
-```
-
-It is important to remember:
-
- You must include a header with your intended action (Add/Delete/Update)
- You must prefix new lines with `+` even when creating a new file
@@ -1,11 +1,11 @@
-import type { LanguageModelV3, LanguageModelV3CallOptions, LanguageModelV3StreamPart } from "@ai-sdk/provider"
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider"
 import { AISDK } from "@opencode-ai/core/aisdk"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { LLM, LLMError, LLMEvent, Message } from "@opencode-ai/ai"
-import { LLMClient, RequestExecutor } from "@opencode-ai/ai/route"
+import { LLM, Message } from "@opencode-ai/ai"
+import { LLMClient } from "@opencode-ai/ai/route"
 import { expect } from "bun:test"
-import { Effect, Layer } from "effect"
+import { Effect } from "effect"
 import { testEffect } from "./lib/effect"

 const it = testEffect(AISDK.locationLayer)
@@ -19,37 +19,6 @@ const model = (packageName: string, settings: Record<string, unknown> = {}) =>
    limit: { context: 100, output: 20 },
  })

-const streamModel = (events: ReadonlyArray<LanguageModelV3StreamPart>): LanguageModelV3 => ({
-  specificationVersion: "v3",
-  provider: "test",
-  modelId: "test",
-  supportedUrls: {},
-  doGenerate: () => Promise.reject(new Error("Unexpected non-streaming request")),
-  doStream: () =>
-    Promise.resolve({
-      stream: new ReadableStream({
-        start(controller) {
-          events.forEach((event) => controller.enqueue(event))
-          controller.close()
-        },
-      }),
-    }),
-})
-
-const usage = {
-  inputTokens: { total: 1, noCache: 1, cacheRead: 0, cacheWrite: 0 },
-  outputTokens: { total: 1, text: 0, reasoning: 0 },
-} as const
-
-const client = LLMClient.layer.pipe(
-  Layer.provide(
-    Layer.succeed(
-      RequestExecutor.Service,
-      RequestExecutor.Service.of({ execute: () => Effect.die("Unexpected HTTP request") }),
-    ),
-  ),
-)
-
 it.effect("keys language models by package and flattened overlays", () =>
  Effect.gen(function* () {
    const aisdk = yield* AISDK.Service
@@ -269,68 +238,3 @@ it.effect("projects replay metadata onto AI SDK prompt parts", () =>
    ])
  }),
 )
-
-it.effect("emits malformed AI SDK tool input without executing it", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    const raw = '{"query":"partial'
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = {
-        languageModel: () =>
-          streamModel([
-            { type: "tool-input-start", id: "call_1", toolName: "lookup" },
-            { type: "tool-input-delta", id: "call_1", delta: raw },
-            { type: "tool-input-end", id: "call_1" },
-            { type: "tool-call", toolCallId: "call_1", toolName: "lookup", input: raw },
-            { type: "finish", finishReason: { unified: "tool-calls", raw: "tool_calls" }, usage },
-          ]),
-      }
-    })
-
-    const resolved = yield* aisdk.model(model("test-ai-sdk"))
-    const response = yield* LLMClient.generate(LLM.request({ model: resolved, prompt: "Lookup" })).pipe(
-      Effect.provide(client),
-    )
-
-    expect(response.events.find(LLMEvent.is.toolInputError)).toMatchObject({
-      id: "call_1",
-      name: "lookup",
-      raw,
-    })
-    expect(response.events.some(LLMEvent.is.toolInputEnd)).toBeTrue()
-    expect(response.events.some(LLMEvent.is.toolCall)).toBeFalse()
-  }),
-)
-
-it.effect("keeps malformed provider-executed AI SDK input terminal", () =>
-  Effect.gen(function* () {
-    const aisdk = yield* AISDK.Service
-    const raw = '{"query":"partial'
-    yield* aisdk.hook.sdk((event) => {
-      event.sdk = {
-        languageModel: () =>
-          streamModel([
-            { type: "tool-input-start", id: "call_1", toolName: "web_search", providerExecuted: true },
-            { type: "tool-input-delta", id: "call_1", delta: raw },
-            { type: "tool-input-end", id: "call_1" },
-            {
-              type: "tool-call",
-              toolCallId: "call_1",
-              toolName: "web_search",
-              input: raw,
-              providerExecuted: true,
-            },
-          ]),
-      }
-    })
-
-    const resolved = yield* aisdk.model(model("hosted-test-ai-sdk"))
-    const error = yield* LLMClient.generate(LLM.request({ model: resolved, prompt: "Search" })).pipe(
-      Effect.provide(client),
-      Effect.flip,
-    )
-
-    expect(error).toBeInstanceOf(LLMError)
-    expect(error.message).toContain("Invalid JSON input for aisdk tool call web_search")
-  }),
-)
@@ -10,6 +10,7 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FSUtil } from "@opencode-ai/core/fs-util"
 import { Global } from "@opencode-ai/core/global"
 import { PermissionV2 } from "@opencode-ai/core/permission"
+import { SHELL_OUTPUT_GLOB } from "@opencode-ai/core/permission/defaults"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { ConfigMigrateV1 } from "@opencode-ai/core/v1/config/migrate"
 import { tmpdir } from "../fixture/tmpdir"
@@ -22,6 +23,11 @@ const defaultPermissions = [
  { action: "*", resource: "*", effect: "allow" },
  { action: "external_directory", resource: "*", effect: "ask" },
 ] satisfies PermissionV2.Ruleset
+const shellOutputPermission = {
+  action: "external_directory",
+  resource: SHELL_OUTPUT_GLOB,
+  effect: "allow",
+} satisfies PermissionV2.Rule

 describe("ConfigAgentPlugin.Plugin", () => {
  it.effect("matches POSIX paths against home-relative permissions", () =>
@@ -114,6 +120,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
        { action: "bash", resource: "*", effect: "ask" },
        { action: "read", resource: "*", effect: "allow" },
        { action: "bash", resource: "git *", effect: "allow" },
+        shellOutputPermission,
      ])
      expect(PermissionV2.evaluate("bash", "git status", buildAgent.permissions).effect).toBe("allow")
      expect(PermissionV2.evaluate("bash", "bun test", buildAgent.permissions).effect).toBe("ask")
@@ -132,6 +139,7 @@ describe("ConfigAgentPlugin.Plugin", () => {
        { action: "read", resource: "*", effect: "allow" },
        { action: "edit", resource: "*", effect: "deny" },
        { action: "read", resource: "*", effect: "deny" },
+        shellOutputPermission,
      ])
      expect(PermissionV2.evaluate("read", "README.md", reviewer.permissions).effect).toBe("deny")
      expect((yield* agents.get(AgentV2.ID.make("late")))?.permissions).toEqual([
@@ -139,11 +147,31 @@ describe("ConfigAgentPlugin.Plugin", () => {
        { action: "bash", resource: "*", effect: "ask" },
        { action: "read", resource: "*", effect: "allow" },
        { action: "edit", resource: "*", effect: "allow" },
+        shellOutputPermission,
      ])
      expect(yield* agents.get(AgentV2.ID.make("removed"))).toBeUndefined()
    }),
  )

+  it.effect("keeps shell output readable through a broad external-directory deny", () =>
+    Effect.gen(function* () {
+      const permissions = yield* loadConfiguredPermissions([
+        { action: "external_directory", resource: "*", effect: "deny" },
+      ])
+      expect(PermissionV2.evaluate("external_directory", SHELL_OUTPUT_GLOB, permissions).effect).toBe("allow")
+    }),
+  )
+
+  it.effect("respects an exact shell output deny", () =>
+    Effect.gen(function* () {
+      const permissions = yield* loadConfiguredPermissions([
+        { action: "external_directory", resource: "*", effect: "deny" },
+        { action: "external_directory", resource: SHELL_OUTPUT_GLOB, effect: "deny" },
+      ])
+      expect(PermissionV2.evaluate("external_directory", SHELL_OUTPUT_GLOB, permissions).effect).toBe("deny")
+    }),
+  )
+
  it.effect("maps configured agent fields and preserves an unspecified model variant", () =>
    Effect.gen(function* () {
      const agents = yield* AgentV2.Service
@@ -294,13 +322,21 @@ Use native v2 fields.`,
            system: "Review carefully.",
            description: "Markdown description",
            request: { body: { temperature: 0.5 } },
-            permissions: [...defaultPermissions, { action: "edit", resource: "*", effect: "deny" }],
+            permissions: [
+              ...defaultPermissions,
+              { action: "edit", resource: "*", effect: "deny" },
+              shellOutputPermission,
+            ],
          })
          expect(yield* agents.get(AgentV2.ID.make("team/helper"))).toMatchObject({ system: "Help the team." })
          expect(yield* agents.get(AgentV2.ID.make("native"))).toMatchObject({
            system: "Use native v2 fields.",
            request: { headers: { "x-agent": "native" }, body: { effort: "high" } },
-            permissions: [...defaultPermissions, { action: "edit", resource: "*", effect: "deny" }],
+            permissions: [
+              ...defaultPermissions,
+              { action: "edit", resource: "*", effect: "deny" },
+              shellOutputPermission,
+            ],
          })
          expect(yield* agents.get(AgentV2.ID.make("disabled"))).toBeUndefined()
          expect(yield* agents.get(AgentV2.ID.make("plan"))).toMatchObject({ system: "Make a plan.", mode: "primary" })
@@ -357,3 +393,26 @@ function loadHomePermissions(home: string) {
    return agent.permissions
  })
 }
+
+function loadConfiguredPermissions(permissions: PermissionV2.Ruleset) {
+  return Effect.gen(function* () {
+    const agents = yield* AgentV2.Service
+    const build = AgentV2.ID.make("build")
+    yield* agents.transform((draft) => draft.update(build, () => {}))
+    const config = Config.Service.of({
+      entries: () =>
+        Effect.succeed([
+          new Config.Document({
+            type: "document",
+            info: decode({ permissions }),
+          }),
+        ]),
+    })
+    yield* ConfigAgentPlugin.Plugin.effect(host({ agent: agentHost(agents) })).pipe(
+      Effect.provideService(Config.Service, config),
+    )
+    const agent = yield* agents.get(build)
+    if (!agent) throw new Error("expected configured build agent")
+    return agent.permissions
+  })
+}
@@ -655,7 +655,6 @@ describe("Config", () => {
                      command: ["node", "./mcp/server.js"],
                      environment: { API_KEY: "secret" },
                      disabled: false,
-                      codemode: false,
                      timeout: { catalog: 10000 },
                    },
                    remote: {
@@ -664,7 +663,6 @@ describe("Config", () => {
                      headers: { Authorization: "Bearer token" },
                      oauth: { client_id: "client", scope: "read write", callback_port: 19876 },
                      disabled: true,
-                      codemode: false,
                      timeout: { startup: 15000 },
                    },
                  },
@@ -742,7 +740,6 @@ describe("Config", () => {
                  command: ["node", "./mcp/server.js"],
                  environment: { API_KEY: "secret" },
                  disabled: false,
-                  codemode: false,
                  timeout: { catalog: 10000 },
                },
                remote: {
@@ -751,7 +748,6 @@ describe("Config", () => {
                  headers: { Authorization: "Bearer token" },
                  oauth: { client_id: "client", scope: "read write", callback_port: 19876 },
                  disabled: true,
-                  codemode: false,
                  timeout: { startup: 15000 },
                },
              },
@@ -18,7 +18,7 @@ import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
-import { Effect, Logger } from "effect"
+import { Effect } from "effect"
 import { Database } from "../../src/database/database"
 import { tmpdir } from "../fixture/tmpdir"
 import { testEffect } from "../lib/effect"
@@ -111,15 +111,8 @@ describe("PluginSupervisor config", () => {
    ),
  )

-  it.live("logs invalid packages and continues loading", () => {
-    const output: string[] = []
-    const logger = Logger.map(Logger.formatStructured, (entry) => {
-      if (!Array.isArray(entry.message) || entry.message[0] !== "failed to load plugin") return
-      const details = entry.message[1]
-      if (typeof details !== "object" || details === null || !("target" in details)) return
-      if (typeof details.target === "string") output.push(details.target)
-    })
-    return withLocation(
+  it.live("ignores invalid packages and continues loading", () =>
+    withLocation(
      {
        plugins: [
          "-*",
@@ -137,13 +130,9 @@ describe("PluginSupervisor config", () => {
        expect(yield* agents.get(AgentV2.ID.make("configured"))).toMatchObject({
          description: "Loaded after invalid plugins",
        })
-        expect(output).toEqual([
-          path.join(import.meta.dir, "../plugin/fixtures/missing-plugin.ts"),
-          path.join(import.meta.dir, "../plugin/fixtures/invalid-plugin.ts"),
-        ])
      }),
-    ).pipe(Effect.provide(Logger.layer([logger])))
-  })
+    ),
+  )

  it.live("loads auto-discovered plugin files", () =>
    withLocation(
@@ -34,8 +34,10 @@ describe("ConfigSkillPlugin.Plugin", () => {
        return { dispose }
      })

+      const agent = host().agent
      yield* ConfigSkillPlugin.Plugin.effect(
        host({
+          agent: { ...agent, transform: () => Effect.succeed({ dispose: Effect.void }) },
          skill: { list: () => Effect.die("unused skill.list"), transform, reload: () => Effect.void },
        }),
      ).pipe(
@@ -9,10 +9,6 @@ export const emptyMcpLayer = Layer.succeed(
  MCP.Service,
  MCP.Service.of({
    servers: () => Effect.succeed([]),
-    add: () => Effect.die("unused mcp.add"),
-    connect: () => Effect.die("unused mcp.connect"),
-    disconnect: () => Effect.die("unused mcp.disconnect"),
-    remove: () => Effect.die("unused mcp.remove"),
    tools: () => Effect.succeed([]),
    callTool: () => Effect.die("unused mcp.callTool"),
    instructions: () => Effect.succeed([]),
@@ -1,5 +1,5 @@
 import { describe, expect } from "bun:test"
-import { Cause, Clock, Duration, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
+import { Cause, Duration, Effect, Exit, Fiber, Layer, Scope, Stream } from "effect"
 import * as TestClock from "effect/testing/TestClock"
 import { Credential } from "@opencode-ai/core/credential"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -414,41 +414,6 @@ describe("Integration", () => {
    }),
  )

-  it.effect("uses provider-defined OAuth attempt expirations", () =>
-    Effect.gen(function* () {
-      const integrations = yield* Integration.Service
-      const integrationID = Integration.ID.make("openai")
-      const created = yield* Clock.currentTimeMillis
-      const expirations = [
-        created + Duration.toMillis(Duration.minutes(5)),
-        created + Duration.toMillis(Duration.minutes(20)),
-      ]
-
-      yield* Effect.forEach(expirations, (expiresAt, index) => {
-        const methodID = Integration.MethodID.make(`browser-${index}`)
-        return Effect.gen(function* () {
-          yield* integrations.transform((editor) =>
-            editor.method.update({
-              integrationID,
-              method: { id: methodID, type: "oauth", label: "Browser" },
-              authorize: () =>
-                Effect.succeed({
-                  mode: "auto" as const,
-                  url: "https://example.com/authorize",
-                  instructions: "Sign in",
-                  expiresAt,
-                  callback: Effect.never,
-                }),
-            }),
-          )
-
-          const attempt = yield* integrations.oauth.connect({ integrationID, methodID, inputs: {} })
-          expect(attempt.time).toEqual({ created, expires: expiresAt })
-        })
-      })
-    }),
-  )
-
  it.effect("projects credential and env connections", () => {
    const integrationID = Integration.ID.make("acme")
    return Effect.acquireUseRelease(
@@ -18,6 +18,7 @@ import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProjectV2 } from "@opencode-ai/core/project"
 import { ProviderV2 } from "@opencode-ai/core/provider"
+import { PermissionV2 } from "@opencode-ai/core/permission"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
@@ -112,6 +113,70 @@ describe("LocationServiceMap", () => {
    ),
  )

+  it.live("allows external skill and reference directories by default", () =>
+    Effect.acquireRelease(
+      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
+      (dirs) => Effect.promise(() => Promise.all(dirs.map((dir) => dir[Symbol.asyncDispose]())).then(() => undefined)),
+    ).pipe(
+      Effect.flatMap(([project, external]) =>
+        Effect.gen(function* () {
+          const skill = path.join(external.path, "skills", "example")
+          const reference = path.join(external.path, "reference")
+          yield* Effect.promise(() =>
+            Promise.all([
+              fs.mkdir(skill, { recursive: true }),
+              fs.mkdir(reference, { recursive: true }),
+              fs.writeFile(
+                path.join(project.path, "opencode.json"),
+                JSON.stringify({
+                  skills: [path.join(external.path, "skills")],
+                  references: { docs: reference },
+                }),
+              ),
+            ]),
+          )
+          yield* Effect.promise(() =>
+            fs.writeFile(
+              path.join(skill, "SKILL.md"),
+              "---\nname: example\ndescription: Example skill.\n---\n\n# Example\n",
+            ),
+          )
+
+          const locations = yield* LocationServiceMap.Service
+          const context = locations.get(Location.Ref.make({ directory: AbsolutePath.make(project.path) }))
+          const permissions = yield* Effect.gen(function* () {
+            const supervisor = yield* PluginSupervisor.Service
+            const agents = yield* AgentV2.Service
+            yield* supervisor.flush
+            for (let attempt = 0; attempt < 100; attempt++) {
+              const build = yield* agents.resolve("build")
+              if (
+                build &&
+                PermissionV2.evaluate(
+                  "external_directory",
+                  path.join(skill, "reference", "notes.md"),
+                  build.permissions,
+                ).effect === "allow" &&
+                PermissionV2.evaluate("external_directory", path.join(reference, "notes.md"), build.permissions)
+                  .effect === "allow"
+              )
+                return build.permissions
+              yield* Effect.sleep("20 millis")
+            }
+            return (yield* agents.resolve("build"))?.permissions ?? []
+          }).pipe(Effect.scoped, Effect.provide(context))
+
+          expect(
+            PermissionV2.evaluate("external_directory", path.join(skill, "reference", "notes.md"), permissions).effect,
+          ).toBe("allow")
+          expect(
+            PermissionV2.evaluate("external_directory", path.join(reference, "notes.md"), permissions).effect,
+          ).toBe("allow")
+        }),
+      ),
+    ),
+  )
+
  itWithSdk.live("reruns activation for SDK plugins registered during startup", () =>
    Effect.acquireRelease(
      Effect.promise(() => tmpdir()),
@@ -60,19 +60,11 @@ describe("LocationMutation", () => {
    ),
  )

-  it.live("requires external-directory authorization for a relative lexical escape", () =>
+  it.live("rejects a relative lexical escape instead of promoting it to external authority", () =>
    withTmp((directory) =>
      Effect.gen(function* () {
-        const target = yield* (yield* LocationMutation.Service).resolve({ path: "../outside.txt" })
-        const root = yield* Effect.promise(() => fs.realpath(path.dirname(directory)))
-        expect(target).toMatchObject({
-          canonical: path.join(root, "outside.txt"),
-          resource: path.join(root, "outside.txt").replaceAll("\\", "/"),
-        })
-        expect(target.externalDirectory).toMatchObject({
-          directory: root,
-          resource: path.join(root, "*").replaceAll("\\", "/"),
-        })
+        const error = yield* Effect.flip((yield* LocationMutation.Service).resolve({ path: "../outside.txt" }))
+        expect(error).toMatchObject({ _tag: "LocationMutation.PathError", reason: "relative_escape" })
      }).pipe(provide(directory)),
    ),
  )
@@ -148,10 +148,7 @@ function resourceServer(
  )
 }

-function resourceMcpLayer(
-  server: string | typeof ConfigMCP.Server.Type,
-  onFormCreated?: (form: Form.Info) => Effect.Effect<void>,
-) {
+function resourceMcpLayer(url: string, onFormCreated?: (form: Form.Info) => Effect.Effect<void>) {
  const directory = AbsolutePath.make(import.meta.dir)
  const unusedIntegration = () => Effect.die("unused integration service")
  return MCP.layer.pipe(
@@ -167,12 +164,7 @@ function resourceMcpLayer(
                  type: "document",
                  info: new Config.Info({
                    mcp: new ConfigMCP.Info({
-                      servers: {
-                        resources:
-                          typeof server === "string"
-                            ? new ConfigMCP.Remote({ type: "remote", url: server, oauth: false })
-                            : server,
-                      },
+                      servers: { resources: new ConfigMCP.Remote({ type: "remote", url, oauth: false }) },
                    }),
                  }),
                }),
@@ -232,13 +224,6 @@ const mcp = Layer.mock(MCP.Service, {
          required: ["ok"],
        },
      }),
-      new MCP.Tool({
-        server: MCP.ServerName.make("direct"),
-        name: "lookup",
-        codemode: false,
-        description: "Lookup",
-        inputSchema: { type: "object", properties: {} },
-      }),
    ]),
  callTool: (input) =>
    Effect.sync(() => {
@@ -649,120 +634,6 @@ test("loads and reads MCP resources", async () => {
  )
 })

-test("adds, disconnects, and reconnects MCP servers at runtime", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "disabled" })
-          expect(yield* service.connect("missing").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-          expect(yield* service.disconnect("missing").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-          yield* service.add(
-            "dynamic",
-            new ConfigMCP.Local({
-              type: "local",
-              command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-            }),
-          )
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-
-          yield* service.add(
-            "dynamic",
-            new ConfigMCP.Local({
-              type: "local",
-              command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-              disabled: true,
-            }),
-          )
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "disabled",
-          })
-          expect(yield* service.tools()).toEqual([])
-
-          yield* service.connect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-          yield* service.disconnect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "disabled",
-          })
-          expect(yield* service.tools()).toEqual([])
-
-          yield* service.connect("dynamic")
-          expect((yield* service.servers()).find((server) => server.name === "dynamic")?.status).toEqual({
-            status: "connected",
-          })
-
-          yield* service.remove("dynamic")
-          expect((yield* service.servers()).some((server) => server.name === "dynamic")).toBe(false)
-          expect(yield* service.tools()).toEqual([])
-          expect(yield* service.remove("dynamic").pipe(Effect.flip)).toBeInstanceOf(MCP.NotFoundError)
-        }).pipe(
-          Effect.provide(
-            resourceMcpLayer(
-              new ConfigMCP.Local({
-                type: "local",
-                command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-                disabled: true,
-              }),
-            ),
-          ),
-        )
-      }),
-    ),
-  )
-})
-
-test("serializes concurrent MCP lifecycle operations", async () => {
-  await Effect.runPromise(
-    Effect.scoped(
-      Effect.gen(function* () {
-        yield* Effect.gen(function* () {
-          const service = yield* MCP.Service
-
-          // Whatever order the racing operations land in, the resulting state must be consistent.
-          yield* Effect.all(
-            [
-              service.connect("resources"),
-              service.connect("resources"),
-              service.disconnect("resources"),
-              service.connect("resources"),
-            ],
-            { concurrency: "unbounded", discard: true },
-          )
-          const status = (yield* service.servers()).find((server) => server.name === "resources")?.status
-          const tools = yield* service.tools()
-          expect(status?.status === "connected" || status?.status === "disabled").toBe(true)
-          if (status?.status === "disabled") expect(tools).toEqual([])
-          if (status?.status === "connected") expect(tools.length).toBeGreaterThan(0)
-
-          yield* service.disconnect("resources")
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "disabled" })
-          expect(yield* service.tools()).toEqual([])
-          yield* service.connect("resources")
-          expect((yield* service.servers())[0]?.status).toEqual({ status: "connected" })
-          expect((yield* service.tools()).length).toBeGreaterThan(0)
-        }).pipe(
-          Effect.provide(
-            resourceMcpLayer(
-              new ConfigMCP.Local({
-                type: "local",
-                command: [process.execPath, path.join(import.meta.dir, "fixture/mcp-output-schema.ts")],
-                disabled: true,
-              }),
-            ),
-          ),
-        )
-      }),
-    ),
-  )
-})
-
 it.effect("advertises MCP output schemas to Code Mode", () =>
  Effect.gen(function* () {
    const registry = yield* ToolRegistry.Service
@@ -773,18 +644,6 @@ it.effect("advertises MCP output schemas to Code Mode", () =>
  }),
 )

-it.effect("advertises MCP tools directly when Code Mode is disabled for the server", () =>
-  Effect.gen(function* () {
-    const registry = yield* ToolRegistry.Service
-    yield* waitForTool(registry, "direct_lookup")
-    const definitions = yield* toolDefinitions(registry)
-    const execute = definitions.find((tool) => tool.name === "execute")
-
-    expect(definitions.some((tool) => tool.name === "direct_lookup")).toBe(true)
-    expect(execute?.description).not.toContain("tools.direct.lookup")
-  }),
-)
-
 it.effect("waits for permission before calling an MCP tool", () =>
  Effect.gen(function* () {
    calls = 0
@@ -25,63 +25,12 @@ describe("Patch", () => {
    ])
  })

-  test("strips a heredoc wrapper without cat", () => {
-    expect(Patch.parse("<<EOF\n*** Begin Patch\n*** Add File: add.txt\n+added\n*** End Patch\nEOF")).toEqual([
-      { type: "add", path: "add.txt", contents: "added" },
-    ])
-  })
-
  test("derives fuzzy line updates while preserving BOM", () => {
    const update = Patch.derive("update.txt", [{ oldLines: ["  old   "], newLines: ["new"] }], "\uFEFFold\n")
    expect(update).toEqual({ content: "new\n", bom: true })
    expect(Patch.joinBom(update.content, update.bom)).toBe("\uFEFFnew\n")
  })

-  test("derives multiple update chunks", () => {
-    expect(
-      Patch.derive(
-        "update.txt",
-        [
-          { oldLines: ["line 2"], newLines: ["LINE 2"] },
-          { oldLines: ["line 4"], newLines: ["LINE 4"] },
-        ],
-        "line 1\nline 2\nline 3\nline 4\n",
-      ).content,
-    ).toBe("line 1\nLINE 2\nline 3\nLINE 4\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",
-    )
-  })
-
-  test("disambiguates updates with change context", () => {
-    expect(
-      Patch.derive(
-        "update.txt",
-        [{ oldLines: ["x=10"], newLines: ["x=11"], changeContext: "fn b" }],
-        "fn a\nx=10\nfn b\nx=10\n",
-      ).content,
-    ).toBe("fn a\nx=10\nfn b\nx=11\n")
-  })
-
-  test("matches leading, trailing, and Unicode punctuation differences", () => {
-    expect(Patch.derive("leading.txt", [{ oldLines: ["line"], newLines: ["next"] }], "  line\n").content).toBe(
-      "next\n",
-    )
-    expect(Patch.derive("trailing.txt", [{ oldLines: ["line"], newLines: ["next"] }], "line  \n").content).toBe(
-      "next\n",
-    )
-    expect(
-      Patch.derive('unicode.txt', [{ oldLines: ['He said "hello"'], newLines: ['He said "hi"'] }], 'He said “hello”\n')
-        .content,
-    ).toBe('He said "hi"\n')
-  })
-
  test("matches EOF-anchored chunks from the end", () => {
    expect(
      Patch.derive(
@@ -105,56 +54,15 @@ describe("Patch", () => {
    ])
  })

-  test("parses an initial update chunk without an explicit header", () => {
-    expect(
-      Patch.parse("*** Begin Patch\n*** Update File: file.py\n import foo\n+bar\n*** End Patch"),
-    ).toEqual([
-      {
-        type: "update",
-        path: "file.py",
-        movePath: undefined,
-        chunks: [
-          {
-            oldLines: ["import foo"],
-            newLines: ["import foo", "bar"],
-            changeContext: undefined,
-            endOfFile: undefined,
-          },
-        ],
-      },
-    ])
-  })
-
-  test("normalizes CRLF patch lines without removing content carriage returns", () => {
-    expect(
-      Patch.parse(
-        "*** Begin Patch\r\n*** Update File: file.txt\r\n@@\r\n-old\r\n+new\r\n*** End Patch\r\n",
-      ),
-    ).toEqual([
-      {
-        type: "update",
-        path: "file.txt",
-        movePath: undefined,
-        chunks: [{ oldLines: ["old"], newLines: ["new"], changeContext: undefined, endOfFile: undefined }],
-      },
-    ])
-
-    expect(
-      Patch.parse(
-        "*** Begin Patch\r\n*** Update File: file.txt\r\n@@\r\n-old\r\r\n+new\r\n*** End Patch\r\n",
-      )[0],
-    ).toMatchObject({ chunks: [{ oldLines: ["old\r"], newLines: ["new"] }] })
-  })
-
-  test("matches V1 lenient parsing of malformed hunk bodies", () => {
-    expect(Patch.parse("*** Begin Patch\n*** Add File: add.txt\nmissing plus\n*** End Patch")).toEqual([
-      { type: "add", path: "add.txt", contents: "" },
-    ])
-    expect(Patch.parse("*** Begin Patch\n*** Update File: update.txt\n*** End Patch")).toEqual([
-      { type: "update", path: "update.txt", movePath: undefined, chunks: [] },
-    ])
-    expect(Patch.parse("*** Begin Patch\n*** Delete File: delete.txt\nunexpected body\n*** End Patch")).toEqual([
-      { type: "delete", path: "delete.txt" },
-    ])
+  test("rejects malformed hunk bodies", () => {
+    expect(() => Patch.parse("*** Begin Patch\n*** Add File: add.txt\nmissing plus\n*** End Patch")).toThrow(
+      "Invalid add file line",
+    )
+    expect(() => Patch.parse("*** Begin Patch\n*** Update File: update.txt\n*** End Patch")).toThrow(
+      "expected at least one @@ chunk",
+    )
+    expect(() => Patch.parse("*** Begin Patch\n*** Delete File: delete.txt\nunexpected body\n*** End Patch")).toThrow(
+      "Invalid patch line",
+    )
  })
 })
@@ -565,22 +565,6 @@ Recent work
              text: "Partial thought",
              state: { itemId: "rs_failed", reasoningEncryptedContent: null },
            }),
-            SessionMessage.AssistantTool.make({
-              type: "tool",
-              id: "hosted-completed",
-              name: "web_search",
-              executed: true,
-              providerState: { itemId: "call_completed" },
-              providerResultState: { itemId: "result_completed" },
-              state: SessionMessage.ToolStateCompleted.make({
-                status: "completed",
-                input: { query: "Effect" },
-                content: [],
-                structured: {},
-                result: { type: "json", value: { found: true } },
-              }),
-              time: { created, completed: created },
-            }),
            SessionMessage.AssistantTool.make({
              type: "tool",
              id: "hosted-failed",
@@ -608,22 +592,6 @@ Recent work

    expect(messages[0]?.content).toEqual([
      { type: "text", text: "Partial thought" },
-      {
-        type: "tool-call",
-        id: "hosted-completed",
-        name: "web_search",
-        input: { query: "Effect" },
-        providerExecuted: true,
-        providerMetadata: { provider: { itemId: "call_completed" } },
-      },
-      {
-        type: "tool-result",
-        id: "hosted-completed",
-        name: "web_search",
-        result: { type: "json", value: { found: true } },
-        providerExecuted: true,
-        providerMetadata: { provider: { itemId: "result_completed" } },
-      },
      {
        type: "tool-call",
        id: "hosted-failed",
@@ -9,8 +9,6 @@ import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionV2 } from "@opencode-ai/core/session"
 import { ModelV2 } from "@opencode-ai/core/model"
 import { ProviderV2 } from "@opencode-ai/core/provider"
-import { RelativePath } from "@opencode-ai/core/schema"
-import { Snapshot } from "@opencode-ai/core/snapshot"
 import { createLLMEventPublisher } from "@opencode-ai/core/session/runner/publish-llm-event"

 const sessionID = SessionV2.ID.make("ses_tool_event_test")
@@ -231,8 +229,6 @@ test("content-filter finish retains failure evidence until step closeout", async
    publisher.publishStepFailure({
      cost: Money.USD.make(1.25),
      tokens: settlement.tokens,
-      snapshot: Snapshot.ID.make("tree-end"),
-      files: [RelativePath.make("src/changed.ts")],
    }),
  )
  expect(published.map((event) => event.type)).toEqual(["session.step.started.1", "session.step.failed.1"])
@@ -240,8 +236,6 @@ test("content-filter finish retains failure evidence until step closeout", async
    error: { type: "provider.content-filter", message: "Provider blocked the response" },
    cost: 1.25,
    tokens: { input: 8, output: 2, reasoning: 1 },
-    snapshot: "tree-end",
-    files: ["src/changed.ts"],
  })
 })

@@ -1892,35 +1892,6 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("records cancelled manual compaction without surfacing an internal failure", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      response = reply.text("Earlier answer", "text-manual-interrupt-history")
-      yield* admit(session, "Earlier question")
-      yield* session.resume(sessionID)
-
-      const streamed = yield* Deferred.make<void>()
-      const partial = fragmentFixture("text", "text-manual-interrupt-summary", ["Partial summary"])
-      responseStream = Stream.concat(
-        Stream.fromIterable(partial.partialEvents),
-        Stream.fromEffect(Deferred.succeed(streamed, undefined)).pipe(Stream.flatMap(() => Stream.never)),
-      )
-      const compaction = yield* session.compact({ sessionID })
-      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
-      yield* Deferred.await(streamed)
-      yield* session.interrupt(sessionID)
-
-      yield* Fiber.await(run)
-      expect(yield* SessionPending.compaction((yield* Database.Service).db, sessionID)).toBeUndefined()
-      expect((yield* session.messages({ sessionID })).find((message) => message.id === compaction.id)).toMatchObject({
-        type: "compaction",
-        status: "failed",
-        reason: "manual",
-        error: { type: "aborted", message: "Compaction cancelled" },
-      })
-    }),
-  )
-
  it.effect("settles an admitted manual compaction when pre-start resolution throws", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -4164,320 +4135,6 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("continues after malformed local tool input without exposing raw arguments", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Recover malformed tool input")
-      const marker = "raw-malformed-marker"
-      const raw = `{"text":"${marker}`
-      responses = [
-        [
-          LLMEvent.stepStart({ index: 0 }),
-          LLMEvent.toolInputStart({ id: "call-malformed", name: "echo" }),
-          LLMEvent.toolInputDelta({ id: "call-malformed", name: "echo", text: raw }),
-          LLMEvent.toolInputEnd({ id: "call-malformed", name: "echo" }),
-          LLMEvent.toolInputError({
-            id: "call-malformed",
-            name: "echo",
-            raw,
-          }),
-          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
-          LLMEvent.finish({ reason: "tool-calls" }),
-        ],
-        reply.stop(),
-      ]
-
-      yield* session.resume(sessionID)
-
-      expect(requests).toHaveLength(2)
-      expect(executions).toEqual([])
-      expect(JSON.stringify(requests[1])).not.toContain(marker)
-      expect(requests[1]?.messages).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            role: "assistant",
-            content: expect.arrayContaining([
-              expect.objectContaining({ type: "tool-call", id: "call-malformed", name: "echo", input: {} }),
-            ]),
-          }),
-          expect.objectContaining({
-            role: "tool",
-            content: expect.arrayContaining([
-              expect.objectContaining({
-                type: "tool-result",
-                id: "call-malformed",
-                result: expect.objectContaining({
-                  type: "error",
-                  value: expect.objectContaining({
-                    error: expect.objectContaining({
-                      message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON.",
-                    }),
-                  }),
-                }),
-              }),
-            ]),
-          }),
-        ]),
-      )
-      const context = yield* session.context(sessionID)
-      const failed = context.find(
-        (message): message is SessionMessage.Assistant =>
-          message.type === "assistant" && message.content.some((item) => item.type === "tool"),
-      )
-      expect(failed).toMatchObject({
-        content: [
-          {
-            type: "tool",
-            id: "call-malformed",
-            executed: false,
-            state: {
-              status: "error",
-              input: {},
-              error: {
-                type: "tool.input-json",
-                message: "Tool call arguments were malformed JSON and were not executed. Retry with valid JSON.",
-              },
-            },
-          },
-        ],
-      })
-      if (!failed) throw new Error("Malformed tool assistant missing")
-      expect(failed.error).toBeUndefined()
-      expect((yield* recordedStepSettlementEvents(sessionID, failed.id)).map((event) => event.type)).toEqual([
-        "session.step.started.1",
-        "session.tool.failed.1",
-        "session.step.ended.1",
-      ])
-      const database = (yield* Database.Service).db
-      const durable = yield* database
-        .select({ type: EventTable.type, data: EventTable.data })
-        .from(EventTable)
-        .where(eq(EventTable.aggregate_id, sessionID))
-        .all()
-        .pipe(Effect.orDie)
-      expect(durable.find((event) => event.type === "session.tool.input.ended.1")?.data).toMatchObject({
-        callID: "call-malformed",
-        text: raw,
-      })
-    }),
-  )
-
-  it.effect("settles a valid sibling before recovering malformed tool input", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Run parallel tools")
-      toolExecutionGate = yield* Deferred.make<void>()
-      toolExecutionsStarted = yield* Deferred.make<void>()
-      toolExecutionsReady = 1
-      responses = [
-        [
-          LLMEvent.stepStart({ index: 0 }),
-          LLMEvent.toolCall({ id: "call-valid", name: "echo", input: { text: "valid" } }),
-          LLMEvent.toolInputError({
-            id: "call-malformed",
-            name: "echo",
-            raw: '{"text":"partial',
-          }),
-          LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
-          LLMEvent.finish({ reason: "tool-calls" }),
-        ],
-        reply.stop(),
-      ]
-
-      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
-      yield* Deferred.await(toolExecutionsStarted)
-      expect(requests).toHaveLength(1)
-      yield* Deferred.succeed(toolExecutionGate, undefined)
-      yield* Fiber.join(run)
-      toolExecutionGate = undefined
-      toolExecutionsStarted = undefined
-
-      expect(requests).toHaveLength(2)
-      expect(executions).toEqual(["valid"])
-      const request = requests[1]
-      if (!request) throw new Error("Malformed recovery request missing")
-      expect(request.messages.flatMap((message) => (message.role === "tool" ? message.content : []))).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({ id: "call-valid", type: "tool-result" }),
-          expect.objectContaining({ id: "call-malformed", type: "tool-result" }),
-        ]),
-      )
-    }),
-  )
-
-  it.effect("does not recover malformed input after sibling execution is interrupted", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Interrupt malformed recovery")
-      toolExecutionGate = yield* Deferred.make<void>()
-      toolExecutionsStarted = yield* Deferred.make<void>()
-      toolExecutionsReady = 1
-      response = [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolCall({ id: "call-valid", name: "echo", input: { text: "blocked" } }),
-        LLMEvent.toolInputError({
-          id: "call-malformed",
-          name: "echo",
-          raw: '{"text":"partial',
-        }),
-        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
-        LLMEvent.finish({ reason: "tool-calls" }),
-      ]
-
-      const run = yield* session.resume(sessionID).pipe(Effect.forkChild)
-      yield* Deferred.await(toolExecutionsStarted)
-      while (
-        !(yield* session.context(sessionID)).some(
-          (message) =>
-            message.type === "assistant" &&
-            message.content.some((item) => item.type === "tool" && item.id === "call-malformed"),
-        )
-      )
-        yield* Effect.yieldNow
-      yield* session.interrupt(sessionID)
-      toolExecutionGate = undefined
-      toolExecutionsStarted = undefined
-
-      expect(yield* Fiber.await(run)).toMatchObject({ _tag: "Failure" })
-      expect(requests).toHaveLength(1)
-      expect(yield* session.context(sessionID)).toMatchObject([
-        { type: "user", text: "Interrupt malformed recovery" },
-        {
-          type: "assistant",
-          error: { type: "aborted", message: "Step interrupted" },
-          content: [
-            { type: "tool", id: "call-valid", state: { status: "error", error: { type: "aborted" } } },
-            { type: "tool", id: "call-malformed", state: { status: "error" } },
-          ],
-        },
-      ])
-    }),
-  )
-
-  it.effect("records malformed provider-executed input as executed", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Fail malformed hosted input")
-      const failure = new LLMError({
-        module: "test",
-        method: "stream",
-        reason: new InvalidProviderOutputReason({ message: "Invalid hosted tool input" }),
-      })
-      responseStream = Stream.fromIterable([
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolInputStart({ id: "call-hosted", name: "web_search", providerExecuted: true }),
-        LLMEvent.toolInputDelta({ id: "call-hosted", name: "web_search", text: '{"query":"partial' }),
-      ]).pipe(Stream.concat(Stream.fail(failure)))
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-      expect(requireAssistant(yield* session.context(sessionID))).toMatchObject({
-        error: { type: "provider.invalid-output", message: "Invalid hosted tool input" },
-        content: [
-          {
-            type: "tool",
-            id: "call-hosted",
-            executed: true,
-            state: { status: "error", error: { type: "provider.invalid-output" } },
-          },
-        ],
-      })
-    }),
-  )
-
-  it.effect("records a provider failure after malformed input", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Fail after malformed input")
-      const failure = new LLMError({
-        module: "test",
-        method: "stream",
-        reason: new InvalidProviderOutputReason({ message: "Provider failed after malformed input" }),
-      })
-      responseStream = Stream.fromIterable([
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolInputError({
-          id: "call-malformed",
-          name: "echo",
-          raw: '{"text":"partial',
-        }),
-      ]).pipe(Stream.concat(Stream.fail(failure)))
-
-      expect(yield* session.resume(sessionID).pipe(Effect.flip)).toBe(failure)
-      expect(requireAssistant(yield* session.context(sessionID))).toMatchObject({
-        error: { type: "provider.invalid-output", message: "Provider failed after malformed input" },
-        content: [
-          {
-            type: "tool",
-            id: "call-malformed",
-            executed: false,
-            state: { status: "error", error: { type: "tool.input-json" } },
-          },
-        ],
-      })
-      expect(requests).toHaveLength(1)
-    }),
-  )
-
-  it.effect("continues after repeated malformed tool input", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Keep producing malformed tools")
-      const malformed = (id: string) => [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolInputError({
-          id,
-          name: "echo",
-          raw: '{"text":"partial',
-        }),
-        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
-        LLMEvent.finish({ reason: "tool-calls" }),
-      ]
-      responses = [
-        malformed("call-first"),
-        reply.tool("call-valid-between", "echo", { text: "valid" }),
-        malformed("call-second"),
-        reply.stop(),
-      ]
-
-      yield* session.resume(sessionID)
-
-      expect(requests).toHaveLength(4)
-      expect(executions).toEqual(["valid"])
-      expect((yield* recordedEventTypes(sessionID)).filter((type) => type === "session.step.failed.1")).toHaveLength(0)
-    }),
-  )
-
-  it.effect("does not continue malformed tool input past the agent step limit", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      const agents = yield* AgentV2.Service
-      yield* agents.transform((editor) =>
-        editor.update(AgentV2.ID.make("build"), (agent) => {
-          agent.steps = 2
-        }),
-      )
-      yield* admit(session, "Stop malformed tools at the step limit")
-      const malformed = (id: string) => [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolInputError({
-          id,
-          name: "echo",
-          raw: '{"text":"partial',
-        }),
-        LLMEvent.stepFinish({ index: 0, reason: "tool-calls" }),
-        LLMEvent.finish({ reason: "tool-calls" }),
-      ]
-      responses = [malformed("call-first"), malformed("call-at-limit")]
-
-      yield* session.resume(sessionID)
-
-      expect(requests).toHaveLength(2)
-      expect(requests[0]?.toolChoice).toBeUndefined()
-      expect(requests[1]?.toolChoice).toMatchObject({ type: "none" })
-      expect((yield* recordedEventTypes(sessionID)).filter((type) => type === "session.tool.failed.1")).toHaveLength(2)
-    }),
-  )
-
  it.effect("does not continue automatically after a provider error follows a local tool call", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -4569,24 +4226,6 @@ describe("SessionRunnerLLM", () => {
    }),
  )

-  it.effect("preserves the provider failure when tool output persistence also fails", () =>
-    Effect.gen(function* () {
-      const session = yield* setup
-      yield* admit(session, "Storage fails while provider fails")
-      response = [
-        LLMEvent.stepStart({ index: 0 }),
-        LLMEvent.toolCall({ id: "call-store-provider-error", name: "storefail", input: {} }),
-        LLMEvent.providerError({ message: "Provider unavailable" }),
-      ]
-
-      expect(yield* session.resume(sessionID).pipe(Effect.exit)).toMatchObject({ _tag: "Failure" })
-
-      expect(requireAssistant(yield* session.context(sessionID))).toMatchObject({
-        error: { type: "provider.unknown", message: "Provider unavailable" },
-      })
-    }),
-  )
-
  it.effect("durably fails a hosted tool left unresolved at normal provider EOF", () =>
    Effect.gen(function* () {
      const session = yield* setup
@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Deferred, Effect, Exit, Fiber, Layer, Schema } from "effect"
+import { Deferred, Effect, Exit, Fiber, Layer } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { FileMutation } from "@opencode-ai/core/file-mutation"
@@ -167,7 +167,7 @@ describe("PatchTool", () => {
                )
                expect(settled.result).toEqual({
                  type: "text",
-                  value: "Success. Updated the following files:\nA nested/new.txt\nM update.txt\nD remove.txt",
+                  value: "Applied patch sequentially:\nA nested/new.txt\nM update.txt\nD remove.txt",
                })
                expect(settled.output?.structured).toMatchObject({
                  applied: [
@@ -217,7 +217,7 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("moves and updates a file", () =>
+  it.live("rejects moves before applying any hunk", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
      (tmp) => {
@@ -234,17 +234,9 @@ describe("PatchTool", () => {
                      "*** Begin Patch\n*** Add File: created.txt\n+created\n*** Update File: old.txt\n*** Move to: moved.txt\n@@\n-before\n+after\n*** End Patch",
                    ),
                  ),
-                ).toEqual({
-                  type: "text",
-                  value: "Success. Updated the following files:\nA created.txt\nM moved.txt",
-                })
-                expect(yield* exists(source)).toBe(false)
-                expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "moved.txt"), "utf8"))).toBe(
-                  "after\n",
-                )
-                expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "created.txt"), "utf8"))).toBe(
-                  "created\n",
-                )
+                ).toEqual({ type: "error", value: "patch moves are not supported yet" })
+                expect(yield* exists(path.join(tmp.path, "created.txt"))).toBe(false)
+                expect(assertions).toEqual([])
              }),
            ),
          ),
@@ -254,201 +246,6 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("moves a file over an existing destination", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        const source = path.join(tmp.path, "old.txt")
-        const destination = path.join(tmp.path, "nested", "moved.txt")
-        return Effect.promise(() =>
-          Promise.all([
-            fs.writeFile(source, "before\n"),
-            fs.mkdir(path.dirname(destination), { recursive: true }).then(() => fs.writeFile(destination, "existing\n")),
-          ]),
-        ).pipe(
-          Effect.andThen(
-            withTool(tmp.path, (registry) =>
-              Effect.gen(function* () {
-                expect(
-                  yield* executeTool(
-                    registry,
-                    call(
-                      "*** Begin Patch\n*** Update File: old.txt\n*** Move to: nested/moved.txt\n@@\n-before\n+after\n*** End Patch",
-                    ),
-                  ),
-                ).toMatchObject({ type: "text" })
-                expect(yield* exists(source)).toBe(false)
-                expect(yield* Effect.promise(() => fs.readFile(destination, "utf8"))).toBe("after\n")
-              }),
-            ),
-          ),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
-  it.live("rejects missing, invalid, and empty patches", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        return withTool(tmp.path, (registry) =>
-          Effect.gen(function* () {
-            expect(yield* executeTool(registry, call(""))).toEqual({ type: "error", value: "patchText is required" })
-            expect(yield* executeTool(registry, call("invalid patch", "invalid"))).toMatchObject({
-              type: "error",
-              value: expect.stringContaining("patch verification failed"),
-            })
-            expect(
-              yield* executeTool(registry, call("*** Begin Patch\n*** End Patch", "empty")),
-            ).toEqual({ type: "error", value: "patch rejected: empty patch" })
-            expect(
-              yield* executeTool(
-                registry,
-                call("*** Begin Patch\n*** Frobnicate File: foo\n*** End Patch", "unknown"),
-              ),
-            ).toEqual({ type: "error", value: "patch verification failed: no hunks found" })
-            expect(yield* executeTool(registry, call("   ", "whitespace"))).toMatchObject({
-              type: "error",
-              value: expect.stringContaining("patch verification failed"),
-            })
-          }),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
-  it.live("matches V1 update, BOM, heredoc, and fuzzy matching behavior", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        return withTool(tmp.path, (registry) =>
-          Effect.gen(function* () {
-            const run = (patchText: string, id: string) => executeTool(registry, call(patchText, id))
-
-            yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "multi.txt"), "a\nb\nc\nd\n"))
-            expect(
-              yield* run(
-                "*** Begin Patch\n*** Update File: multi.txt\n@@\n-b\n+B\n@@\n-d\n+D\n*** End Patch",
-                "multi",
-              ),
-            ).toMatchObject({ type: "text" })
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "multi.txt"), "utf8"))).toBe(
-              "a\nB\nc\nD\n",
-            )
-
-            const bom = "\uFEFF"
-            yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "bom.txt"), `${bom}first\nsecond\n`))
-            const bomResult = yield* settleTool(
-              registry,
-              call(
-                "*** Begin Patch\n*** Update File: bom.txt\n@@\n-second\n+changed\n*** End Patch",
-                "bom",
-              ),
-            )
-            const bomOutput = Schema.decodeUnknownSync(PatchTool.Output)(bomResult.output?.structured)
-            expect(bomOutput.files[0]?.patch).not.toContain(bom)
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "bom.txt"), "utf8"))).toBe(
-              `${bom}first\nchanged\n`,
-            )
-
-            const bomAddResult = yield* settleTool(
-              registry,
-              call(`*** Begin Patch\n*** Add File: bom-add.txt\n+${bom}first\n*** End Patch`, "bom-add"),
-            )
-            const bomAddOutput = Schema.decodeUnknownSync(PatchTool.Output)(bomAddResult.output?.structured)
-            expect(bomAddOutput.files[0]?.patch).not.toContain(bom)
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "bom-add.txt"), "utf8"))).toBe(
-              `${bom}first\n`,
-            )
-
-            yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "no-newline.txt"), "old"))
-            yield* run(
-              "*** Begin Patch\n*** Update File: no-newline.txt\n@@\n-old\n+new\n*** End Patch",
-              "no-newline",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "no-newline.txt"), "utf8"))).toBe(
-              "new\n",
-            )
-
-            yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "context.txt"), "fn a\nx=10\nfn b\nx=10\n"))
-            yield* run(
-              "*** Begin Patch\n*** Update File: context.txt\n@@ fn b\n-x=10\n+x=11\n*** End Patch",
-              "context",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "context.txt"), "utf8"))).toBe(
-              "fn a\nx=10\nfn b\nx=11\n",
-            )
-
-            yield* run(
-              "cat <<'EOF'\n*** Begin Patch\n*** Add File: heredoc.txt\n+with cat\n*** End Patch\nEOF",
-              "heredoc-cat",
-            )
-            yield* run(
-              "<<EOF\n*** Begin Patch\n*** Add File: heredoc-plain.txt\n+without cat\n*** End Patch\nEOF",
-              "heredoc-plain",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "heredoc.txt"), "utf8"))).toBe(
-              "with cat\n",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "heredoc-plain.txt"), "utf8"))).toBe(
-              "without cat\n",
-            )
-
-            yield* Effect.promise(() =>
-              Promise.all([
-                fs.writeFile(path.join(tmp.path, "leading.txt"), "  line\n"),
-                fs.writeFile(path.join(tmp.path, "trailing.txt"), "line  \n"),
-                fs.writeFile(path.join(tmp.path, "unicode.txt"), 'He said “hello”\n'),
-              ]),
-            )
-            yield* run(
-              "*** Begin Patch\n*** Update File: leading.txt\n@@\n-line\n+leading\n*** Update File: trailing.txt\n@@\n-line\n+trailing\n*** Update File: unicode.txt\n@@\n-He said \"hello\"\n+He said \"hi\"\n*** End Patch",
-              "fuzzy",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "leading.txt"), "utf8"))).toBe(
-              "leading\n",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "trailing.txt"), "utf8"))).toBe(
-              "trailing\n",
-            )
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "unicode.txt"), "utf8"))).toBe(
-              'He said "hi"\n',
-            )
-
-            yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "unchanged.txt"), "line1\nline2\n"))
-            expect(
-              yield* run(
-                "*** Begin Patch\n*** Update File: unchanged.txt\n@@\n-missing\n+changed\n*** End Patch",
-                "missing-context",
-              ),
-            ).toMatchObject({
-              type: "error",
-              value: expect.stringContaining("Failed to find expected lines"),
-            })
-            expect(yield* Effect.promise(() => fs.readFile(path.join(tmp.path, "unchanged.txt"), "utf8"))).toBe(
-              "line1\nline2\n",
-            )
-            expect(
-              yield* run(
-                "*** Begin Patch\n*** Update File: missing.txt\n@@\n-old\n+new\n*** End Patch",
-                "missing-update",
-              ),
-            ).toMatchObject({ type: "error" })
-            expect(
-              yield* run("*** Begin Patch\n*** Delete File: missing.txt\n*** End Patch", "missing-delete"),
-            ).toMatchObject({ type: "error" })
-          }),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ),
-  )
-
  it.live("approves an external directory and the batch before reading external update content", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
@@ -480,38 +277,6 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("approves a relative external target before reading update content", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
-      ([active, outside]) => {
-        reset()
-        const target = path.join(outside.path, "external.txt")
-        const relative = path.relative(active.path, target)
-        return Effect.promise(() => fs.writeFile(target, "before\n")).pipe(
-          Effect.andThen(
-            withTool(active.path, (registry) =>
-              Effect.gen(function* () {
-                expect(
-                  yield* executeTool(
-                    registry,
-                    call(`*** Begin Patch\n*** Update File: ${relative}\n@@\n-before\n+after\n*** End Patch`),
-                  ),
-                ).toMatchObject({ type: "text" })
-                expect(assertions.map((input) => input.action)).toEqual(["external_directory", "edit"])
-                expect(readsBeforeEditApproval).toBe(0)
-                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("after\n")
-              }),
-            ),
-          ),
-        )
-      },
-      ([active, outside]) =>
-        Effect.promise(() =>
-          Promise.all([active[Symbol.asyncDispose](), outside[Symbol.asyncDispose]()]).then(() => undefined),
-        ),
-    ),
-  )
-
  it.live("approves one external directory scope for multiple files under the same parent", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => Promise.all([tmpdir(), tmpdir()])),
@@ -572,7 +337,7 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("adds files by overwriting existing targets", () =>
+  it.live("rejects add hunks targeting an existing file without replacing it", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
      (tmp) => {
@@ -587,8 +352,8 @@ describe("PatchTool", () => {
                    registry,
                    call("*** Begin Patch\n*** Add File: existing.txt\n+replacement\n*** End Patch"),
                  ),
-                ).toMatchObject({ type: "text" })
-                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("replacement\n")
+                ).toEqual({ type: "error", value: "Unable to apply patch at existing.txt" })
+                expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("sentinel\n")
              }),
            ),
          ),
@@ -598,7 +363,7 @@ describe("PatchTool", () => {
    ),
  )

-  it.live("overwrites an add target that appears during permission approval", () =>
+  it.live("rejects an add target that appears during permission approval", () =>
    Effect.acquireUseRelease(
      Effect.promise(() => tmpdir()),
      (tmp) => {
@@ -612,8 +377,8 @@ describe("PatchTool", () => {
                registry,
                call("*** Begin Patch\n*** Add File: appeared.txt\n+replacement\n*** End Patch"),
              ),
-            ).toMatchObject({ type: "text" })
-            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("replacement\n")
+            ).toEqual({ type: "error", value: "Unable to apply patch at appeared.txt" })
+            expect(yield* Effect.promise(() => fs.readFile(target, "utf8"))).toBe("winner\n")
          }),
        )
      },
@@ -2,7 +2,7 @@ import fs from "fs/promises"
 import { realpathSync } from "node:fs"
 import path from "path"
 import { describe, expect, test } from "bun:test"
-import { DateTime, Deferred, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
+import { DateTime, Duration, Effect, Fiber, Layer, Scope, Stream } from "effect"
 import { Money } from "@opencode-ai/schema/money"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
@@ -166,10 +166,10 @@ const overflowCommand = (bytes: number) =>
  isWindows
    ? `[Console]::Out.Write(('x' * ${bytes})); Start-Sleep -Milliseconds 100`
    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'`
-const progressOverflowCommand = (bytes: number, release: string) =>
+const progressOverflowCommand = (bytes: number) =>
  isWindows
-    ? `[Console]::Out.Write(('x' * ${bytes})); while (!(Test-Path -LiteralPath '${release}')) { Start-Sleep -Milliseconds 50 }`
-    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'; while [ ! -e '${release}' ]; do sleep 0.05; done`
+    ? `[Console]::Out.Write(('x' * ${bytes})); Start-Sleep -Milliseconds 1500`
+    : `head -c ${bytes} /dev/zero | tr '\\0' 'x'; sleep 1.5`

 const withSession = <A, E, R>(directory: string, body: (registry: ToolRegistry.Interface) => Effect.Effect<A, E, R>) =>
  Effect.gen(function* () {
@@ -417,49 +417,33 @@ describe("ShellTool", () => {
    ),
  )

-  it.live(
-    "reports bounded output progress for a running command",
-    () =>
-      Effect.acquireUseRelease(
-        Effect.promise(() => tmpdir()),
-        (tmp) => {
-          reset()
-          const release = "shell-progress-release"
-          const releasePath = path.join(tmp.path, release)
-          return withSession(tmp.path, (registry) =>
-            Effect.gen(function* () {
-              const observed = yield* Deferred.make<ToolRegistry.Progress>()
-              yield* settleTool(registry, {
-                ...call(
-                  { command: progressOverflowCommand(ShellTool.MAX_CAPTURE_BYTES + 1024, release) },
-                  "call-progress",
-                ),
-                progress: (update) =>
-                  Effect.gen(function* () {
-                    if (update.structured.truncated !== true) return
-                    const content = update.content[0]
-                    if (content?.type !== "text") return
-                    if (content.text.indexOf("\n\n[output truncated; full output saved to:") !== ShellTool.MAX_CAPTURE_BYTES)
-                      return
-                    yield* Deferred.succeed(observed, update)
-                    yield* Effect.promise(() => fs.writeFile(releasePath, ""))
-                  }),
-              })
+  it.live("reports bounded output progress for a running command", () =>
+    Effect.acquireUseRelease(
+      Effect.promise(() => tmpdir()),
+      (tmp) => {
+        reset()
+        const bytes = ShellTool.MAX_CAPTURE_BYTES + 1024
+        return withSession(tmp.path, (registry) =>
+          Effect.gen(function* () {
+            const progress: ToolRegistry.Progress[] = []
+            yield* settleTool(registry, {
+              ...call({ command: progressOverflowCommand(bytes) }, "call-progress"),
+              progress: (update) => Effect.sync(() => progress.push(update)),
+            })

-              const progress = yield* Deferred.await(observed)
-              expect(progress.structured).toEqual({ truncated: true })
-              const content = progress.content[0]
-              expect(content?.type).toBe("text")
-              if (content?.type !== "text") return
-              expect(content.text.indexOf("\n\n[output truncated; full output saved to:")).toBe(
-                ShellTool.MAX_CAPTURE_BYTES,
-              )
-            }).pipe(Effect.ensuring(Effect.promise(() => fs.writeFile(releasePath, "")).pipe(Effect.ignore))),
-          )
-        },
-        (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-      ),
-    { timeout: 15_000 },
+            expect(progress).toHaveLength(1)
+            expect(progress[0]?.structured).toEqual({ truncated: true })
+            const content = progress[0]?.content[0]
+            expect(content?.type).toBe("text")
+            if (content?.type !== "text") return
+            expect(content.text.indexOf("\n\n[output truncated; full output saved to:")).toBe(
+              ShellTool.MAX_CAPTURE_BYTES,
+            )
+          }),
+        )
+      },
+      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
+    ),
  )

  it.live("returns a useful timeout settlement", () =>
--- a/Show More
+++ b/Show More