diff --git a/package.json b/package.json
index 382e607..2b43ed6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@openchamber/opencode-claude",
-  "version": "0.14.0",
+  "version": "0.14.0-fix.1",
   "description": "Claude Code in OpenCode — local CLI auth, Agent SDK harness, effort variants, tools/MCP, images & compact.",
   "license": "MIT",
   "type": "module",
@@ -21,7 +21,7 @@
   "scripts": {
     "prebuild": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc -p tsconfig.json",
-    "test": "bun test/smoke.ts",
+    "test": "bun test/smoke.ts && bun test/usage-regression.ts && bun test/request-kind-regression.ts && bun test/compaction-resume-regression.ts && bun test/persistent-query-regression.ts && bun test/bridge-teardown-regression.ts && bun test/persistent-park-race-regression.ts && bun test/persistent-pump-concurrency-regression.ts && bun test/persistent-continuation-lifecycle-regression.ts && bun test/lifecycle-instrumentation-regression.ts && bun test/pump-gate-regression.ts && bun test/iterator-race-regression.ts",
     "test:haiku": "bun test/haiku-live.ts",
     "prepublishOnly": "npm run build"
   },
diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index 9259084..a03f9c8 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -3,12 +3,23 @@
  * (Cursor bridge-pool pattern).
  */
 import type { ClaudeQueryHandle } from "./query.js";
+import type { ClaudePromptInput } from "./prompt-input.js";
+import type { ExclusivePumpGate } from "./serialized-iterator.js";
+import type { OpenAIUsage } from "./usage.js";
+import { log } from "./log.js";
+import type { ToolResultAttachment } from "./prompt.js";
+
+/** Resolved payload for a parked tool call, including image attachments. */
+export type ToolResultPayload = {
+  text: string;
+  attachments: ToolResultAttachment[];
+};
 
 export type ParkedToolCall = {
   id: string;
   name: string;
   arguments: string;
-  resolve: (result: string) => void;
+  resolve: (result: ToolResultPayload) => void;
   reject: (error: Error) => void;
 };
 
@@ -19,13 +30,45 @@ export type ParkedBridge = {
   pendingTools: Map<string, ParkedToolCall>;
   /** SDK assistant messages whose usage was already reported to OpenCode. */
   seenAssistantUsageIds: Set<string>;
+  /** Latest assistant usage, retained for replay-only tool continuations. */
+  lastAssistantUsage?: OpenAIUsage;
   createdAt: number;
   /** Continues consuming the SDK stream after tools resolve. */
-  continueStream?: () => AsyncGenerator<unknown, void, unknown>;
+  continueStream?: (
+    releasePump?: () => void,
+    requestSignal?: AbortSignal,
+  ) => AsyncGenerator<unknown, void, unknown>;
+  pumpGate: ExclusivePumpGate;
+  input?: ClaudePromptInput;
+  streamIterator?: AsyncIterator<unknown>;
+  persistent?: boolean;
+  closed?: boolean;
+  modelId?: string;
+  cwd?: string;
 };
 
 const bridges = new Map<string, ParkedBridge>();
 
+/**
+ * Closing the prompt input tears the SDK stream down synchronously, which put
+ * multi-second latency directly on the response path: every turn paid to close
+ * the previous turn's bridge before it could proceed. Defer it to the next
+ * macrotask instead. The stream still closes and the leak this lifecycle work
+ * fixes stays fixed — it just no longer happens while a request is waiting.
+ */
+function closeInputDeferred(bridge: ParkedBridge): void {
+  const input = bridge.input;
+  if (!input) return;
+  setTimeout(() => {
+    try {
+      input.close();
+    } catch {
+      // teardown is best-effort
+    }
+  }, 0);
+}
+
+
 export function putBridge(bridge: ParkedBridge): void {
   // One active bridge per conversation — drop any prior turn for this key.
   for (const [id, existing] of bridges) {
@@ -34,6 +77,8 @@ export function putBridge(bridge: ParkedBridge): void {
         tool.reject(new Error("Superseded by a newer turn"));
       }
       existing.pendingTools.clear();
+      closeInputDeferred(existing);
+      existing.closed = true;
       try {
         existing.handle.close();
       } catch {
@@ -67,14 +112,33 @@ export function findBridgeByPendingTool(
   return undefined;
 }
 
+export function deleteBridgesByConversation(conversationKey: string): void {
+  for (const [id, bridge] of bridges) {
+    if (bridge.conversationKey === conversationKey) deleteBridge(id);
+  }
+}
+
 export function deleteBridge(id: string): void {
   const bridge = bridges.get(id);
   if (!bridge) return;
+  bridge.closed = true;
   for (const tool of bridge.pendingTools.values()) {
     tool.reject(new Error("Bridge closed"));
   }
-  bridge.handle.close();
-  bridges.delete(id);
+  bridge.pendingTools.clear();
+  closeInputDeferred(bridge);
+  try {
+    bridge.handle.close();
+  } catch {
+    log.warn("[opencode-claude] bridge handle close failed", { bridgeId: id });
+  } finally {
+    bridges.delete(id);
+    log.info("[opencode-claude] bridge close", {
+      bridgeId: id,
+      conversationKey: bridge.conversationKey,
+      pendingTools: bridge.pendingTools.size,
+    });
+  }
 }
 
 export function clearAllBridges(): void {
diff --git a/src/executable-path.ts b/src/executable-path.ts
index 11a8e44..52f036b 100644
--- a/src/executable-path.ts
+++ b/src/executable-path.ts
@@ -34,7 +34,11 @@ function knownClaudeLocations(
   env: NodeJS.ProcessEnv | Record<string, string | undefined>,
 ): string[] {
   const home = typeof env.HOME === "string" && env.HOME ? env.HOME : homedir();
-  const candidates = [join(home, ".local", "bin", "claude")];
+  const names =
+    process.platform === "win32"
+      ? ["claude.cmd", "claude.exe", "claude.bat", "claude"]
+      : ["claude"];
+  const candidates = names.map((name) => join(home, ".local", "bin", name));
 
   try {
     const prefix = spawnSync("npm", ["prefix", "-g"], {
@@ -44,7 +48,9 @@ function knownClaudeLocations(
       stdio: ["ignore", "pipe", "ignore"],
     });
     const dir = `${prefix.stdout || ""}`.trim();
-    if (dir) candidates.push(join(dir, "bin", "claude"));
+    if (dir) {
+      for (const name of names) candidates.push(join(dir, "bin", name));
+    }
   } catch {
     // no npm prefix available — PATH and ~/.local/bin remain
   }
diff --git a/src/index.ts b/src/index.ts
index 9e9936e..afea018 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -108,6 +108,7 @@ function buildProviderModel(
     cost: zeroCost(),
     limit: {
       context: model.contextWindow,
+      ...(model.inputWindow ? { input: model.inputWindow } : {}),
       output: model.maxTokens,
     },
     status: "active",
@@ -142,6 +143,7 @@ function buildConfigModelEntry(model: ClaudeModel): Record<string, unknown> {
     },
     limit: {
       context: model.contextWindow,
+      ...(model.inputWindow ? { input: model.inputWindow } : {}),
       output: model.maxTokens,
     },
     options: {
diff --git a/src/models.ts b/src/models.ts
index 5960853..6e7c791 100644
--- a/src/models.ts
+++ b/src/models.ts
@@ -9,10 +9,13 @@ export type ClaudeModel = {
   reasoning: boolean;
   contextWindow: number;
   maxTokens: number;
+  inputWindow?: number;
   resolvedId?: string;
 };
 
-const LIMIT_1M = { context: 1_000_000, output: 128_000 } as const;
+// Declare an input window so OpenCode's auto-compaction trigger (input − reserved)
+// fires predictably (~90%) instead of falling back to (context − output).
+const LIMIT_1M = { context: 1_000_000, input: 900_000, output: 128_000 } as const;
 const LIMIT_200K = { context: 200_000, output: 64_000 } as const;
 
 /** OpenCode may inject these before merging plugin variants — disable extras. */
@@ -29,7 +32,7 @@ export const GENERATED_VARIANT_KEYS = [
 function model(
   id: string,
   name: string,
-  limit: { context: number; output: number },
+  limit: { context: number; input?: number; output: number },
   resolvedId?: string,
 ): ClaudeModel {
   return {
@@ -38,6 +41,7 @@ function model(
     reasoning: true,
     contextWindow: limit.context,
     maxTokens: limit.output,
+    ...(limit.input ? { inputWindow: limit.input } : {}),
     ...(resolvedId ? { resolvedId } : {}),
   };
 }
diff --git a/src/prompt-input.ts b/src/prompt-input.ts
new file mode 100644
index 0000000..1f48943
--- /dev/null
+++ b/src/prompt-input.ts
@@ -0,0 +1,61 @@
+import type { SdkUserPrompt } from "./prompt.js";
+
+type PromptResult = IteratorResult<SdkUserPrompt>;
+
+class PromptQueue implements AsyncIterable<SdkUserPrompt>, AsyncIterator<SdkUserPrompt> {
+  private readonly values: SdkUserPrompt[] = [];
+  private readonly waiters: Array<(result: PromptResult) => void> = [];
+  private closed = false;
+
+  push(prompt: SdkUserPrompt): void {
+    if (this.closed) {
+      throw new Error("Claude prompt stream is closed");
+    }
+    const resolve = this.waiters.shift();
+    if (resolve) {
+      resolve({ done: false, value: prompt });
+    } else {
+      this.values.push(prompt);
+    }
+  }
+
+  close(): void {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.waiters.length > 0) {
+      this.waiters.shift()!({ done: true, value: undefined as never });
+    }
+  }
+
+  async next(): Promise<PromptResult> {
+    const value = this.values.shift();
+    if (value) return { done: false, value };
+    if (this.closed) return { done: true, value: undefined as never };
+    return new Promise((resolve) => this.waiters.push(resolve));
+  }
+
+  async return(): Promise<PromptResult> {
+    this.close();
+    return { done: true, value: undefined as never };
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<SdkUserPrompt> {
+    return this;
+  }
+}
+
+export type ClaudePromptInput = {
+  stream: AsyncIterable<SdkUserPrompt>;
+  push: (prompt: SdkUserPrompt) => void;
+  close: () => void;
+};
+
+export function createClaudePromptInput(initial: SdkUserPrompt): ClaudePromptInput {
+  const queue = new PromptQueue();
+  queue.push(initial);
+  return {
+    stream: queue,
+    push: (prompt) => queue.push(prompt),
+    close: () => queue.close(),
+  };
+}
diff --git a/src/prompt.ts b/src/prompt.ts
index 6eab0ec..0ec94cf 100644
--- a/src/prompt.ts
+++ b/src/prompt.ts
@@ -376,6 +376,115 @@ export function contentHasAttachments(content: unknown): boolean {
     );
   });
 }
+/**
+ * Extract image parts from an OpenAI-compatible tool result content array so
+ * they can be re-attached as MCP image content blocks when a parked tool call
+ * is resolved (tool-result images otherwise never reach Claude).
+ * Text stays in `extractTextContent`; this only collects binaries. Remote
+ * http(s) image URLs are skipped — MCP image content requires base64 data.
+ */
+export type ToolResultAttachment = {
+  type: "image";
+  data: string;
+  mimeType: string;
+};
+
+export function extractToolResultImages(
+  content: unknown,
+): ToolResultAttachment[] {
+  if (!Array.isArray(content)) return [];
+  const images: ToolResultAttachment[] = [];
+  const push = (mediaType: string, data: string): void => {
+    if (!data || !mediaLooksLikeImage(mediaType)) return;
+    images.push({ type: "image", data, mimeType: mediaType });
+  };
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    const p = part as Record<string, unknown>;
+    const type = typeof p.type === "string" ? p.type : "";
+
+    if (type === "image_url" || type === "input_image") {
+      const imageUrl = p.image_url;
+      const url =
+        typeof imageUrl === "string"
+          ? imageUrl
+          : imageUrl &&
+              typeof imageUrl === "object" &&
+              typeof (imageUrl as { url?: unknown }).url === "string"
+            ? (imageUrl as { url: string }).url
+            : null;
+      const parsed = url ? parseDataUrl(url) : null;
+      if (parsed) push(parsed.mediaType, parsed.data);
+      continue;
+    }
+
+    if (type === "file" || type === "input_file") {
+      const file = (
+        p.file && typeof p.file === "object" ? p.file : p
+      ) as Record<string, unknown>;
+      const fileData =
+        typeof file.file_data === "string" ? file.file_data : null;
+      const url =
+        typeof file.url === "string"
+          ? file.url
+          : fileData && /^data:/i.test(fileData)
+            ? fileData
+            : null;
+      const data =
+        typeof file.data === "string"
+          ? file.data
+          : fileData && !/^data:/i.test(fileData)
+            ? fileData
+            : null;
+      const mediaType =
+        typeof file.media_type === "string"
+          ? file.media_type
+          : typeof file.mime_type === "string"
+            ? file.mime_type
+            : typeof file.mime === "string"
+              ? file.mime
+              : "";
+      const parsed = url
+        ? parseDataUrl(url)
+        : data && /^data:/i.test(data)
+          ? parseDataUrl(data)
+          : null;
+      if (parsed) push(parsed.mediaType, parsed.data);
+      else if (data && mediaType) push(mediaType, data);
+      continue;
+    }
+
+    if (type === "image") {
+      const mediaType =
+        typeof p.media_type === "string"
+          ? p.media_type
+          : typeof p.mimeType === "string"
+            ? p.mimeType
+            : typeof p.mime === "string"
+              ? p.mime
+              : "image/png";
+      const source = p.source;
+      if (source && typeof source === "object") {
+        const s = source as Record<string, unknown>;
+        if (s.type === "base64" && typeof s.data === "string")
+          push(mediaType, s.data);
+        else if (s.type === "url" && typeof s.url === "string") {
+          const parsed = parseDataUrl(s.url);
+          if (parsed) push(parsed.mediaType, parsed.data);
+        }
+        continue;
+      }
+      const image = p.image;
+      if (typeof image === "string") {
+        const parsed = parseDataUrl(image);
+        if (parsed) push(parsed.mediaType, parsed.data);
+        else push(mediaType, image);
+      }
+      continue;
+    }
+  }
+  return images;
+}
 
 export function openaiContentToAnthropicBlocks(
   content: unknown,
diff --git a/src/proxy.ts b/src/proxy.ts
index 8aae174..e780610 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -10,12 +10,15 @@
  */
 import { createHash, randomUUID } from "node:crypto";
 import {
+  clearAllBridges,
   deleteBridge,
+  deleteBridgesByConversation,
   findBridgeByConversation,
   findBridgeByPendingTool,
   putBridge,
   type ParkedBridge,
   type ParkedToolCall,
+  type ToolResultPayload,
 } from "./bridge-pool.js";
 import { buildClaudeCodeChildEnv } from "./auth-env.js";
 import {
@@ -55,23 +58,31 @@ import {
 import {
   buildConversationTranscript,
   extractTextContent,
+  extractToolResultImages,
   latestUserPrompt,
   priorMessagesOf,
   promptAsStream,
   withConversationContext,
   type SdkUserPrompt,
 } from "./prompt.js";
+import { createClaudePromptInput } from "./prompt-input.js";
+import {
+  ExclusivePumpGate,
+  SerializedAsyncIterator,
+} from "./serialized-iterator.js";
 import {
   detectMetaRequestKind,
   metaSystemPrompt,
   requestKeyNamespace,
 } from "./request-kind.js";
 import {
-  addUniqueAssistantUsage,
+  addUniqueAssistantUsageState,
   formatCompactNote,
-  resolveTurnUsage,
+  resolveOpenCodeUsage,
   usageFromAssistantEvent,
   usageFromSdkResult,
+  usageFromSdkTurnResult,
+  type AssistantUsageState,
   type OpenAIUsage,
 } from "./usage.js";
 
@@ -258,6 +269,7 @@ export async function startProxy(): Promise<number> {
 }
 
 export async function stopProxy(): Promise<void> {
+  clearAllBridges();
   if (server) {
     server.stop(true);
     server = null;
@@ -325,15 +337,49 @@ async function handleRequest(req: Request): Promise<Response> {
 
 function collectToolResults(
   messages: OpenAIMessage[],
-): Map<string, string> {
-  const results = new Map<string, string>();
+): Map<string, ToolResultPayload> {
+  const results = new Map<string, ToolResultPayload>();
   for (const msg of messages) {
     if (msg.role !== "tool" || !msg.tool_call_id) continue;
-    results.set(msg.tool_call_id, extractTextContent(msg.content));
+    const attachments = extractToolResultImages(msg.content);
+    if (attachments.length > 0) {
+      log.info("[opencode-claude] tool result attachments", {
+        toolCallId: msg.tool_call_id,
+        count: attachments.length,
+        mimeTypes: attachments.map((a) => a.mimeType),
+      });
+    }
+    results.set(msg.tool_call_id, {
+      text: extractTextContent(msg.content),
+      attachments,
+    });
   }
   return results;
 }
 
+/**
+ * OpenCode promotes tool-result media (images/PDFs) into a synthetic user
+ * message ("Attached media from tool result:") for providers that cannot carry
+ * media inside tool results — which includes every openai-compatible provider.
+ * In the parked-bridge path that message would otherwise be dropped, because
+ * the turn resumes by resolving the parked MCP call only. Relay its images
+ * with the tool result so Claude actually sees them.
+ */
+const SYNTHETIC_TOOL_MEDIA_PROMPT = "Attached media from tool result:";
+
+function collectSyntheticToolMedia(
+  messages: OpenAIMessage[],
+): Array<{ type: "image"; data: string; mimeType: string }> {
+  const media: Array<{ type: "image"; data: string; mimeType: string }> = [];
+  for (const msg of messages) {
+    if (msg.role !== "user") continue;
+    if (extractTextContent(msg.content).trim() !== SYNTHETIC_TOOL_MEDIA_PROMPT)
+      continue;
+    media.push(...extractToolResultImages(msg.content));
+  }
+  return media;
+}
+
 function selectionFromRequest(
   req: Request,
   body: ChatCompletionRequest,
@@ -354,15 +400,45 @@ async function handleChatCompletions(
   const messages = Array.isArray(body.messages) ? body.messages : [];
   const metaKind = detectMetaRequestKind(messages);
   const sessionHeader = req.headers.get(SESSION_HEADER);
+  const baseConversationKey =
+    sessionHeader || conversationKeyFromMessages(messages);
   const conversationKey =
-    requestKeyNamespace(metaKind) +
-    (sessionHeader || conversationKeyFromMessages(messages));
+    requestKeyNamespace(metaKind) + baseConversationKey;
+  if (metaKind === "summary") {
+    // OpenCode has compacted its history; resuming the old Claude session would
+    // restore the pre-compaction context and make the next usage snapshot jump.
+    deleteBridgesByConversation(baseConversationKey);
+    clearForeignSessionId(baseConversationKey);
+  }
   const selection = selectionFromRequest(req, body);
   const model = resolveClaudeModelId(selection.modelId);
   const stream = body.stream !== false;
+  const requestDirectory = req.headers.get(DIRECTORY_HEADER)?.trim();
+  const cwd =
+    process.env.OPENCODE_CLAUDE_CWD || requestDirectory || process.cwd();
 
   // Resume a parked bridge if OpenCode returned tool results.
   const toolResults = collectToolResults(messages);
+  // Media promoted by OpenCode to a synthetic "Attached media from tool result:"
+  // user message must ride the resolved tool call, or the parked turn resumes
+  // without the image attached.
+  const syntheticMedia = collectSyntheticToolMedia(messages);
+  if (syntheticMedia.length > 0) {
+    if (toolResults.size === 1) {
+      const only = [...toolResults.values()][0];
+      if (only.attachments.length === 0) {
+        only.attachments = syntheticMedia;
+        log.info("[opencode-claude] attached promoted tool-result media", {
+          count: syntheticMedia.length,
+        });
+      }
+    } else {
+      log.warn("[opencode-claude] promoted tool media could not be mapped", {
+        toolResults: toolResults.size,
+        count: syntheticMedia.length,
+      });
+    }
+  }
   let existing = findBridgeByConversation(conversationKey);
   // Fallback: match by tool_call_id when the session header is missing/changed.
   if ((!existing || existing.pendingTools.size === 0) && toolResults.size > 0) {
@@ -375,47 +451,49 @@ async function handleChatCompletions(
     }
   }
   if (existing && existing.pendingTools.size > 0) {
-    let resolved = 0;
-    for (const [toolId, tool] of existing.pendingTools) {
-      const result = toolResults.get(toolId);
-      if (result !== undefined) {
-        tool.resolve(result);
-        existing.pendingTools.delete(toolId);
-        resolved++;
+    const releasePump = await existing.pumpGate.acquire();
+    let handedOff = false;
+    try {
+      if (!existing.closed) {
+        let resolved = 0;
+        for (const [toolId, tool] of existing.pendingTools) {
+          const result = toolResults.get(toolId);
+          if (result !== undefined) {
+            tool.resolve(result);
+            existing.pendingTools.delete(toolId);
+            resolved++;
+          }
+        }
+        if (existing.pendingTools.size === 0 && existing.continueStream) {
+          log.info("[opencode-claude] resuming parked bridge", {
+            conversationKey: existing.conversationKey,
+            resolved,
+          });
+          const continued = existing.continueStream(releasePump, req.signal);
+          handedOff = true;
+          return stream
+            ? streamOpenAIResponse(continued, body.model || model, existing)
+            : collectTurnResponse(continued, body.model || model, existing);
+        }
+        // Still parked — do not start a parallel Claude turn (OpenCode may retry
+        // or send a follow-up before tool results arrive). Re-emit pending calls.
+        // Also covers partial tool results (resolved > 0 but others still pending).
+        if (existing.pendingTools.size > 0) {
+          log.info("[opencode-claude] re-emitting parked tool_calls", {
+            conversationKey: existing.conversationKey,
+            pending: existing.pendingTools.size,
+            resolved,
+          });
+          const parkedEvents = (async function* () {
+            yield { type: "__park__", tools: [...existing!.pendingTools.values()] };
+          })();
+          return stream
+            ? streamOpenAIResponse(parkedEvents, body.model || model, existing)
+            : collectTurnResponse(parkedEvents, body.model || model, existing);
+        }
       }
-    }
-    if (existing.pendingTools.size === 0 && existing.continueStream) {
-      log.info("[opencode-claude] resuming parked bridge", {
-        conversationKey: existing.conversationKey,
-        resolved,
-      });
-      return stream
-        ? streamOpenAIResponse(
-            existing.continueStream(),
-            body.model || model,
-            existing,
-          )
-        : collectTurnResponse(
-            existing.continueStream(),
-            body.model || model,
-            existing,
-          );
-    }
-    // Still parked — do not start a parallel Claude turn (OpenCode may retry
-    // or send a follow-up before tool results arrive). Re-emit pending calls.
-    // Also covers partial tool results (resolved > 0 but others still pending).
-    if (existing.pendingTools.size > 0) {
-      log.info("[opencode-claude] re-emitting parked tool_calls", {
-        conversationKey: existing.conversationKey,
-        pending: existing.pendingTools.size,
-        resolved,
-      });
-      const parkedEvents = (async function* () {
-        yield { type: "__park__", tools: [...existing!.pendingTools.values()] };
-      })();
-      return stream
-        ? streamOpenAIResponse(parkedEvents, body.model || model, existing)
-        : collectTurnResponse(parkedEvents, body.model || model, existing);
+    } finally {
+      if (!handedOff) releasePump();
     }
   }
 
@@ -433,9 +511,6 @@ async function handleChatCompletions(
 
   const openCodeTools = Array.isArray(body.tools) ? body.tools : [];
   const isMetaRequest = metaKind !== null;
-  const requestDirectory = req.headers.get(DIRECTORY_HEADER)?.trim();
-  const cwd =
-    process.env.OPENCODE_CLAUDE_CWD || requestDirectory || process.cwd();
   const bridgeId = randomUUID();
   const pendingTools = new Map<string, ParkedToolCall>();
   let handle: ClaudeQueryHandle | null = null;
@@ -444,6 +519,11 @@ async function handleChatCompletions(
 
   const notifyPark = () => {
     parked = true;
+    log.info("[opencode-claude] MCP park", {
+      bridgeId,
+      conversationKey,
+      pendingTools: pendingTools.size,
+    });
     const waiters = parkWaiters;
     parkWaiters = [];
     for (const resolve of waiters) resolve();
@@ -513,6 +593,42 @@ async function handleChatCompletions(
     );
   }
 
+  if (
+    existing?.persistent &&
+    !existing.closed &&
+    existing.input &&
+    existing.continueStream
+  ) {
+    if (existing.modelId !== model || existing.cwd !== cwd) {
+      deleteBridge(existing.id);
+      existing = undefined;
+    } else {
+      const input = existing.input;
+      const continueStream = existing.continueStream;
+      log.info("[opencode-claude] reusing persistent bridge", {
+        bridgeId: existing.id,
+        conversationKey: existing.conversationKey,
+        model,
+      });
+      const releasePump = await existing.pumpGate.acquire();
+      let handedOff = false;
+      try {
+        if (existing.closed) {
+          existing = undefined;
+        } else {
+          input.push(toSdkUserPrompt(prompt));
+          const continued = continueStream(releasePump, req.signal);
+          handedOff = true;
+          return stream
+            ? streamOpenAIResponse(continued, body.model || model, existing)
+            : collectTurnResponse(continued, body.model || model, existing);
+        }
+      } finally {
+        if (!handedOff) releasePump();
+      }
+    }
+  }
+
   let resume = getForeignSessionId(conversationKey);
   if (resume && !findClaudeSessionFile(resume)) {
     // The claude CLI resumes by looking the session up on disk. A missing
@@ -576,7 +692,7 @@ async function handleChatCompletions(
   const titleSource = [...messages]
     .reverse()
     .find((message) => message.role === "user");
-  const queryPrompt: string | AsyncIterable<SdkUserPrompt> = metaKind === "title"
+  const queryPrompt: string | SdkUserPrompt = metaKind === "title"
     ? [
         "Create a concise 3-7 word session title for the request quoted below.",
         "Output only the title, with no quotation marks or punctuation at the end.",
@@ -588,7 +704,15 @@ async function handleChatCompletions(
       ].join("\n")
     : typeof contextualPrompt === "string"
       ? contextualPrompt || " "
-      : promptAsStream(contextualPrompt);
+      : contextualPrompt;
+  const persistentInput = isMetaRequest
+    ? undefined
+    : createClaudePromptInput(toSdkUserPrompt(queryPrompt));
+  const sdkPrompt: string | AsyncIterable<SdkUserPrompt> = persistentInput
+    ? persistentInput.stream
+    : typeof queryPrompt === "string"
+      ? queryPrompt
+      : promptAsStream(queryPrompt);
 
   const hasTodoWrite = openCodeToolNames.includes("todowrite");
   const utilitySystemPrompt = isMetaRequest
@@ -599,8 +723,16 @@ async function handleChatCompletions(
           "This is a single-turn text transformation. Return only the requested summary. Do not inspect files, execute commands, or use tools.",
         ].filter(Boolean).join("\n\n")
     : undefined;
+  log.info("[opencode-claude] query start", {
+    bridgeId,
+    conversationKey,
+    model,
+    persistent: !isMetaRequest,
+    hasMcp: mcpServers !== undefined,
+    resumed: resume !== undefined,
+  });
   handle = await queryStarter({
-    prompt: queryPrompt,
+    prompt: sdkPrompt,
     cwd,
     model,
     resume: isMetaRequest ? undefined : resume,
@@ -649,6 +781,26 @@ async function handleChatCompletions(
         : {}),
     },
   });
+  log.info("[opencode-claude] query acquired", {
+    bridgeId,
+    conversationKey,
+    model,
+  });
+  const streamIterator = handle.stream[Symbol.asyncIterator]();
+  const serializedIterator = new SerializedAsyncIterator(streamIterator, {
+    onNextStart: (shared) => {
+      log.info("[opencode-claude] iterator next start", { bridgeId, shared });
+    },
+    onNextFinish: (done) => {
+      log.info("[opencode-claude] iterator next finish", { bridgeId, done });
+    },
+    onNextError: () => {
+      log.info("[opencode-claude] iterator next error", { bridgeId });
+    },
+    onRelease: () => {
+      log.info("[opencode-claude] iterator next release", { bridgeId });
+    },
+  });
 
   const bridge: ParkedBridge = {
     id: bridgeId,
@@ -657,11 +809,35 @@ async function handleChatCompletions(
     pendingTools,
     seenAssistantUsageIds: new Set(),
     createdAt: Date.now(),
+    input: persistentInput,
+    streamIterator: serializedIterator,
+    pumpGate: new ExclusivePumpGate(),
+    persistent: !isMetaRequest,
+    modelId: model,
+    cwd,
   };
   putBridge(bridge);
 
-  async function* consumeStream(): AsyncGenerator<unknown, void, unknown> {
-    const iterator = handle!.stream[Symbol.asyncIterator]();
+  async function* consumeStream(
+    suppliedReleasePump?: () => void,
+    requestSignal: AbortSignal = req.signal,
+  ): AsyncGenerator<unknown, void, unknown> {
+    const iterator = serializedIterator;
+    const releasePump =
+      suppliedReleasePump ?? (await bridge.pumpGate.acquire());
+    let keepBridge = false;
+    let sawFirstSdkEvent = false;
+    const noteFirstSdkEvent = (event: unknown) => {
+      if (sawFirstSdkEvent) return;
+      sawFirstSdkEvent = true;
+      const type =
+        event &&
+        typeof event === "object" &&
+        typeof (event as { type?: unknown }).type === "string"
+          ? (event as { type: string }).type
+          : typeof event;
+      log.info("[opencode-claude] first SDK event", { bridgeId, type });
+    };
     try {
       while (true) {
         const parkControl = {
@@ -698,6 +874,12 @@ async function handleChatCompletions(
           }, ms);
           stallTimer.unref?.();
         });
+        let requestAbortHandler: (() => void) | undefined;
+        const requestAbortPromise = new Promise<never>((_, reject) => {
+          requestAbortHandler = () => reject(new Error("Claude request aborted"));
+          if (requestSignal.aborted) requestAbortHandler();
+          else requestSignal.addEventListener("abort", requestAbortHandler, { once: true });
+        });
 
         const nextPromise = iterator.next();
         let raced:
@@ -708,45 +890,64 @@ async function handleChatCompletions(
             nextPromise.then((value) => ({ kind: "event" as const, value })),
             parkPromise.then(() => ({ kind: "park" as const })),
             stallPromise,
+            requestAbortPromise,
           ]);
         } catch (error) {
           // Stall watchdog fired — the turn is dead. Swallow the late
           // iterator settlement so it cannot surface as an unhandled
           // rejection after we throw.
+          parkControl.cancel?.();
           nextPromise.then(
             () => {},
             () => {},
           );
+          log.warn("[opencode-claude] stream wait interrupted", {
+            bridgeId,
+            reason: requestSignal.aborted ? "client-abort" : "watchdog-or-iterator-error",
+          });
           throw error;
         } finally {
           if (stallTimer) clearTimeout(stallTimer);
+          if (requestAbortHandler) {
+            requestSignal.removeEventListener("abort", requestAbortHandler);
+          }
         }
 
         if (raced.kind === "park" || (parked && pendingTools.size > 0)) {
+          keepBridge = true;
           parkControl.cancel?.();
           await Promise.resolve();
           // The iterator's pending next() may already have consumed the
           // assistant event that carries the parked tool call (and its
           // per-call usage). Forward it before parking so usage accounting
           // and session binding stay intact.
-          if (raced.kind === "event" && !raced.value.done) {
-            const pendingEvent = raced.value.value;
-            const pendingSessionId = extractSessionId(pendingEvent);
-            if (pendingSessionId) {
-              setForeignSessionId(conversationKey, pendingSessionId, {
-                modelId: model,
-                cwd,
-              });
+          if (raced.kind === "event") {
+            iterator.release(nextPromise);
+            if (!raced.value.done) {
+              const pendingEvent = raced.value.value;
+              noteFirstSdkEvent(pendingEvent);
+              const pendingSessionId = extractSessionId(pendingEvent);
+              if (pendingSessionId) {
+                setForeignSessionId(conversationKey, pendingSessionId, {
+                  modelId: model,
+                  cwd,
+                });
+              }
+              yield pendingEvent;
             }
-            yield pendingEvent;
           }
           yield { type: "__park__", tools: [...pendingTools.values()] };
           return;
         }
 
         parkControl.cancel?.();
-        if (raced.value.done) break;
+        if (raced.value.done) {
+          iterator.release(nextPromise);
+          break;
+        }
         const event = raced.value.value;
+        iterator.release(nextPromise);
+        noteFirstSdkEvent(event);
         const sessionId = extractSessionId(event);
         if (sessionId) {
           setForeignSessionId(conversationKey, sessionId, {
@@ -755,19 +956,28 @@ async function handleChatCompletions(
           });
         }
         yield event;
+        if (isTurnBoundary(event)) {
+          keepBridge = bridge.persistent === true && !isErrorResult(event);
+          return;
+        }
       }
     } finally {
-      if (!parked) {
-        handle?.close();
+      releasePump();
+      if (!keepBridge && !bridge.closed) {
         deleteBridge(bridgeId);
       }
     }
   }
 
-  bridge.continueStream = async function* () {
+  bridge.continueStream = async function* (suppliedReleasePump, requestSignal) {
+    log.info("[opencode-claude] bridge continuation", {
+      bridgeId,
+      conversationKey,
+      suppliedPump: suppliedReleasePump !== undefined,
+    });
     parked = false;
     parkWaiters = [];
-    yield* consumeStream();
+    yield* consumeStream(suppliedReleasePump, requestSignal);
   };
 
   // A turn that dies BEFORE producing any content (bad token, session limit,
@@ -785,6 +995,32 @@ async function handleChatCompletions(
   return collectTurnResponse(consumeStream(), body.model || model, bridge);
 }
 
+function toSdkUserPrompt(prompt: string | SdkUserPrompt): SdkUserPrompt {
+  if (typeof prompt !== "string") return prompt;
+  return {
+    type: "user",
+    message: { role: "user", content: prompt },
+    parent_tool_use_id: null,
+  };
+}
+
+function isTurnBoundary(event: unknown): boolean {
+  return (
+    !!event &&
+    typeof event === "object" &&
+    (event as { type?: unknown }).type === "result"
+  );
+}
+
+function isErrorResult(event: unknown): boolean {
+  return (
+    !!event &&
+    typeof event === "object" &&
+    (event as { type?: unknown; is_error?: unknown }).type === "result" &&
+    (event as { is_error?: unknown }).is_error === true
+  );
+}
+
 
 function extractSessionId(event: unknown): string | null {
   if (!event || typeof event !== "object") return null;
@@ -869,16 +1105,25 @@ async function buildOpenCodeMcpServer(
               resolve: () => {},
               reject: () => {},
             };
-            const resultPromise = new Promise<string>((resolve, reject) => {
-              pending.resolve = resolve;
-              pending.reject = reject;
-            });
+            const resultPromise = new Promise<ToolResultPayload>(
+              (resolve, reject) => {
+                pending.resolve = resolve;
+                pending.reject = reject;
+              },
+            );
             // Register before notifying so the stream consumer sees the tool.
             pendingTools.set(id, pending);
             onPark();
             const result = await resultPromise;
             return {
-              content: [{ type: "text", text: result }],
+              content: [
+                { type: "text" as const, text: result.text },
+                ...result.attachments.map((attachment) => ({
+                  type: "image" as const,
+                  data: attachment.data,
+                  mimeType: attachment.mimeType,
+                })),
+              ],
             };
           },
           { alwaysLoad: true },
@@ -922,7 +1167,10 @@ async function collectTurnResponse(
 
   let content = "";
   let reasoning = "";
-  let turnUsage: OpenAIUsage | null = null;
+  let usageState: AssistantUsageState = {
+    aggregate: null,
+    latest: bridge.lastAssistantUsage ?? null,
+  };
   let resultUsage: OpenAIUsage | null = null;
   let lastErrorNorm: string | null = null;
   let errorText: string | null = null;
@@ -949,12 +1197,13 @@ async function collectTurnResponse(
       } else if (mapped.kind === "reasoning") {
         if (!suppressReasoning) reasoning += mapped.text;
       } else if (mapped.kind === "usage-delta") {
-        turnUsage = addUniqueAssistantUsage(
-          turnUsage,
+        usageState = addUniqueAssistantUsageState(
+          usageState,
           mapped.usage,
           mapped.messageId,
           bridge.seenAssistantUsageIds,
         );
+        if (usageState.latest) bridge.lastAssistantUsage = usageState.latest;
       } else if (mapped.kind === "usage") {
         resultUsage = mapped.usage;
       } else if (mapped.kind === "error") {
@@ -972,7 +1221,7 @@ async function collectTurnResponse(
     noteError(message);
   }
 
-  const usage = resolveTurnUsage(turnUsage, resultUsage);
+  const usage = resolveOpenCodeUsage(usageState, resultUsage);
 
   // Buffered responses have not committed HTTP headers yet. Even if an agent
   // produced partial work first, preserve the real 429 so OpenCode starts its
@@ -1248,7 +1497,10 @@ function streamOpenAIResponse(
       });
 
       let finishReason: string | null = "stop";
-      let turnUsage: OpenAIUsage | null = null;
+      let usageState: AssistantUsageState = {
+        aggregate: null,
+        latest: bridge.lastAssistantUsage ?? null,
+      };
       let resultUsage: OpenAIUsage | null = null;
       let lastErrorNorm: string | null = null;
       const sendError = (text: string) => {
@@ -1362,12 +1614,13 @@ function streamOpenAIResponse(
           }
 
           if (mapped.kind === "usage-delta") {
-            turnUsage = addUniqueAssistantUsage(
-              turnUsage,
+            usageState = addUniqueAssistantUsageState(
+              usageState,
               mapped.usage,
               mapped.messageId,
               bridge.seenAssistantUsageIds,
             );
+            if (usageState.latest) bridge.lastAssistantUsage = usageState.latest;
           }
 
           if (mapped.kind === "usage") {
@@ -1401,7 +1654,7 @@ function streamOpenAIResponse(
         finishReason = "stop";
       }
 
-      const usage = resolveTurnUsage(turnUsage, resultUsage);
+      const usage = resolveOpenCodeUsage(usageState, resultUsage);
       if (!streamClosed) {
         send({
           id: completionId,
@@ -1429,6 +1682,10 @@ function streamOpenAIResponse(
       // the turn down instead of leaking the CLI process and the bridge.
       streamClosed = true;
       if (heartbeat) clearInterval(heartbeat);
+      log.info("[opencode-claude] client stream cancel", {
+        bridgeId: bridge.id,
+        conversationKey: bridge.conversationKey,
+      });
       deleteBridge(bridge.id);
     },
   });
@@ -1586,7 +1843,16 @@ function mapSdkEvent(event: unknown): MappedEvent {
   }
 
   if (e.type === "result") {
-    const usage = usageFromSdkResult(event);
+    const turnUsage = usageFromSdkTurnResult(event);
+    const accountingUsage = usageFromSdkResult(event);
+    const usage = turnUsage
+      ? {
+          ...turnUsage,
+          ...(accountingUsage?.model_usage !== undefined
+            ? { model_usage: accountingUsage.model_usage }
+            : {}),
+        }
+      : null;
     if (e.is_error) {
       const text =
         typeof e.result === "string"
diff --git a/src/query.ts b/src/query.ts
index e458a71..554c99c 100644
--- a/src/query.ts
+++ b/src/query.ts
@@ -349,6 +349,10 @@ export async function startClaudeQuery(
   const close = () => {
     if (closed) return;
     closed = true;
+    if (result && typeof result.close === "function") {
+      result.close();
+      return;
+    }
     killProcessTree(getPid(), { signal: "SIGTERM", force: true });
     if (result && typeof result.return === "function") {
       try {
diff --git a/src/request-kind.ts b/src/request-kind.ts
index de5296b..d51d447 100644
--- a/src/request-kind.ts
+++ b/src/request-kind.ts
@@ -11,6 +11,9 @@ type MessageLike = {
   content?: unknown;
 };
 
+const OPENCODE_UPDATE_SUMMARY_PATTERN =
+  /here is the conversation so far:\s*<conversation>[\s\S]*?<\/conversation>\s*here is the summary of the conversation before the <conversation> above:\s*<prior-summary>[\s\S]*?<\/prior-summary>\s*the <prior-summary> summarizes everything that happened before the <conversation>\. construct a new summary that combines both\.\s*output exactly the markdown structure shown inside <template>/;
+
 export function metaSystemPrompt(messages: MessageLike[]): string {
   return messages
     .filter((m) => m.role === "system")
@@ -49,6 +52,7 @@ export function isSummaryGenerationRequest(messages: MessageLike[]): boolean {
 
   const user = userText(messages).toLowerCase();
   return (
+    OPENCODE_UPDATE_SUMMARY_PATTERN.test(user) ||
     user.includes(
       "this summary will be the only context available when the conversation continues",
     ) ||
@@ -57,7 +61,8 @@ export function isSummaryGenerationRequest(messages: MessageLike[]): boolean {
     ) ||
     user.includes("anchored summary from the conversation history") ||
     user.includes("anchored summary below using the conversation history") ||
-    user.includes("<previous-summary>")
+    user.includes("<previous-summary>") ||
+    user.includes("<prior-summary>")
   );
 }
 
diff --git a/src/serialized-iterator.ts b/src/serialized-iterator.ts
new file mode 100644
index 0000000..c898c00
--- /dev/null
+++ b/src/serialized-iterator.ts
@@ -0,0 +1,74 @@
+/**
+ * Prevent overlapping calls to an async iterator while allowing a parked
+ * consumer to resume the same in-flight call later.
+ */
+export class SerializedAsyncIterator<T> {
+  private pending: Promise<IteratorResult<T>> | null = null;
+
+  constructor(
+    private readonly iterator: AsyncIterator<T>,
+    private readonly observer?: SerializedAsyncIteratorObserver,
+  ) {}
+
+  next(): Promise<IteratorResult<T>> {
+    if (this.pending) {
+      this.observer?.onNextStart?.(true);
+      return this.pending;
+    }
+
+    this.observer?.onNextStart?.(false);
+    const pending = Promise.resolve(this.iterator.next());
+    this.pending = pending;
+    void pending.then(
+      (result) => this.observer?.onNextFinish?.(result.done === true),
+      () => this.observer?.onNextError?.(),
+    );
+    return pending;
+  }
+
+  release(pending: Promise<IteratorResult<T>>): void {
+    if (this.pending === pending) {
+      this.pending = null;
+      this.observer?.onRelease?.();
+    }
+  }
+}
+
+export type SerializedAsyncIteratorObserver = {
+  onNextStart?: (shared: boolean) => void;
+  onNextFinish?: (done: boolean) => void;
+  onNextError?: () => void;
+  onRelease?: () => void;
+};
+
+type Deferred = {
+  promise: Promise<void>;
+  resolve: () => void;
+};
+
+function createDeferred(): Deferred {
+  let resolveDeferred: (() => void) | undefined;
+  const promise = new Promise<void>((resolve) => {
+    resolveDeferred = resolve;
+  });
+  if (!resolveDeferred) throw new Error("Failed to create pump lease");
+  return { promise, resolve: resolveDeferred };
+}
+
+export class ExclusivePumpGate {
+  private tail = Promise.resolve();
+
+  async acquire(): Promise<() => void> {
+    const previous = this.tail;
+    const next = createDeferred();
+    this.tail = next.promise;
+    await previous;
+
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      next.resolve();
+    };
+  }
+}
diff --git a/src/usage.ts b/src/usage.ts
index 49b6852..89e8866 100644
--- a/src/usage.ts
+++ b/src/usage.ts
@@ -30,6 +30,12 @@ export type OpenAIUsage = {
       context_window?: number;
     }
   >;
+  aggregate_usage?: OpenAIUsage;
+};
+
+export type AssistantUsageState = {
+  readonly aggregate: OpenAIUsage | null;
+  readonly latest: OpenAIUsage | null;
 };
 
 function asNumber(value: unknown): number {
@@ -146,6 +152,23 @@ export function usageFromSdkResult(event: unknown): OpenAIUsage | null {
   return null;
 }
 
+/** Extract the per-turn usage snapshot from an Agent SDK `result` event. */
+export function usageFromSdkTurnResult(event: unknown): OpenAIUsage | null {
+  if (!event || typeof event !== "object") return null;
+  const e = event as Record<string, unknown>;
+  if (e.type !== "result") return null;
+  if (!e.usage || typeof e.usage !== "object") return null;
+
+  const usage = fromAnthropicUsage(e.usage as Record<string, unknown>);
+  if (
+    typeof e.total_cost_usd === "number" &&
+    Number.isFinite(e.total_cost_usd)
+  ) {
+    usage.cost_usd = e.total_cost_usd;
+  }
+  return usage;
+}
+
 /**
  * Extract per-API-call usage from an Agent SDK `assistant` event
  * (`message.usage`). Each assistant event carries the usage of exactly one
@@ -210,6 +233,22 @@ export function addUniqueAssistantUsage(
   return addOpenAIUsage(acc, delta);
 }
 
+export function addUniqueAssistantUsageState(
+  state: AssistantUsageState,
+  delta: OpenAIUsage,
+  messageId: string | null,
+  seen: Set<string>,
+): AssistantUsageState {
+  if (messageId) {
+    if (seen.has(messageId)) return state;
+    seen.add(messageId);
+  }
+  return {
+    aggregate: addOpenAIUsage(state.aggregate, delta),
+    latest: delta,
+  };
+}
+
 /**
  * Combine the per-response accumulated usage (one entry per Anthropic API
  * call seen during this HTTP response) with the SDK `result` snapshot.
@@ -237,6 +276,37 @@ export function resolveTurnUsage(
   };
 }
 
+export function resolveOpenCodeUsage(
+  state: AssistantUsageState,
+  result: OpenAIUsage | null,
+): OpenAIUsage | null {
+  const current = state.latest ?? state.aggregate ?? result;
+  if (!current) return null;
+  const aggregate = state.aggregate;
+  const aggregateDiffers =
+    aggregate !== null &&
+    state.latest !== null &&
+    (aggregate.prompt_tokens !== state.latest.prompt_tokens ||
+      aggregate.completion_tokens !== state.latest.completion_tokens ||
+      aggregate.total_tokens !== state.latest.total_tokens ||
+      aggregate.prompt_tokens_details?.cached_tokens !==
+        state.latest.prompt_tokens_details?.cached_tokens ||
+      aggregate.prompt_tokens_details?.cache_write_tokens !==
+        state.latest.prompt_tokens_details?.cache_write_tokens);
+  return {
+    ...current,
+    ...(current.cost_usd === undefined && result?.cost_usd !== undefined
+      ? { cost_usd: result.cost_usd }
+      : {}),
+    ...(current.model_usage === undefined && result?.model_usage !== undefined
+      ? { model_usage: result.model_usage }
+      : {}),
+    ...(aggregateDiffers
+      ? { aggregate_usage: aggregate }
+      : {}),
+  };
+}
+
 export function formatCompactNote(meta: unknown): string {
   if (!meta || typeof meta !== "object") {
     return "[compact] Conversation compacted.\n";
diff --git a/test/bridge-teardown-regression.ts b/test/bridge-teardown-regression.ts
new file mode 100644
index 0000000..57c53a8
--- /dev/null
+++ b/test/bridge-teardown-regression.ts
@@ -0,0 +1,80 @@
+/**
+ * Regression: tearing a bridge down must not block the response path.
+ *
+ * `input.close()` tears the SDK stream down synchronously. Calling it inline
+ * put multi-second latency on every turn, because each request paid to close
+ * the previous turn's bridge before it could proceed. The close must still
+ * happen — the stream leak stays fixed — but off the critical path.
+ */
+import assert from "node:assert/strict";
+
+const { putBridge, deleteBridge, getBridge } = await import("../src/bridge-pool.ts");
+
+type CloseLog = { inputClosed: boolean; handleClosed: boolean };
+
+function makeBridge(
+  id: string,
+  conversationKey: string,
+  log: CloseLog,
+  handleCloseThrows = false,
+) {
+  return {
+    id,
+    conversationKey,
+    handle: {
+      close() {
+        log.handleClosed = true;
+        if (handleCloseThrows) throw new Error("close failed");
+      },
+    },
+    pendingTools: new Map(),
+    seenAssistantUsageIds: new Set<string>(),
+    createdAt: Date.now(),
+    input: {
+      close() {
+        log.inputClosed = true;
+      },
+    },
+  } as unknown as Parameters<typeof putBridge>[0];
+}
+
+const nextMacrotask = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+// deleteBridge: input.close() is deferred, everything else stays synchronous.
+const deleted: CloseLog = { inputClosed: false, handleClosed: false };
+putBridge(makeBridge("bridge-delete", "conv-delete", deleted));
+deleteBridge("bridge-delete");
+
+assert.equal(deleted.inputClosed, false, "input.close() must not run on the request path");
+assert.equal(deleted.handleClosed, true, "handle.close() still runs synchronously");
+assert.equal(getBridge("bridge-delete"), undefined, "bridge leaves the pool immediately");
+
+await nextMacrotask();
+assert.equal(deleted.inputClosed, true, "input.close() must still run, on the next tick");
+
+// putBridge superseding an earlier turn for the same conversation defers too.
+const superseded: CloseLog = { inputClosed: false, handleClosed: false };
+putBridge(makeBridge("bridge-old", "conv-supersede", superseded));
+putBridge(
+  makeBridge("bridge-new", "conv-supersede", { inputClosed: false, handleClosed: false }),
+);
+
+assert.equal(superseded.inputClosed, false, "superseded input.close() must not run synchronously");
+assert.equal(superseded.handleClosed, true, "superseded handle.close() still runs synchronously");
+
+await nextMacrotask();
+assert.equal(superseded.inputClosed, true, "superseded input.close() must still run");
+
+const throwing: CloseLog = { inputClosed: false, handleClosed: false };
+putBridge(makeBridge("bridge-throwing", "conv-throwing", throwing, true));
+assert.doesNotThrow(
+  () => deleteBridge("bridge-throwing"),
+  "handle close failure must not abort bridge removal",
+);
+assert.equal(
+  getBridge("bridge-throwing"),
+  undefined,
+  "bridge must leave the pool even when handle.close() throws",
+);
+
+console.log("bridge-teardown-regression: ok");
diff --git a/test/compaction-resume-regression.ts b/test/compaction-resume-regression.ts
new file mode 100644
index 0000000..5ecc7f2
--- /dev/null
+++ b/test/compaction-resume-regression.ts
@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const summaryPrompt = [
+  "Here is the conversation so far:",
+  "<conversation>old work</conversation>",
+  "Here is the summary of the conversation before the <conversation> above:",
+  "<prior-summary>compacted work</prior-summary>",
+  "The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both.",
+  "Output exactly the Markdown structure shown inside <template>",
+].join("\n");
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-data-"));
+const claudeConfigDir = mkdtempSync(join(homedir(), "opencode-claude-config-"));
+const oldSessionId = "old-claude-session";
+const sessionKey = "compaction-boundary-regression";
+mkdirSync(join(claudeConfigDir, "projects", "fixture"), { recursive: true });
+writeFileSync(
+  join(claudeConfigDir, "projects", "fixture", `${oldSessionId}.jsonl`),
+  "",
+  "utf8",
+);
+
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+
+const { clearForeignSessionId, getForeignSessionId, setForeignSessionId } =
+  await import("../src/session-store.ts");
+const {
+  getClaudeProxyBaseUrl,
+  setClaudeQueryStarter,
+  startProxy,
+  stopProxy,
+} = await import("../src/proxy.ts");
+
+const resumes: Array<string | undefined> = [];
+const prompts: Array<string | AsyncIterable<unknown>> = [];
+setForeignSessionId(sessionKey, oldSessionId);
+setClaudeQueryStarter(async (params) => {
+  resumes.push(params.resume);
+  prompts.push(params.prompt);
+  return {
+    stream: (async function* (): AsyncGenerator<unknown, void, unknown> {
+      yield {
+        type: "stream_event",
+        event: {
+          type: "content_block_delta",
+          delta: { type: "text_delta", text: "ok" },
+        },
+      };
+    })(),
+    interrupt: async () => {},
+    close: () => {},
+    getPid: () => null,
+  };
+});
+
+await startProxy();
+try {
+  const post = async (
+    messages: Array<{ role: string; content: string }>,
+  ): Promise<Response> =>
+    fetch(`${getClaudeProxyBaseUrl()}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencode-claude-session": sessionKey,
+      },
+      body: JSON.stringify({ model: "sonnet", stream: false, messages }),
+    });
+
+  const summaryResponse = await post([{ role: "user", content: summaryPrompt }]);
+  assert.equal(summaryResponse.status, 200);
+  assert.equal(
+    getForeignSessionId(sessionKey),
+    undefined,
+    "summary boundary must retire the old Claude session binding",
+  );
+  assert.deepEqual(resumes, [undefined]);
+
+  const continuationResponse = await post([
+    { role: "assistant", content: "compacted work" },
+    { role: "user", content: "continue after compaction" },
+  ]);
+  assert.equal(continuationResponse.status, 200);
+  assert.deepEqual(resumes, [undefined, undefined]);
+  const continuationPrompt = await firstPromptText(prompts[1]);
+  assert.match(
+    continuationPrompt,
+    /<conversation_history>[\s\S]*compacted work[\s\S]*<\/conversation_history>/,
+  );
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  clearForeignSessionId(sessionKey);
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+}
+
+async function firstPromptText(prompt: string | AsyncIterable<unknown>): Promise<string> {
+  if (typeof prompt === "string") return prompt;
+  const next = await prompt[Symbol.asyncIterator]().next();
+  return JSON.stringify(next.value);
+}
diff --git a/test/iterator-race-regression.ts b/test/iterator-race-regression.ts
new file mode 100644
index 0000000..783728e
--- /dev/null
+++ b/test/iterator-race-regression.ts
@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { SerializedAsyncIterator } from "../src/serialized-iterator.ts";
+
+let resolveFirst: ((result: IteratorResult<string>) => void) | undefined;
+let nextCalls = 0;
+const rawIterator: AsyncIterator<string> = {
+  next() {
+    nextCalls++;
+    if (nextCalls === 1) {
+      return new Promise<IteratorResult<string>>((resolve) => {
+        resolveFirst = resolve;
+      });
+    }
+    return Promise.resolve({ value: "second", done: false });
+  },
+};
+
+const iterator = new SerializedAsyncIterator(rawIterator);
+const first = iterator.next();
+const second = iterator.next();
+
+assert.equal(first, second, "an in-flight next() must be shared across continuations");
+assert.equal(nextCalls, 1, "a parked continuation must not call next() concurrently");
+
+resolveFirst?.({ value: "first", done: false });
+assert.deepEqual(await first, { value: "first", done: false });
+const resumed = iterator.next();
+assert.equal(
+  resumed,
+  first,
+  "a settled result must remain available until the continuation consumes it",
+);
+assert.deepEqual(await resumed, { value: "first", done: false });
+iterator.release(resumed);
+assert.deepEqual(await iterator.next(), { value: "second", done: false });
+assert.equal(nextCalls, 2, "the next event may be requested after the first settles");
+
+console.log("iterator-race-regression: ok");
diff --git a/test/lifecycle-instrumentation-regression.ts b/test/lifecycle-instrumentation-regression.ts
new file mode 100644
index 0000000..491c83e
--- /dev/null
+++ b/test/lifecycle-instrumentation-regression.ts
@@ -0,0 +1,80 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-log-data-"));
+const configHome = mkdtempSync(join(homedir(), "opencode-claude-log-config-"));
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+const previousRateLimitStore = process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+const previousDebug = process.env.OPENCODE_CLAUDE_DEBUG;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = configHome;
+process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = join(dataHome, "rate-limit.json");
+process.env.OPENCODE_CLAUDE_DEBUG = "1";
+
+const { setClaudeQueryStarter, startProxy, stopProxy } = await import("../src/proxy.ts");
+const { log } = await import("../src/log.ts");
+const sessionKey = `lifecycle-log-${randomUUID()}`;
+
+setClaudeQueryStarter(async () => ({
+  stream: (async function* () {
+    yield { type: "system", subtype: "init", session_id: "lifecycle-log-session" };
+    yield {
+      type: "stream_event",
+      event: {
+        type: "content_block_delta",
+        delta: { type: "text_delta", text: "instrumented" },
+      },
+    };
+    yield { type: "result", subtype: "success", is_error: false, result: "done" };
+  })(),
+  interrupt: async () => {},
+  close: () => {},
+  getPid: () => null,
+}));
+
+const port = await startProxy();
+try {
+  const response = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-opencode-claude-session": sessionKey,
+    },
+    body: JSON.stringify({
+      model: "sonnet",
+      stream: false,
+      messages: [{ role: "user", content: "instrumentation request" }],
+    }),
+  });
+  assert.equal(response.status, 200);
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  const output = readFileSync(log.filePath(), "utf8");
+  assert.match(output, /query start/);
+  assert.match(output, /query acquired/);
+  assert.match(output, /iterator next start/);
+  assert.match(output, /iterator next finish/);
+  assert.match(output, /first SDK event/);
+  assert.match(output, /bridge close/);
+  assert.doesNotMatch(output, /instrumentation request/);
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+  if (previousRateLimitStore === undefined) {
+    delete process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+  } else {
+    process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = previousRateLimitStore;
+  }
+  if (previousDebug === undefined) delete process.env.OPENCODE_CLAUDE_DEBUG;
+  else process.env.OPENCODE_CLAUDE_DEBUG = previousDebug;
+  rmSync(dataHome, { recursive: true, force: true });
+  rmSync(configHome, { recursive: true, force: true });
+}
+
+console.log("lifecycle-instrumentation-regression: ok");
diff --git a/test/persistent-continuation-lifecycle-regression.ts b/test/persistent-continuation-lifecycle-regression.ts
new file mode 100644
index 0000000..822eaa3
--- /dev/null
+++ b/test/persistent-continuation-lifecycle-regression.ts
@@ -0,0 +1,320 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type ToolCall = {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+};
+
+type CompletionResponse = {
+  choices?: Array<{
+    message?: { tool_calls?: ToolCall[] };
+  }>;
+};
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
+
+function asRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object") throw new Error(`${label} is not an object`);
+  return value as Record<string, unknown>;
+}
+
+function getMcpToolHandler(servers: Record<string, unknown> | undefined): ToolHandler {
+  const opencode = asRecord(servers?.opencode, "opencode MCP server");
+  const instance = asRecord(opencode.instance, "opencode MCP instance");
+  const registeredTools = asRecord(instance._registeredTools, "registered MCP tools");
+  const tool = asRecord(registeredTools.get_secret, "get_secret MCP tool");
+  const handler = tool.handler;
+  if (typeof handler !== "function") throw new Error("get_secret MCP tool is not callable");
+  return async (args) => handler(args);
+}
+
+const tools = [
+  {
+    type: "function",
+    function: {
+      name: "get_secret",
+      description: "Return a secret code for a label",
+      parameters: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"],
+      },
+    },
+  },
+];
+
+function initEvent(): unknown {
+  return { type: "system", subtype: "init", session_id: "lifecycle-session" };
+}
+
+function resultEvent(): unknown {
+  return { type: "result", subtype: "success", is_error: false, result: "done" };
+}
+
+function timeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => {
+      const timer = setTimeout(() => reject(new Error(message)), ms);
+      timer.unref?.();
+    }),
+  ]);
+}
+
+async function runPersistentContinuationTimeout(): Promise<void> {
+  const sessionKey = `persistent-timeout-${randomUUID()}`;
+  let closeCalled = false;
+  let resolveClosed: (() => void) | undefined;
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+  let rawNextCalls = 0;
+
+  setClaudeQueryStarter(async (params) => {
+    const toolHandler = getMcpToolHandler(params.mcpServers);
+    const rawIterator: AsyncIterator<unknown> & AsyncIterable<unknown> = {
+      next() {
+        rawNextCalls++;
+        if (rawNextCalls === 1) {
+          return Promise.resolve({ done: false, value: initEvent() });
+        }
+        if (rawNextCalls === 2) {
+          return new Promise<IteratorResult<unknown>>((_, reject) => {
+            void toolHandler({ label: "alpha" }).then(
+              () => {},
+              reject,
+            );
+          });
+        }
+        return Promise.resolve({ done: false, value: resultEvent() });
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
+    return {
+      stream: rawIterator,
+      interrupt: async () => {},
+      close: () => {
+        closeCalled = true;
+        resolveClosed?.();
+      },
+      getPid: () => null,
+    };
+  });
+
+  const { findBridgeByConversation } = await import("../src/bridge-pool.ts");
+  const port = await startProxy();
+  const post = (messages: Array<Record<string, unknown>>) =>
+    fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencode-claude-session": sessionKey,
+      },
+      body: JSON.stringify({ model: "sonnet", stream: false, messages, tools }),
+    });
+
+  try {
+    const first = await post([{ role: "user", content: "Call get_secret for alpha." }]);
+    const firstBody = (await first.json()) as CompletionResponse;
+    const toolCall = firstBody.choices?.[0]?.message?.tool_calls?.[0];
+    if (!toolCall) throw new Error("first response did not contain a tool call");
+
+    const second = await post([
+      { role: "user", content: "Call get_secret for alpha." },
+      { role: "assistant", tool_calls: [toolCall] },
+      { role: "tool", tool_call_id: toolCall.id, content: "SECRET_TOOL_VALUE" },
+    ]);
+    assert.equal(second.status, 500);
+    assert.match((await second.text()), /no output/i);
+    await timeout(closed, 2_500, "persistent continuation did not close its SDK handle");
+    assert.equal(closeCalled, true);
+    assert.equal(findBridgeByConversation(sessionKey), undefined);
+  } finally {
+    await stopProxy();
+  }
+}
+
+async function runPreContentCancellation(): Promise<void> {
+  const sessionKey = `persistent-cancel-${randomUUID()}`;
+  let resolveFirstNextStarted: (() => void) | undefined;
+  const firstNextStarted = new Promise<void>((resolve) => {
+    resolveFirstNextStarted = resolve;
+  });
+  let closeCalled = false;
+  let resolveClosed: (() => void) | undefined;
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+
+  setClaudeQueryStarter(async () => {
+    const rawIterator: AsyncIterator<unknown> & AsyncIterable<unknown> = {
+      next() {
+        resolveFirstNextStarted?.();
+        return new Promise<IteratorResult<unknown>>(() => {});
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
+    return {
+      stream: rawIterator,
+      interrupt: async () => {},
+      close: () => {
+        closeCalled = true;
+        resolveClosed?.();
+      },
+      getPid: () => null,
+    };
+  });
+
+  const port = await startProxy();
+  const abort = new AbortController();
+  const request = fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-opencode-claude-session": sessionKey,
+    },
+    body: JSON.stringify({
+      model: "sonnet",
+      stream: true,
+      messages: [{ role: "user", content: "wait" }],
+    }),
+    signal: abort.signal,
+  });
+
+  try {
+    await firstNextStarted;
+    abort.abort();
+    await assert.rejects(request);
+    await timeout(closed, 500, "pre-content cancellation did not close the SDK handle");
+    assert.equal(closeCalled, true);
+  } finally {
+    await stopProxy();
+  }
+}
+
+async function runResumedContinuationCancellation(): Promise<void> {
+  const sessionKey = `persistent-resumed-cancel-${randomUUID()}`;
+  let closeCalled = false;
+  let resolveClosed: (() => void) | undefined;
+  const closed = new Promise<void>((resolve) => {
+    resolveClosed = resolve;
+  });
+  let rawNextCalls = 0;
+
+  setClaudeQueryStarter(async (params) => {
+    const toolHandler = getMcpToolHandler(params.mcpServers);
+    const rawIterator: AsyncIterator<unknown> & AsyncIterable<unknown> = {
+      next() {
+        rawNextCalls++;
+        if (rawNextCalls === 1) {
+          return Promise.resolve({ done: false, value: initEvent() });
+        }
+        if (rawNextCalls === 2) {
+          return new Promise<IteratorResult<unknown>>((_, reject) => {
+            void toolHandler({ label: "alpha" }).then(
+              () => {},
+              reject,
+            );
+          });
+        }
+        return new Promise<IteratorResult<unknown>>(() => {});
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
+    return {
+      stream: rawIterator,
+      interrupt: async () => {},
+      close: () => {
+        closeCalled = true;
+        resolveClosed?.();
+      },
+      getPid: () => null,
+    };
+  });
+
+  const { findBridgeByConversation } = await import("../src/bridge-pool.ts");
+  const port = await startProxy();
+  const post = (messages: Array<Record<string, unknown>>, signal?: AbortSignal) =>
+    fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencode-claude-session": sessionKey,
+      },
+      body: JSON.stringify({ model: "sonnet", stream: false, messages, tools }),
+      signal,
+    });
+
+  try {
+    const first = await post([{ role: "user", content: "Call get_secret for alpha." }]);
+    const firstBody = (await first.json()) as CompletionResponse;
+    const toolCall = firstBody.choices?.[0]?.message?.tool_calls?.[0];
+    if (!toolCall) throw new Error("first response did not contain a tool call");
+
+    const abort = new AbortController();
+    const resumed = post(
+      [
+        { role: "user", content: "Call get_secret for alpha." },
+        { role: "assistant", tool_calls: [toolCall] },
+        { role: "tool", tool_call_id: toolCall.id, content: "SECRET_TOOL_VALUE" },
+      ],
+      abort.signal,
+    );
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    abort.abort();
+    await assert.rejects(resumed);
+    await timeout(closed, 500, "resumed continuation did not close its SDK handle");
+    assert.equal(closeCalled, true);
+    assert.equal(findBridgeByConversation(sessionKey), undefined);
+  } finally {
+    await stopProxy();
+  }
+}
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-lifecycle-data-"));
+const configHome = mkdtempSync(join(homedir(), "opencode-claude-lifecycle-config-"));
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+const previousRateLimitStore = process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+const previousStallEnv = process.env.OPENCODE_CLAUDE_TURN_STALL_MS;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = configHome;
+process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = join(dataHome, "rate-limit.json");
+process.env.OPENCODE_CLAUDE_TURN_STALL_MS = "1000";
+
+const { setClaudeQueryStarter, startProxy, stopProxy } = await import("../src/proxy.ts");
+
+try {
+  await runPersistentContinuationTimeout();
+  await runResumedContinuationCancellation();
+  await runPreContentCancellation();
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+  if (previousRateLimitStore === undefined) {
+    delete process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+  } else {
+    process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = previousRateLimitStore;
+  }
+  if (previousStallEnv === undefined) delete process.env.OPENCODE_CLAUDE_TURN_STALL_MS;
+  else process.env.OPENCODE_CLAUDE_TURN_STALL_MS = previousStallEnv;
+  rmSync(dataHome, { recursive: true, force: true });
+  rmSync(configHome, { recursive: true, force: true });
+}
+
+console.log("persistent-continuation-lifecycle-regression: ok");
diff --git a/test/persistent-park-race-regression.ts b/test/persistent-park-race-regression.ts
new file mode 100644
index 0000000..23ccff8
--- /dev/null
+++ b/test/persistent-park-race-regression.ts
@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type ToolCall = {
+  id: string;
+  type: "function";
+  function: { name: string; arguments: string };
+};
+
+type CompletionResponse = {
+  choices?: Array<{
+    message?: { content?: unknown; tool_calls?: ToolCall[] };
+  }>;
+};
+
+type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
+
+function asRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!value || typeof value !== "object") {
+    throw new Error(`${label} is not an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function getMcpToolHandler(servers: Record<string, unknown> | undefined): ToolHandler {
+  const opencode = asRecord(servers?.opencode, "opencode MCP server");
+  const instance = asRecord(opencode.instance, "opencode MCP instance");
+  const registeredTools = asRecord(instance._registeredTools, "registered MCP tools");
+  const tool = asRecord(registeredTools.get_secret, "get_secret MCP tool");
+  const handler = tool.handler;
+  if (typeof handler !== "function") {
+    throw new Error("get_secret MCP tool has no callable handler");
+  }
+  return async (args) => handler(args);
+}
+
+function textEvent(text: string): unknown {
+  return {
+    type: "stream_event",
+    event: {
+      type: "content_block_delta",
+      delta: { type: "text_delta", text },
+    },
+  };
+}
+
+function initEvent(): unknown {
+  return { type: "system", subtype: "init", session_id: "park-race-session" };
+}
+
+function resultEvent(): unknown {
+  return { type: "result", subtype: "success", is_error: false, result: "done" };
+}
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-park-race-data-"));
+const configHome = mkdtempSync(join(homedir(), "opencode-claude-park-race-config-"));
+const rateLimitStore = join(dataHome, "rate-limit.json");
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+const previousRateLimitStore = process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = configHome;
+process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = rateLimitStore;
+
+const { setClaudeQueryStarter, startProxy, stopProxy } = await import("../src/proxy.ts");
+
+const sessionKey = `persistent-park-race-${randomUUID()}`;
+const tools = [
+  {
+    type: "function",
+    function: {
+      name: "get_secret",
+      description: "Return a secret code for a label",
+      parameters: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"],
+      },
+    },
+  },
+];
+
+let rawNextCalls = 0;
+let activeRawNext = 0;
+let maxActiveRawNext = 0;
+let resolveParkedNext: ((result: IteratorResult<unknown>) => void) | undefined;
+
+async function trackNext(
+  promise: Promise<IteratorResult<unknown>>,
+): Promise<IteratorResult<unknown>> {
+  activeRawNext++;
+  maxActiveRawNext = Math.max(maxActiveRawNext, activeRawNext);
+  return promise.finally(() => {
+    activeRawNext--;
+  });
+}
+
+setClaudeQueryStarter(async (params) => {
+  const toolHandler = getMcpToolHandler(params.mcpServers);
+  const rawIterator: AsyncIterator<unknown> & AsyncIterable<unknown> = {
+    next() {
+      rawNextCalls++;
+      if (rawNextCalls === 1) {
+        return trackNext(Promise.resolve({ done: false, value: initEvent() }));
+      }
+      if (rawNextCalls === 2) {
+        const parked = new Promise<IteratorResult<unknown>>((resolve, reject) => {
+          resolveParkedNext = resolve;
+          void toolHandler({ label: "alpha" }).then(
+            () => {
+              const resolveNext = resolveParkedNext;
+              resolveParkedNext = undefined;
+              resolveNext?.({ done: false, value: textEvent("POST_TOOL_OK") });
+            },
+            reject,
+          );
+        });
+        return trackNext(parked);
+      }
+      if (rawNextCalls === 3) {
+        return trackNext(Promise.resolve({ done: false, value: resultEvent() }));
+      }
+      return trackNext(Promise.resolve({ done: true, value: undefined as never }));
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  return {
+    stream: rawIterator,
+    interrupt: async () => {},
+    close: () => {},
+    getPid: () => null,
+  };
+});
+
+const port = await startProxy();
+const post = async (messages: Array<Record<string, unknown>>): Promise<Response> =>
+  fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-opencode-claude-session": sessionKey,
+    },
+    body: JSON.stringify({ model: "sonnet", stream: false, messages, tools }),
+  });
+
+try {
+  const first = await post([{ role: "user", content: "Call get_secret for alpha." }]);
+  assert.equal(first.status, 200);
+  const firstBody = (await first.json()) as CompletionResponse;
+  const toolCall = firstBody.choices?.[0]?.message?.tool_calls?.[0];
+  if (!toolCall) throw new Error("first response did not contain a tool call");
+  assert.equal(toolCall.function.name, "get_secret");
+
+  const second = await post([
+    { role: "user", content: "Call get_secret for alpha." },
+    { role: "assistant", tool_calls: [toolCall] },
+    { role: "tool", tool_call_id: toolCall.id, content: "SECRET_TOOL_VALUE" },
+  ]);
+  assert.equal(second.status, 200);
+  const secondBody = (await second.json()) as CompletionResponse;
+  const content = String(secondBody.choices?.[0]?.message?.content ?? "");
+  assert.equal(
+    content.match(/POST_TOOL_OK/g)?.length ?? 0,
+    1,
+    "the pending post-tool event must be delivered exactly once",
+  );
+  assert.equal(
+    maxActiveRawNext,
+    1,
+    "MCP park/resume must not call the raw iterator concurrently",
+  );
+  assert.equal(rawNextCalls, 3, "resume must consume the held event before the result");
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+  if (previousRateLimitStore === undefined) {
+    delete process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+  } else {
+    process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = previousRateLimitStore;
+  }
+  rmSync(dataHome, { recursive: true, force: true });
+  rmSync(configHome, { recursive: true, force: true });
+}
+
+console.log("persistent-park-race-regression: ok");
diff --git a/test/persistent-pump-concurrency-regression.ts b/test/persistent-pump-concurrency-regression.ts
new file mode 100644
index 0000000..2f96509
--- /dev/null
+++ b/test/persistent-pump-concurrency-regression.ts
@@ -0,0 +1,144 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type CompletionResponse = {
+  choices?: Array<{ message?: { content?: unknown } }>;
+};
+
+function textEvent(text: string): unknown {
+  return {
+    type: "stream_event",
+    event: {
+      type: "content_block_delta",
+      delta: { type: "text_delta", text },
+    },
+  };
+}
+
+function initEvent(): unknown {
+  return { type: "system", subtype: "init", session_id: "pump-session" };
+}
+
+function resultEvent(): unknown {
+  return { type: "result", subtype: "success", is_error: false, result: "done" };
+}
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-pump-data-"));
+const configHome = mkdtempSync(join(homedir(), "opencode-claude-pump-config-"));
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+const previousRateLimitStore = process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = configHome;
+process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = join(dataHome, "rate-limit.json");
+
+const { setClaudeQueryStarter, startProxy, stopProxy } = await import("../src/proxy.ts");
+const { findBridgeByConversation } = await import("../src/bridge-pool.ts");
+
+const sessionKey = `persistent-pump-${randomUUID()}`;
+let rawNextCalls = 0;
+let resolveFirstEvent: ((result: IteratorResult<unknown>) => void) | undefined;
+let resolveFirstNextStarted: (() => void) | undefined;
+const firstNextStarted = new Promise<void>((resolve) => {
+  resolveFirstNextStarted = resolve;
+});
+
+setClaudeQueryStarter(async () => {
+  const rawIterator: AsyncIterator<unknown> & AsyncIterable<unknown> = {
+    next() {
+      rawNextCalls++;
+      if (rawNextCalls === 1) {
+        return Promise.resolve({ done: false, value: initEvent() });
+      }
+      if (rawNextCalls === 2) {
+        resolveFirstNextStarted?.();
+        return new Promise<IteratorResult<unknown>>((resolve) => {
+          resolveFirstEvent = resolve;
+        });
+      }
+      if (rawNextCalls === 3) {
+        return Promise.resolve({ done: false, value: resultEvent() });
+      }
+      if (rawNextCalls === 4) {
+        return Promise.resolve({ done: false, value: textEvent("SECOND_ONLY") });
+      }
+      return Promise.resolve({ done: false, value: resultEvent() });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+  };
+
+  return {
+    stream: rawIterator,
+    interrupt: async () => {},
+    close: () => {},
+    getPid: () => null,
+  };
+});
+
+const port = await startProxy();
+const post = async (content: string): Promise<Response> =>
+  fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-opencode-claude-session": sessionKey,
+    },
+    body: JSON.stringify({
+      model: "sonnet",
+      stream: false,
+      messages: [{ role: "user", content }],
+    }),
+  });
+
+try {
+  const firstPromise = post("first request");
+  await firstNextStarted;
+  const bridge = findBridgeByConversation(sessionKey);
+  if (!bridge?.continueStream) {
+    throw new Error("persistent bridge was not created");
+  }
+  const secondPump = bridge.continueStream();
+  const secondEventPromise = secondPump.next();
+  resolveFirstEvent?.({ done: false, value: textEvent("FIRST_ONLY") });
+
+  const first = await firstPromise;
+  assert.equal(first.status, 200);
+
+  const firstBody = (await first.json()) as CompletionResponse;
+  const firstContent = String(firstBody.choices?.[0]?.message?.content ?? "");
+  assert.match(firstContent, /FIRST_ONLY/);
+  const secondEvent = await secondEventPromise;
+  assert.equal(secondEvent.done, false);
+  assert.doesNotMatch(
+    JSON.stringify(secondEvent.value),
+    /FIRST_ONLY/,
+    "a second persistent pump must not receive the first pump's event",
+  );
+  assert.match(JSON.stringify(secondEvent.value), /SECOND_ONLY/);
+  assert.equal(rawNextCalls, 4, "the second pump must begin after the first completes");
+  const secondResult = await secondPump.next();
+  assert.equal(secondResult.done, false);
+  assert.match(JSON.stringify(secondResult.value), /result/);
+  assert.equal(rawNextCalls, 5);
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+  if (previousRateLimitStore === undefined) {
+    delete process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE;
+  } else {
+    process.env.OPENCODE_CLAUDE_RATE_LIMIT_STORE = previousRateLimitStore;
+  }
+  rmSync(dataHome, { recursive: true, force: true });
+  rmSync(configHome, { recursive: true, force: true });
+}
+
+console.log("persistent-pump-concurrency-regression: ok");
diff --git a/test/persistent-query-regression.ts b/test/persistent-query-regression.ts
new file mode 100644
index 0000000..5695e27
--- /dev/null
+++ b/test/persistent-query-regression.ts
@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const dataHome = mkdtempSync(join(homedir(), "opencode-claude-data-"));
+const claudeConfigDir = mkdtempSync(join(homedir(), "opencode-claude-config-"));
+const previousDataHome = process.env.XDG_DATA_HOME;
+const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
+process.env.XDG_DATA_HOME = dataHome;
+process.env.CLAUDE_CONFIG_DIR = claudeConfigDir;
+
+const { clearForeignSessionId } = await import("../src/session-store.ts");
+const {
+  getClaudeProxyBaseUrl,
+  setClaudeQueryStarter,
+  startProxy,
+  stopProxy,
+} = await import("../src/proxy.ts");
+
+const sessionKey = "persistent-query-regression";
+const starts: Array<{ prompt: unknown; mcpServers: unknown }> = [];
+const handles: unknown[] = [];
+const receivedPrompts: unknown[] = [];
+
+setClaudeQueryStarter(async (params) => {
+  starts.push({ prompt: params.prompt, mcpServers: params.mcpServers });
+  const input = params.prompt;
+  const stream = (async function* (): AsyncGenerator<unknown, void, unknown> {
+    if (typeof input === "string") {
+      receivedPrompts.push(input);
+      yield textEvent(input);
+      yield resultEvent();
+      return;
+    }
+
+    const iterator = input[Symbol.asyncIterator]();
+    while (true) {
+      const next = await iterator.next();
+      if (next.done) return;
+      receivedPrompts.push(next.value);
+      yield textEvent("reply");
+      yield resultEvent();
+    }
+  })();
+
+  const handle = {
+    stream,
+    interrupt: async () => {},
+    close: () => {},
+    getPid: () => null,
+  };
+  handles.push(handle);
+  return handle;
+});
+
+await startProxy();
+try {
+  const post = async (
+    messages: Array<Record<string, unknown>>,
+    tools?: Array<Record<string, unknown>>,
+  ): Promise<Response> =>
+    fetch(`${getClaudeProxyBaseUrl()}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencode-claude-session": sessionKey,
+      },
+      body: JSON.stringify({ model: "sonnet", stream: false, messages, tools }),
+    });
+
+  const tools = [
+    {
+      type: "function",
+      function: {
+        name: "read",
+        description: "Read a file",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string" } },
+          required: ["path"],
+        },
+      },
+    },
+  ];
+
+  const first = await post([{ role: "user", content: "first" }], tools);
+  assert.equal(first.status, 200);
+  assert.equal(starts.length, 1);
+
+  const second = await post([
+    { role: "user", content: "first" },
+    { role: "assistant", content: "reply" },
+    { role: "user", content: "second" },
+  ], tools);
+  assert.equal(second.status, 200);
+  assert.equal(starts.length, 1, "later turns must reuse one SDK query");
+  assert.ok(starts[0]?.mcpServers, "the first query must receive an MCP server");
+  assert.equal(receivedPrompts.length, 2);
+  assert.equal(
+    (receivedPrompts[1] as { message?: { content?: unknown } }).message?.content,
+    "second",
+  );
+
+  const summary = [
+    "Here is the conversation so far:",
+    "<conversation>old work</conversation>",
+    "Here is the summary of the conversation before the <conversation> above:",
+    "<prior-summary>compacted work</prior-summary>",
+    "The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both.",
+    "Output exactly the Markdown structure shown inside <template>",
+  ].join("\n");
+  const summaryResponse = await post([{ role: "user", content: summary }]);
+  assert.equal(summaryResponse.status, 200);
+  assert.equal(starts.length, 2);
+  assert.equal(handles.length, 2);
+  assert.notEqual(
+    handles[1],
+    handles[0],
+    "a summary boundary must create a separate SDK Query object",
+  );
+  assert.equal(
+    starts[1]?.mcpServers,
+    undefined,
+    "summary Query must not receive the normal-turn MCP server",
+  );
+
+  const continuation = await post([
+    { role: "assistant", content: "compacted work" },
+    { role: "user", content: "after compaction" },
+  ], tools);
+  assert.equal(continuation.status, 200);
+  assert.equal(
+    starts.length,
+    3,
+    "a summary boundary must retire the old persistent query",
+  );
+  assert.equal(handles.length, 3);
+  assert.notEqual(
+    handles[2],
+    handles[0],
+    "post-summary turns must not reuse the prior SDK Query object",
+  );
+  const firstMcpServer = (starts[0]?.mcpServers as { opencode?: unknown })?.opencode;
+  const nextMcpServer = (starts[2]?.mcpServers as { opencode?: unknown })?.opencode;
+  assert.ok(firstMcpServer, "the first normal Query must receive an MCP instance");
+  assert.ok(nextMcpServer, "the post-summary Query must receive an MCP instance");
+  assert.notEqual(
+    nextMcpServer,
+    firstMcpServer,
+    "separate Query lifecycles must not reuse the same MCP server instance",
+  );
+  // The SDK does not expose its private transport; McpServer identity is the
+  // public lifecycle boundary we can assert without reaching into internals.
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+  clearForeignSessionId(sessionKey);
+  if (previousDataHome === undefined) delete process.env.XDG_DATA_HOME;
+  else process.env.XDG_DATA_HOME = previousDataHome;
+  if (previousClaudeConfigDir === undefined) delete process.env.CLAUDE_CONFIG_DIR;
+  else process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
+}
+
+function textEvent(text: string): unknown {
+  return {
+    type: "stream_event",
+    event: {
+      type: "content_block_delta",
+      delta: { type: "text_delta", text },
+    },
+  };
+}
+
+function resultEvent(): unknown {
+  return { type: "result", subtype: "success", is_error: false, result: "ok" };
+}
diff --git a/test/pump-gate-regression.ts b/test/pump-gate-regression.ts
new file mode 100644
index 0000000..877b284
--- /dev/null
+++ b/test/pump-gate-regression.ts
@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { ExclusivePumpGate } from "../src/serialized-iterator.ts";
+
+const gate = new ExclusivePumpGate();
+const releaseFirst = await gate.acquire();
+
+let secondAcquired = false;
+const secondLeasePromise = gate.acquire().then((release) => {
+  secondAcquired = true;
+  return release;
+});
+
+await Promise.resolve();
+assert.equal(secondAcquired, false, "a second pump must wait for the first lease");
+
+releaseFirst();
+const releaseSecond = await secondLeasePromise;
+assert.equal(secondAcquired, true, "the second pump must acquire after release");
+
+let thirdAcquired = false;
+const thirdLeasePromise = gate.acquire().then((release) => {
+  thirdAcquired = true;
+  return release;
+});
+await Promise.resolve();
+assert.equal(thirdAcquired, false, "the third pump must wait for the second lease");
+
+releaseSecond();
+const releaseThird = await thirdLeasePromise;
+assert.equal(thirdAcquired, true, "the third pump must acquire after release");
+
+releaseThird();
+releaseThird();
+console.log("pump-gate-regression: ok");
diff --git a/test/request-kind-regression.ts b/test/request-kind-regression.ts
new file mode 100644
index 0000000..2229e87
--- /dev/null
+++ b/test/request-kind-regression.ts
@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import { detectMetaRequestKind } from "../src/request-kind.ts";
+
+const updateSummaryMessages = [
+  {
+    role: "user",
+    content: [
+      "Here is the conversation so far:",
+      "",
+      "<conversation>",
+      "User: Continue the implementation.",
+      "</conversation>",
+      "",
+      "Here is the summary of the conversation before the <conversation> above:",
+      "",
+      "<prior-summary>",
+      "## Objective\n- Continue the implementation",
+      "</prior-summary>",
+      "",
+      "The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both.",
+      "",
+      "Output exactly the Markdown structure shown inside <template> and keep the section order unchanged.",
+    ].join("\n"),
+  },
+];
+
+assert.equal(detectMetaRequestKind(updateSummaryMessages), "summary");
+assert.equal(
+  detectMetaRequestKind([{ role: "user", content: "<prior-summary>old</prior-summary>" }]),
+  "summary",
+);
+assert.equal(
+  detectMetaRequestKind([
+    { role: "system", content: "You are a coding assistant." },
+    { role: "user", content: "fix a bug" },
+  ]),
+  null,
+);
diff --git a/test/smoke.ts b/test/smoke.ts
index 048b4cb..cfc65b3 100644
--- a/test/smoke.ts
+++ b/test/smoke.ts
@@ -4,6 +4,7 @@
 import assert from "node:assert/strict";
 import { spawnSync } from "node:child_process";
 import { EventEmitter } from "node:events";
+import { fileURLToPath } from "node:url";
 
 async function main() {
   const { buildClaudeCodeChildEnv } = await import("../src/auth-env.ts");
@@ -215,9 +216,8 @@ async function main() {
 
   // CLI resolution finds install locations a clean server PATH misses.
   {
-    const { mkdtempSync, writeFileSync, chmodSync, mkdirSync } = await import(
-      "node:fs"
-    );
+    const { mkdtempSync, writeFileSync, copyFileSync, chmodSync, mkdirSync } =
+      await import("node:fs");
     const { tmpdir } = await import("node:os");
     const { join } = await import("node:path");
     const { resolveClaudeCli } = await import("../src/executable-path.ts");
@@ -225,20 +225,25 @@ async function main() {
     const home = mkdtempSync(join(tmpdir(), "oc-claude-home-"));
     const binDir = join(home, ".local", "bin");
     mkdirSync(binDir, { recursive: true });
-    const fake = join(binDir, "claude");
-    writeFileSync(
-      fake,
-      '#!/bin/sh\necho "2.1.226 (Claude Code)"\n',
-      { mode: 0o755 },
+    const fake = join(
+      binDir,
+      process.platform === "win32" ? "claude.exe" : "claude",
     );
-    chmodSync(fake, 0o755);
+    if (process.platform === "win32") {
+      copyFileSync(process.execPath, fake);
+    } else {
+      writeFileSync(fake, '#!/bin/sh\necho "2.1.226 (Claude Code)"\n', {
+        mode: 0o755,
+      });
+    }
+    if (process.platform !== "win32") chmodSync(fake, 0o755);
 
-    assert.equal(resolveClaudeCli({ PATH: "/usr/bin:/bin", HOME: home }), fake);
+    const resolverEnv = { ...process.env, PATH: "/usr/bin:/bin", HOME: home };
+    const resolved = resolveClaudeCli(resolverEnv);
+    assert.equal(resolved, fake);
+    assert.ok(resolved);
     // And PATH itself still wins when the CLI is on it.
-    assert.equal(
-      resolveClaudeCli({ PATH: "/usr/bin:/bin", HOME: home }).length > 0,
-      true,
-    );
+    assert.equal(resolved.length > 0, true);
   }
 
   // The one-click install path: official npm package, script as fallback.
@@ -331,6 +336,14 @@ async function main() {
   assert.equal(resolveClaudeModelId("haiku"), "claude-haiku-4-5");
   assert.equal(resolveClaudeModelId("sonnet"), "sonnet");
 
+  // 1M models declare an input window so OpenCode's auto-compaction trigger
+  // (limit.input minus reserved) fires predictably; 200K models stay untouched.
+  const aliasModel = (id: string) => CLAUDE_CODE_MODELS.find((m) => m.id === id)!;
+  assert.equal(aliasModel("fable").inputWindow, 900_000);
+  assert.equal(aliasModel("opus").inputWindow, 900_000);
+  assert.equal(aliasModel("sonnet").inputWindow, 900_000);
+  assert.equal(aliasModel("haiku").inputWindow, undefined);
+
   const sonnet = CLAUDE_CODE_MODELS.find((m) => m.id === "sonnet")!;
   const variants = buildEffortVariants(sonnet);
   for (const level of EFFORT_LEVELS) {
@@ -723,13 +736,13 @@ async function main() {
     if (existsSync(logPath)) unlinkSync(logPath);
 
     const off = spawnSync(
-      "bun",
+      process.execPath,
       [
         "-e",
         `import { log } from "./src/log.ts"; log.info("SILENT_INFO"); log.error("ALWAYS_ERROR");`,
       ],
       {
-        cwd: new URL("..", import.meta.url).pathname,
+        cwd: fileURLToPath(new URL("..", import.meta.url)),
         encoding: "utf8",
         env: { ...process.env, OPENCODE_CLAUDE_DEBUG: "0" },
       },
@@ -739,13 +752,13 @@ async function main() {
     assert.match(off.stderr, /ALWAYS_ERROR/);
 
     const on = spawnSync(
-      "bun",
+      process.execPath,
       [
         "-e",
         `import { log } from "./src/log.ts"; log.info("DEBUG_INFO", { ok: true });`,
       ],
       {
-        cwd: new URL("..", import.meta.url).pathname,
+        cwd: fileURLToPath(new URL("..", import.meta.url)),
         encoding: "utf8",
         env: { ...process.env, OPENCODE_CLAUDE_DEBUG: "1" },
       },
@@ -823,9 +836,9 @@ async function main() {
   // Title meta requests use a constrained, tool-free Agent SDK turn.
   {
     const { setClaudeQueryStarter } = await import("../src/proxy.ts");
-    let titleOptions: Record<string, unknown> | null = null;
+    const titleOptions = { value: null as Record<string, unknown> | null };
     setClaudeQueryStarter(async (params) => {
-      titleOptions = params as unknown as Record<string, unknown>;
+      titleOptions.value = params as unknown as Record<string, unknown>;
       return {
         stream: (async function* () {
           yield {
@@ -870,23 +883,26 @@ async function main() {
       assert.match(titleBody, /data: /);
       assert.match(titleBody, /\[DONE\]/);
       assert.match(titleBody, /Binary search trees/);
-      assert.ok(titleOptions, "title request reached Agent SDK");
+      const capturedTitleOptions = titleOptions.value;
+      if (!capturedTitleOptions) {
+        throw new Error("title request did not reach Agent SDK");
+      }
       assert.equal(
-        (titleOptions!.env as Record<string, unknown>).CLAUDE_CODE_OAUTH_TOKEN,
+        (capturedTitleOptions.env as Record<string, unknown>).CLAUDE_CODE_OAUTH_TOKEN,
         undefined,
       );
-      assert.deepEqual(titleOptions!.tools, []);
-      assert.deepEqual(titleOptions!.settingSources, []);
-      assert.deepEqual(titleOptions!.skills, []);
-      assert.equal(titleOptions!.maxTurns, 1);
-      assert.equal(titleOptions!.autoCompactEnabled, false);
-      assert.deepEqual(titleOptions!.thinking, { type: "disabled" });
-      assert.equal(titleOptions!.resume, undefined);
+      assert.deepEqual(capturedTitleOptions.tools, []);
+      assert.deepEqual(capturedTitleOptions.settingSources, []);
+      assert.deepEqual(capturedTitleOptions.skills, []);
+      assert.equal(capturedTitleOptions.maxTurns, 1);
+      assert.equal(capturedTitleOptions.autoCompactEnabled, false);
+      assert.deepEqual(capturedTitleOptions.thinking, { type: "disabled" });
+      assert.equal(capturedTitleOptions.resume, undefined);
       assert.equal(
-        titleOptions!.systemPrompt,
+        capturedTitleOptions.systemPrompt,
         "You generate short session titles. Follow the requested output format exactly.",
       );
-      assert.match(String(titleOptions!.prompt), /<request>\nExplain how binary search trees work\n<\/request>/);
+      assert.match(String(capturedTitleOptions.prompt), /<request>\nExplain how binary search trees work\n<\/request>/);
     } finally {
       setClaudeQueryStarter(null);
     }
@@ -903,7 +919,6 @@ async function main() {
       normalizeClaudeErrorText,
       parseResetTimeFromText,
       rateLimitGate,
-      recordRateLimitErrorText,
       recordRateLimitInfo,
     } = await import("../src/rate-limit.ts");
     const { setClaudeQueryStarter } = await import("../src/proxy.ts");
@@ -1027,9 +1042,9 @@ async function main() {
       // Proxy + mock SDK: successful turn streams text, note, usage — and the
       // todowrite alias + plan-persistence prompt reach the query starter.
       __resetRateLimitNoteDedupe();
-      let seenParams: Record<string, unknown> | null = null;
+      const seenParams = { value: null as Record<string, unknown> | null };
       setClaudeQueryStarter(async (params) => {
-        seenParams = params as unknown as Record<string, unknown>;
+        seenParams.value = params as unknown as Record<string, unknown>;
         const events = [
           { type: "system", subtype: "init", session_id: "mock-sess-1" },
           {
@@ -1123,13 +1138,16 @@ async function main() {
       assert.equal(okJson.usage?.prompt_tokens, 11);
 
       // Query starter received the todo alias + plan-persistence append
-      assert.ok(seenParams, "query starter params captured");
-      assert.equal(seenParams.cwd, "/data/projects/infra");
-      const aliases = (seenParams as { toolAliases?: Record<string, string> })
+      const capturedSeenParams = seenParams.value;
+      if (!capturedSeenParams) {
+        throw new Error("query starter params not captured");
+      }
+      assert.equal(capturedSeenParams.cwd, "/data/projects/infra");
+      const aliases = (capturedSeenParams as { toolAliases?: Record<string, string> })
         .toolAliases;
       assert.equal(aliases?.TodoWrite, "mcp__opencode__todowrite");
       assert.equal(aliases?.todowrite, "mcp__opencode__todowrite");
-      const sysPrompt = seenParams.systemPrompt as { append?: string };
+      const sysPrompt = capturedSeenParams.systemPrompt as { append?: string };
       assert.match(sysPrompt.append ?? "", /mcp__opencode__todowrite/);
       assert.match(sysPrompt.append ?? "", /[Bb]atch independent tool calls/);
 
@@ -1471,7 +1489,7 @@ async function main() {
       assert.match(String(res1Json.choices?.[0]?.message?.content ?? ""), /MOCK_OK/);
       assert.ok(seen1.params, "query starter called");
       assert.equal(seen1.params!.resume, undefined);
-      const promptText = String(seen1.params!.prompt ?? "");
+      const promptText = await readPromptText(seen1.params!.prompt);
       assert.match(promptText, /<conversation_history>/);
       assert.match(promptText, /AXIOM-9042/);
       assert.match(promptText, /Latest user message:\nwhat is the codename\?/);
@@ -1500,7 +1518,7 @@ async function main() {
       await res2.text();
       assert.equal(seen2.params!.resume, "mock-sess-live");
       assert.doesNotMatch(
-        String(seen2.params!.prompt ?? ""),
+        await readPromptText(seen2.params!.prompt),
         /<conversation_history>/,
       );
       rmSync(fakeProjectsDir, { recursive: true, force: true });
@@ -1514,7 +1532,10 @@ async function main() {
       assert.equal(res3.status, 200);
       await res3.text();
       assert.equal(seen3.params!.resume, undefined);
-      assert.match(String(seen3.params!.prompt ?? ""), /<conversation_history>/);
+      assert.match(
+        await readPromptText(seen3.params!.prompt),
+        /<conversation_history>/,
+      );
       assert.equal(getForeignSessionId("smoke-history-dead"), undefined);
 
       clearForeignSessionId("smoke-history-fresh");
@@ -1712,8 +1733,14 @@ async function main() {
   // ---- Turn stall watchdog + client-cancel teardown + CLI resolution cache ----
   {
     const { setClaudeQueryStarter } = await import("../src/proxy.ts");
-    const { mkdtempSync, rmSync, writeFileSync, chmodSync, unlinkSync } =
-      await import("node:fs");
+    const {
+      mkdtempSync,
+      rmSync,
+      writeFileSync,
+      copyFileSync,
+      chmodSync,
+      unlinkSync,
+    } = await import("node:fs");
     const { tmpdir } = await import("node:os");
     const { join: joinPath } = await import("node:path");
     const { resolveClaudeCli, resetClaudeCliResolutionCache } = await import(
@@ -1835,15 +1862,26 @@ async function main() {
     // child processes that hard-block the host's event loop on every query.
     const binDir = mkdtempSync(joinPath(tmpdir(), "oc-claude-bin-"));
     try {
-      const fakeCli = joinPath(binDir, "claude");
-      writeFileSync(fakeCli, "#!/bin/sh\necho 9.9.9-smoke\n");
-      chmodSync(fakeCli, 0o755);
+      const fakeCli = joinPath(
+        binDir,
+        process.platform === "win32" ? "claude.exe" : "claude",
+      );
+      if (process.platform === "win32") {
+        copyFileSync(process.execPath, fakeCli);
+      } else {
+        writeFileSync(fakeCli, "#!/bin/sh\necho 9.9.9-smoke\n");
+      }
+      if (process.platform !== "win32") chmodSync(fakeCli, 0o755);
       // HOME points at the temp dir so the well-known-location fallback
       // (~/.local/bin/claude on this dev box) cannot mask a negative result.
-      const env = { PATH: binDir, HOME: binDir };
+      const env = { ...process.env, PATH: binDir, HOME: binDir };
       resetClaudeCliResolutionCache();
       const first = resolveClaudeCli(env);
-      assert.ok(first && first.endsWith("claude"), "fake CLI resolved");
+      assert.ok(
+        first &&
+          /[\\/]claude(?:\.(?:cmd|exe|bat))?$/.test(first),
+        `fake CLI resolved: ${String(first)}`,
+      );
       unlinkSync(fakeCli);
       const second = resolveClaudeCli(env);
       assert.equal(second, first, "resolution must be memoized");
@@ -1862,8 +1900,8 @@ async function main() {
   await stopProxy();
 
   // TypeScript build
-  const build = spawnSync("bun", ["run", "build"], {
-    cwd: new URL("..", import.meta.url).pathname,
+  const build = spawnSync(process.execPath, ["run", "build"], {
+    cwd: fileURLToPath(new URL("..", import.meta.url)),
     encoding: "utf8",
   });
   if (build.status !== 0) {
@@ -1875,6 +1913,30 @@ async function main() {
   console.log("ok — opencode-claude smoke tests passed");
 }
 
+async function readPromptText(prompt: unknown): Promise<string> {
+  if (typeof prompt === "string") return prompt;
+  if (prompt && typeof prompt === "object" && Symbol.asyncIterator in prompt) {
+    const next = await (prompt as AsyncIterable<unknown>)[
+      Symbol.asyncIterator
+    ]().next();
+    if (
+      next.value &&
+      typeof next.value === "object" &&
+      "message" in next.value &&
+      next.value.message &&
+      typeof next.value.message === "object" &&
+      "content" in next.value.message &&
+      typeof next.value.message.content === "string"
+    ) {
+      return next.value.message.content;
+    }
+    return typeof next.value === "string"
+      ? next.value
+      : (JSON.stringify(next.value) ?? String(next.value));
+  }
+  return String(prompt ?? "");
+}
+
 main().catch((err) => {
   console.error(err);
   process.exit(1);
diff --git a/test/usage-regression.ts b/test/usage-regression.ts
new file mode 100644
index 0000000..f0c5233
--- /dev/null
+++ b/test/usage-regression.ts
@@ -0,0 +1,243 @@
+import assert from "node:assert/strict";
+import {
+  addUniqueAssistantUsageState,
+  resolveOpenCodeUsage,
+  usageFromSdkResult,
+  usageFromSdkTurnResult,
+} from "../src/usage.ts";
+
+const firstContext = {
+  prompt_tokens: 899_900,
+  completion_tokens: 100,
+  total_tokens: 900_000,
+  prompt_tokens_details: { cached_tokens: 899_000 },
+};
+const secondContext = {
+  prompt_tokens: 949_900,
+  completion_tokens: 100,
+  total_tokens: 950_000,
+  prompt_tokens_details: { cached_tokens: 949_000 },
+};
+const seen = new Set<string>();
+const firstState = addUniqueAssistantUsageState(
+  { aggregate: null, latest: null },
+  firstContext,
+  "sdk-context-1",
+  seen,
+);
+const secondState = addUniqueAssistantUsageState(
+  firstState,
+  secondContext,
+  "sdk-context-2",
+  seen,
+);
+const contextUsage = resolveOpenCodeUsage(secondState, null);
+
+assert.equal(contextUsage?.total_tokens, secondContext.total_tokens);
+assert.equal(
+  contextUsage?.aggregate_usage?.total_tokens,
+  firstContext.total_tokens + secondContext.total_tokens,
+);
+const replayOnlyUsage = resolveOpenCodeUsage(
+  { aggregate: null, latest: firstContext },
+  {
+    prompt_tokens: 1_850_000,
+    completion_tokens: 200,
+    total_tokens: 1_850_200,
+  },
+);
+assert.equal(replayOnlyUsage?.total_tokens, firstContext.total_tokens);
+assert.deepEqual(
+  addUniqueAssistantUsageState(
+    secondState,
+    firstContext,
+    "sdk-context-1",
+    seen,
+  ),
+  secondState,
+);
+const continuationSeen = new Set(["sdk-context-1"]);
+const replayedContinuation = addUniqueAssistantUsageState(
+  { aggregate: null, latest: firstContext },
+  firstContext,
+  "sdk-context-1",
+  continuationSeen,
+);
+const continuedState = addUniqueAssistantUsageState(
+  replayedContinuation,
+  secondContext,
+  "sdk-context-2",
+  continuationSeen,
+);
+assert.equal(continuedState.latest?.total_tokens, secondContext.total_tokens);
+assert.equal(
+  continuedState.aggregate?.total_tokens,
+  secondContext.total_tokens,
+);
+
+const singleState = addUniqueAssistantUsageState(
+  { aggregate: null, latest: null },
+  firstContext,
+  "sdk-single",
+  new Set<string>(),
+);
+assert.equal(
+  resolveOpenCodeUsage(singleState, null)?.aggregate_usage,
+  undefined,
+);
+
+const resultEvent = {
+  type: "result",
+  usage: {
+    input_tokens: 900,
+    output_tokens: 100,
+    cache_read_input_tokens: 949_000,
+  },
+  modelUsage: {
+    sonnet: {
+      inputTokens: 1_800,
+      outputTokens: 200,
+      cacheReadInputTokens: 1_848_000,
+      cacheCreationInputTokens: 0,
+      costUSD: 0.42,
+    },
+  },
+};
+assert.equal(usageFromSdkResult(resultEvent)?.total_tokens, 1_850_000);
+assert.equal(usageFromSdkTurnResult(resultEvent)?.total_tokens, 950_000);
+
+const {
+  getClaudeProxyBaseUrl,
+  setClaudeQueryStarter,
+  startProxy,
+  stopProxy,
+} = await import("../src/proxy.ts");
+const proxyEvents = [
+  {
+    type: "assistant",
+    message: {
+      id: "sdk-proxy-1",
+      usage: {
+        input_tokens: 900,
+        output_tokens: 100,
+        cache_read_input_tokens: 899_000,
+      },
+    },
+  },
+  {
+    type: "stream_event",
+    event: {
+      type: "content_block_delta",
+      delta: { type: "text_delta", text: "ok" },
+    },
+  },
+  {
+    type: "assistant",
+    message: {
+      id: "sdk-proxy-2",
+      usage: {
+        input_tokens: 900,
+        output_tokens: 100,
+        cache_read_input_tokens: 949_000,
+      },
+    },
+  },
+  { type: "result", is_error: false, usage: {} },
+];
+setClaudeQueryStarter(async () => ({
+  stream: (async function* () {
+    for (const event of proxyEvents) yield event;
+  })(),
+  interrupt: async () => {},
+  close: () => {},
+  getPid: () => null,
+}));
+await startProxy();
+try {
+  const request = async (stream: boolean, suffix: string): Promise<Response> =>
+    fetch(`${getClaudeProxyBaseUrl()}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-opencode-claude-session": `usage-regression-${suffix}`,
+      },
+      body: JSON.stringify({
+        model: "sonnet",
+        stream,
+        messages: [{ role: "user", content: "measure usage" }],
+      }),
+    });
+
+  const bufferedResponse = await request(false, "buffered");
+  assert.equal(bufferedResponse.status, 200);
+  const bufferedUsage = (await bufferedResponse.json()) as {
+    usage?: {
+      total_tokens?: number;
+      aggregate_usage?: { total_tokens?: number };
+    };
+  };
+  assert.equal(bufferedUsage.usage?.total_tokens, 950_000);
+  assert.equal(bufferedUsage.usage?.aggregate_usage?.total_tokens, 1_850_000);
+
+  const streamingResponse = await request(true, "streaming");
+  assert.equal(streamingResponse.status, 200);
+  const payloads = (await streamingResponse.text())
+    .split("\n\n")
+    .flatMap((block) => {
+      const line = block
+        .split("\n")
+        .find((candidate) => candidate.startsWith("data: "));
+      return line && line !== "data: [DONE]"
+        ? [
+            JSON.parse(line.slice("data: ".length)) as {
+              usage?: {
+                total_tokens?: number;
+                aggregate_usage?: { total_tokens?: number };
+              };
+            },
+          ]
+        : [];
+    });
+  const usage = payloads.find((payload) => payload.usage)?.usage;
+  assert.equal(usage?.total_tokens, 950_000);
+  assert.equal(usage?.aggregate_usage?.total_tokens, 1_850_000);
+
+  setClaudeQueryStarter(async () => ({
+    stream: (async function* () {
+      yield {
+        type: "stream_event",
+        event: {
+          type: "content_block_delta",
+          delta: { type: "text_delta", text: "fallback" },
+        },
+      };
+      yield resultEvent;
+    })(),
+    interrupt: async () => {},
+    close: () => {},
+    getPid: () => null,
+  }));
+  const fallbackResponse = await request(true, "result-fallback");
+  assert.equal(fallbackResponse.status, 200);
+  const fallbackPayloads = (await fallbackResponse.text())
+    .split("\n\n")
+    .flatMap((block) => {
+      const line = block
+        .split("\n")
+        .find((candidate) => candidate.startsWith("data: "));
+      return line && line !== "data: [DONE]"
+        ? [
+            JSON.parse(line.slice("data: ".length)) as {
+              usage?: { total_tokens?: number };
+            },
+          ]
+        : [];
+    });
+  assert.equal(
+    fallbackPayloads.find((payload) => payload.usage)?.usage?.total_tokens,
+    950_000,
+  );
+} finally {
+  setClaudeQueryStarter(null);
+  await stopProxy();
+}