@khalilgharbaoui/opencode-claude-code-plugin 0.53.2 → 0.53.4

package/dist/index.d.ts

@@ -1364,7 +1364,7 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private effectiveMcpConfig;
     /** Resolve ProxyToolDef[] for the configured proxyTools names. */
     private resolvedProxyTools;
-    /** Resolve ProxyToolDef[] for opencode's MCP-backed tools. */
+    /** Resolve ProxyToolDef[] for opencode's MCP-backed tools, and route the rest. */
     private resolvedProxyMcpTools;
     /** One `client.tool.list()` fetch, shaped for this turn's gates. */
     private fetchLiveToolInfo;

package/dist/index.js

@@ -3860,8 +3860,8 @@ function buildProxyTimeoutError(toolName, ms) {
   return new Error(base);
 }
 var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Calls block until the subagent finishes. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls have no proxy deadline by default: the call waits for the subagent to finish (a positive proxyToolTimeoutMs override adds a deadline).";
-var TASK_BACKGROUND_NOTE = 'Fire-and-collect: set `background: true` and the call returns at once with `<task id="ses_..." state="running">` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own as a new message. Do NOT poll, sleep or loop waiting for it. The `id` in that envelope is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want.';
-var TASK_BACKGROUND_NOTE_V2 = 'Fire-and-collect: set `background: true` and the call returns at once with `The subagent is working in the background (sessionID: ses_...)` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own, as a `<subagent sessionID="..." state="completed">` message. Do NOT poll, sleep or loop waiting for it. That sessionID is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want.';
+var TASK_BACKGROUND_NOTE = 'Fire-and-collect: set `background: true` and the call returns at once with `<task id="ses_..." state="running">` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own as a new message. Do NOT poll, sleep or loop waiting for it. The `id` in that envelope is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want. The dispatch result may end with how many background subagents are running now: that is for information, never a reason to poll or wait.';
+var TASK_BACKGROUND_NOTE_V2 = 'Fire-and-collect: set `background: true` and the call returns at once with `The subagent is working in the background (sessionID: ses_...)` instead of the subagent\'s answer. Keep working on something that does not overlap it, then end your turn: when the subagent finishes, opencode delivers its result to this conversation on its own, as a `<subagent sessionID="..." state="completed">` message. Do NOT poll, sleep or loop waiting for it. That sessionID is the task_id: pass it to task_status to read a result the notification did not deliver, or to task_cancel to stop a background subagent you no longer want. The dispatch result may end with how many background subagents are running now: that is for information, never a reason to poll or wait.';
 var TASK_BATCH_TOOL_NAME = "task_batch";
 var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Like task it has no proxy deadline by default (a positive proxyToolTimeoutMs override adds one).";
 var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
@@ -4679,7 +4679,11 @@ function resolveProxyOpencodeToolDefs(options) {
   return out;
 }
 function resolveMcpProxyToolDefs(options) {
-  const empty = { defs: [], coveredServers: /* @__PURE__ */ new Set() };
+  const empty = {
+    defs: [],
+    coveredServers: /* @__PURE__ */ new Set(),
+    matchedServers: /* @__PURE__ */ new Set()
+  };
   const serverNames = options.serverNames ?? [];
   if (serverNames.length === 0) return empty;
   const tools = options.tools;
@@ -4688,6 +4692,7 @@ function resolveMcpProxyToolDefs(options) {
   const taken = options.taken ?? /* @__PURE__ */ new Set();
   const defs = [];
   const coveredServers = /* @__PURE__ */ new Set();
+  const matchedServers = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
   const collided = [];
   for (const tool of tools) {
@@ -4699,6 +4704,7 @@ function resolveMcpProxyToolDefs(options) {
       (server2) => name === server2 || name.startsWith(`${server2}_`)
     );
     if (!matchedServer) continue;
+    matchedServers.add(matchedServer);
     if (seen.has(name)) continue;
     if (taken.has(name)) {
       collided.push(name);
@@ -4718,7 +4724,7 @@ function resolveMcpProxyToolDefs(options) {
       { collided }
     );
   }
-  return { defs, coveredServers };
+  return { defs, coveredServers, matchedServers };
 }
 function readBody(req) {
   return new Promise((resolve6, reject) => {
@@ -5707,7 +5713,7 @@ async function fetchSessionRunState(sessionID, directory) {
 async function settleSessionRunState(sessionID, options = {}) {
   const pollMs = options.pollMs ?? 150;
   const windowMs = options.windowMs ?? 1500;
-  const started = Date.now();
+  const started2 = Date.now();
   let last = "unknown";
   let directory = options.directory;
   for (; ; ) {
@@ -5715,7 +5721,7 @@ async function settleSessionRunState(sessionID, options = {}) {
     const state = await fetchSessionRunState(sessionID, directory ?? "");
     if (state === "busy") return "busy";
     if (state !== "unknown") last = state;
-    if (Date.now() - started >= windowMs) return last;
+    if (Date.now() - started2 >= windowMs) return last;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
@@ -5765,9 +5771,9 @@ async function waitForPendingMcpServers(first, budgetMs, signal) {
   let current = first;
   const waitedFor = pendingMcpServers(current);
   if (waitedFor.length === 0) return current;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
-    if (Date.now() - started >= budgetMs) break;
+    if (Date.now() - started2 >= budgetMs) break;
     if (signal?.aborted) break;
     await new Promise((resolve6) => setTimeout(resolve6, MCP_CONNECT_POLL_MS));
     if (signal?.aborted) break;
@@ -5781,7 +5787,7 @@ async function waitForPendingMcpServers(first, budgetMs, signal) {
     waitedFor,
     stillPending,
     budgetMs,
-    elapsedMs: Date.now() - started,
+    elapsedMs: Date.now() - started2,
     aborted: signal?.aborted === true
   });
   return current;
@@ -5909,6 +5915,123 @@ function clearBackgroundTasks(sessionKey2) {
   collected.delete(sessionKey2);
   cancelled.delete(sessionKey2);
 }
+var MAX_STARTED = 128;
+var started = /* @__PURE__ */ new Map();
+function backgroundTaskIdsIn(text) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/<task id="([^"\s]+)" state="running">/g)) {
+    ids.add(match[1]);
+  }
+  for (const match of text.matchAll(/in the background \(sessionID: ([^)\s]+)\)/g)) {
+    ids.add(match[1]);
+  }
+  return [...ids];
+}
+function noteBackgroundDispatchResult(sessionKey2, result, now = Date.now()) {
+  if (result.kind !== "text" || result.isError === true) return;
+  for (const taskId of backgroundTaskIdsIn(result.text)) {
+    started.delete(taskId);
+    started.set(taskId, { sessionKey: sessionKey2, at: now });
+    while (started.size > MAX_STARTED) {
+      const oldest = started.keys().next();
+      if (oldest.done) break;
+      started.delete(oldest.value);
+    }
+  }
+}
+async function countRunningBackgroundTasks() {
+  const entries = [...started.entries()];
+  const cancelledIds = cancelledTaskIds();
+  const states = await Promise.all(
+    entries.map(([taskId]) => backgroundTaskState(taskId, cancelledIds))
+  );
+  return {
+    running: states.filter((state) => state === "running").length,
+    started: entries.length,
+    unreadable: states.filter((state) => state === "unreadable").length
+  };
+}
+function cancelledTaskIds() {
+  const ids = /* @__PURE__ */ new Set();
+  for (const set of cancelled.values()) for (const id of set) ids.add(id);
+  return ids;
+}
+async function backgroundTaskState(taskId, cancelledIds) {
+  if (cancelledIds.has(taskId)) return "stopped";
+  try {
+    const runState = await fetchSessionRunState(taskId);
+    if (runState !== "unknown") {
+      return isBackgroundTaskRunning(runState, []) ? "running" : "stopped";
+    }
+    const replies = await fetchSessionReplies(taskId);
+    if (replies === void 0) return "unreadable";
+    return isBackgroundTaskRunning(runState, replies) ? "running" : "stopped";
+  } catch {
+    return "unreadable";
+  }
+}
+var BACKGROUND_COUNT_BUDGET_MS = 500;
+var BACKGROUND_COUNT_CONCURRENCY = 4;
+async function countOtherRunningWithin(exclude, budgetMs) {
+  const taskIds = [...started.keys()].filter((taskId) => !exclude.has(taskId));
+  if (taskIds.length === 0) return 0;
+  const cancelledIds = cancelledTaskIds();
+  let overBudget = false;
+  let unreadable = false;
+  let next = 0;
+  let running = 0;
+  const worker = async () => {
+    while (!overBudget && !unreadable && next < taskIds.length) {
+      const taskId = taskIds[next++];
+      const state = await backgroundTaskState(taskId, cancelledIds);
+      if (state === "running") running++;
+      if (state === "unreadable") unreadable = true;
+    }
+  };
+  const workers = Array.from(
+    { length: Math.min(BACKGROUND_COUNT_CONCURRENCY, taskIds.length) },
+    worker
+  );
+  let timer;
+  const deadline = new Promise((resolve6) => {
+    timer = setTimeout(() => resolve6("over"), budgetMs);
+    timer.unref?.();
+  });
+  try {
+    const outcome = await Promise.race([Promise.all(workers).then(() => "done"), deadline]);
+    if (outcome === "over") {
+      overBudget = true;
+      return void 0;
+    }
+    return unreadable ? void 0 : running;
+  } catch {
+    overBudget = true;
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function withBackgroundRunningCount(result, budgetMs = BACKGROUND_COUNT_BUDGET_MS) {
+  if (result.kind !== "text" || result.isError === true) return result;
+  const dispatched = backgroundTaskIdsIn(result.text);
+  if (dispatched.length === 0) return result;
+  const others = await countOtherRunningWithin(new Set(dispatched), budgetMs);
+  if (others === void 0) {
+    log.info("background running count omitted: a lookup was slow or unreadable", {
+      budgetMs,
+      dispatched: dispatched.length
+    });
+    return result;
+  }
+  return { ...result, text: result.text + formatBackgroundRunningLine(others, dispatched.length) };
+}
+function formatBackgroundRunningLine(others, dispatched) {
+  const total = others + dispatched;
+  const including = dispatched === 1 ? "this one" : `the ${dispatched} just started`;
+  return `
+
+Background subagents running now: ${total} (including ${including}).`;
+}
 var lastGate;
 function recordBackgroundSubagentGate(gate, now = Date.now()) {
   lastGate = { ...gate, at: now };
@@ -7635,21 +7758,21 @@ async function sessionStatus(client, sessionID) {
 async function waitForSessionIdle(client, sessionID, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const timeoutMs = options.timeoutMs ?? IDLE_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     if (options.stop?.()) return true;
     if (await sessionStatus(client, sessionID) !== "busy") return true;
-    if (Date.now() - started >= timeoutMs) return false;
+    if (Date.now() - started2 >= timeoutMs) return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
 async function deliverAsideInline(client, sessionID, text, options = {}) {
   const pollMs = options.inlinePollMs ?? INLINE_POLL_MS;
   const timeoutMs = options.inlineWaitMs ?? INLINE_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     if (emitAsideInline(sessionID, text)) return true;
-    if (Date.now() - started >= timeoutMs) return false;
+    if (Date.now() - started2 >= timeoutMs) return false;
     if (await sessionStatus(client, sessionID) !== "busy") return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
@@ -7658,12 +7781,12 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
   const spawnWaitMs = options.spawnWaitMs ?? SPAWN_WAIT_MAX_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     const active = findActiveProcessBySessionId(sessionID);
     if (active) return active;
     const busy = await sessionStatus(client, sessionID) === "busy";
-    const waitedMs = Date.now() - started;
+    const waitedMs = Date.now() - started2;
     if (!busy && waitedMs >= settleMs) {
       log.info("btw: no live claude process for session, leaving it to the turn", { sessionID, waitedMs });
       return void 0;
@@ -7678,12 +7801,12 @@ async function waitForAsideProcess(client, sessionID, options = {}) {
 async function settleSessionBusy(client, sessionID, active, options = {}) {
   const pollMs = options.pollMs ?? IDLE_POLL_MS;
   const settleMs = options.settleMs ?? BUSY_SETTLE_MS;
-  const started = Date.now();
+  const started2 = Date.now();
   for (; ; ) {
     const status = await sessionStatus(client, sessionID);
     if (status === "busy") return true;
     if (status === "unknown") return isProcessBusy(active);
-    if (Date.now() - started >= settleMs) return false;
+    if (Date.now() - started2 >= settleMs) return false;
     await new Promise((resolve6) => setTimeout(resolve6, pollMs));
   }
 }
@@ -7787,7 +7910,7 @@ async function handleBtwCommand(client, input, options = {}) {
     );
   }
   if (!busy) return;
-  const started = Date.now();
+  const started2 = Date.now();
   const outcome = await Promise.race([
     inlineDelivered,
     waitForSessionIdle(client, input.sessionID, { ...options, stop: () => inlineDone }).then(
@@ -7797,14 +7920,14 @@ async function handleBtwCommand(client, input, options = {}) {
   if (outcome === "inline") {
     log.info("btw: answered inside the running turn, dropping the /btw message", {
       sessionID: input.sessionID,
-      waitedMs: Date.now() - started
+      waitedMs: Date.now() - started2
     });
     throw new BtwHandledError(BTW_INLINE_HANDLED_MESSAGE);
   }
   log.info("btw: turn over, releasing the /btw message", {
     sessionID: input.sessionID,
     idle: outcome === "idle",
-    waitedMs: Date.now() - started
+    waitedMs: Date.now() - started2
   });
   if (outcome === "timeout") {
     showToast(client, { title: "btw", message: BTW_TURN_TOO_LONG_MESSAGE, variant: "warning", duration: 8e3 });
@@ -7933,6 +8056,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "proxy-mcp interceptor failed",
   "proxy-mcp rejected a request",
   "proxy-mcp tool call timed out",
+  "proxyOpencodeMcpTools cannot route V2 Code Mode's MCP tools, which reach the model through execute; for Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true",
   "proxyOpencodeTools entry dropped: a proxy tool already holds that name, and it keeps it",
   "proxyOpencodeTools is set but opencode's tool registry did not answer; forwarding nothing this spawn",
   "refusing the pid-named scratch directory",
@@ -9168,6 +9292,10 @@ function formatDoctorReport(report) {
 }
 function formatBackgroundSubagents(state) {
   const lines = [];
+  if (state.running) {
+    lines.push(...formatRunningCount(state.running));
+    lines.push("");
+  }
   const gate = state.gate;
   if (!gate) {
     lines.push(
@@ -9213,6 +9341,19 @@ function formatBackgroundSubagents(state) {
   }
   return lines;
 }
+function formatRunningCount(count) {
+  if (count.started === 0) {
+    return ["running now: 0 (none started by this process)"];
+  }
+  const lines = [`running now: ${count.running} (of ${count.started} started by this process)`];
+  if (count.unreadable > 0) {
+    lines.push("");
+    lines.push(
+      `${count.unreadable} could not be read from opencode (deleted, or no session route on this build) and are not counted as running.`
+    );
+  }
+  return lines;
+}
 function describeBackgroundGateSource(gate) {
   if (gate.hostApi === "v2") {
     return "opencode 2 offers `background` unconditionally, so the registry is not consulted";
@@ -9297,7 +9438,8 @@ async function gatherDoctorReport(options) {
     planUsage,
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
-      ledgers: snapshotBackgroundTasks()
+      ledgers: snapshotBackgroundTasks(),
+      running: await countRunningBackgroundTasks().catch(() => void 0)
     }
   };
 }
@@ -11968,12 +12110,12 @@ function spawnInteractiveProcess(opts) {
         }
       }
       closeProxyServer();
-      const started = startPromise !== null;
+      const started2 = startPromise !== null;
       try {
         session.dispose();
       } catch {
       }
-      if (!started && proc.exitCode === null && proc.signalCode === null) {
+      if (!started2 && proc.exitCode === null && proc.signalCode === null) {
         proc.signalCode = "SIGTERM";
         proc.emit("exit", null, "SIGTERM");
         proc.emit("close", null, "SIGTERM");
@@ -12125,6 +12267,7 @@ This opencode host runs background subagents, so \`mcp__opencode_proxy__task\` t
 - A background dispatch returns at once with \`<task id="ses_..." state="running">\` instead of the subagent's answer. That is success, not a truncated result.
 - After starting one, keep working on something that does not overlap it, then end your turn normally. When the subagent finishes, opencode delivers its result into this conversation as a new message on its own. Do not sleep, poll, or ask the operator to wait.
 - The \`id\` in that envelope is the task_id. \`mcp__opencode_proxy__task_status\` reads a result back if the automatic delivery did not arrive (an interrupted or errored turn); \`mcp__opencode_proxy__task_cancel\` stops a background subagent you no longer want. Neither is a progress poll.
+- A background dispatch's result may end with \`Background subagents running now: N\`. That number is for information, so you can avoid starting more than the work needs; it is never a reason to poll, sleep or wait.
 - Foreground is still the default and still the right choice when you need the answer before you can continue. Use background only for work that genuinely runs alongside yours.`;
 var BACKGROUND_SUBAGENT_HINT_V2 = `## Background subagents
 
@@ -12133,6 +12276,7 @@ This opencode host runs background subagents, so \`mcp__opencode_proxy__task\` t
 - A background dispatch returns at once with \`The subagent is working in the background (sessionID: ses_...)\` instead of the subagent's answer. That is success, not a truncated result.
 - After starting one, keep working on something that does not overlap it, then end your turn normally. When the subagent finishes, opencode delivers its result into this conversation on its own, as a \`<subagent sessionID="..." state="completed">\` message. Do not sleep, poll, or ask the operator to wait.
 - That \`sessionID\` is the task_id. \`mcp__opencode_proxy__task_status\` reads a result back if the automatic delivery did not arrive (an interrupted or errored turn); \`mcp__opencode_proxy__task_cancel\` stops a background subagent you no longer want. Neither is a progress poll.
+- A background dispatch's result may end with \`Background subagents running now: N\`. That number is for information, so you can avoid starting more than the work needs; it is never a reason to poll, sleep or wait.
 - Foreground is still the default and still the right choice when you need the answer before you can continue. Use background only for work that genuinely runs alongside yours.`;
 function backgroundSubagentHint(dialect) {
   return dialect === "v2" ? BACKGROUND_SUBAGENT_HINT_V2 : BACKGROUND_SUBAGENT_HINT;
@@ -12737,7 +12881,13 @@ function resolvedProxyTools(config) {
   }
   return picked.length > 0 ? picked : null;
 }
-function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken) {
+function decideMcpServerRoute(input) {
+  if (input.covered) return "proxy";
+  if (input.inToolSet) return "bridge";
+  if (input.toolSetKnown && input.status === "connected") return "withhold";
+  return "bridge";
+}
+function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken, runtimeStatus) {
   if (config.proxyOpencodeMcpTools !== true) return null;
   if (config.bridgeOpencodeMcp === false) return null;
   if (allEnabledServerNames.length === 0) return null;
@@ -12746,18 +12896,47 @@ function resolvedProxyMcpTools(config, allEnabledServerNames, modelTools, taken)
     tools: modelTools,
     taken
   });
-  if (resolution.defs.length === 0) {
+  const codeMode = config.hostApi === "v2" && (modelTools?.some((tool) => tool.name === "execute") ?? false);
+  const toolSetKnown = (modelTools?.length ?? 0) > 0 && !codeMode;
+  const withheld = [];
+  const bridged = [];
+  for (const server2 of allEnabledServerNames) {
+    const route = decideMcpServerRoute({
+      covered: resolution.coveredServers.has(server2),
+      inToolSet: resolution.matchedServers.has(server2),
+      status: runtimeStatus?.[server2],
+      toolSetKnown
+    });
+    if (route === "withhold") withheld.push(server2);
+    else if (route === "bridge") bridged.push(server2);
+  }
+  if (codeMode && resolution.defs.length === 0) {
     log.warn(
-      "proxyOpencodeMcpTools is on but no MCP tool was found in opencode's tool set; those servers stay on the direct bridge this spawn" + (config.hostApi === "v2" && modelTools?.some((tool) => tool.name === "execute") ? ". For V2 Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true" : ""),
-      { servers: allEnabledServerNames, modelTools: modelTools?.length ?? 0 }
+      "proxyOpencodeMcpTools cannot route V2 Code Mode's MCP tools, which reach the model through execute; for Code Mode, explicitly allowlist execute in proxyOpencodeTools and use bridgeOpencodeMcp: false with strictMcpConfig: true",
+      { servers: allEnabledServerNames }
     );
-    return null;
   }
-  log.debug("routing opencode MCP tools through the proxy", {
-    servers: [...resolution.coveredServers],
-    tools: resolution.defs.map((def) => def.name)
-  });
-  return resolution;
+  if (withheld.length > 0 || bridged.length > 0) {
+    log.info("proxyOpencodeMcpTools: MCP servers outside this agent's tool set", {
+      proxied: [...resolution.coveredServers],
+      withheld,
+      bridged,
+      modelTools: modelTools?.length ?? 0,
+      statusKnown: runtimeStatus !== void 0
+    });
+  } else {
+    log.debug("routing opencode MCP tools through the proxy", {
+      servers: [...resolution.coveredServers],
+      tools: resolution.defs.map((def) => def.name)
+    });
+  }
+  const exclude = /* @__PURE__ */ new Set([...resolution.coveredServers, ...withheld]);
+  return {
+    resolution,
+    withheld,
+    bridged,
+    excludeServers: exclude.size > 0 ? exclude : void 0
+  };
 }
 async function fetchLiveToolInfo(config, modelId) {
   const items = await fetchOpencodeToolList(
@@ -14684,13 +14863,14 @@ var ClaudeCodeLanguageModel = class {
   resolvedProxyTools() {
     return resolvedProxyTools(this.config);
   }
-  /** Resolve ProxyToolDef[] for opencode's MCP-backed tools. */
-  resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken) {
+  /** Resolve ProxyToolDef[] for opencode's MCP-backed tools, and route the rest. */
+  resolvedProxyMcpTools(allEnabledServerNames, modelTools, taken, runtimeStatus) {
     return resolvedProxyMcpTools(
       this.config,
       allEnabledServerNames,
       modelTools,
-      taken
+      taken,
+      runtimeStatus
     );
   }
   /** One `client.tool.list()` fetch, shaped for this turn's gates. */
@@ -15999,13 +16179,14 @@ var ClaudeCodeLanguageModel = class {
               void 0,
               runtimeStatus
             );
-            const mcpResolution = self.resolvedProxyMcpTools(
+            const mcpRouting = self.resolvedProxyMcpTools(
               discovery.allEnabledServerNames,
               options.tools,
-              new Set((resolvedProxy ?? []).map((def) => def.name))
+              new Set((resolvedProxy ?? []).map((def) => def.name)),
+              runtimeStatus
             );
-            const proxyMcpTools = mcpResolution?.defs ?? null;
-            const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
+            const proxyMcpTools = mcpRouting && mcpRouting.resolution.defs.length > 0 ? mcpRouting.resolution.defs : null;
+            const excludeServers = mcpRouting?.excludeServers;
             const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
             const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
             const opencodeToolsRequested = (self.config.proxyOpencodeTools?.length ?? 0) > 0;
@@ -16844,8 +17025,14 @@ var ClaudeCodeLanguageModel = class {
               await new Promise((resolve6) => setTimeout(resolve6, FORWARD_SETTLE_MS));
               if (state.controllerClosed) return;
             }
-            for (const { call, result } of previousPendingProxyMatches) {
-              if (result) {
+            for (const { call, result: opencodeResult } of previousPendingProxyMatches) {
+              if (opencodeResult) {
+                let result = opencodeResult;
+                if (call.toolName === "task" || call.toolName === TASK_BATCH_TOOL_NAME) {
+                  noteBackgroundDispatchResult(sk, result);
+                  result = await withBackgroundRunningCount(result);
+                  if (state.controllerClosed) return;
+                }
                 const channelClosed = isPendingProxyCallChannelClosed(call);
                 log.info("resolving pending proxy call from tool result prompt", {
                   sessionKey: sk,