From 29ffae048a3a7a1625344eb6be52823b0dab1bf0 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Thu, 3 Sep 2026 19:59:20 +0300
Subject: [PATCH 01/18] fix: report per-turn usage across compaction
 continuations

---
 src/bridge-pool.ts       |   3 +
 src/proxy.ts             |  41 +++++--
 src/usage.ts             |  70 +++++++++++
 test/usage-regression.ts | 243 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 346 insertions(+), 11 deletions(-)
 create mode 100644 test/usage-regression.ts

diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index 9259084..b880d66 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -3,6 +3,7 @@
  * (Cursor bridge-pool pattern).
  */
 import type { ClaudeQueryHandle } from "./query.js";
+import type { OpenAIUsage } from "./usage.js";
 
 export type ParkedToolCall = {
   id: string;
@@ -19,6 +20,8 @@ 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>;
diff --git a/src/proxy.ts b/src/proxy.ts
index 8aae174..53ba639 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -67,11 +67,13 @@ import {
   requestKeyNamespace,
 } from "./request-kind.js";
 import {
-  addUniqueAssistantUsage,
+  addUniqueAssistantUsageState,
   formatCompactNote,
-  resolveTurnUsage,
+  resolveOpenCodeUsage,
   usageFromAssistantEvent,
   usageFromSdkResult,
+  usageFromSdkTurnResult,
+  type AssistantUsageState,
   type OpenAIUsage,
 } from "./usage.js";
 
@@ -922,7 +924,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 +954,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 +978,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 +1254,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 +1371,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 +1411,7 @@ function streamOpenAIResponse(
         finishReason = "stop";
       }
 
-      const usage = resolveTurnUsage(turnUsage, resultUsage);
+      const usage = resolveOpenCodeUsage(usageState, resultUsage);
       if (!streamClosed) {
         send({
           id: completionId,
@@ -1586,7 +1596,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/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/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();
+}

From 994db2b40e6bc802b29348c7b563793aacdfe66b Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Thu, 3 Sep 2026 20:00:35 +0300
Subject: [PATCH 02/18] fix: classify OpenCode summary updates as metadata

---
 src/request-kind.ts             |  4 ++++
 test/request-kind-regression.ts | 34 +++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+)
 create mode 100644 test/request-kind-regression.ts

diff --git a/src/request-kind.ts b/src/request-kind.ts
index de5296b..2a70b75 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",
     ) ||
diff --git a/test/request-kind-regression.ts b/test/request-kind-regression.ts
new file mode 100644
index 0000000..147ff58
--- /dev/null
+++ b/test/request-kind-regression.ts
@@ -0,0 +1,34 @@
+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: "system", content: "You are a coding assistant." },
+    { role: "user", content: "fix a bug" },
+  ]),
+  null,
+);

From 848ed77c3ff013c5aa0069de82c05e0b05bd82f5 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Thu, 3 Sep 2026 20:01:30 +0300
Subject: [PATCH 03/18] test: wire compaction regressions into package suite

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 382e607..9f80469 100644
--- a/package.json
+++ b/package.json
@@ -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",
     "test:haiku": "bun test/haiku-live.ts",
     "prepublishOnly": "npm run build"
   },

From fb4d999127e4d3ecc52b33c3ab2539fc252af75e Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Fri, 4 Sep 2026 13:16:02 +0300
Subject: [PATCH 04/18] test: cover Claude session reset after compaction

---
 package.json                         |   2 +-
 test/compaction-resume-regression.ts | 103 +++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 1 deletion(-)
 create mode 100644 test/compaction-resume-regression.ts

diff --git a/package.json b/package.json
index 9f80469..1513663 100644
--- a/package.json
+++ b/package.json
@@ -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 && bun test/usage-regression.ts && bun test/request-kind-regression.ts",
+    "test": "bun test/smoke.ts && bun test/usage-regression.ts && bun test/request-kind-regression.ts && bun test/compaction-resume-regression.ts",
     "test:haiku": "bun test/haiku-live.ts",
     "prepublishOnly": "npm run build"
   },
diff --git a/test/compaction-resume-regression.ts b/test/compaction-resume-regression.ts
new file mode 100644
index 0000000..bd3f4eb
--- /dev/null
+++ b/test/compaction-resume-regression.ts
@@ -0,0 +1,103 @@
+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]);
+  assert.match(
+    String(prompts[1]),
+    /<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;
+}

From f858a34b1b7b82419d304644f4f78576ff5a93e3 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Fri, 4 Sep 2026 13:16:13 +0300
Subject: [PATCH 05/18] fix: reset Claude session after compaction

---
 src/proxy.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/proxy.ts b/src/proxy.ts
index 53ba639..630a4eb 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -356,9 +356,15 @@ 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.
+    clearForeignSessionId(baseConversationKey);
+  }
   const selection = selectionFromRequest(req, body);
   const model = resolveClaudeModelId(selection.modelId);
   const stream = body.stream !== false;

From 5f600b86dc6df45d9a8248d8e5f54f2110091d44 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 17:41:38 +0300
Subject: [PATCH 06/18] feat(claude-prompt): persistent prompt input queue

Introduce ClaudePromptInput, a long-lived AsyncIterable<SDKUserMessage>
backed by an unbounded queue. Each push() resolves the next pending
pull; close() releases any waiting consumer. This is the primitive the
proxy uses to stream user input into a persistent Agent SDK Query.
---
 src/prompt-input.ts | 61 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 src/prompt-input.ts

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(),
+  };
+}

From 95841421e17e10e401900a81158fd01c36238d28 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 19:51:47 +0300
Subject: [PATCH 07/18] refactor(bridge-pool): persist bridge input and
 iterator

---
 src/bridge-pool.ts | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index b880d66..bc5899c 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -3,6 +3,7 @@
  * (Cursor bridge-pool pattern).
  */
 import type { ClaudeQueryHandle } from "./query.js";
+import type { ClaudePromptInput } from "./prompt-input.js";
 import type { OpenAIUsage } from "./usage.js";
 
 export type ParkedToolCall = {
@@ -25,6 +26,12 @@ export type ParkedBridge = {
   createdAt: number;
   /** Continues consuming the SDK stream after tools resolve. */
   continueStream?: () => AsyncGenerator<unknown, void, unknown>;
+  input?: ClaudePromptInput;
+  streamIterator?: AsyncIterator<unknown>;
+  persistent?: boolean;
+  closed?: boolean;
+  modelId?: string;
+  cwd?: string;
 };
 
 const bridges = new Map<string, ParkedBridge>();
@@ -37,6 +44,8 @@ export function putBridge(bridge: ParkedBridge): void {
         tool.reject(new Error("Superseded by a newer turn"));
       }
       existing.pendingTools.clear();
+      existing.input?.close();
+      existing.closed = true;
       try {
         existing.handle.close();
       } catch {
@@ -70,12 +79,20 @@ 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.input?.close();
   bridge.handle.close();
   bridges.delete(id);
 }

From 55112dbd7641ef8e13b98070783b6d0bcb69e62a Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 19:52:33 +0300
Subject: [PATCH 08/18] feat(proxy): reuse Claude SDK Query across normal turns

---
 src/proxy.ts        | 86 ++++++++++++++++++++++++++++++++++++++++-----
 src/query.ts        |  4 +++
 src/request-kind.ts |  3 +-
 3 files changed, 83 insertions(+), 10 deletions(-)

diff --git a/src/proxy.ts b/src/proxy.ts
index 630a4eb..e03d1dd 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -10,7 +10,9 @@
  */
 import { createHash, randomUUID } from "node:crypto";
 import {
+  clearAllBridges,
   deleteBridge,
+  deleteBridgesByConversation,
   findBridgeByConversation,
   findBridgeByPendingTool,
   putBridge,
@@ -61,6 +63,7 @@ import {
   withConversationContext,
   type SdkUserPrompt,
 } from "./prompt.js";
+import { createClaudePromptInput } from "./prompt-input.js";
 import {
   detectMetaRequestKind,
   metaSystemPrompt,
@@ -260,6 +263,7 @@ export async function startProxy(): Promise<number> {
 }
 
 export async function stopProxy(): Promise<void> {
+  clearAllBridges();
   if (server) {
     server.stop(true);
     server = null;
@@ -363,11 +367,15 @@ async function handleChatCompletions(
   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);
@@ -441,9 +449,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;
@@ -521,6 +526,24 @@ 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 {
+      existing.input.push(toSdkUserPrompt(prompt));
+      const continued = existing.continueStream();
+      return stream
+        ? streamOpenAIResponse(continued, body.model || model, existing)
+        : collectTurnResponse(continued, body.model || model, existing);
+    }
+  }
+
   let resume = getForeignSessionId(conversationKey);
   if (resume && !findClaudeSessionFile(resume)) {
     // The claude CLI resumes by looking the session up on disk. A missing
@@ -584,7 +607,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.",
@@ -596,7 +619,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
@@ -608,7 +639,7 @@ async function handleChatCompletions(
         ].filter(Boolean).join("\n\n")
     : undefined;
   handle = await queryStarter({
-    prompt: queryPrompt,
+    prompt: sdkPrompt,
     cwd,
     model,
     resume: isMetaRequest ? undefined : resume,
@@ -657,6 +688,7 @@ async function handleChatCompletions(
         : {}),
     },
   });
+  const streamIterator = handle.stream[Symbol.asyncIterator]();
 
   const bridge: ParkedBridge = {
     id: bridgeId,
@@ -665,11 +697,17 @@ async function handleChatCompletions(
     pendingTools,
     seenAssistantUsageIds: new Set(),
     createdAt: Date.now(),
+    input: persistentInput,
+    streamIterator,
+    persistent: !isMetaRequest,
+    modelId: model,
+    cwd,
   };
   putBridge(bridge);
 
   async function* consumeStream(): AsyncGenerator<unknown, void, unknown> {
-    const iterator = handle!.stream[Symbol.asyncIterator]();
+    const iterator = streamIterator;
+    let keepBridge = false;
     try {
       while (true) {
         const parkControl = {
@@ -731,6 +769,7 @@ async function handleChatCompletions(
         }
 
         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
@@ -763,10 +802,13 @@ async function handleChatCompletions(
           });
         }
         yield event;
+        if (isTurnBoundary(event)) {
+          keepBridge = bridge.persistent === true && !isErrorResult(event);
+          return;
+        }
       }
     } finally {
-      if (!parked) {
-        handle?.close();
+      if (!keepBridge && !bridge.closed) {
         deleteBridge(bridgeId);
       }
     }
@@ -793,6 +835,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;
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 2a70b75..d51d447 100644
--- a/src/request-kind.ts
+++ b/src/request-kind.ts
@@ -61,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>")
   );
 }
 

From 0c89d3a81c7159b333255c4f28c73c329a621d7e Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 19:52:52 +0300
Subject: [PATCH 09/18] fix(executable-path): resolve Windows Claude CLI
 fallbacks

---
 src/executable-path.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

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
   }

From ae1a42e06ddda7ef53f65686832cae3eaf6d6fdd Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 19:53:25 +0300
Subject: [PATCH 10/18] test: cover persistent Claude Query lifecycle

---
 package.json                         |   4 +-
 test/compaction-resume-regression.ts |   9 +-
 test/persistent-query-regression.ts  | 177 +++++++++++++++++++++++++++
 test/request-kind-regression.ts      |   4 +
 test/smoke.ts                        | 154 +++++++++++++++--------
 5 files changed, 295 insertions(+), 53 deletions(-)
 create mode 100644 test/persistent-query-regression.ts

diff --git a/package.json b/package.json
index 1513663..4532a15 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 && bun test/usage-regression.ts && bun test/request-kind-regression.ts && bun test/compaction-resume-regression.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",
     "test:haiku": "bun test/haiku-live.ts",
     "prepublishOnly": "npm run build"
   },
diff --git a/test/compaction-resume-regression.ts b/test/compaction-resume-regression.ts
index bd3f4eb..5ecc7f2 100644
--- a/test/compaction-resume-regression.ts
+++ b/test/compaction-resume-regression.ts
@@ -88,8 +88,9 @@ try {
   ]);
   assert.equal(continuationResponse.status, 200);
   assert.deepEqual(resumes, [undefined, undefined]);
+  const continuationPrompt = await firstPromptText(prompts[1]);
   assert.match(
-    String(prompts[1]),
+    continuationPrompt,
     /<conversation_history>[\s\S]*compacted work[\s\S]*<\/conversation_history>/,
   );
 } finally {
@@ -101,3 +102,9 @@ try {
   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/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/request-kind-regression.ts b/test/request-kind-regression.ts
index 147ff58..2229e87 100644
--- a/test/request-kind-regression.ts
+++ b/test/request-kind-regression.ts
@@ -25,6 +25,10 @@ const updateSummaryMessages = [
 ];
 
 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." },
diff --git a/test/smoke.ts b/test/smoke.ts
index 048b4cb..7bd07d5 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.
@@ -723,13 +728,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 +744,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 +828,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 +875,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 +911,6 @@ async function main() {
       normalizeClaudeErrorText,
       parseResetTimeFromText,
       rateLimitGate,
-      recordRateLimitErrorText,
       recordRateLimitInfo,
     } = await import("../src/rate-limit.ts");
     const { setClaudeQueryStarter } = await import("../src/proxy.ts");
@@ -1027,9 +1034,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 +1130,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 +1481,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 +1510,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 +1524,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 +1725,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 +1854,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 +1892,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 +1905,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);

From d0cb807004379febf06c4cb7dd01ecc7166c9818 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 6 Sep 2026 21:13:20 +0300
Subject: [PATCH 11/18] perf(bridge-pool): defer input.close() off the response
 path
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Closing the prompt input tears the SDK stream down synchronously. Doing it
inline meant every turn paid to close the previous turn's bridge before it
could proceed, adding seconds to every request. Measured on Windows with
Opus 5: ~11s for a trivial prompt, ~3s once deferred.

The close still happens, so the stream leak this branch fixes stays fixed —
it just runs on the next macrotask instead of while a request is waiting.
handle.close() and removal from the pool remain synchronous.

Adds test/bridge-teardown-regression.ts covering both teardown paths:
deleteBridge, and putBridge superseding an earlier turn for the same
conversation.
---
 package.json                       |  2 +-
 src/bridge-pool.ts                 | 24 +++++++++++-
 test/bridge-teardown-regression.ts | 62 ++++++++++++++++++++++++++++++
 3 files changed, 85 insertions(+), 3 deletions(-)
 create mode 100644 test/bridge-teardown-regression.ts

diff --git a/package.json b/package.json
index 4532a15..ba02519 100644
--- a/package.json
+++ b/package.json
@@ -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 && bun test/usage-regression.ts && bun test/request-kind-regression.ts && bun test/compaction-resume-regression.ts && bun test/persistent-query-regression.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",
     "test:haiku": "bun test/haiku-live.ts",
     "prepublishOnly": "npm run build"
   },
diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index bc5899c..be174d7 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -36,6 +36,26 @@ export type ParkedBridge = {
 
 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) {
@@ -44,7 +64,7 @@ export function putBridge(bridge: ParkedBridge): void {
         tool.reject(new Error("Superseded by a newer turn"));
       }
       existing.pendingTools.clear();
-      existing.input?.close();
+      closeInputDeferred(existing);
       existing.closed = true;
       try {
         existing.handle.close();
@@ -92,7 +112,7 @@ export function deleteBridge(id: string): void {
   for (const tool of bridge.pendingTools.values()) {
     tool.reject(new Error("Bridge closed"));
   }
-  bridge.input?.close();
+  closeInputDeferred(bridge);
   bridge.handle.close();
   bridges.delete(id);
 }
diff --git a/test/bridge-teardown-regression.ts b/test/bridge-teardown-regression.ts
new file mode 100644
index 0000000..2620cf6
--- /dev/null
+++ b/test/bridge-teardown-regression.ts
@@ -0,0 +1,62 @@
+/**
+ * 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) {
+  return {
+    id,
+    conversationKey,
+    handle: {
+      close() {
+        log.handleClosed = true;
+      },
+    },
+    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");
+
+console.log("bridge-teardown-regression: ok");

From 0b1aa2fb87988b698dbdb27cf74d6717d2fda0a9 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sat, 12 Sep 2026 08:00:33 +0300
Subject: [PATCH 12/18] refactor(iterator): serialize SDK stream pulls

---
 src/serialized-iterator.ts       | 74 ++++++++++++++++++++++++++++++++
 test/iterator-race-regression.ts | 38 ++++++++++++++++
 test/pump-gate-regression.ts     | 34 +++++++++++++++
 3 files changed, 146 insertions(+)
 create mode 100644 src/serialized-iterator.ts
 create mode 100644 test/iterator-race-regression.ts
 create mode 100644 test/pump-gate-regression.ts

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/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/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");

From 00b87c96656493de43ce5079dcd39b8e65137377 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sat, 12 Sep 2026 08:00:52 +0300
Subject: [PATCH 13/18] fix(bridge-pool): harden bridge teardown

---
 src/bridge-pool.ts                 | 23 ++++++++++++++++++++---
 test/bridge-teardown-regression.ts | 20 +++++++++++++++++++-
 2 files changed, 39 insertions(+), 4 deletions(-)

diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index be174d7..de367d0 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -4,7 +4,9 @@
  */
 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";
 
 export type ParkedToolCall = {
   id: string;
@@ -25,7 +27,11 @@ export type ParkedBridge = {
   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;
@@ -112,9 +118,20 @@ export function deleteBridge(id: string): void {
   for (const tool of bridge.pendingTools.values()) {
     tool.reject(new Error("Bridge closed"));
   }
+  bridge.pendingTools.clear();
   closeInputDeferred(bridge);
-  bridge.handle.close();
-  bridges.delete(id);
+  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/test/bridge-teardown-regression.ts b/test/bridge-teardown-regression.ts
index 2620cf6..57c53a8 100644
--- a/test/bridge-teardown-regression.ts
+++ b/test/bridge-teardown-regression.ts
@@ -12,13 +12,19 @@ const { putBridge, deleteBridge, getBridge } = await import("../src/bridge-pool.
 
 type CloseLog = { inputClosed: boolean; handleClosed: boolean };
 
-function makeBridge(id: string, conversationKey: string, log: CloseLog) {
+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(),
@@ -59,4 +65,16 @@ assert.equal(superseded.handleClosed, true, "superseded handle.close() still run
 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");

From 8c24d641b5176a8efaf1e9372e7403bdcabe0145 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sat, 12 Sep 2026 08:01:09 +0300
Subject: [PATCH 14/18] fix(proxy): serialize persistent response pumps

---
 src/proxy.ts                                  | 228 +++++++++++++-----
 test/persistent-park-race-regression.ts       | 195 +++++++++++++++
 .../persistent-pump-concurrency-regression.ts | 144 +++++++++++
 3 files changed, 507 insertions(+), 60 deletions(-)
 create mode 100644 test/persistent-park-race-regression.ts
 create mode 100644 test/persistent-pump-concurrency-regression.ts

diff --git a/src/proxy.ts b/src/proxy.ts
index e03d1dd..29365fb 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -64,6 +64,10 @@ import {
   type SdkUserPrompt,
 } from "./prompt.js";
 import { createClaudePromptInput } from "./prompt-input.js";
+import {
+  ExclusivePumpGate,
+  SerializedAsyncIterator,
+} from "./serialized-iterator.js";
 import {
   detectMetaRequestKind,
   metaSystemPrompt,
@@ -391,47 +395,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();
     }
   }
 
@@ -457,6 +463,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();
@@ -536,11 +547,29 @@ async function handleChatCompletions(
       deleteBridge(existing.id);
       existing = undefined;
     } else {
-      existing.input.push(toSdkUserPrompt(prompt));
-      const continued = existing.continueStream();
-      return stream
-        ? streamOpenAIResponse(continued, body.model || model, existing)
-        : collectTurnResponse(continued, body.model || model, existing);
+      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();
+      }
     }
   }
 
@@ -638,6 +667,14 @@ 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: sdkPrompt,
     cwd,
@@ -688,7 +725,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,
@@ -698,16 +754,34 @@ async function handleChatCompletions(
     seenAssistantUsageIds: new Set(),
     createdAt: Date.now(),
     input: persistentInput,
-    streamIterator,
+    streamIterator: serializedIterator,
+    pumpGate: new ExclusivePumpGate(),
     persistent: !isMetaRequest,
     modelId: model,
     cwd,
   };
   putBridge(bridge);
 
-  async function* consumeStream(): AsyncGenerator<unknown, void, unknown> {
-    const iterator = streamIterator;
+  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 = {
@@ -744,6 +818,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:
@@ -754,18 +834,27 @@ 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)) {
@@ -776,24 +865,33 @@ async function handleChatCompletions(
           // 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, {
@@ -808,16 +906,22 @@ async function handleChatCompletions(
         }
       }
     } finally {
+      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,
@@ -1513,6 +1617,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);
     },
   });
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");

From 0865ab1dab99e3d2b25aa5ee86aa4bf620b956bb Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sat, 12 Sep 2026 08:01:27 +0300
Subject: [PATCH 15/18] test: cover persistent continuation cancellation

---
 ...stent-continuation-lifecycle-regression.ts | 320 ++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 test/persistent-continuation-lifecycle-regression.ts

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");

From f6fe917147323ab10fda5380aea7d31ef8085573 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sat, 12 Sep 2026 08:01:50 +0300
Subject: [PATCH 16/18] test: cover lifecycle instrumentation

---
 package.json                                 |  2 +-
 test/lifecycle-instrumentation-regression.ts | 80 ++++++++++++++++++++
 2 files changed, 81 insertions(+), 1 deletion(-)
 create mode 100644 test/lifecycle-instrumentation-regression.ts

diff --git a/package.json b/package.json
index ba02519..2b43ed6 100644
--- a/package.json
+++ b/package.json
@@ -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 && 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",
+    "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/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");

From de6c8158ec4c5db389d82d3d988ae2d0bb6ee515 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Sun, 13 Sep 2026 21:12:48 +0300
Subject: [PATCH 17/18] feat(models): declare input window for 1M models

OpenCode schedules automatic compaction at (limit.input - reserved)
when a model declares an input cap, falling back to (context - maxOutput)
otherwise. The 1M Claude Code models declared only context/output, so
scheduled compaction landed at the very edge of the window (~98%
observed in long sessions). Declaring a 900k input window moves the
trigger to ~88-90% and leaves 200K models unchanged.
---
 src/index.ts  | 2 ++
 src/models.ts | 8 ++++++--
 test/smoke.ts | 8 ++++++++
 3 files changed, 16 insertions(+), 2 deletions(-)

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/test/smoke.ts b/test/smoke.ts
index 7bd07d5..cfc65b3 100644
--- a/test/smoke.ts
+++ b/test/smoke.ts
@@ -336,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) {

From 7d8f4998e923a82fe9036a3921791554c5d22759 Mon Sep 17 00:00:00 2001
From: "Mohamed R. Khalil" <m.radwan.khalil@gmail.com>
Date: Wed, 16 Sep 2026 16:52:41 +0300
Subject: [PATCH 18/18] fix(proxy): relay tool-result media to the parked
 Claude turn
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

OpenCode cannot carry media inside tool results for openai-compatible
providers (the claude-code provider), so it promotes tool media — e.g.
`read` on an image — into a synthetic user message
("Attached media from tool result:"). In the parked-bridge path that
message was dropped: the turn resumed by resolving the parked MCP call
with text only, so Claude never saw the image.

- collectToolResults returns {text, attachments}; image parts are
  extracted when a transport does carry them inside the tool result.
- collectSyntheticToolMedia finds OpenCode’s promoted synthetic
  message; its images merge into the single resolved tool call payload.
- Parked MCP replies now emit `image` content blocks next to `text`.

Verified on OpenCode + claude-code/opus:
- `read` on a PNG → model reports the exact image text.
- `read` on a JPEG → same.
- plain text, bash tool, and text-file reads unchanged.
- repo test suite (bun, 12 regression files) green.
---
 src/bridge-pool.ts |   9 +++-
 src/prompt.ts      | 109 +++++++++++++++++++++++++++++++++++++++++++++
 src/proxy.ts       |  81 +++++++++++++++++++++++++++++----
 3 files changed, 190 insertions(+), 9 deletions(-)

diff --git a/src/bridge-pool.ts b/src/bridge-pool.ts
index de367d0..a03f9c8 100644
--- a/src/bridge-pool.ts
+++ b/src/bridge-pool.ts
@@ -7,12 +7,19 @@ 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;
 };
 
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 29365fb..e780610 100644
--- a/src/proxy.ts
+++ b/src/proxy.ts
@@ -18,6 +18,7 @@ import {
   putBridge,
   type ParkedBridge,
   type ParkedToolCall,
+  type ToolResultPayload,
 } from "./bridge-pool.js";
 import { buildClaudeCodeChildEnv } from "./auth-env.js";
 import {
@@ -57,6 +58,7 @@ import {
 import {
   buildConversationTranscript,
   extractTextContent,
+  extractToolResultImages,
   latestUserPrompt,
   priorMessagesOf,
   promptAsStream,
@@ -335,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,
@@ -383,6 +419,26 @@ async function handleChatCompletions(
 
   // 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) {
@@ -1049,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 },