@khalilgharbaoui/opencode-claude-code-plugin 0.9.3 → 0.10.0

package/dist/index.js

@@ -733,6 +733,10 @@ import * as fs2 from "fs";
 import * as path2 from "path";
 import * as os2 from "os";
 import * as crypto from "crypto";
+import {
+  parse as parseJsonc,
+  printParseErrorCode
+} from "jsonc-parser";
 
 // src/tmp.ts
 import * as fs from "fs";
@@ -776,49 +780,18 @@ function dirExists(p) {
     return false;
   }
 }
-function stripJsonComments(text) {
-  let out = "";
-  let i = 0;
-  let inString = null;
-  while (i < text.length) {
-    const c = text[i];
-    if (inString) {
-      out += c;
-      if (c === "\\" && i + 1 < text.length) {
-        out += text[i + 1];
-        i += 2;
-        continue;
-      }
-      if (c === inString) inString = null;
-      i++;
-      continue;
-    }
-    if (c === '"' || c === "'") {
-      inString = c;
-      out += c;
-      i++;
-      continue;
-    }
-    if (c === "/" && text[i + 1] === "/") {
-      while (i < text.length && text[i] !== "\n") i++;
-      continue;
-    }
-    if (c === "/" && text[i + 1] === "*") {
-      i += 2;
-      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/"))
-        i++;
-      i += 2;
-      continue;
-    }
-    out += c;
-    i++;
-  }
-  return out;
-}
 function readAndParse(file) {
   try {
     const raw = fs2.readFileSync(file, "utf8");
-    return JSON.parse(stripJsonComments(raw));
+    const errors = [];
+    const parsed = parseJsonc(raw, errors, { allowTrailingComma: true });
+    if (errors.length > 0) {
+      const first = errors[0];
+      throw new Error(
+        `${printParseErrorCode(first.error)} at offset ${first.offset}`
+      );
+    }
+    return parsed;
   } catch (e) {
     log.warn("failed to parse opencode config", {
       file,
@@ -1243,6 +1216,8 @@ function cliSupportsThinking(v) {
 var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
 var MAX_ACTIVE_PROCESSES = 16;
+var PROCESS_EXIT_TIMEOUT_MS = 1500;
+var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
 function envFlagEnabled(value) {
   if (value === void 0) return false;
   const normalized = value.trim().toLowerCase();
@@ -1289,13 +1264,54 @@ function getActiveProcess(key) {
 function setActiveProcess(key, ap) {
   activeProcesses.set(key, ap);
 }
-function deleteActiveProcess(key) {
+function detachActiveProcess(key) {
   const ap = activeProcesses.get(key);
-  if (ap) {
-    void ap.proxyServer?.close();
-    ap.proc.kill();
-    activeProcesses.delete(key);
-  }
+  if (!ap) return void 0;
+  activeProcesses.delete(key);
+  void ap.proxyServer?.close();
+  return ap;
+}
+function deleteActiveProcess(key) {
+  const ap = detachActiveProcess(key);
+  ap?.proc.kill();
+}
+function hasProcessExited(proc) {
+  return proc.exitCode !== null || proc.signalCode !== null;
+}
+function waitForProcessExit(proc, timeoutMs) {
+  if (hasProcessExited(proc)) return Promise.resolve(true);
+  return new Promise((resolve4) => {
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve4(true);
+    };
+    const timer = setTimeout(() => {
+      proc.off("exit", onExit);
+      resolve4(hasProcessExited(proc));
+    }, timeoutMs);
+    proc.once("exit", onExit);
+  });
+}
+async function deleteActiveProcessAndWait(key, options = {}) {
+  const ap = detachActiveProcess(key);
+  if (!ap || hasProcessExited(ap.proc)) return true;
+  const gracefulExit = waitForProcessExit(
+    ap.proc,
+    options.exitTimeoutMs ?? PROCESS_EXIT_TIMEOUT_MS
+  );
+  ap.proc.kill();
+  if (await gracefulExit) return true;
+  const forcedExit = waitForProcessExit(
+    ap.proc,
+    options.forceExitTimeoutMs ?? PROCESS_FORCE_EXIT_TIMEOUT_MS
+  );
+  ap.proc.kill("SIGKILL");
+  if (await forcedExit) return true;
+  log.warn("claude process did not exit; starting a fresh session", {
+    sessionKey: key
+  });
+  deleteClaudeSessionId(key);
+  return false;
 }
 function getClaudeSessionId(key) {
   return claudeSessions.get(key);
@@ -1343,8 +1359,9 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
       void unlink(systemPromptFile).catch(() => {
       });
     }
-    activeProcesses.delete(sessionKey2);
-    if (code !== 0 && code !== null) {
+    const ownsSessionKey = activeProcesses.get(sessionKey2) === ap;
+    if (ownsSessionKey) activeProcesses.delete(sessionKey2);
+    if (ownsSessionKey && code !== 0 && code !== null) {
       log.info("process exited with error, clearing session", {
         code,
         sessionKey: sessionKey2
@@ -1355,16 +1372,50 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   proc.stderr?.on("data", (data) => {
     const stderr = data.toString();
     log.debug("stderr", { data: stderr.slice(0, 200) });
-    if (stderr.includes("Session ID") && (stderr.includes("already in use") || stderr.includes("not found") || stderr.includes("invalid"))) {
-      log.warn("claude session ID error, clearing session", {
-        sessionKey: sessionKey2,
-        error: stderr.slice(0, 200)
-      });
-      claudeSessions.delete(sessionKey2);
+    if (stderr.includes("No conversation found") || stderr.includes("Session ID") && (stderr.includes("already in use") || stderr.includes("not found") || stderr.includes("invalid"))) {
+      if (activeProcesses.get(sessionKey2) === ap) {
+        log.warn("claude session ID error, clearing session", {
+          sessionKey: sessionKey2,
+          error: stderr.slice(0, 200)
+        });
+        claudeSessions.delete(sessionKey2);
+      } else {
+        log.debug("ignoring session ID error from stale claude process", {
+          sessionKey: sessionKey2
+        });
+      }
     }
   });
   return ap;
 }
+function appendResumeIfNeeded(sessionKey2, cliArgs) {
+  if (cliArgs.includes("--resume") || cliArgs.includes("--session-id")) {
+    return cliArgs;
+  }
+  const sid = claudeSessions.get(sessionKey2);
+  if (!sid) return cliArgs;
+  return [...cliArgs, "--resume", sid];
+}
+function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropicApiKey) {
+  const old = activeProcesses.get(sessionKey2);
+  if (!old) return void 0;
+  activeProcesses.delete(sessionKey2);
+  old.proc.removeAllListeners("exit");
+  try {
+    old.proc.kill();
+  } catch {
+  }
+  return spawnClaudeProcess(
+    cliPath,
+    appendResumeIfNeeded(sessionKey2, cliArgs),
+    cwd,
+    sessionKey2,
+    old.proxyServer,
+    old.mcpHash,
+    old.systemPromptFile,
+    ignoreAnthropicApiKey
+  );
+}
 function buildCliArgs(opts) {
   const {
     sessionKey: sessionKey2,
@@ -1398,7 +1449,7 @@ function buildCliArgs(opts) {
   if (includeSessionId) {
     const sessionId = claudeSessions.get(sessionKey2);
     if (sessionId && !activeProcesses.has(sessionKey2)) {
-      args.push("--session-id", sessionId);
+      args.push("--resume", sessionId);
     }
   }
   if (mcpConfig) {
@@ -1990,10 +2041,61 @@ import * as fs4 from "fs";
 import * as path4 from "path";
 import * as crypto2 from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
+var SERVER_CLOSED_MESSAGE = "proxy MCP server closed";
+function isExpectedCleanupError(message) {
+  return message.includes("timed out after") && message.includes("waiting for opencode to resolve") || message.includes("rejecting as orphaned") || message.includes("was orphaned by a new user turn") || message.includes("stream was aborted") || message.includes(SERVER_CLOSED_MESSAGE);
+}
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
-var PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
+var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
+  task: 60 * 60 * 1e3
+  // 60 min
+};
+var MAX_PROXY_TIMEOUT_MS = 2 ** 31 - 1;
+function resolveProxyCallTimeoutMs(toolName, input, overrides) {
+  const key = toolName.toLowerCase();
+  let ms = PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS[key] ?? PROXY_DEFAULT_TIMEOUT_MS;
+  if (overrides) {
+    const ov = lookupCaseInsensitive(overrides, key);
+    if (typeof ov === "number" && ov > 0) ms = ov;
+  }
+  if (key === "bash") {
+    const requested = input?.timeout;
+    if (typeof requested === "number" && requested > ms) ms = requested;
+  }
+  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
+}
+function lookupCaseInsensitive(map, key) {
+  if (Object.prototype.hasOwnProperty.call(map, key)) return map[key];
+  for (const k of Object.keys(map)) {
+    if (k.toLowerCase() === key) return map[k];
+  }
+  return void 0;
+}
+function resolveProxyClientCeilingMs(overrides) {
+  let ms = PROXY_DEFAULT_TIMEOUT_MS;
+  for (const v of Object.values(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
+    if (v > ms) ms = v;
+  }
+  if (overrides) {
+    for (const v of Object.values(overrides)) {
+      if (typeof v === "number" && v > ms) ms = v;
+    }
+  }
+  return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
+}
+function buildProxyTimeoutError(toolName, ms) {
+  const key = toolName.toLowerCase();
+  const base = `Proxy tool '${toolName}' timed out after ${ms}ms waiting for opencode to resolve the call`;
+  if (key === "task") {
+    return new Error(
+      base + " (the subagent). The subagent may still be running but its result is no longer reachable in this session. Do not declare the dispatch failed, and do not 'schedule a wake-up' or defer -- that mechanism does not apply here. If the result is required, re-dispatch or verify it directly now."
+    );
+  }
+  return new Error(base);
+}
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -2086,7 +2188,7 @@ var DEFAULT_PROXY_TOOLS = [
   },
   {
     name: "task",
-    description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). The call blocks until the subagent finishes; the 10-minute proxy timeout applies.",
+    description: "Launch an opencode subagent to handle a complex multi-step task autonomously. Routed through opencode's task tool so subagent orchestration, permission, and lifecycle are handled by opencode. Use `subagent_type` to pick which configured subagent runs (e.g. `build`, `general`, `explore`, or any custom subagent declared in opencode.json). Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).",
     inputSchema: {
       type: "object",
       properties: {
@@ -2109,13 +2211,17 @@ var DEFAULT_PROXY_TOOLS = [
         command: {
           type: "string",
           description: "The command that triggered this task"
+        },
+        background: {
+          type: "boolean",
+          description: "Run the task in the background when supported by opencode"
         }
       },
       required: ["description", "prompt", "subagent_type"]
     }
   }
 ];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides) {
   const calls = new EventEmitter3();
   const pending = /* @__PURE__ */ new Map();
   const server2 = createServer(async (req, res) => {
@@ -2124,13 +2230,17 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       res.end();
       return;
     }
+    let requestId = null;
+    let requestMethod = null;
     try {
       const body = await readBody(req);
       const request = JSON.parse(body);
+      requestId = request?.id ?? null;
+      requestMethod = typeof request?.method === "string" ? request.method : null;
       if (request?.jsonrpc !== "2.0" || typeof request.method !== "string") {
         writeJson(res, {
           jsonrpc: "2.0",
-          id: request?.id ?? null,
+          id: requestId,
           error: { code: -32600, message: "Invalid request" }
         });
         return;
@@ -2142,7 +2252,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       if (request.method === "initialize") {
         writeJson(res, {
           jsonrpc: "2.0",
-          id: request.id ?? null,
+          id: requestId,
           result: {
             protocolVersion: PROTOCOL_VERSION,
             capabilities: { tools: {} },
@@ -2162,7 +2272,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       if (request.method === "tools/list") {
         writeJson(res, {
           jsonrpc: "2.0",
-          id: request.id ?? null,
+          id: requestId,
           result: {
             tools: tools.map((t) => ({
               name: t.name,
@@ -2180,10 +2290,10 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         if (!tools.some((t) => t.name === toolName)) {
           writeJson(res, {
             jsonrpc: "2.0",
-            id: request.id ?? null,
-            error: {
-              code: -32601,
-              message: `Unknown proxy tool: ${toolName}`
+            id: requestId,
+            result: {
+              content: [{ type: "text", text: `Unknown proxy tool: ${toolName}` }],
+              isError: true
             }
           });
           return;
@@ -2205,20 +2315,21 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
               reject
             };
             pending.set(callId, entry);
+            const deadlineMs = resolveProxyCallTimeoutMs(
+              toolName,
+              input,
+              timeoutOverrides
+            );
             timer = setTimeout(() => {
               if (!pending.has(callId)) return;
               pending.delete(callId);
               log.notice("proxy-mcp tool call timed out", {
                 callId,
                 toolName,
-                timeoutMs: PROXY_CALL_TIMEOUT_MS
+                deadlineMs
               });
-              reject(
-                new Error(
-                  `Proxy tool '${toolName}' timed out after ${PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
-                )
-              );
-            }, PROXY_CALL_TIMEOUT_MS);
+              reject(buildProxyTimeoutError(toolName, deadlineMs));
+            }, deadlineMs);
             calls.emit("call", entry);
           }
         ).finally(() => {
@@ -2228,17 +2339,17 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         if (result.kind === "error") {
           writeJson(res, {
             jsonrpc: "2.0",
-            id: request.id ?? null,
-            error: {
-              code: -32e3,
-              message: result.message
+            id: requestId,
+            result: {
+              content: [{ type: "text", text: result.message }],
+              isError: true
             }
           });
           return;
         }
         writeJson(res, {
           jsonrpc: "2.0",
-          id: request.id ?? null,
+          id: requestId,
           result: {
             content: [{ type: "text", text: result.text }],
             isError: result.isError === true
@@ -2248,20 +2359,38 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       }
       writeJson(res, {
         jsonrpc: "2.0",
-        id: request.id ?? null,
+        id: requestId,
         error: { code: -32601, message: `Unknown method: ${request.method}` }
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const isExpectedCleanup = errorMessage.includes("timed out after") && errorMessage.includes("waiting for opencode to resolve") || errorMessage.includes("rejecting as orphaned") || errorMessage.includes("was orphaned by a new user turn");
-      const logFn = isExpectedCleanup ? log.notice : log.warn;
+      const logFn = isExpectedCleanupError(errorMessage) ? log.notice : log.warn;
       logFn("proxy-mcp error handling request", {
         error: errorMessage
       });
+      if (requestMethod === "tools/call") {
+        try {
+          writeJson(res, {
+            jsonrpc: "2.0",
+            id: requestId,
+            result: {
+              content: [{ type: "text", text: errorMessage }],
+              isError: true
+            }
+          });
+        } catch {
+          try {
+            res.statusCode = 500;
+            res.end();
+          } catch {
+          }
+        }
+        return;
+      }
       try {
         writeJson(res, {
           jsonrpc: "2.0",
-          id: null,
+          id: requestId,
           error: {
             code: -32603,
             message: error instanceof Error ? error.message : "Internal error"
@@ -2306,7 +2435,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
           mcpServers: {
             [SERVER_NAME]: {
               type: "http",
-              url
+              url,
+              timeout: resolveProxyClientCeilingMs(timeoutOverrides)
             }
           }
         },
@@ -2324,7 +2454,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
     },
     async close() {
       for (const entry of pending.values()) {
-        entry.reject(new Error("proxy MCP server closed"));
+        entry.reject(new Error(SERVER_CLOSED_MESSAGE));
       }
       pending.clear();
       await new Promise((resolve4) => {
@@ -2386,7 +2516,6 @@ import { EventEmitter as EventEmitter4 } from "events";
 var pendingByCallId = /* @__PURE__ */ new Map();
 var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter4();
-var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
 }
@@ -2409,7 +2538,7 @@ function onPendingProxyCall(sessionKey2, handler) {
   emitter.on(name, handler);
   return () => emitter.off(name, handler);
 }
-function queuePendingProxyCall(sessionKey2, call) {
+function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
   const previous = pendingByCallId.get(call.id);
   if (previous) {
     clearTimeout(previous.timer);
@@ -2419,23 +2548,24 @@ function queuePendingProxyCall(sessionKey2, call) {
     pendingByCallId.delete(call.id);
     indexRemove(previous.sessionKey, call.id);
   }
+  const deadlineMs = resolveProxyCallTimeoutMs(
+    call.toolName,
+    call.input,
+    timeoutOverrides
+  );
   const timer = setTimeout(() => {
     const current = pendingByCallId.get(call.id);
     if (!current) return;
     pendingByCallId.delete(call.id);
     indexRemove(current.sessionKey, call.id);
-    current.reject(
-      new Error(
-        `Proxy tool call '${call.toolName}' timed out after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
-      )
-    );
+    current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
     log.notice("timed out pending proxy call", {
       sessionKey: current.sessionKey,
       toolCallId: call.id,
       toolName: call.toolName,
-      timeoutMs: PENDING_PROXY_CALL_TIMEOUT_MS
+      deadlineMs
     });
-  }, PENDING_PROXY_CALL_TIMEOUT_MS);
+  }, deadlineMs);
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
@@ -2574,6 +2704,7 @@ function hasNewUserContent(prompt) {
 var AUTO_CONTINUE_MAX_ATTEMPTS = 8;
 var AUTO_CONTINUE_MAX_ELAPSED_MS = 10 * 60 * 1e3;
 var AUTO_CONTINUE_NO_PROGRESS_LIMIT = 2;
+var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
 var AUTO_CONTINUE_PROMPT = "Continue the task from where you stopped. Do not summarize; keep working until the requested task is complete, you need clarification, or you hit a real blocker.";
 function normalizeVisibleText(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -2911,9 +3042,10 @@ var ClaudeCodeLanguageModel = class {
    * The process lifecycle owns the server lifecycle via session-manager.
    */
   async ensureProxyServer(tools, sessionKeyForCalls) {
-    const srv = await createProxyMcpServer(tools);
+    const timeoutOverrides = this.config.proxyToolTimeoutMs;
+    const srv = await createProxyMcpServer(tools, timeoutOverrides);
     srv.calls.on("call", (call) => {
-      queuePendingProxyCall(sessionKeyForCalls, call);
+      queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
     });
     return srv;
   }
@@ -3668,22 +3800,32 @@ ${plan}
         let activeProcess = getActiveProcess(sk);
         let proc;
         let lineEmitter;
+        let cliArgs;
         let proxyServer = activeProcess?.proxyServer ?? null;
-        if (!compactionMode && activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
-          const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
-          const previousHash = activeProcess.mcpHash ?? null;
-          if (previousHash !== probe.bridgedHash) {
-            log.info("opencode MCP config changed, respawning claude", {
-              sk,
-              previousHash,
-              currentHash: probe.bridgedHash
-            });
-            deleteActiveProcess(sk);
-            activeProcess = void 0;
-            proxyServer = null;
-          }
-        }
         const setup = async () => {
+          if (!compactionMode && activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
+            const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
+            const previousHash = activeProcess.mcpHash ?? null;
+            if (previousHash !== probe.bridgedHash) {
+              if (previousPendingProxyCalls.length > 0) {
+                log.info("deferring MCP hot reload until proxy calls resolve", {
+                  sk,
+                  previousHash,
+                  currentHash: probe.bridgedHash,
+                  pendingCalls: previousPendingProxyCalls.length
+                });
+              } else {
+                log.info("opencode MCP config changed, respawning claude", {
+                  sk,
+                  previousHash,
+                  currentHash: probe.bridgedHash
+                });
+                await deleteActiveProcessAndWait(sk);
+                activeProcess = void 0;
+                proxyServer = null;
+              }
+            }
+          }
           if (useInteractive && !compactionMode) {
             const mcp = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
             if (activeProcess) {
@@ -3744,7 +3886,6 @@ ${plan}
               });
             }
           } else {
-            let cliArgs;
             let spawnSystemPromptFile;
             let spawnProxyServer = null;
             let spawnMcpHash = null;
@@ -3847,6 +3988,7 @@ ${plan}
           let controllerClosed = false;
           let pendingProxyUnsubscribe = null;
           let resultFallbackTimer = null;
+          let pendingResultCompletion = null;
           let hasReceivedContent = false;
           let visibleTextSinceContinue = "";
           let lastVisibleTextSinceContinue = "";
@@ -3877,6 +4019,103 @@ ${plan}
               closeHandler();
             }, delayMs);
           };
+          const START_WATCHDOG_MS = (() => {
+            const env = process.env.CLAUDE_CODE_START_WATCHDOG_MS;
+            const parsed = env ? Number.parseInt(env, 10) : NaN;
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : 9e4;
+          })();
+          let startWatchdog = null;
+          let respawnAttempted = false;
+          const clearStartWatchdog = () => {
+            if (startWatchdog) {
+              clearTimeout(startWatchdog);
+              startWatchdog = null;
+            }
+          };
+          const onStartWatchdogFire = () => {
+            startWatchdog = null;
+            if (controllerClosed || hasReceivedContent) return;
+            if (respawnAttempted) {
+              log.error(
+                "claude process still silent after respawn; ending turn",
+                { sessionKey: sk }
+              );
+              deleteActiveProcess(sk);
+              deleteClaudeSessionId(sk);
+              controllerClosed = true;
+              cleanupTurn();
+              controller.enqueue({
+                type: "error",
+                error: new Error(
+                  "Claude process produced no output after the envelope write (start watchdog timeout)."
+                )
+              });
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
+            respawnAttempted = true;
+            log.warn(
+              "no stdout after envelope write; respawning claude process to resume conversation",
+              { sessionKey: sk, startWatchdogMs: START_WATCHDOG_MS }
+            );
+            lineEmitter.off("line", lineHandler);
+            lineEmitter.off("close", closeHandler);
+            proc.off("error", procErrorHandler);
+            const newAp = respawnActiveProcess(
+              sk,
+              cliPath,
+              cliArgs,
+              cwd,
+              self.config.ignoreAnthropicApiKey
+            );
+            if (!newAp) {
+              log.error(
+                "no active process to respawn (start watchdog); ending turn",
+                { sessionKey: sk }
+              );
+              controllerClosed = true;
+              cleanupTurn();
+              controller.enqueue({
+                type: "error",
+                error: new Error(
+                  "No active claude process to respawn after start watchdog timeout."
+                )
+              });
+              try {
+                controller.close();
+              } catch {
+              }
+              return;
+            }
+            proc = newAp.proc;
+            lineEmitter = newAp.lineEmitter;
+            activeProcess = newAp;
+            lineEmitter.on("line", lineHandler);
+            lineEmitter.on("close", closeHandler);
+            proc.on("error", procErrorHandler);
+            try {
+              proc.stdin?.write(userMsg + "\n");
+              log.debug("re-sent user message after respawn", {
+                textLength: userMsg.length
+              });
+            } catch (err) {
+              log.error("failed to re-send envelope after respawn", {
+                error: err instanceof Error ? err.message : String(err)
+              });
+            }
+            startWatchdog = setTimeout(
+              onStartWatchdogFire,
+              START_WATCHDOG_MS
+            );
+          };
+          const armStartWatchdog = () => {
+            clearStartWatchdog();
+            if (controllerClosed) return;
+            startWatchdog = setTimeout(onStartWatchdogFire, START_WATCHDOG_MS);
+          };
           const toolCallMap = /* @__PURE__ */ new Map();
           const skipResultForIds = /* @__PURE__ */ new Set();
           const toolCallsById = /* @__PURE__ */ new Map();
@@ -3932,6 +4171,28 @@ ${plan}
             });
             finishWithToolCalls(batch);
           };
+          const settleResultBoundary = () => {
+            drainTimer = null;
+            const completeResult2 = pendingResultCompletion;
+            pendingResultCompletion = null;
+            if (!completeResult2 || controllerClosed) return;
+            if (drainBuffer.length > 0) {
+              drainNow();
+              return;
+            }
+            completeResult2();
+          };
+          const scheduleResultBoundary = (completeResult2, delayMs) => {
+            pendingResultCompletion = completeResult2;
+            if (drainTimer) clearTimeout(drainTimer);
+            drainTimer = setTimeout(settleResultBoundary, delayMs);
+          };
+          const noteResultBoundaryCall = () => {
+            if (!pendingResultCompletion) return false;
+            if (drainTimer) clearTimeout(drainTimer);
+            drainTimer = setTimeout(settleResultBoundary, DRAIN_QUIET_MS);
+            return true;
+          };
           const noteVisibleText = (text) => {
             visibleTextSinceContinue += text;
             lastVisibleTextSinceContinue += text;
@@ -3956,11 +4217,106 @@ ${plan}
             hadProxyActivitySinceContinue = false;
             lastStopReason = null;
           };
+          const completeResult = (msg) => {
+            if (controllerClosed) return;
+            if (drainBuffer.length > 0) {
+              drainNow();
+              return;
+            }
+            const pendingSiblings = getPendingProxyCalls(sk);
+            if (pendingSiblings.length > 0) {
+              log.info("leaving parallel proxy calls pending at result boundary", {
+                sessionKey: sk,
+                count: pendingSiblings.length
+              });
+            }
+            const autoDecision = shouldAutoContinueIncompleteTurn(
+              autoContinueState,
+              {
+                text: visibleTextSinceContinue,
+                lastVisibleText: lastVisibleTextSinceContinue,
+                hadReasoning: hadReasoningSinceContinue,
+                hadToolActivity: hadToolActivitySinceContinue,
+                hadProxyActivity: hadProxyActivitySinceContinue,
+                isError: msg.is_error,
+                stopReason: lastStopReason
+              }
+            );
+            if (autoDecision.continue) {
+              const signature = continuationSignature({
+                text: visibleTextSinceContinue,
+                lastVisibleText: lastVisibleTextSinceContinue,
+                hadReasoning: hadReasoningSinceContinue,
+                hadToolActivity: hadToolActivitySinceContinue,
+                hadProxyActivity: hadProxyActivitySinceContinue,
+                isError: msg.is_error
+              });
+              autoContinueState.noProgressCount = signature === autoContinueState.lastSignature ? autoContinueState.noProgressCount + 1 : 0;
+              autoContinueState.lastSignature = signature;
+              autoContinueState.attempts++;
+              log.notice("auto-continuing incomplete claude result", {
+                sessionKey: sk,
+                reason: autoDecision.reason,
+                attempts: autoContinueState.attempts,
+                textLength: visibleTextSinceContinue.length,
+                lastTextLength: lastVisibleTextSinceContinue.length,
+                hadReasoning: hadReasoningSinceContinue,
+                hadToolActivity: hadToolActivitySinceContinue,
+                hadProxyActivity: hadProxyActivitySinceContinue
+              });
+              turnCompleted = false;
+              resetAutoContinueWindow();
+              proc.stdin?.write(makeAutoContinueMessage() + "\n");
+              return;
+            }
+            log.notice("auto-continuation stopped", {
+              sessionKey: sk,
+              reason: autoDecision.reason,
+              stopReason: lastStopReason,
+              attempts: autoContinueState.attempts,
+              textLength: visibleTextSinceContinue.length,
+              lastTextLength: lastVisibleTextSinceContinue.length,
+              hadReasoning: hadReasoningSinceContinue,
+              hadToolActivity: hadToolActivitySinceContinue,
+              hadProxyActivity: hadProxyActivitySinceContinue
+            });
+            for (const [idx, reasoningId] of reasoningIds) {
+              if (reasoningStarted.get(idx)) {
+                controller.enqueue({
+                  type: "reasoning-end",
+                  id: reasoningId
+                });
+              }
+            }
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("stop"),
+              usage: toUsage(msg.usage),
+              providerMetadata: {
+                "claude-code": {
+                  ...resultMeta,
+                  ...compactionMode ? { compactionModel: effectiveModelId } : {}
+                },
+                ...typeof msg.usage?.cache_creation_input_tokens === "number" ? {
+                  anthropic: {
+                    cacheCreationInputTokens: msg.usage.cache_creation_input_tokens
+                  }
+                } : {}
+              }
+            });
+            controllerClosed = true;
+            cleanupTurn();
+            try {
+              controller.close();
+            } catch {
+            }
+          };
           let gotPartialEvents = false;
           const lineHandler = (line) => {
             if (!line.trim()) return;
             if (controllerClosed) return;
             startResultFallback();
+            clearStartWatchdog();
             try {
               const outer = JSON.parse(line);
               const msg = outer.type === "stream_event" && outer.event ? { ...outer.event, session_id: outer.session_id } : outer;
@@ -4150,6 +4506,7 @@ ${plan}
                     });
                     endTextBlock();
                   } else if (tc.name.startsWith(PROXY_TOOL_PREFIX)) {
+                    noteProxyActivity();
                     log.debug("ignoring proxy tool_use block; broker handles it", {
                       name: tc.name,
                       id: tc.id
@@ -4316,6 +4673,7 @@ ${plan}
                       });
                       endTextBlock();
                     } else if (block.name.startsWith(PROXY_TOOL_PREFIX)) {
+                      noteProxyActivity();
                       log.debug("ignoring proxy tool_use from assistant message", {
                         name: block.name,
                         id: block.id
@@ -4466,113 +4824,36 @@ ${plan}
                 });
                 turnCompleted = true;
                 endTextBlock();
-                if (drainBuffer.length > 0) {
+                const shouldDeferResult = !msg.is_error && !autoContinueState.aborted && !autoContinueState.sawAskUserQuestion;
+                if (drainBuffer.length > 0 && shouldDeferResult) {
                   log.info(
-                    "draining pending proxy calls at turn-result boundary",
+                    "waiting for parallel proxy calls at turn-result boundary",
                     {
                       sessionKey: sk,
                       count: drainBuffer.length
                     }
                   );
-                  drainNow();
+                  scheduleResultBoundary(
+                    () => completeResult(msg),
+                    DRAIN_QUIET_MS
+                  );
                   return;
                 }
-                const orphanPending = getPendingProxyCalls(sk);
-                if (orphanPending.length > 0) {
-                  log.warn(
-                    "rejecting orphan pending proxy calls at turn-result boundary",
+                if (drainBuffer.length === 0 && hadProxyActivitySinceContinue && shouldDeferResult) {
+                  log.info(
+                    "waiting for delayed proxy call at turn-result boundary",
                     {
                       sessionKey: sk,
-                      count: orphanPending.length
+                      graceMs: PROXY_RESULT_BOUNDARY_GRACE_MS
                     }
                   );
-                  rejectAllPendingProxyCallsForSession(
-                    sk,
-                    new Error(
-                      "Claude CLI emitted result with pending proxy calls not in drain buffer"
-                    )
+                  scheduleResultBoundary(
+                    () => completeResult(msg),
+                    PROXY_RESULT_BOUNDARY_GRACE_MS
                   );
-                }
-                const autoDecision = shouldAutoContinueIncompleteTurn(
-                  autoContinueState,
-                  {
-                    text: visibleTextSinceContinue,
-                    lastVisibleText: lastVisibleTextSinceContinue,
-                    hadReasoning: hadReasoningSinceContinue,
-                    hadToolActivity: hadToolActivitySinceContinue,
-                    hadProxyActivity: hadProxyActivitySinceContinue,
-                    isError: msg.is_error,
-                    stopReason: lastStopReason
-                  }
-                );
-                if (autoDecision.continue) {
-                  const signature = continuationSignature({
-                    text: visibleTextSinceContinue,
-                    lastVisibleText: lastVisibleTextSinceContinue,
-                    hadReasoning: hadReasoningSinceContinue,
-                    hadToolActivity: hadToolActivitySinceContinue,
-                    hadProxyActivity: hadProxyActivitySinceContinue,
-                    isError: msg.is_error
-                  });
-                  autoContinueState.noProgressCount = signature === autoContinueState.lastSignature ? autoContinueState.noProgressCount + 1 : 0;
-                  autoContinueState.lastSignature = signature;
-                  autoContinueState.attempts++;
-                  log.notice("auto-continuing incomplete claude result", {
-                    sessionKey: sk,
-                    reason: autoDecision.reason,
-                    attempts: autoContinueState.attempts,
-                    textLength: visibleTextSinceContinue.length,
-                    lastTextLength: lastVisibleTextSinceContinue.length,
-                    hadReasoning: hadReasoningSinceContinue,
-                    hadToolActivity: hadToolActivitySinceContinue,
-                    hadProxyActivity: hadProxyActivitySinceContinue
-                  });
-                  turnCompleted = false;
-                  resetAutoContinueWindow();
-                  proc.stdin?.write(makeAutoContinueMessage() + "\n");
                   return;
                 }
-                log.notice("auto-continuation stopped", {
-                  sessionKey: sk,
-                  reason: autoDecision.reason,
-                  stopReason: lastStopReason,
-                  attempts: autoContinueState.attempts,
-                  textLength: visibleTextSinceContinue.length,
-                  lastTextLength: lastVisibleTextSinceContinue.length,
-                  hadReasoning: hadReasoningSinceContinue,
-                  hadToolActivity: hadToolActivitySinceContinue,
-                  hadProxyActivity: hadProxyActivitySinceContinue
-                });
-                for (const [idx, reasoningId] of reasoningIds) {
-                  if (reasoningStarted.get(idx)) {
-                    controller.enqueue({
-                      type: "reasoning-end",
-                      id: reasoningId
-                    });
-                  }
-                }
-                controller.enqueue({
-                  type: "finish",
-                  finishReason: toFinishReason("stop"),
-                  usage: toUsage(msg.usage),
-                  providerMetadata: {
-                    "claude-code": {
-                      ...resultMeta,
-                      ...compactionMode ? { compactionModel: effectiveModelId } : {}
-                    },
-                    ...typeof msg.usage?.cache_creation_input_tokens === "number" ? {
-                      anthropic: {
-                        cacheCreationInputTokens: msg.usage.cache_creation_input_tokens
-                      }
-                    } : {}
-                  }
-                });
-                controllerClosed = true;
-                cleanupTurn();
-                try {
-                  controller.close();
-                } catch {
-                }
+                completeResult(msg);
               }
             } catch (e) {
               log.debug("failed to parse line", {
@@ -4616,6 +4897,8 @@ ${plan}
             if (cleanedUp) return;
             cleanedUp = true;
             clearFallbackTimer();
+            pendingResultCompletion = null;
+            clearStartWatchdog();
             if (drainTimer) {
               clearTimeout(drainTimer);
               drainTimer = null;
@@ -4676,6 +4959,7 @@ ${plan}
             noteProxyActivity();
             noteToolActivity();
             drainBuffer.push(call);
+            if (noteResultBoundaryCall()) return;
             if (drainTimer) clearTimeout(drainTimer);
             drainTimer = setTimeout(drainNow, DRAIN_QUIET_MS);
           });
@@ -4689,6 +4973,15 @@ ${plan}
                   "abort signal received before content, closing stream immediately",
                   { cwd }
                 );
+                if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
+                  rejectAllPendingProxyCallsForSession(
+                    sk,
+                    new Error(
+                      "Provider stream was aborted before pending proxy calls were emitted"
+                    )
+                  );
+                  drainBuffer.length = 0;
+                }
                 controllerClosed = true;
                 cleanupTurn();
                 try {
@@ -4714,20 +5007,14 @@ ${plan}
                 });
                 resolvePendingProxyCallById(call.toolCallId, result);
               } else {
-                log.notice(
-                  "pending proxy call had no matching tool-result; rejecting as orphan",
+                log.info(
+                  "leaving unmatched parallel proxy call pending",
                   {
                     sessionKey: sk,
                     toolCallId: call.toolCallId,
                     toolName: call.toolName
                   }
                 );
-                rejectPendingProxyCallById(
-                  call.toolCallId,
-                  new Error(
-                    `Pending proxy call '${call.toolName}' (${call.toolCallId}) was not matched in tool-result turn; rejecting as orphaned`
-                  )
-                );
               }
             }
             return;
@@ -4744,6 +5031,7 @@ ${plan}
           }
           proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
+          armStartWatchdog();
         };
         void setup().catch((err) => {
           log.error("failed to set up doStream", {
@@ -5236,6 +5524,13 @@ function pickOpencodeDirectory(input) {
   return void 0;
 }
 var warnedAnthropicApiKey = false;
+var DEFAULT_PROXY_TOOL_NAMES = [
+  "Bash",
+  "Edit",
+  "Write",
+  "WebFetch",
+  "Task"
+];
 function warnIfAnthropicApiKey(ignore) {
   if (warnedAnthropicApiKey) return;
   if (!process.env.ANTHROPIC_API_KEY && !process.env.ANTHROPIC_AUTH_TOKEN) return;
@@ -5262,7 +5557,7 @@ function createClaudeCode(settings = {}) {
   warnIfAnthropicApiKey(settings.ignoreAnthropicApiKey);
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
   const providerName = settings.providerID ?? settings.name ?? "claude-code";
-  const proxyTools = settings.proxyTools ?? ["Bash", "Edit", "Write", "WebFetch"];
+  const proxyTools = settings.proxyTools ?? [...DEFAULT_PROXY_TOOL_NAMES];
   const createModel = (modelId) => {
     return new ClaudeCodeLanguageModel(modelId, {
       provider: providerName,
@@ -5280,6 +5575,7 @@ function createClaudeCode(settings = {}) {
       controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
+      proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
@@ -5374,7 +5670,7 @@ function configModelsForProvider(providerModels, providerID, modelSuffix) {
 async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefaults = {}, displayName) {
   const mergedOptions = {
     cliPath: "claude",
-    proxyTools: ["Bash", "Edit", "Write", "WebFetch"],
+    proxyTools: [...DEFAULT_PROXY_TOOL_NAMES],
     ...optionDefaults,
     ...cleanProviderOptions(existing?.options),
     providerID