chore: update nix node_modules hashes

2026-08-21 00:56:45 +00:00 · 2026-08-20 07:59:11 +00:00
35 changed files with 559 additions and 1300 deletions
@@ -1,5 +0,0 @@
---
-"@opencode-ai/core": patch
---
-
-Title generation and compaction summaries now build their model requests through the shared session request boundary, gaining unsupported-media filtering and image bounds while explicitly opting out of session context hooks: plugins that shape the agent conversation do not observe title or compaction requests. Title requests gain the fork-aware session prompt cache key, and compaction summaries in forked sessions reuse the fork root's prompt cache key instead of the fork's own.
@@ -1,100 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "tool",
-      "continuation"
-    ],
-    "name": "openai-responses-websocket/continues-a-tool-call-over-one-socket",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Call get_weather once, then reply exactly: Paris is sunny.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"What is the weather in Paris?\"}]}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.function_call_arguments.delta\",\"item_id\":\"fc_ws_weather\",\"delta\":\"{\\\"city\\\":\\\"Paris\\\"}\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"function_call\",\"id\":\"fc_ws_weather\",\"call_id\":\"call_ws_weather\",\"name\":\"get_weather\",\"arguments\":\"{\\\"city\\\":\\\"Paris\\\"}\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_1\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"type\":\"function_call_output\",\"call_id\":\"call_ws_weather\",\"output\":\"{\\\"temperature\\\":22,\\\"condition\\\":\\\"sunny\\\"}\"}],\"tools\":[{\"type\":\"function\",\"name\":\"get_weather\",\"description\":\"Get current weather for a city.\",\"parameters\":{\"type\":\"object\",\"properties\":{\"city\":{\"type\":\"string\"}},\"required\":[\"city\"],\"additionalProperties\":false},\"strict\":false}],\"store\":false,\"max_output_tokens\":50,\"previous_response_id\":\"resp_ws_tool_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_tool_2\",\"delta\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_tool_2\",\"text\":\"Paris is sunny.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_tool_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Paris is sunny.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_tool_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -1,119 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "reconnect",
-      "full-context"
-    ],
-    "name": "openai-responses-websocket/reconstructs-full-context-after-reconnect",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_1\",\"delta\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_1\",\"text\":\"Alpha.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Alpha.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_reconnect_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Alpha.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Beta.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_reconnect_2\",\"delta\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_reconnect_2\",\"text\":\"Beta.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_reconnect_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Beta.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_reconnect_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -1,129 +0,0 @@
-{
-  "version": 1,
-  "metadata": {
-    "provider": "openai",
-    "protocol": "openai-responses",
-    "transport": "websocket",
-    "model": "gpt-5.5",
-    "tags": [
-      "prefix:openai-responses-websocket",
-      "provider:openai",
-      "protocol:openai-responses",
-      "transport:websocket",
-      "continuation",
-      "recovery"
-    ],
-    "name": "openai-responses-websocket/recovers-from-explicit-continuation-rejection",
-    "recordedAt": "2026-08-20T00:00:00.000Z"
-  },
-  "interactions": [
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 0,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_1\",\"delta\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_1\",\"text\":\"Ready.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_1\"}}"
-        }
-      ]
-    },
-    {
-      "transport": "websocket",
-      "connection": {
-        "sequence": 1,
-        "url": "wss://api.openai.com/v1/responses",
-        "protocols": [],
-        "close": {
-          "code": 1000,
-          "reason": ""
-        }
-      },
-      "events": [
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"previous_response_id\":\"resp_ws_rejection_1\",\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"error\",\"error\":{\"code\":\"previous_response_not_found\",\"message\":\"Previous response not found\"}}"
-        },
-        {
-          "direction": "client",
-          "kind": "text",
-          "body": "{\"type\":\"response.create\",\"model\":\"gpt-5.5\",\"input\":[{\"role\":\"system\",\"content\":\"Follow the user's exact reply instruction.\"},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Ready.\"}]},{\"type\":\"message\",\"id\":\"msg_ws_rejection_1\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Ready.\"}]},{\"role\":\"user\",\"content\":[{\"type\":\"input_text\",\"text\":\"Reply exactly: Recovered.\"}]}],\"store\":false,\"max_output_tokens\":30,\"include\":[\"reasoning.encrypted_content\"],\"reasoning\":{\"effort\":\"medium\",\"summary\":\"auto\"},\"text\":{\"verbosity\":\"low\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.created\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.added\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.delta\",\"item_id\":\"msg_ws_rejection_2\",\"delta\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_text.done\",\"item_id\":\"msg_ws_rejection_2\",\"text\":\"Recovered.\"}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.output_item.done\",\"item\":{\"type\":\"message\",\"id\":\"msg_ws_rejection_2\",\"role\":\"assistant\",\"content\":[{\"type\":\"output_text\",\"text\":\"Recovered.\"}]}}"
-        },
-        {
-          "direction": "server",
-          "kind": "text",
-          "body": "{\"type\":\"response.completed\",\"response\":{\"id\":\"resp_ws_rejection_2\"}}"
-        }
-      ]
-    }
-  ]
-}
@@ -1,216 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Stream } from "effect"
-import { Socket } from "effect/unstable/socket"
-import { LLM, LLMRequest, Message, ToolRuntime } from "../../src/index.js"
-import {
-  LLMClient,
-  WebSocketTransport,
-  type ChannelCheckpoint,
-  type ChannelObservation,
-  type WebSocketChannelExchange,
-  type WebSocketChannelExecutor,
-  type WebSocketConnection,
-} from "../../src/route.js"
-import { configure } from "../../src/providers/openai.js"
-import { decodeJson } from "../../src/protocols/shared.js"
-import { weatherRuntimeTool, weatherTool, weatherToolName } from "../recorded-scenarios.js"
-import { recordedTests } from "../recorded-test.js"
-
-const model = configure({ apiKey: process.env.OPENAI_API_KEY ?? "fixture" }).responses("gpt-5.5")
-const recorded = recordedTests({
-  prefix: "openai-responses-websocket",
-  provider: "openai",
-  protocol: "openai-responses",
-  requires: ["OPENAI_API_KEY"],
-  tags: ["transport:websocket"],
-  metadata: { transport: "websocket", model: model.id },
-})
-
-const observationFrame = (observation: ChannelObservation) => {
-  if (observation.type === "frame" || observation.type === "completed" || observation.type === "incomplete")
-    return Effect.succeed(observation.frame)
-  return Effect.fail(observation.error)
-}
-
-const terminal = (observation: ChannelObservation) => observation.type !== "frame"
-
-// This deliberately models only sequential test traffic. Core owns production connection pooling and recovery.
-const makeChannel = Effect.gen(function* () {
-  const constructor = yield* Socket.WebSocketConstructor
-  let connection: WebSocketConnection | undefined
-  let checkpoint: ChannelCheckpoint | undefined
-  let pending: ChannelCheckpoint | undefined
-  let opens = 0
-  const sent: unknown[] = []
-
-  const close = Effect.suspend(() => {
-    const current = connection
-    connection = undefined
-    return current ? current.close : Effect.void
-  })
-  yield* Effect.addFinalizer(() => close)
-
-  const executor: WebSocketChannelExecutor = {
-    execute: (exchange: WebSocketChannelExchange) =>
-      Effect.gen(function* () {
-        if (!connection) {
-          connection = yield* WebSocketTransport.open(exchange.connect).pipe(
-            Effect.provideService(Socket.WebSocketConstructor, constructor),
-          )
-          opens += 1
-        }
-        const current = connection
-        const create = yield* exchange.driver.create(checkpoint)
-        if (create.mode === "full") checkpoint = undefined
-        pending = undefined
-        sent.push(decodeJson(create.message))
-        yield* current.sendText(create.message)
-        const decoder = new TextDecoder()
-        return {
-          frames: current.messages.pipe(
-            Stream.map((message) => WebSocketTransport.messageText(message, decoder)),
-            Stream.mapEffect((frame) => exchange.driver.observe(create, frame)),
-            Stream.tap((observation) =>
-              Effect.sync(() => {
-                if (!terminal(observation)) return
-                pending = observation.type === "completed" ? observation.checkpoint : undefined
-                if (observation.type !== "completed") checkpoint = undefined
-              }),
-            ),
-            Stream.takeUntil(terminal),
-            Stream.mapEffect(observationFrame),
-          ),
-          complete: Effect.sync(() => {
-            checkpoint = pending
-            pending = undefined
-          }),
-        }
-      }),
-  }
-
-  return {
-    executor,
-    sent,
-    opens: () => opens,
-    reconnect: (preserveCheckpoint = false) =>
-      close.pipe(
-        Effect.andThen(
-          Effect.sync(() => {
-            pending = undefined
-            if (!preserveCheckpoint) checkpoint = undefined
-          }),
-        ),
-      ),
-  }
-})
-
-describe("OpenAI Responses WebSocket recorded", () => {
-  recorded.effect.with("continues a tool call over one socket", { tags: ["tool", "continuation"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_tool",
-        model,
-        system: "Call get_weather once, then reply exactly: Paris is sunny.",
-        prompt: "What is the weather in Paris?",
-        tools: [weatherTool],
-        generation: { maxTokens: 50 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const call = first.toolCalls[0]
-      if (!call) yield* Effect.die("Expected get_weather tool call")
-      const result = yield* ToolRuntime.dispatch({ [weatherToolName]: weatherRuntimeTool }, call)
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [
-            ...request.messages,
-            first.message,
-            Message.tool({ id: call.id, name: call.name, result: result.result }),
-          ],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(second.text).toBe("Paris is sunny.")
-      expect(channel.opens()).toBe(1)
-      expect(channel.sent).toHaveLength(2)
-      expect(channel.sent[1]).toMatchObject({
-        previous_response_id: expect.any(String),
-        input: [{ type: "function_call_output", call_id: call.id, output: expect.any(String) }],
-      })
-    }),
-  )
-
-  recorded.effect.with("reconstructs full context after reconnect", { tags: ["reconnect", "full-context"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_reconnect",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Alpha.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      yield* channel.reconnect()
-      const second = yield* LLMClient.generate(
-        LLMRequest.update(request, {
-          messages: [...request.messages, first.message, Message.user("Reply exactly: Beta.")],
-        }),
-        { webSocket: channel.executor },
-      )
-
-      expect(first.text).toBe("Alpha.")
-      expect(second.text).toBe("Beta.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[1]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Alpha." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Alpha." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Beta." }] },
-        ],
-      })
-    }),
-  )
-
-  recorded.effect.with("recovers from explicit continuation rejection", { tags: ["continuation", "recovery"] }, () =>
-    Effect.gen(function* () {
-      const channel = yield* makeChannel
-      const request = LLM.request({
-        id: "recorded_openai_responses_websocket_rejection",
-        model,
-        system: "Follow the user's exact reply instruction.",
-        prompt: "Reply exactly: Ready.",
-        generation: { maxTokens: 30 },
-        cache: "none",
-      })
-      const first = yield* LLMClient.generate(request, { webSocket: channel.executor })
-      const continuation = LLMRequest.update(request, {
-        messages: [...request.messages, first.message, Message.user("Reply exactly: Recovered.")],
-      })
-      yield* channel.reconnect(true)
-      const rejected = yield* LLMClient.generate(continuation, { webSocket: channel.executor }).pipe(Effect.flip)
-      const recovered = yield* LLMClient.generate(continuation, { webSocket: channel.executor })
-
-      expect(rejected).toMatchObject({
-        reason: { _tag: "Transport", delivery: "rejected", recovery: "retry-full" },
-      })
-      expect(recovered.text).toBe("Recovered.")
-      expect(channel.opens()).toBe(2)
-      expect(channel.sent[1]).toHaveProperty("previous_response_id", expect.any(String))
-      expect(channel.sent[2]).not.toHaveProperty("previous_response_id")
-      expect(channel.sent[2]).toMatchObject({
-        input: [
-          { role: "system", content: "Follow the user's exact reply instruction." },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Ready." }] },
-          { role: "assistant", content: [{ type: "output_text", text: "Ready." }] },
-          { role: "user", content: [{ type: "input_text", text: "Reply exactly: Recovered." }] },
-        ],
-      })
-    }),
-  )
-})
@@ -1,7 +1,5 @@
 import { HttpRecorder } from "@opencode-ai/http-recorder"
-import { NodeSocket } from "@effect/platform-node"
 import { Layer } from "effect"
-import { Socket } from "effect/unstable/socket"
 import * as path from "node:path"
 import { fileURLToPath } from "node:url"
 import { LLMClient, RequestExecutor } from "../src/route.js"
@@ -18,7 +16,7 @@ import {
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const FIXTURES_DIR = path.resolve(__dirname, "fixtures", "recordings")

-type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService | Socket.WebSocketConstructor
+type RecordedEnv = RequestExecutorService | LLMClientService | ImageClientService

 type RecordedTestsOptions = RecordedGroupOptions & {
  readonly options?: HttpRecorder.RecorderOptions
@@ -71,7 +69,7 @@ export const recordedTests = (options: RecordedTestsOptions) =>
        ...metadata,
      }
      if (recording) {
-        if (process.env.CI !== undefined) throw new Error("Unset CI before recording cassettes")
+        if (process.env.CI !== undefined) throw new Error("Unset CI before recording HTTP cassettes")
        HttpRecorder.removeCassetteSync(cassette, { directory: FIXTURES_DIR })
      }
      const requestExecutor = RequestExecutor.layer.pipe(
@@ -83,16 +81,10 @@ export const recordedTests = (options: RecordedTestsOptions) =>
          }),
        ),
      )
-      const webSocket = HttpRecorder.layerWebSocketConstructor(cassette, {
-        ...recorderOptions,
-        directory: FIXTURES_DIR,
-        metadata: recorderMetadata,
-      }).pipe(Layer.provide(NodeSocket.layerWebSocketConstructorWS))
      return Layer.mergeAll(
        requestExecutor,
        LLMClient.layer.pipe(Layer.provide(requestExecutor)),
        ImageClient.layer.pipe(Layer.provide(requestExecutor)),
-        webSocket,
      )
    },
  })
@@ -209,7 +209,19 @@ const layer = Layer.effect(
        small: Effect.fn("Catalog.model.small")(function* (providerID) {
          const record = state.get().providers.get(providerID)
          if (!record) return
-          const models = pipe(
+          const provider = record.provider
+
+          // TODO: Remove these provider-specific assumptions once model syncing reliably reports available deployments.
+          if (providerID === Provider.ID.azure) {
+            return
+          }
+
+          if (providerID === Provider.ID.opencode) {
+            const gpt5Nano = record.models.get(Model.ID.make("gpt-5-nano"))
+            if (gpt5Nano?.enabled && gpt5Nano.status === "active") return projectModel(gpt5Nano, provider)
+          }
+
+          const candidates = pipe(
            Array.fromIterable(record.models.values()),
            Array.filter(
              (model) =>
@@ -219,12 +231,31 @@ const layer = Layer.effect(
                model.capabilities.input.some((item) => item.startsWith("text")) &&
                model.capabilities.output.some((item) => item.startsWith("text")),
            ),
-            Array.sortWith((model) => model.time.released, Order.flip(Order.Number)),
+            Array.map((model) => ({
+              model,
+              cost: model.cost[0] ? model.cost[0].input + model.cost[0].output : 999,
+              age: (Date.now() - model.time.released) / (1000 * 60 * 60 * 24 * 30),
+              small: SMALL_MODEL_RE.test(`${model.id} ${model.family ?? ""} ${model.name}`.toLowerCase()),
+            })),
+            Array.filter((item) => item.cost > 0 && item.age <= 18),
          )
-          for (const family of SMALL_MODEL_FAMILY_PRIORITY) {
-            const selected = models.find((model) => model.family === family)
-            if (selected) return projectModel(selected, record.provider)
+
+          const pick = (items: typeof candidates) => {
+            if (!Array.isReadonlyArrayNonEmpty(items)) return
+            const maxCost = Math.max(...items.map((item) => item.cost), 0.01)
+            const maxAge = Math.max(...items.map((item) => item.age), 0.01)
+            const selected = Array.min(
+              items,
+              Order.mapInput(
+                Order.Number,
+                (item: (typeof candidates)[number]) => (item.cost / maxCost) * 0.8 + (item.age / maxAge) * 0.2,
+              ),
+            )
+            return projectModel(selected.model, provider)
          }
+
+          const small = candidates.filter((item) => item.small)
+          return pick(small.length > 0 ? small : candidates)
        }),
      },
    }
@@ -233,6 +264,6 @@ const layer = Layer.effect(
  }),
 )

-const SMALL_MODEL_FAMILY_PRIORITY = ["gemini-flash", "gpt-luna", "gpt-nano", "claude-haiku"]
+const SMALL_MODEL_RE = /\b(nano|flash|lite|mini|haiku|small|fast)\b/

 export const node = makeLocationNode({ service: Service, layer, deps: [Bus.node, Integration.node] })
@@ -5,7 +5,7 @@ import { McpEvent } from "@opencode-ai/schema/mcp-event"
 import { Command } from "@opencode-ai/schema/command"
 import { createHash } from "node:crypto"
 import { isDeepStrictEqual } from "node:util"
-import { Cause, Context, Effect, Exit, FiberSet, Latch, Layer, Schema, Scope, Stream, Types } from "effect"
+import { Cause, Context, Deferred, Effect, Exit, FiberSet, Layer, Schema, Scope, Stream, Types } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Credential } from "../credential.js"
 import { Bus } from "../bus.js"
@@ -111,7 +111,7 @@ export class ToolCallError extends Schema.TaggedError<ToolCallError>()("MCP.Tool
 type ServerEntry = {
  readonly config: Mcp.ServerConfig
  status: Status
-  readonly startup: Latch.Latch
+  readonly startup: Deferred.Deferred<void>
  scope?: Scope.Closeable
  client?: MCPClient.Connection
  tools?: ReadonlyArray<Tool>
@@ -535,7 +535,7 @@ export const layer = (options?: Options) =>
              : { status: "failed", error: error instanceof Error ? error.message : String(error) }
          yield* Effect.logWarning("mcp connect failed", { server: name, status: entry.status })
          yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
-        }).pipe(Effect.ensuring(entry.startup.open))
+        }).pipe(Effect.ensuring(Deferred.succeed(entry.startup, undefined)))

      const stopServer = Effect.fnUntraced(function* (name: ServerName, entry: ServerEntry) {
        const scope = entry.scope
@@ -562,7 +562,7 @@ export const layer = (options?: Options) =>
        const entry: ServerEntry = {
          config: serverConfig,
          status: { status: "pending" },
-          startup: Latch.makeUnsafe(),
+          startup: Deferred.makeUnsafe<void>(),
        }
        entries.set(name, entry)
        yield* Effect.gen(function* () {
@@ -575,7 +575,7 @@ export const layer = (options?: Options) =>
          yield* startServer(name, entry)
        }).pipe(
          // Settle startup even when registration fails or replacement is interrupted, so readers cannot hang.
-          Effect.ensuring(entry.startup.open),
+          Effect.ensuring(Effect.sync(() => Deferred.doneUnsafe(entry.startup, Exit.void))),
        )
      })

@@ -597,7 +597,7 @@ export const layer = (options?: Options) =>
            entries.set(name, {
              config: server,
              status: { status: "pending" },
-              startup: Latch.makeUnsafe(),
+              startup: Deferred.makeUnsafe<void>(),
            })
          }
          yield* Effect.forEach(entries, ([name, entry]) => register(name, entry), { discard: true })
@@ -607,7 +607,7 @@ export const layer = (options?: Options) =>
          for (const [name, entry] of entries) {
            if (entry.config.disabled) {
              entry.status = { status: "disabled" }
-              entry.startup.openUnsafe()
+              Deferred.doneUnsafe(entry.startup, Exit.void)
              yield* bus.publish(McpEvent.StatusChanged, { server: name }).pipe(Effect.ignore)
              continue
            }
@@ -685,7 +685,7 @@ export const layer = (options?: Options) =>

      // Suspend so each await sees current entries; a bare Map iterator is exhausted after one run.
      const whenAllReady = Effect.suspend(() =>
-        Effect.forEach(Array.from(entries.values()), (entry) => entry.startup.await, {
+        Effect.forEach(Array.from(entries.values()), (entry) => Deferred.await(entry.startup), {
          concurrency: "unbounded",
          discard: true,
        }),
@@ -734,7 +734,7 @@ export const layer = (options?: Options) =>
        }),
        callTool: Effect.fn("MCP.callTool")(function* (input) {
          const target = yield* requireServer(input.server)
-          yield* target.entry.startup.await
+          yield* Deferred.await(target.entry.startup)
          if (!target.entry.client)
            return yield* new ToolCallError({
              server: target.name,
@@ -773,7 +773,7 @@ export const layer = (options?: Options) =>
        }),
        prompt: Effect.fn("MCP.prompt")(function* (input) {
          const target = yield* requireServer(input.server)
-          yield* target.entry.startup.await
+          yield* Deferred.await(target.entry.startup)
          if (!target.entry.client) return undefined
          const result = yield* target.entry.client
            .prompt({ name: input.name, args: input.args })
@@ -827,7 +827,7 @@ export const layer = (options?: Options) =>
        }),
        readResource: Effect.fn("MCP.readResource")(function* (input) {
          const target = yield* requireServer(input.server)
-          yield* target.entry.startup.await
+          yield* Deferred.await(target.entry.startup)
          if (!target.entry.client) return undefined
          const result = yield* target.entry.client
            .readResource({ uri: input.uri })
@@ -3,7 +3,7 @@ export { Service, type Interface } from "./supervisor-service.js"

 import type { Plugin as PluginDefinition } from "@opencode-ai/plugin/effect/plugin"
 import { Event } from "@opencode-ai/schema/config"
-import { Cause, Effect, Latch, Layer, Schema, Stream } from "effect"
+import { Cause, Deferred, Effect, Layer, Schema, Stream } from "effect"
 import path from "path"
 import { pathToFileURL } from "url"
 import { ConfigPluginSource } from "../config/plugin/source.js"
@@ -137,7 +137,7 @@ export const layer = Layer.effect(
    const sdk = yield* SdkPlugins.Service
    const sources = yield* ConfigPluginSource.Service
    const bus = yield* Bus.Service
-    const ready = yield* Latch.make()
+    const ready = { current: yield* Deferred.make<void>() }
    let observed = 0

    const activate = Effect.fn("PluginSupervisor.activate")(function* () {
@@ -164,7 +164,7 @@ export const layer = Layer.effect(
      Stream.mapEffect(() =>
        Effect.gen(function* () {
          observed++
-          yield* ready.close
+          if (yield* Deferred.isDone(ready.current)) ready.current = yield* Deferred.make<void>()
          return observed
        }),
      ),
@@ -176,12 +176,12 @@ export const layer = Layer.effect(
      Stream.runForEach((target) =>
        Effect.gen(function* () {
          yield* activate()
-          if (observed === target) yield* ready.open
+          if (observed === target) yield* Deferred.succeed(ready.current, undefined)
        }).pipe(Effect.catchCause((cause) => Effect.logError("failed to reload plugins", { cause }))),
      ),
      Effect.forkScoped({ startImmediately: true }),
    )
-    return Service.of({ flush: ready.await })
+    return Service.of({ flush: Effect.suspend(() => Deferred.await(ready.current)) })
  }),
 )

@@ -1,6 +1,6 @@
 export * as SessionCompaction from "./compaction.js"

-import { LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
+import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
 import { SessionError } from "@opencode-ai/schema/session-error"
 import { Context, Effect, Layer, Stream } from "effect"
@@ -9,12 +9,17 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { llmClient } from "../effect/app-node-platform.js"
 import { SessionEvent } from "./event.js"
 import type { SessionMessage } from "./message.js"
-import { SessionModelRequest } from "./model-request.js"
+import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
+import { SessionModelHttp } from "./model-http.js"
+import { SessionPromptCacheKey } from "./prompt-cache-key.js"
+import { App } from "../app.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
 import { toSessionError } from "./to-session-error.js"
 import { Token } from "../util/token.js"
 import { SessionUsage } from "./usage.js"
+import { PluginHooks } from "../plugin/hooks.js"
 import { Agent } from "../agent.js"
 import { State } from "../state.js"

@@ -65,12 +70,13 @@ export type Draft = {
 }

 type Dependencies = {
+  readonly app: App.Info
  readonly bus: Bus.Interface
  readonly llm: {
    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
  }
  readonly models: SessionRunnerModel.Interface
-  readonly modelRequests: SessionModelRequest.Interface
+  readonly hooks: PluginHooks.Interface
 }

 export type AutoInput = {
@@ -79,8 +85,6 @@ export type AutoInput = {
  readonly resolved: SessionRunnerModel.Resolved
 }

-type RequiredInput = Pick<AutoInput, "messages" | "resolved">
-
 export type ManualInput = {
  readonly session: SessionSchema.Info
  readonly messages: readonly SessionMessage.Info[]
@@ -88,6 +92,8 @@ export type ManualInput = {
  readonly started?: boolean
 }

+type RequiredInput = Pick<AutoInput, "messages" | "resolved">
+
 type Plan = {
  readonly session: SessionSchema.Info
  readonly resolved: SessionRunnerModel.Resolved
@@ -110,19 +116,8 @@ export interface Interface extends State.Transformable<Draft> {

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

-export const truncateToolOutput = (value: string) => {
-  if (value.length <= TOOL_OUTPUT_MAX_CHARS) return value
-  let end = 0
-  for (let count = 0; count < TOOL_OUTPUT_MAX_CHARS && end < value.length; count++) {
-    const code = value.charCodeAt(end)
-    end +=
-      code >= 0xd800 && code <= 0xdbff && value.charCodeAt(end + 1) >= 0xdc00 && value.charCodeAt(end + 1) <= 0xdfff
-        ? 2
-        : 1
-  }
-  if (end === value.length) return value
-  return `${value.slice(0, end)}\n[truncated]`
-}
+const truncate = (value: string) =>
+  value.length <= TOOL_OUTPUT_MAX_CHARS ? value : `${value.slice(0, TOOL_OUTPUT_MAX_CHARS)}\n[truncated]`

 export const serializeToolContent = (content: SessionMessage.ToolStateCompleted["content"]) =>
  content
@@ -151,7 +146,7 @@ const serialize = (message: SessionMessage.Info) => {
        if (part.state.status === "completed")
          return [
            `[Assistant tool call]: ${part.name}(${input})`,
-            `[Tool result]: ${truncateToolOutput(serializeToolContent(part.state.content))}`,
+            `[Tool result]: ${truncate(serializeToolContent(part.state.content))}`,
          ]
        if (part.state.status === "error")
          return [`[Assistant tool call]: ${part.name}(${input})`, `[Tool error]: ${part.state.error.message}`]
@@ -162,8 +157,7 @@ const serialize = (message: SessionMessage.Info) => {
  if (message.type === "system") return `[System update]: ${message.text}`
  if (message.type === "synthetic") return `[Synthetic context]: ${message.text}`
  if (message.type === "skill") return `[Skill activated: ${message.name}]\n${message.text}`
-  if (message.type === "shell")
-    return `[Shell]: ${message.command}\n${truncateToolOutput(message.output?.output ?? "")}`
+  if (message.type === "shell") return `[Shell]: ${message.command}\n${truncate(message.output?.output ?? "")}`
  return ""
 }

@@ -272,51 +266,65 @@ const make = (dependencies: Dependencies) => {
          })
        : Effect.void,
    )
-    const prepared = yield* dependencies.modelRequests.prepare({
-      scope: { session: plan.session, agentID: Agent.ID.make("compaction"), model: plan.resolved },
-      transcript: { system: [], messages: [Message.user(plan.prompt)] },
-      contextHooks: false,
-    })
-    yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-      Stream.runForEach((event) => {
-        if (LLMEvent.is.providerError(event))
-          failure = {
-            type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
-            message: event.message,
-          }
-        if (LLMEvent.is.textDelta(event)) {
-          chunks.push(event.text)
-          return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
-            sessionID: plan.session.id,
-            text: event.text,
-          })
-        }
-        if (LLMEvent.is.stepFinish(event)) {
-          const step = SessionUsage.record(event.usage, plan.resolved.cost)
-          usage = usage ? SessionUsage.add(usage, step) : step
-        }
-        return Effect.void
+    const request = yield* SessionModelHook.apply(
+      dependencies.hooks,
+      { sessionID: plan.session.id, agent: Agent.ID.make("compaction"), model: plan.resolved.ref },
+      LLM.request({
+        model: plan.resolved.model,
+        promptCacheKey: SessionPromptCacheKey.make(plan.session.id),
+        http: { headers: SessionModelHeaders.make(plan.session, dependencies.app) },
+        messages: [Message.user(plan.prompt)],
+        tools: [],
      }),
-      Effect.catchTag("AI.Error", (error) =>
-        Effect.sync(() => {
-          failure = toSessionError(error)
+    )
+    yield* dependencies.llm
+      .stream(request, {
+        http: SessionModelHttp.middleware(dependencies.hooks, {
+          sessionID: plan.session.id,
+          agent: Agent.ID.make("compaction"),
+          model: plan.resolved.ref,
        }),
-      ),
-      Effect.onInterrupt(() =>
-        recordUsage.pipe(
-          Effect.andThen(
-            plan.reason === "auto"
-              ? failed({
-                  sessionID: plan.session.id,
-                  reason: plan.reason,
-                  error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
-                  inputID: plan.inputID,
-                }).pipe(Effect.asVoid)
-              : Effect.void,
+      })
+      .pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event))
+            failure = {
+              type: event.classification === "context-overflow" ? "provider.invalid-request" : "provider.error",
+              message: event.message,
+            }
+          if (LLMEvent.is.textDelta(event)) {
+            chunks.push(event.text)
+            return dependencies.bus.publish(SessionEvent.Compaction.Delta, {
+              sessionID: plan.session.id,
+              text: event.text,
+            })
+          }
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, plan.resolved.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.catchTag("AI.Error", (error) =>
+          Effect.sync(() => {
+            failure = toSessionError(error)
+          }),
+        ),
+        Effect.onInterrupt(() =>
+          recordUsage.pipe(
+            Effect.andThen(
+              plan.reason === "auto"
+                ? failed({
+                    sessionID: plan.session.id,
+                    reason: plan.reason,
+                    error: { type: "compaction.interrupted", message: "Compaction was interrupted" },
+                    inputID: plan.inputID,
+                  }).pipe(Effect.asVoid)
+                : Effect.void,
+            ),
          ),
        ),
-      ),
-    )
+      )
    yield* recordUsage
    const summary = chunks.join("")
    if (failure || !summary.trim()) {
@@ -417,13 +425,14 @@ export const layer = Layer.effect(
    const bus = yield* Bus.Service
    const llm = yield* LLMClient.Service
    const models = yield* SessionRunnerModel.Service
-    const modelRequests = yield* SessionModelRequest.Service
-    return make({ bus, llm, models, modelRequests })
+    const app = yield* App.Metadata
+    const hooks = yield* PluginHooks.Service
+    return make({ bus, llm, models, app, hooks })
  }),
 )

 export const node = makeLocationNode({
  service: Service,
  layer,
-  deps: [Bus.node, llmClient, SessionRunnerModel.node, SessionModelRequest.node],
+  deps: [Bus.node, llmClient, SessionRunnerModel.node, App.node, PluginHooks.node],
 })
@@ -61,20 +61,13 @@ interface PrepareInput {
    readonly session: SessionSchema.Info
    readonly agentID: Agent.ID
    readonly model: SessionRunnerModel.Resolved
-    /** Omitted for requests that carry no tools (title, compaction). */
-    readonly tools?: Tool.Snapshot
+    readonly tools: Tool.Snapshot
  }
  readonly transcript: {
    readonly system: Array<SystemPart>
    readonly messages: Array<Message>
  }
  readonly toolChoice?: LLM.RequestInput["toolChoice"]
-  /**
-   * Session context hooks shape the agent conversation. Requests that are not
-   * part of the conversation (title, compaction) opt out: their transcripts
-   * pass through unchanged.
-   */
-  readonly contextHooks?: false
  /** Stateful Session WebSocket channels require an explicit durable-runner opt-in. */
  readonly webSocket?: "session"
 }
@@ -216,10 +209,7 @@ export const layer = Layer.effect(
      const session = input.scope.session
      const resolved = input.scope.model
      const model = resolved.model
-      const tools = input.scope.tools ?? {
-        definitions: [],
-        execute: () => new Tool.Error({ message: "Tools are not available for this request" }),
-      }
+      const tools = input.scope.tools
      const registry = new Map(tools.definitions.map((tool) => [tool.name, tool]))
      // The definition objects we hand to hooks, mapped back to their tools. Hooks rename a
      // tool by moving its definition to a new key; recognizing the object recovers the tool.
@@ -229,18 +219,14 @@ export const layer = Layer.effect(
        ),
      )
      // Hooks mutate this record in place: edit descriptions and schemas, rename, or remove.
-      const definitions = Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition]))
-      const context =
-        input.contextHooks === false
-          ? { system: input.transcript.system, messages: input.transcript.messages, tools: definitions }
-          : yield* hooks.trigger("session", "context", {
-              sessionID: session.id,
-              agent: input.scope.agentID,
-              model: resolved.ref,
-              system: input.transcript.system,
-              messages: input.transcript.messages,
-              tools: definitions,
-            })
+      const context = yield* hooks.trigger("session", "context", {
+        sessionID: session.id,
+        agent: input.scope.agentID,
+        model: resolved.ref,
+        system: input.transcript.system,
+        messages: input.transcript.messages,
+        tools: Object.fromEntries(Array.from(given, ([definition, tool]) => [tool.name, definition])),
+      })
      // Match each surviving entry back to its tool, by recognizing a moved definition or
      // by key. Identity wins so a definition moved onto another tool's name still executes
      // the tool it describes. Entries matching neither were invented by a hook and dropped.
@@ -89,15 +89,7 @@ const classifyToolExits = (
    .flatMap((cause) => {
      if (Cause.hasInterrupts(cause)) return []
      const reasons = cause.reasons.flatMap(
-        (reason): Array<Cause.Reason<never>> =>
-          Cause.isFailReason(reason)
-            ? isDecline(reason.error)
-              ? []
-              : // A typed failure here broke the ExecuteError contract (the per-fiber
-                // `catchTag("Tool.Error")` consumes honest ones). Surfacing it as a defect
-                // keeps it from being dropped, which would leave its call unsettled forever.
-                [Cause.makeDieReason(reason.error)]
-            : [reason],
+        (reason): Array<Cause.Reason<never>> => (Cause.isFailReason(reason) ? [] : [reason]),
      )
      return reasons.length > 0 ? [Cause.fromReasons(reasons)] : []
    })
@@ -323,6 +315,7 @@ const layer = Layer.effect(
      const loaded = yield* context.load(selected)
      const { session, agent } = loaded
      const resolved = loaded.model
+      const model = resolved.model
      // Make room: history must fit the context window before the call. A pending manual
      // compaction owns this instead; the runner executes it between steps.
      const compactionInput = { session, messages: loaded.messages, resolved }
@@ -1,19 +1,21 @@
 export * as SessionTitle from "./title.js"

-import { LLMClient, AIError, LLMEvent, Message, SystemPart, type LLMRequest } from "@opencode-ai/ai"
+import { LLM, LLMClient, AIError, LLMEvent, Message, type LLMRequest } from "@opencode-ai/ai"
 import type { StreamOptions } from "@opencode-ai/ai/route"
 import { Context, DateTime, Effect, Layer, Stream } from "effect"
 import { Agent } from "../agent.js"
-import { Catalog } from "../catalog.js"
 import { Database } from "../database/database.js"
 import { Bus } from "../bus.js"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { isExactRootFallback } from "@opencode-ai/util/session-title-fallback"
+import { App } from "../app.js"
 import { llmClient } from "../effect/app-node-platform.js"
-import { Model } from "../model.js"
+import { PluginHooks } from "../plugin/hooks.js"
 import { SessionEvent } from "./event.js"
 import { SessionHistory } from "./history.js"
-import { SessionModelRequest } from "./model-request.js"
+import { SessionModelHeaders } from "./model-headers.js"
+import { SessionModelHook } from "./model-hook.js"
+import { SessionModelHttp } from "./model-http.js"
 import { SessionRunnerModel } from "./runner/model.js"
 import { SessionSchema } from "./schema.js"
 import { SessionUsage } from "./usage.js"
@@ -23,15 +25,15 @@ const MAX_LENGTH = 100
 const titleChanged = Symbol("Session title changed")

 type Dependencies = {
+  readonly app: App.Info
  readonly bus: Bus.Interface
  readonly llm: {
    readonly stream: (request: LLMRequest, options?: StreamOptions) => Stream.Stream<LLMEvent, AIError>
  }
  readonly agents: Agent.Interface
-  readonly catalog: Catalog.Interface
  readonly models: SessionRunnerModel.Interface
-  readonly modelRequests: SessionModelRequest.Interface
  readonly store: SessionStore.Interface
+  readonly hooks: PluginHooks.Interface
 }

 export interface Interface {
@@ -48,61 +50,6 @@ const isUntitled = (session: SessionSchema.Info) =>
    time: { created: DateTime.toEpochMillis(session.time.created) },
  })

-const attempt = Effect.fn("SessionTitle.attempt")(function* (
-  dependencies: Dependencies,
-  input: {
-    readonly session: SessionSchema.Info
-    readonly agent: Agent.Info
-    readonly text: string
-    readonly model: SessionRunnerModel.Resolved
-  },
-) {
-  const chunks: string[] = []
-  let failed = false
-  let usage: SessionUsage.Recorded | undefined
-  const recordUsage = Effect.suspend(() =>
-    usage
-      ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
-          sessionID: input.session.id,
-          source: "title",
-          ...usage,
-        })
-      : Effect.void,
-  )
-  const prepared = yield* dependencies.modelRequests.prepare({
-    scope: { session: input.session, agentID: input.agent.id, model: input.model },
-    transcript: {
-      system: input.agent.system ? [SystemPart.make(input.agent.system)] : [],
-      messages: [Message.user(input.text)],
-    },
-    contextHooks: false,
-  })
-  const streamed = yield* dependencies.llm.stream(prepared.request, prepared.options).pipe(
-    Stream.runForEach((event) => {
-      if (LLMEvent.is.providerError(event)) failed = true
-      if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
-      if (LLMEvent.is.stepFinish(event)) {
-        const step = SessionUsage.record(event.usage, input.model.cost)
-        usage = usage ? SessionUsage.add(usage, step) : step
-      }
-      return Effect.void
-    }),
-    Effect.as(true),
-    Effect.catchTag("AI.Error", () => Effect.succeed(false)),
-    Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
-  )
-  yield* recordUsage
-  if (!streamed || failed) return
-  return chunks
-    .join("")
-    .split("\n")
-    .map((line) => line.trim())
-    .find((line) => line.length > 0)
-})
-
-const sameModel = (left: SessionRunnerModel.Resolved, right: SessionRunnerModel.Resolved) =>
-  left.ref.providerID === right.ref.providerID && left.ref.id === right.ref.id && left.ref.variant === right.ref.variant
-
 const make = (dependencies: Dependencies) => {
  const generateForFirstPrompt = Effect.fn("SessionTitle.generateForFirstPrompt")(function* (
    db: Database.Interface["db"],
@@ -116,21 +63,64 @@ const make = (dependencies: Dependencies) => {
    if (!firstUser) return
    const agent = yield* dependencies.agents.get(Agent.ID.make("title"))
    if (!agent) return
-    const primary = yield* dependencies.models.resolve(session).pipe(Effect.catch(() => Effect.succeed(undefined)))
-    const small = agent.model || !primary ? undefined : yield* dependencies.catalog.model.small(primary.ref.providerID)
-    const preferredRef = agent.model ?? (small && Model.Ref.make({ providerID: small.providerID, id: small.id }))
-    const preferred = preferredRef
-      ? yield* dependencies.models
-          .resolve({ ...session, model: preferredRef })
-          .pipe(Effect.catch(() => Effect.succeed(undefined)))
-      : undefined
-    const selected = preferred ?? primary
-    if (!selected) return
-    const generated = yield* attempt(dependencies, { session, agent, text: firstUser.text, model: selected })
-    const fallback = primary && !sameModel(selected, primary) ? primary : undefined
-    const title =
-      generated ??
-      (fallback ? yield* attempt(dependencies, { session, agent, text: firstUser.text, model: fallback }) : undefined)
+    const resolved = yield* (
+      agent.model
+        ? dependencies.models.resolve({ ...session, model: agent.model })
+        : dependencies.models.resolve(session)
+    ).pipe(Effect.catch(() => Effect.succeed(undefined)))
+    if (!resolved) return
+    const chunks: string[] = []
+    let failed = false
+    let usage: SessionUsage.Recorded | undefined
+    const recordUsage = Effect.suspend(() =>
+      usage
+        ? dependencies.bus.publish(SessionEvent.UsageRecorded, {
+            sessionID: session.id,
+            source: "title",
+            ...usage,
+          })
+        : Effect.void,
+    )
+    const request = yield* SessionModelHook.apply(
+      dependencies.hooks,
+      { sessionID: session.id, agent: agent.id, model: resolved.ref },
+      LLM.request({
+        model: resolved.model,
+        http: { headers: SessionModelHeaders.make(session, dependencies.app) },
+        system: agent.system,
+        messages: [Message.user(firstUser.text)],
+        tools: [],
+      }),
+    )
+    const streamed = yield* dependencies.llm
+      .stream(request, {
+        http: SessionModelHttp.middleware(dependencies.hooks, {
+          sessionID: session.id,
+          agent: agent.id,
+          model: resolved.ref,
+        }),
+      })
+      .pipe(
+        Stream.runForEach((event) => {
+          if (LLMEvent.is.providerError(event)) failed = true
+          if (LLMEvent.is.textDelta(event)) chunks.push(event.text)
+          if (LLMEvent.is.stepFinish(event)) {
+            const step = SessionUsage.record(event.usage, resolved.cost)
+            usage = usage ? SessionUsage.add(usage, step) : step
+          }
+          return Effect.void
+        }),
+        Effect.as(true),
+        Effect.catchTag("AI.Error", () => Effect.succeed(false)),
+        Effect.onInterrupt(() => recordUsage.pipe(Effect.asVoid)),
+      )
+    yield* recordUsage
+    if (!streamed || failed) return
+    const title = chunks
+      .join("")
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0)
    if (!title) return
    const expectedSequence = (yield* Bus.latestSequence(db, sessionID)) + 1
    const current = yield* dependencies.store.get(sessionID)
@@ -155,12 +145,12 @@ export const layer = Layer.effect(
    const bus = yield* Bus.Service
    const llm = yield* LLMClient.Service
    const agents = yield* Agent.Service
-    const catalog = yield* Catalog.Service
    const models = yield* SessionRunnerModel.Service
-    const modelRequests = yield* SessionModelRequest.Service
    const store = yield* SessionStore.Service
    const database = yield* Database.Service
-    const title = make({ bus, llm, agents, catalog, models, modelRequests, store })
+    const app = yield* App.Metadata
+    const hooks = yield* PluginHooks.Service
+    const title = make({ bus, llm, agents, models, store, app, hooks })
    return Service.of({
      generateForFirstPrompt: (sessionID) => title.generateForFirstPrompt(database.db, sessionID),
    })
@@ -174,10 +164,10 @@ export const node = makeLocationNode({
    Bus.node,
    llmClient,
    Agent.node,
-    Catalog.node,
    SessionRunnerModel.node,
-    SessionModelRequest.node,
    SessionStore.node,
    Database.node,
+    App.node,
+    PluginHooks.node,
  ],
 })
@@ -1,7 +1,7 @@
 export * as Shell from "./shell.js"

 import path from "path"
-import { Context, Deferred, Duration, Effect, Fiber, Latch, Layer, Schema, Schedule, Stream } from "effect"
+import { Context, Deferred, Duration, Effect, Fiber, Layer, Schema, Schedule, Stream } from "effect"
 import { ChildProcess } from "effect/unstable/process"
 import { produce } from "immer"
 import { Shell } from "@opencode-ai/schema/shell"
@@ -286,7 +286,7 @@ const layer = () =>
              sessions.set(id, session)

              const stream = createWriteStream(file)
-              const outputDone = Latch.makeUnsafe()
+              const outputDone = Deferred.makeUnsafe<void>()
              const pump = handle.all.pipe(
                Stream.runForEach((chunk: Uint8Array) =>
                  Effect.sync(() => {
@@ -304,8 +304,8 @@ const layer = () =>
                        stream.end(() => resolve())
                      }),
                  )
-                  yield* outputDone.open
-                }).pipe(Effect.catch(() => outputDone.open)),
+                  yield* Deferred.succeed(outputDone, undefined)
+                }).pipe(Effect.catch(() => Deferred.succeed(outputDone, undefined))),
              )
              yield* Effect.promise(
                () =>
@@ -324,7 +324,7 @@ const layer = () =>
                    draft.time.completed = Date.now()
                  })
                  yield* beforeWait
-                  yield* outputDone.await
+                  yield* Deferred.await(outputDone)
                  // Resolve waiters with the terminal Info before any retention eviction, so an evicted
                  // session still reports success rather than the removal NotFoundError. This runs before
                  // the timeout-fiber interrupt below, which on the timeout path would otherwise cancel
@@ -2,6 +2,7 @@ export * as ShellTool from "./shell.js"

 import path from "path"
 import { ToolFailure } from "@opencode-ai/ai"
+import type { Content } from "@opencode-ai/schema/tool"
 import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin"
 import { Deferred, Effect, Schema, Scope } from "effect"
 import { Config } from "../../config.js"
@@ -71,27 +72,10 @@ const Output = Schema.Struct({

 type Output = typeof Output.Type

-const resultMessages = (output: Output) => {
-  const notice = (() => {
-    if (output.status === "running") return BACKGROUND_INSTRUCTION
-    if (output.timeout) return "Command timed out before completion."
-    if (output.exit !== undefined) return `Command exited with code ${output.exit}.`
-  })()
-  return [output.output, ...(notice ? [notice] : [])]
-}
-
-const toolResult = (output: Output) => {
-  return {
-    output,
-    content: resultMessages(output).map((text) => ({ type: "text" as const, text })),
-    metadata: {
-      status: output.status,
-      truncated: output.truncated,
-      ...(output.exit !== undefined ? { exit: output.exit } : {}),
-      ...(output.shellID !== undefined ? { shellID: output.shellID } : {}),
-      ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
-    },
-  }
+const modelOutput = (output: Output): string | undefined => {
+  if (output.status === "running") return BACKGROUND_INSTRUCTION
+  if (output.timeout) return "Command timed out before completion."
+  return `Command exited with code ${output.exit}.`
 }

 export const Plugin = {
@@ -108,50 +92,32 @@ export const Plugin = {
    const notifyWhenDone = Effect.fn("ShellTool.notifyWhenDone")(function* (
      sessionID: SessionSchema.ID,
      id: string,
-      shellID: string,
      command: string,
-      settled: Deferred.Deferred<Output>,
    ) {
      yield* runtime.job.wait({ id: id }).pipe(
-        Effect.flatMap((result) =>
-          Effect.gen(function* () {
-            const info = result.info
-            if (!info) return
-            const state =
-              info.status === "completed"
-                ? "completed"
-                : info.status === "error"
-                  ? "error"
-                  : info.status === "cancelled"
-                    ? "cancelled"
-                    : undefined
-            if (state === undefined) return
-            const output = state === "completed" ? yield* Deferred.await(settled) : undefined
-            const text = output
-              ? resultMessages(output).join("\n\n")
+        Effect.flatMap((result) => {
+          const state =
+            result.info?.status === "completed"
+              ? "completed"
+              : result.info?.status === "error"
+                ? "error"
+                : result.info?.status === "cancelled"
+                  ? "cancelled"
+                  : undefined
+          if (state === undefined) return Effect.void
+          const text =
+            state === "completed"
+              ? (result.info!.output ?? "")
              : state === "error"
-                ? (info.error ?? "Command failed")
+                ? (result.info!.error ?? "Command failed")
                : "Command cancelled"
-            yield* runtime.session.synthetic({
-              sessionID,
-              text: `<shell id="${id}" state="${state}" command="${command}">\n${text}\n</shell>`,
-              description: command,
-              metadata: {
-                source: "shell",
-                jobID: id,
-                shellID,
-                state,
-                ...(output
-                  ? {
-                      truncated: output.truncated,
-                      ...(output.exit !== undefined ? { exit: output.exit } : {}),
-                      ...(output.timeout !== undefined ? { timeout: output.timeout } : {}),
-                    }
-                  : {}),
-              },
-            })
-          }),
-        ),
+          return runtime.session.synthetic({
+            sessionID,
+            text: `<shell id="${id}" state="${state}" command="${command}">\n${text}\n</shell>`,
+            description: command,
+            metadata: { source: "shell", jobID: id, state },
+          })
+        }),
        Effect.forkIn(scope, { startImmediately: true }),
      )
    })
@@ -302,7 +268,7 @@ export const Plugin = {

              if (input.background === true) {
                yield* runtime.job.background(job.id)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
+                yield* notifyWhenDone(context.sessionID, context.id, info.command)
                return {
                  output: BACKGROUND_STARTED,
                  shellID: info.id,
@@ -316,7 +282,7 @@ export const Plugin = {
                .pipe(Effect.onInterrupt(() => runtime.job.cancel(job.id).pipe(Effect.ignore)))
              if (result?.type === "backgrounded") {
                yield* shell.timeout(info.id, 0)
-                yield* notifyWhenDone(context.sessionID, context.id, info.id, info.command, settled)
+                yield* notifyWhenDone(context.sessionID, context.id, info.command)
                return {
                  output: BACKGROUND_STARTED,
                  shellID: info.id,
@@ -330,7 +296,22 @@ export const Plugin = {

              return yield* Deferred.await(settled)
            }).pipe(
-              Effect.map(toolResult),
+              Effect.map((output) => {
+                const content: Array<Content> = [{ type: "text", text: output.output }]
+                const model = modelOutput(output)
+                if (model) content.push({ type: "text", text: model })
+                return {
+                  output,
+                  content,
+                  metadata: {
+                    status: output.status,
+                    truncated: output.truncated,
+                    ...("exit" in output && output.exit !== undefined ? { exit: output.exit } : {}),
+                    ...("shellID" in output && output.shellID !== undefined ? { shellID: output.shellID } : {}),
+                    ...("timeout" in output && output.timeout !== undefined ? { timeout: output.timeout } : {}),
+                  },
+                }
+              }),
              Effect.mapError(
                (error) => new ToolFailure({ message: `Unable to execute command: ${input.command}`, error }),
              ),
@@ -13,20 +13,7 @@ export const definition = (tool: Tool.Info<any, any>): ToolDefinition => ({
 export const execute = (tool: Tool.Info<any, any>, input: unknown, context: Tool.Context) =>
  Effect.gen(function* () {
    const decoded = yield* decodeInput(tool.input, input)
-    // Tool implementations declare `Tool.Error` but plugins can fail with anything at
-    // runtime. A foreign typed failure would slip past every `catchTag("Tool.Error")`
-    // downstream and leave its call permanently unsettled, so the declared contract is
-    // enforced here at the untrusted boundary. Declines tunnel through as defects and
-    // interrupts are not errors; neither is touched.
-    const result = yield* tool.execute(decoded, context).pipe(
-      Effect.mapError((error: unknown) =>
-        error instanceof Tool.Error
-          ? error
-          : new Tool.Error({
-              message: error instanceof globalThis.Error ? error.message : String(error),
-            }),
-      ),
-    )
+    const result = yield* tool.execute(decoded, context)
    if (tool.output === undefined) {
      if ("output" in result) return yield* Effect.die("Tool result declared output without an output schema")
      return {
@@ -1,4 +1,5 @@
 import { describe, expect } from "bun:test"
+import { Money } from "@opencode-ai/schema/money"
 import { Effect, Fiber, Layer, Stream } from "effect"
 import { TestClock } from "effect/testing"
 import { Catalog } from "@opencode-ai/core/catalog"
@@ -321,50 +322,45 @@ describe("Catalog", () => {
    }),
  )

-  it.effect("small model uses the newest release in the first matching family", () =>
+  it.effect("small model prefers small keyword candidates before cost scoring", () =>
    Effect.gen(function* () {
      const catalog = yield* Catalog.Service
      const providerID = Provider.ID.make("test")
      yield* catalog.transform((catalog) => {
        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("newer-nano"), (model) => {
-          model.family = Model.Family.make("gpt-nano")
+        catalog.model.update(providerID, Model.ID.make("cheap-large"), (model) => {
          model.capabilities.input = ["text"]
          model.capabilities.output = ["text"]
-          model.time.released = 3000
+          model.cost = [
+            {
+              input: Money.USDPerMillionTokens.make(1),
+              output: Money.USDPerMillionTokens.make(1),
+              cache: {
+                read: Money.USDPerMillionTokens.zero,
+                write: Money.USDPerMillionTokens.zero,
+              },
+            },
+          ]
+          model.time.released = Date.now()
        })
-        catalog.model.update(providerID, Model.ID.make("older-luna"), (model) => {
-          model.family = Model.Family.make("gpt-luna")
+        catalog.model.update(providerID, Model.ID.make("expensive-mini"), (model) => {
          model.capabilities.input = ["text"]
          model.capabilities.output = ["text"]
-          model.time.released = 1000
-        })
-        catalog.model.update(providerID, Model.ID.make("newer-luna"), (model) => {
-          model.family = Model.Family.make("gpt-luna")
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-          model.time.released = 2000
+          model.cost = [
+            {
+              input: Money.USDPerMillionTokens.make(10),
+              output: Money.USDPerMillionTokens.make(10),
+              cache: {
+                read: Money.USDPerMillionTokens.zero,
+                write: Money.USDPerMillionTokens.zero,
+              },
+            },
+          ]
+          model.time.released = Date.now()
        })
      })

-      expect((yield* catalog.model.small(providerID))?.id).toBe(Model.ID.make("newer-luna"))
-    }),
-  )
-
-  it.effect("small model returns undefined without a matching family", () =>
-    Effect.gen(function* () {
-      const catalog = yield* Catalog.Service
-      const providerID = Provider.ID.make("test")
-      yield* catalog.transform((catalog) => {
-        catalog.provider.update(providerID, () => {})
-        catalog.model.update(providerID, Model.ID.make("large"), (model) => {
-          model.family = Model.Family.make("gpt")
-          model.capabilities.input = ["text"]
-          model.capabilities.output = ["text"]
-        })
-      })
-
-      expect(yield* catalog.model.small(providerID)).toBeUndefined()
+      expect((yield* catalog.model.small(providerID))?.id).toMatch("expensive-mini")
    }),
  )
 })
@@ -516,7 +516,6 @@ describe("OpencodePlugin", () => {
          model.time.released = Date.now()
        })
        catalog.model.update(providerID, Model.ID.make("gpt-5-nano"), (model) => {
-          model.family = Model.Family.make("gpt-nano")
          model.capabilities.input = ["text"]
          model.capabilities.output = ["text"]
          model.cost = [...cost(10, 10)]
@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { LLMClient, LLMEvent, LanguageModel, SystemPart, type LLMRequest } from "@opencode-ai/ai"
+import { LLMClient, LLMEvent, LanguageModel, type LLMRequest } from "@opencode-ai/ai"
 import { OpenAIChat } from "@opencode-ai/ai/protocols"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
@@ -19,7 +19,6 @@ import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { App } from "@opencode-ai/core/app"
 import { Agent } from "@opencode-ai/core/agent"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { Location } from "@opencode-ai/core/location"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Money } from "@opencode-ai/schema/money"
@@ -77,14 +76,7 @@ const models = Layer.mock(SessionRunnerModel.Service)({
 })
 const it = testEffect(
  AppNodeBuilder.build(
-    LayerNode.group([
-      Database.node,
-      Bus.node,
-      SessionProjector.node,
-      SessionStore.node,
-      PluginHooks.node,
-      SessionCompaction.node,
-    ]),
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, SessionCompaction.node]),
    [
      [Bus.node, Bus.configured({ persist: true })],
      [llmClient, client],
@@ -118,13 +110,6 @@ test("compaction describes tool media without embedding base64", () => {
  expect(serialized).not.toContain(base64)
 })

-test("compaction truncation does not split surrogate pairs", () => {
-  const prefix = "a".repeat(1_999)
-
-  expect(SessionCompaction.truncateToolOutput(`${prefix}😀suffix`)).toBe(`${prefix}😀\n[truncated]`)
-  expect(SessionCompaction.truncateToolOutput("😀".repeat(2_000))).toBe("😀".repeat(2_000))
-})
-
 test("compaction prompt requires the checkpoint headings in order", () => {
  const prompt = SessionCompaction.buildPrompt({ context: ["Conversation history"] })
  expect(prompt.match(/^#{2,3} .+$/gm)).toEqual([
@@ -189,35 +174,6 @@ it.effect("auto compaction reserves a buffer below the prompt ceiling", () =>
  }),
 )

-/** Seeds the global project plus one session row, returning the projected session. */
-const insertSession = (id: Session.ID, overrides?: Partial<typeof SessionTable.$inferInsert>) =>
-  Effect.gen(function* () {
-    const db = (yield* Database.Service).db
-    yield* db
-      .insert(ProjectTable)
-      .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
-      .onConflictDoNothing()
-      .run()
-      .pipe(Effect.orDie)
-    yield* db
-      .insert(SessionTable)
-      .values({
-        id,
-        project_id: Project.ID.global,
-        slug: id,
-        directory: "/project",
-        title: id,
-        version: "test",
-        ...overrides,
-      })
-      .run()
-      .pipe(Effect.orDie)
-    const store = yield* SessionStore.Service
-    return yield* store
-      .get(id)
-      .pipe(Effect.flatMap((session) => (session ? Effect.succeed(session) : Effect.die(`session missing: ${id}`))))
-  })
-
 it.effect("manual compaction summarizes short context instead of no-op", () =>
  Effect.gen(function* () {
    requests = []
@@ -233,7 +189,33 @@ it.effect("manual compaction summarizes short context instead of no-op", () =>
      text: "Manual compaction should include this short conversation.",
      time: { created: DateTime.makeUnsafe(0) },
    }
-    const session = yield* insertSession(sessionID, { parent_id: parentID })
+    yield* db
+      .insert(ProjectTable)
+      .values({ id: Project.ID.global, worktree: AbsolutePath.make("/project"), sandboxes: [] })
+      .onConflictDoNothing()
+      .run()
+      .pipe(Effect.orDie)
+    yield* db
+      .insert(SessionTable)
+      .values({
+        id: sessionID,
+        project_id: Project.ID.global,
+        parent_id: parentID,
+        slug: "manual-compaction",
+        directory: "/project",
+        title: "Manual compaction",
+        version: "test",
+      })
+      .run()
+      .pipe(Effect.orDie)
+
+    const session = yield* store
+      .get(sessionID)
+      .pipe(
+        Effect.flatMap((session) =>
+          session ? Effect.succeed(session) : Effect.die("manual compaction test session missing"),
+        ),
+      )

    const delta = yield* bus
      .subscribe(SessionEvent.Compaction.Delta)
@@ -283,66 +265,3 @@ it.effect("manual compaction summarizes short context instead of no-op", () =>
    ])
  }),
 )
-
-it.effect("forked session compaction reuses the fork root prompt cache key", () =>
-  Effect.gen(function* () {
-    requests = []
-    const compaction = yield* SessionCompaction.Service
-    const sessionID = Session.ID.make("ses_fork_compaction")
-    const rootID = Session.ID.make("ses_fork_compaction_root")
-    const session = yield* insertSession(sessionID, {
-      fork_session_id: rootID,
-      fork_boundary: { type: "before", messageID: SessionMessage.ID.create() },
-    })
-    expect(
-      yield* compaction.compactManual({
-        session,
-        messages: [
-          {
-            id: SessionMessage.ID.create(),
-            type: "user",
-            text: "Summarize the forked conversation.",
-            time: { created: DateTime.makeUnsafe(0) },
-          },
-        ],
-        inputID: SessionMessage.ID.make("msg_fork_compaction"),
-      }),
-    ).toEqual({ status: "completed" })
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.promptCacheKey).toBe(rootID)
-  }),
-)
-
-it.effect("keeps session context hooks away from compaction requests", () =>
-  Effect.gen(function* () {
-    requests = []
-    const compaction = yield* SessionCompaction.Service
-    // Context hooks shape the agent conversation; compaction is not part of it,
-    // so it opts out and the transcript passes through unchanged.
-    const hooks = yield* PluginHooks.Service
-    yield* hooks.register("session", "context", (event) =>
-      Effect.sync(() => {
-        event.system.push(SystemPart.make("Injected conversation context"))
-      }),
-    )
-    const session = yield* insertSession(Session.ID.make("ses_hook_compaction"))
-    expect(
-      yield* compaction.compactManual({
-        session,
-        messages: [
-          {
-            id: SessionMessage.ID.create(),
-            type: "user",
-            text: "Summarize this conversation.",
-            time: { created: DateTime.makeUnsafe(0) },
-          },
-        ],
-        inputID: SessionMessage.ID.make("msg_hook_compaction"),
-      }),
-    ).toEqual({ status: "completed" })
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.system).toEqual([])
-  }),
-)
@@ -1,8 +1,7 @@
-import { beforeEach, expect } from "bun:test"
-import { LLMClient, LLMEvent, LanguageModel, SystemPart, type LLMRequest } from "@opencode-ai/ai"
+import { expect } from "bun:test"
+import { LLMClient, LLMEvent, LanguageModel, type LLMRequest } from "@opencode-ai/ai"
 import { OpenAIChat } from "@opencode-ai/ai/protocols"
 import { Agent } from "@opencode-ai/core/agent"
-import { Catalog } from "@opencode-ai/core/catalog"
 import { Database } from "@opencode-ai/core/database/database"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { llmClient } from "@opencode-ai/core/effect/app-node-platform"
@@ -15,30 +14,21 @@ import { SessionRunnerModel } from "@opencode-ai/core/session/runner/model"
 import { SessionTable } from "@opencode-ai/core/session/sql"
 import { SessionStore } from "@opencode-ai/core/session/store"
 import { SessionTitle } from "@opencode-ai/core/session/title"
-import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { Session } from "@opencode-ai/core/session"
 import { Project } from "@opencode-ai/core/project"
 import { ProjectTable } from "@opencode-ai/core/project/sql"
 import { App } from "@opencode-ai/core/app"
-import { Model } from "@opencode-ai/core/model"
-import { Provider } from "@opencode-ai/core/provider"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Money } from "@opencode-ai/schema/money"
 import { Deferred, Effect, Fiber, Layer, Stream } from "effect"
 import { testEffect } from "./lib/effect"

 let requests: LLMRequest[] = []
-let selectedSmall: Model.Info | undefined
 const model = LanguageModel.make({
  id: "title-model",
  provider: "test",
  route: OpenAIChat.route,
 })
-const smallModel = LanguageModel.make({
-  id: "title-small",
-  provider: "test",
-  route: OpenAIChat.route,
-})
 const cost = [
  {
    input: Money.USDPerMillionTokens.make(1),
@@ -77,43 +67,20 @@ const client = Layer.mock(LLMClient.Service)({
  generate: () => Effect.die("unused"),
 })
 const models = Layer.mock(SessionRunnerModel.Service)({
-  resolve: (session) =>
+  resolve: () =>
    Effect.succeed(
-      SessionRunnerModel.resolved(session.model?.id === "title-small" ? smallModel : model, {
+      SessionRunnerModel.resolved(model, {
        capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
        cost,
        limit: { context: 200_000, output: 32_000 },
      }),
    ),
 })
-const catalog = Layer.mock(Catalog.Service, {
-  provider: {
-    get: () => Effect.die("unused"),
-    all: () => Effect.die("unused"),
-    available: () => Effect.die("unused"),
-  },
-  model: {
-    get: () => Effect.die("unused"),
-    all: () => Effect.die("unused"),
-    available: () => Effect.die("unused"),
-    default: () => Effect.die("unused"),
-    small: () => Effect.succeed(selectedSmall),
-  },
-})
 const it = testEffect(
  AppNodeBuilder.build(
-    LayerNode.group([
-      Database.node,
-      Bus.node,
-      SessionProjector.node,
-      SessionStore.node,
-      Agent.node,
-      PluginHooks.node,
-      SessionTitle.node,
-    ]),
+    LayerNode.group([Database.node, Bus.node, SessionProjector.node, SessionStore.node, Agent.node, SessionTitle.node]),
    [
      [llmClient, client],
-      [Catalog.node, catalog],
      [SessionRunnerModel.node, models],
    ],
  ),
@@ -159,18 +126,6 @@ const prompt = (sessionID: Session.ID, text: string) =>
    })
  })

-const small = Model.Info.make({
-  ...Model.Info.default(Provider.ID.make("test"), Model.ID.make("title-small")),
-  family: Model.Family.make("gpt-nano"),
-  capabilities: { tools: false, input: ["text"], output: ["text"] },
-})
-
-beforeEach(() => {
-  requests = []
-  selectedSmall = undefined
-  titleStream = successfulTitle
-})
-
 it.effect("generates a title from the sole user message and renames the session", () =>
  Effect.gen(function* () {
    requests = []
@@ -200,9 +155,6 @@ it.effect("generates a title from the sole user message and renames the session"
      "x-opencode-session": sessionID,
      "x-opencode-client": "opencode",
    })
-    expect(requests[0]?.promptCacheKey).toBe(sessionID)
-    expect(requests[0]?.tools).toEqual([])
-    expect(requests[0]?.system.map((part) => part.text)).toEqual(["You are a title generator."])
    expect(JSON.stringify(requests[0]?.messages)).toContain("Help me debug the failing build")
    const renamed = yield* store.get(sessionID)
    expect(renamed?.title).toBe("Generated Title")
@@ -211,61 +163,6 @@ it.effect("generates a title from the sole user message and renames the session"
  }),
 )

-it.effect("uses a small model from the primary provider", () =>
-  Effect.gen(function* () {
-    requests = []
-    titleStream = successfulTitle
-    selectedSmall = small
-    const agentService = yield* Agent.Service
-    yield* agentService.transform((editor) => {
-      editor.update(Agent.ID.make("title"), (agent) => {
-        agent.mode = "primary"
-        agent.hidden = true
-        agent.system = "You are a title generator."
-      })
-    })
-    const sessionID = Session.ID.make("ses_title_small_model")
-    yield* insertSession(sessionID)
-    yield* prompt(sessionID, "Use a small model for this title")
-
-    const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(sessionID)
-
-    expect(requests.map((request) => String(request.model.id))).toEqual(["title-small"])
-    const store = yield* SessionStore.Service
-    expect((yield* store.get(sessionID))?.title).toBe("Generated Title")
-  }),
-)
-
-it.effect("falls back to the primary model when the small model fails", () =>
-  Effect.gen(function* () {
-    requests = []
-    titleStream = () =>
-      requests.length === 1
-        ? Stream.make(LLMEvent.providerError({ message: "Small model unavailable" }))
-        : successfulTitle()
-    selectedSmall = small
-    const agentService = yield* Agent.Service
-    yield* agentService.transform((editor) => {
-      editor.update(Agent.ID.make("title"), (agent) => {
-        agent.mode = "primary"
-        agent.hidden = true
-        agent.system = "You are a title generator."
-      })
-    })
-    const sessionID = Session.ID.make("ses_title_small_fallback")
-    yield* insertSession(sessionID)
-    yield* prompt(sessionID, "Fall back when title generation fails")
-
-    const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(sessionID)
-
-    expect(requests.map((request) => String(request.model.id))).toEqual(["title-small", "title-model"])
-    const store = yield* SessionStore.Service
-    expect((yield* store.get(sessionID))?.title).toBe("Generated Title")
-  }),
-)
-
 it.effect("generates from the first user message after later messages exist", () =>
  Effect.gen(function* () {
    requests = []
@@ -426,38 +323,6 @@ it.effect("retries after a failed title request", () =>
  }),
 )

-it.effect("keeps session context hooks away from title requests", () =>
-  Effect.gen(function* () {
-    requests = []
-    titleStream = successfulTitle
-    const agentService = yield* Agent.Service
-    yield* agentService.transform((editor) => {
-      editor.update(Agent.ID.make("title"), (agent) => {
-        agent.mode = "primary"
-        agent.hidden = true
-        agent.system = "You are a title generator."
-      })
-    })
-    // Context hooks shape the agent conversation; title generation is not part of
-    // it, so it opts out and the transcript passes through unchanged.
-    const hooks = yield* PluginHooks.Service
-    yield* hooks.register("session", "context", (event) =>
-      Effect.sync(() => {
-        event.system.push(SystemPart.make("Keep titles in sentence case."))
-      }),
-    )
-    const sessionID = Session.ID.make("ses_title_context_hook")
-    yield* insertSession(sessionID)
-    yield* prompt(sessionID, "Hook this title request")
-
-    const title = yield* SessionTitle.Service
-    yield* title.generateForFirstPrompt(sessionID)
-
-    expect(requests).toHaveLength(1)
-    expect(requests[0]?.system.map((part) => part.text)).toEqual(["You are a title generator."])
-  }),
-)
-
 it.effect("preserves a manual rename completed while generation is in flight", () =>
  Effect.gen(function* () {
    requests = []
@@ -94,24 +94,6 @@ test("declared outputs cannot bypass validation and raw outputs stay JSON-compat
  )
 })

-test("foreign typed failures settle as Tool.Error at the untrusted boundary", async () => {
-  class ForeignFailure extends Schema.TaggedError<ForeignFailure>()("Plugin.ForeignFailure", {
-    message: Schema.String,
-  }) {}
-  const lying: Info = {
-    name: "lying",
-    description: "Fails with a non-Tool.Error typed failure",
-    input: Schema.Struct({}),
-    execute: () => new ForeignFailure({ message: "transport died" }) as never,
-  }
-
-  const exit = await Effect.runPromiseExit(execute(lying, {}, context))
-  expect(exit._tag).toBe("Failure")
-  const error = exit._tag === "Failure" ? exit.cause.reasons.find((reason) => "error" in reason)?.error : undefined
-  expect(error).toBeInstanceOf(Tool.Error)
-  expect((error as Tool.Error).message).toBe("transport died")
-})
-
 test("execute supports callable namespace tools", async () => {
  const callable: Info = {
    name: "admin",
@@ -760,52 +760,10 @@ describe("ShellTool", () => {
            expect((yield* shell.list()).map((info) => info.id)).toContain(id)
            expect((yield* shell.wait(id)).status).toBe("timeout")
            expect((yield* Fiber.join(admitted)).valueOrUndefined?.data.item.payload).toMatchObject({
-              text: expect.stringContaining("Command timed out before completion."),
              description: idleCommand,
              metadata: {
                source: "shell",
-                shellID,
                state: "completed",
-                timeout: true,
-                truncated: false,
-              },
-            })
-          }),
-        )
-      },
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]().then(() => undefined)),
-    ),
-  )
-
-  it.live("preserves a background command's non-zero exit", () =>
-    Effect.acquireUseRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => {
-        reset()
-        return withSession(tmp.path, (registry) =>
-          Effect.gen(function* () {
-            const bus = yield* Bus.Service
-            const admitted = yield* bus.subscribe(SessionEvent.InboxEnqueued).pipe(
-              Stream.filter((event) => event.data.sessionID === sessionID && event.data.item.type === "synthetic"),
-              Stream.runHead,
-              Effect.forkScoped({ startImmediately: true }),
-            )
-            const settled = yield* executeTool(
-              registry,
-              call({ command: bodyExitCommand, background: true }, "call-background-nonzero"),
-            )
-            const shellID = settled.metadata?.shellID
-            expect(typeof shellID).toBe("string")
-            expect((yield* Fiber.join(admitted)).valueOrUndefined?.data.item.payload).toMatchObject({
-              text: expect.stringContaining("Command exited with code 7."),
-              description: bodyExitCommand,
-              metadata: {
-                source: "shell",
-                jobID: "call-background-nonzero",
-                shellID,
-                state: "completed",
-                exit: 7,
-                truncated: false,
              },
            })
          }),
@@ -31,11 +31,8 @@ interface PendingRecordings {
 }
 type Frame = string | Uint8Array

-const normalizeProtocols = (protocols: unknown): Array<string> => {
-  if (typeof protocols === "string") return [protocols]
-  if (Array.isArray(protocols)) return protocols.filter((protocol): protocol is string => typeof protocol === "string")
-  return []
-}
+const normalizeProtocols = (protocols?: string | Array<string>): Array<string> =>
+  protocols === undefined ? [] : typeof protocols === "string" ? [protocols] : [...protocols]
 const frameFromWebSocketData = async (data: unknown): Promise<Frame> => {
  if (typeof data === "string") return data
  if (data instanceof Blob) return new Uint8Array(await data.arrayBuffer())
@@ -374,7 +371,7 @@ const makeRecordingWebSocketConstructor = (
  return (url, protocols) => {
    const sequence = nextSequence++
    const requestedProtocols = normalizeProtocols(protocols)
-    const native = Reflect.apply(upstream, undefined, [url, protocols])
+    const native = upstream(url, requestedProtocols)
    const events: WebSocketEvent[] = []
    let opened = false
    let failed = false
@@ -80,38 +80,6 @@ describe("WebSocket", () => {
    ])
  })

-  test("constructor recording forwards handshake options", async () => {
-    using directory = tempDirectory("http-recorder-websocket-constructor-")
-    let received: unknown
-    const recorder = HttpRecorder.layerWebSocketConstructor("websocket/constructor-options", {
-      directory: directory.path,
-    }).pipe(
-      Layer.provide(
-        Layer.succeed(Socket.WebSocketConstructor, (url, options) => {
-          received = options
-          // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- the fixture implements the WebSocket surface used by the recorder.
-          return new EchoWebSocket(url) as unknown as globalThis.WebSocket
-        }),
-      ),
-    )
-
-    await Effect.runPromise(
-      Effect.gen(function* () {
-        const constructor = yield* Socket.WebSocketConstructor
-        const options = { headers: { authorization: "Bearer fixture" } }
-        const socket = Reflect.apply(constructor, undefined, ["wss://echo.example.test/options", options])
-        yield* Effect.callback<void>((resume) => {
-          socket.addEventListener("open", () => {
-            socket.close()
-            resume(Effect.void)
-          })
-        })
-      }).pipe(Effect.scoped, Effect.provide(recorder)),
-    )
-
-    expect(received).toEqual({ headers: { authorization: "Bearer fixture" } })
-  })
-
  test("constructor replay validates dynamic URLs and protocols without opening a live socket", async () => {
    using directory = tempDirectory("http-recorder-websocket-constructor-")
    await seedCassetteDirectory(directory.path, "websocket/constructor", [
@@ -3,7 +3,7 @@ export * as ServerProcess from "./process"
 import { NodeHttpServer } from "@effect/platform-node"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
-import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect"
+import { Cause, Context, Deferred, Effect, Exit, Layer, Option, Ref, Scope } from "effect"
 import { HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { createServer } from "node:http"
 import { ServerAuth } from "./auth"
@@ -47,7 +47,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
  if (!password) return yield* Effect.fail(new Error("Missing server password"))
  const hostname = options.hostname ?? "127.0.0.1"
  const port = Option.fromNullishOr(options.port)
-  const shutdown = yield* Latch.make()
+  const shutdown = yield* Deferred.make<void>()
  const status = yield* Status.make()
  const bound = yield* listen({ hostname, port })
  const application = yield* Ref.make(Option.none<App>())
@@ -61,7 +61,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
    )
    .pipe(withoutParentSpan)
  if (lifecycle)
-    yield* lifecycle.onListen(bound.http.address, shutdown.open.pipe(Effect.asVoid)).pipe(
+    yield* lifecycle.onListen(bound.http.address, Deferred.succeed(shutdown, undefined).pipe(Effect.asVoid)).pipe(
      Effect.flatMap((cleanup) =>
        Effect.addFinalizer(() => Scope.close(bound.scope, Exit.void).pipe(Effect.andThen(cleanup))),
      ),
@@ -101,7 +101,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
    const app = Context.get(context, HttpRouter.HttpRouter).asHttpEffect()
    yield* Ref.set(application, Option.some(transform ? transform(app) : app))
    yield* status.ready
-    return { address: bound.http.address, shutdown: shutdown.await }
+    return { address: bound.http.address, shutdown: Deferred.await(shutdown) }
  }).pipe(
    Effect.catchCause((cause) => {
      if (!lifecycle || Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause)
@@ -119,7 +119,7 @@ export const start = Effect.fn("ServerProcess.start")(function* <E, R>(
    }),
  )
  if (!lifecycle) return yield* boot
-  return yield* Effect.raceFirst(boot, shutdown.await.pipe(Effect.andThen(Effect.interrupt)))
+  return yield* Effect.raceFirst(boot, Deferred.await(shutdown).pipe(Effect.andThen(Effect.interrupt)))
 })

 function listen(options: { readonly hostname: string; readonly port: Option.Option<number> }) {
@@ -59,6 +59,11 @@
      "node": "./src/attention-sounds.node.ts",
      "default": "./src/attention-sounds.bun.ts"
    },
+    "#terminal-win32": {
+      "bun": "./src/terminal-win32.bun.ts",
+      "node": "./src/terminal-win32.node.ts",
+      "default": "./src/terminal-win32.bun.ts"
+    },
    "#string-width": {
      "bun": "./src/util/string-width.bun.ts",
      "node": "./src/util/string-width.node.ts",
@@ -1,6 +1,6 @@
 import { render, useRenderer, useTerminalDimensions } from "@opentui/solid"
 import { registerOpencodeSpinner } from "./component/register-spinner"
-import { Effect, Latch } from "effect"
+import { Deferred, Effect } from "effect"
 import { Service, type Endpoint } from "@opencode-ai/client/effect/service"
 import { OpenCode, type SessionInfo } from "@opencode-ai/client"
 import { Global } from "@opencode-ai/util/global"
@@ -96,6 +96,7 @@ import { CommandPaletteDialog } from "./component/command-palette"
 import { COMMAND_PALETTE_COMMAND, Keymap, type KeymapCommand } from "./context/keymap"

 import { DialogVariant } from "./component/dialog-variant"
+import { win32DisableProcessedInput, win32FlushInputBuffer } from "./terminal-win32"
 import { destroyRenderer } from "./util/renderer"
 import { cliErrorMessage, errorFormat } from "./util/error"
 import { AttentionProvider } from "./context/attention"
@@ -265,6 +266,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
            Effect.catch((error) => Effect.sync(() => log("error", "Failed to dispose TUI clipboard", { error }))),
          ),
      )
+      win32DisableProcessedInput()
      const finalizers = new Set<() => Promise<void>>()
      yield* Effect.addFinalizer(() =>
        Effect.promise(async () => {
@@ -274,13 +276,13 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
            .forEach((result) => log("error", "Failed to dispose TUI resource", { error: result.reason }))
        }),
      )
-      const shutdown = yield* Latch.make()
+      const shutdown = yield* Deferred.make<unknown>()
      const onSighup = () => destroyRenderer(renderer)
      yield* Effect.acquireRelease(
        Effect.sync(() => process.on("SIGHUP", onSighup)),
        () => Effect.sync(() => process.off("SIGHUP", onSighup)),
      )
-      renderer.once("destroy", () => shutdown.openUnsafe())
+      renderer.once("destroy", () => Deferred.doneUnsafe(shutdown, Effect.void))
      yield* Effect.tryPromise(async () => {
        // Prewarm palette before ThemeProvider mounts so `system` theme avoids a first-paint fallback flash.
        void renderer.getPalette({ size: 16 }).catch(() => undefined)
@@ -443,11 +445,12 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
          renderer.requestRender()
        }
      })
-      yield* shutdown.await
+      yield* Deferred.await(shutdown)
      return { epilogue: exit.epilogue, reason: exit.reason }
    }),
  )
  yield* Effect.sync(() => {
+    win32FlushInputBuffer()
    if (result.reason !== undefined)
      process.stderr.write((cliErrorMessage(result.reason) ?? errorFormat(result.reason)) + "\n")
    if (result.epilogue) process.stdout.write(result.epilogue + "\n")
@@ -189,7 +189,7 @@ export const Definitions = {
  "prompt.clear": keybind("ctrl+c", "Clear input field"),
  "prompt.paste": keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
  "input.submit": keybind("return", "Submit input"),
-  "input.newline": keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
+  "input.newline": keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
  "input.move.left": keybind("left,ctrl+b", "Move cursor left in input"),
  "input.move.right": keybind("right,ctrl+f", "Move cursor right in input"),
  "input.move.up": keybind("up", "Move cursor up in input"),
@@ -174,7 +174,7 @@ export const Definitions = {
  input_clear: keybind("ctrl+c", "Clear input field"),
  input_paste: keybind({ key: "ctrl+v", preventDefault: false }, "Paste from clipboard"),
  input_submit: keybind("return", "Submit input"),
-  input_newline: keybind("shift+return,ctrl+return,alt+return,ctrl+j", "Insert newline in input"),
+  input_newline: keybind("shift+return,ctrl+return,ctrl+j", "Insert newline in input"),
  input_move_left: keybind("left,ctrl+b", "Move cursor left in input"),
  input_move_right: keybind("right,ctrl+f", "Move cursor right in input"),
  input_move_up: keybind("up", "Move cursor up in input"),
@@ -121,14 +121,7 @@ const TRANSCRIPT_BACKFILL_CHUNK = 60
 type PendingAction = "steer" | "queue" | "cancel"

 const context = createContext<{
-  /** Content width: terminal width minus vertical tabs, sidebar, and padding. */
  width: number
-  /**
-   * Shared reactive terminal size. Transcript-row components must read this
-   * instead of calling useTerminalDimensions(), which registers one renderer
-   * resize listener per mounted component and grows with transcript length.
-   */
-  terminal: { width: number; height: number }
  sessionID: string
  thinkingMode: () => ThinkingMode
  showThinking: () => boolean
@@ -1131,25 +1124,12 @@ export function Session(props: { verticalTabsWidth: number }) {
    ),
  )

-  // Memoized per axis so width readers do not re-run on height-only resizes
-  // (dimensions() is one object signal with identity equality) and vice versa.
-  const terminalWidth = createMemo(() => dimensions().width)
-  const terminalHeight = createMemo(() => dimensions().height)
-
  return (
    <context.Provider
      value={{
        get width() {
          return contentWidth()
        },
-        terminal: {
-          get width() {
-            return terminalWidth()
-          },
-          get height() {
-            return terminalHeight()
-          },
-        },
        sessionID: route.sessionID,
        thinkingMode,
        showThinking,
@@ -1825,6 +1805,7 @@ function AssistantFooter(props: { message: SessionMessageAssistant }) {
  const ctx = use()
  const data = useData()
  const local = useLocal()
+  const dimensions = useTerminalDimensions()
  const theme = useTheme("elevated")
  const model = createMemo(
    () =>
@@ -1848,10 +1829,10 @@ function AssistantFooter(props: { message: SessionMessageAssistant }) {
          <span style={{ fg: props.message.error ? theme.text.subdued : local.agent.color(props.message.agent) }}>
            {Locale.titlecase(props.message.agent)}
          </span>
-          <Show when={ctx.terminal.width >= 28}>
+          <Show when={dimensions().width >= 28}>
            <span style={{ fg: theme.text.subdued }}> · {model()}</span>
          </Show>
-          <Show when={duration() && (ctx.terminal.width < 28 || ctx.terminal.width >= 36)}>
+          <Show when={duration() && (dimensions().width < 28 || dimensions().width >= 36)}>
            <span style={{ fg: theme.text.subdued }}> · {Locale.duration(duration())}</span>
          </Show>
          <Show when={interrupted()}>
@@ -2540,8 +2521,9 @@ function ToolImages(props: { parts: readonly SessionMessageAssistantTool[] }) {
 function SessionImages(props: { images: readonly { uri: string }[]; paddingLeft?: number }) {
  const ctx = use()
  const dialog = useDialog()
+  const dimensions = useTerminalDimensions()
  const images = createMemo(() => (ctx.config.session?.image_preview ? props.images : []))
-  const height = createMemo(() => Math.max(4, Math.min(8, Math.floor(ctx.terminal.height / 4))))
+  const height = createMemo(() => Math.max(4, Math.min(8, Math.floor(dimensions().height / 4))))
  const visible = createMemo(() => images().slice(0, 3))

  return (
@@ -0,0 +1,130 @@
+import { dlopen, ptr } from "bun:ffi"
+import type { ReadStream } from "node:tty"
+
+const STD_INPUT_HANDLE = -10
+const ENABLE_PROCESSED_INPUT = 0x0001
+
+const kernel = () =>
+  dlopen("kernel32.dll", {
+    GetStdHandle: { args: ["i32"], returns: "ptr" },
+    GetConsoleMode: { args: ["ptr", "ptr"], returns: "i32" },
+    SetConsoleMode: { args: ["ptr", "u32"], returns: "i32" },
+    FlushConsoleInputBuffer: { args: ["ptr"], returns: "i32" },
+  })
+
+let k32: ReturnType<typeof kernel> | undefined
+
+function load() {
+  if (process.platform !== "win32") return false
+  try {
+    k32 ??= kernel()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Clear ENABLE_PROCESSED_INPUT on the console stdin handle.
+ */
+export function win32DisableProcessedInput() {
+  if (process.platform !== "win32") return
+  if (!process.stdin.isTTY) return
+  if (!load()) return
+
+  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
+  const buf = new Uint32Array(1)
+  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
+
+  const mode = buf[0]!
+  if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
+  k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
+}
+
+/**
+ * Discard any queued console input (mouse events, key presses, etc.).
+ */
+export function win32FlushInputBuffer() {
+  if (process.platform !== "win32") return
+  if (!process.stdin.isTTY) return
+  if (!load()) return
+
+  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
+  k32!.symbols.FlushConsoleInputBuffer(handle)
+}
+
+let unhook: (() => void) | undefined
+
+/**
+ * Keep ENABLE_PROCESSED_INPUT disabled.
+ *
+ * On Windows, Ctrl+C becomes a CTRL_C_EVENT (instead of stdin input) when
+ * ENABLE_PROCESSED_INPUT is set. Various runtimes can re-apply console modes
+ * (sometimes on a later tick), and the flag is console-global, not per-process.
+ *
+ * We combine:
+ * - A `setRawMode(...)` hook to re-clear after known raw-mode toggles.
+ * - A low-frequency poll as a backstop for native/external mode changes.
+ */
+export function win32InstallCtrlCGuard() {
+  if (process.platform !== "win32") return
+  if (!process.stdin.isTTY) return
+  if (!load()) return
+  if (unhook) return unhook
+
+  const stdin = process.stdin as ReadStream
+  const original = stdin.setRawMode
+
+  const handle = k32!.symbols.GetStdHandle(STD_INPUT_HANDLE)
+  const buf = new Uint32Array(1)
+
+  if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
+  const initial = buf[0]!
+
+  const enforce = () => {
+    if (k32!.symbols.GetConsoleMode(handle, ptr(buf)) === 0) return
+    const mode = buf[0]!
+    if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
+    k32!.symbols.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
+  }
+
+  // Some runtimes can re-apply console modes on the next tick; enforce twice.
+  const later = () => {
+    enforce()
+    setImmediate(enforce)
+  }
+
+  let wrapped: ReadStream["setRawMode"] | undefined
+
+  if (typeof original === "function") {
+    wrapped = (mode: boolean) => {
+      const result = original.call(stdin, mode)
+      later()
+      return result
+    }
+
+    stdin.setRawMode = wrapped
+  }
+
+  // Ensure it's cleared immediately too (covers any earlier mode changes).
+  later()
+
+  const interval = setInterval(enforce, 100)
+  interval.unref()
+
+  let done = false
+  unhook = () => {
+    if (done) return
+    done = true
+
+    clearInterval(interval)
+    if (wrapped && stdin.setRawMode === wrapped) {
+      stdin.setRawMode = original
+    }
+
+    k32!.symbols.SetConsoleMode(handle, initial)
+    unhook = undefined
+  }
+
+  return unhook
+}
@@ -0,0 +1,77 @@
+import { dlopen } from "node:ffi"
+import type { ReadStream } from "node:tty"
+
+const STD_INPUT_HANDLE = -10
+const ENABLE_PROCESSED_INPUT = 0x0001
+
+const kernel = () =>
+  dlopen("kernel32.dll", {
+    GetStdHandle: { arguments: ["i32"], return: "pointer" },
+    GetConsoleMode: { arguments: ["pointer", "pointer"], return: "i32" },
+    SetConsoleMode: { arguments: ["pointer", "u32"], return: "i32" },
+    FlushConsoleInputBuffer: { arguments: ["pointer"], return: "i32" },
+  }).functions
+
+let k32: ReturnType<typeof kernel> | undefined
+
+function load() {
+  if (process.platform !== "win32") return false
+  try {
+    k32 ??= kernel()
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function win32DisableProcessedInput() {
+  if (process.platform !== "win32" || !process.stdin.isTTY || !load()) return
+  const handle = k32!.GetStdHandle(STD_INPUT_HANDLE)
+  const buffer = new Uint32Array(1)
+  if (k32!.GetConsoleMode(handle, buffer) === 0) return
+  const mode = buffer[0]!
+  if ((mode & ENABLE_PROCESSED_INPUT) === 0) return
+  k32!.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
+}
+
+export function win32FlushInputBuffer() {
+  if (process.platform !== "win32" || !process.stdin.isTTY || !load()) return
+  k32!.FlushConsoleInputBuffer(k32!.GetStdHandle(STD_INPUT_HANDLE))
+}
+
+let unhook: (() => void) | undefined
+
+export function win32InstallCtrlCGuard() {
+  if (process.platform !== "win32" || !process.stdin.isTTY || !load() || unhook) return unhook
+  const stdin = process.stdin as ReadStream
+  const original = stdin.setRawMode
+  const handle = k32!.GetStdHandle(STD_INPUT_HANDLE)
+  const buffer = new Uint32Array(1)
+  if (k32!.GetConsoleMode(handle, buffer) === 0) return
+  const initial = buffer[0]!
+  const enforce = () => {
+    if (k32!.GetConsoleMode(handle, buffer) === 0) return
+    const mode = buffer[0]!
+    if ((mode & ENABLE_PROCESSED_INPUT) !== 0) k32!.SetConsoleMode(handle, mode & ~ENABLE_PROCESSED_INPUT)
+  }
+  const later = () => {
+    enforce()
+    setImmediate(enforce)
+  }
+  const wrapped: ReadStream["setRawMode"] = (mode) => {
+    const result = original.call(stdin, mode)
+    later()
+    return result
+  }
+  stdin.setRawMode = wrapped
+  later()
+  const interval = setInterval(enforce, 100)
+  interval.unref()
+  unhook = () => {
+    clearInterval(interval)
+    if (stdin.setRawMode === wrapped) stdin.setRawMode = original
+    k32!.SetConsoleMode(handle, initial)
+    unhook = undefined
+  }
+  return unhook
+}
@@ -0,0 +1 @@
+export { win32DisableProcessedInput, win32FlushInputBuffer, win32InstallCtrlCGuard } from "#terminal-win32"
@@ -107,29 +107,6 @@ test("dialog prompt submit wins when return is also input newline", async () =>
  }
 })

-test("alt return inserts a newline with default keybinds", async () => {
-  await using tmp = await tmpdir()
-  const confirmed: string[] = []
-  const prompt = await mountPrompt({
-    root: tmp.path,
-    keybinds: {},
-    onConfirm: (value) => confirmed.push(value),
-  })
-
-  try {
-    await wait(() => prompt.app.renderer.currentFocusedEditor instanceof TextareaRenderable)
-    const textarea = prompt.app.renderer.currentFocusedEditor
-    if (!(textarea instanceof TextareaRenderable)) throw new Error("expected focused dialog textarea")
-
-    prompt.app.mockInput.pressEnter({ meta: true })
-
-    expect(confirmed).toEqual([])
-    expect(textarea.plainText).toBe("draft\n")
-  } finally {
-    await prompt.cleanup()
-  }
-})
-
 test("dialog prompt submit can be rebound separately from input submit", async () => {
  await using tmp = await tmpdir()
  const confirmed: string[] = []
@@ -21,7 +21,7 @@ describe("run runtime boot", () => {
    expect(result.keybinds.get("prompt.history.next")?.[0]?.key).toBe("down")
    expect(result.keybinds.get("prompt.clear")?.[0]?.key).toBe("ctrl+c")
    expect(result.keybinds.get("input.submit")?.[0]?.key).toBe("return")
-    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,alt+return,ctrl+j")
+    expect(result.keybinds.get("input.newline")?.[0]?.key).toBe("shift+return,ctrl+return,ctrl+j")
    expect(result.keybinds.get("prompt.queue")?.[0]?.key).toBe("<leader>return")
  })
				`@@ -0,0 +1 @@`
				`export { win32DisableProcessedInput, win32FlushInputBuffer, win32InstallCtrlCGuard } from "#terminal-win32"`