@khalilgharbaoui/opencode-claude-code-plugin 0.53.1 → 0.53.3

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

@@ -4044,7 +4044,13 @@ var TASK_INPUT_PROPERTIES = {
   },
   background: {
     type: "boolean",
-    description: 'Run the subagent in the background and return immediately with a `<task id="..." state="running">` envelope instead of its answer. You are notified automatically when it completes. Do NOT sleep, poll or proactively check on its progress.'
+    // Both majors, for the reason the `task_id` field names both: a model
+    // told to look for only V1's envelope finds nothing on opencode 2, where
+    // a background dispatch answers in prose, and then has no task_id to pass
+    // to task_status or task_cancel. This constant is shared by `task` and by
+    // every `task_batch` item and is built with no dialect in hand, so it
+    // names both rather than being rewritten per host.
+    description: 'Run the subagent in the background and return immediately instead of its answer: opencode 1.x answers with a `<task id="..." state="running">` envelope, opencode 2 with `The subagent is working in the background (sessionID: ses_...)`. You are notified automatically when it completes. Do NOT sleep, poll or proactively check on its progress.'
   }
 };
 var TASK_INPUT_PROPERTIES_NO_BACKGROUND = Object.fromEntries(
@@ -4673,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;
@@ -4682,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) {
@@ -4693,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);
@@ -4712,7 +4724,7 @@ function resolveMcpProxyToolDefs(options) {
       { collided }
     );
   }
-  return { defs, coveredServers };
+  return { defs, coveredServers, matchedServers };
 }
 function readBody(req) {
   return new Promise((resolve6, reject) => {
@@ -5701,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 (; ; ) {
@@ -5709,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));
   }
 }
@@ -5759,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;
@@ -5775,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;
@@ -5903,6 +5915,56 @@ 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 = /* @__PURE__ */ new Set();
+  for (const ids of cancelled.values()) for (const id of ids) cancelledIds.add(id);
+  const states = await Promise.all(
+    entries.map(async ([taskId]) => {
+      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";
+      }
+    })
+  );
+  return {
+    running: states.filter((state) => state === "running").length,
+    started: entries.length,
+    unreadable: states.filter((state) => state === "unreadable").length
+  };
+}
 var lastGate;
 function recordBackgroundSubagentGate(gate, now = Date.now()) {
   lastGate = { ...gate, at: now };
@@ -7629,21 +7691,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));
   }
@@ -7652,12 +7714,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;
@@ -7672,12 +7734,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));
   }
 }
@@ -7781,7 +7843,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(
@@ -7791,14 +7853,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 });
@@ -7927,6 +7989,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",
@@ -9162,6 +9225,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(
@@ -9207,6 +9274,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";
@@ -9291,7 +9371,8 @@ async function gatherDoctorReport(options) {
     planUsage,
     backgroundSubagents: {
       gate: snapshotBackgroundSubagentGate(),
-      ledgers: snapshotBackgroundTasks()
+      ledgers: snapshotBackgroundTasks(),
+      running: await countRunningBackgroundTasks().catch(() => void 0)
     }
   };
 }
@@ -11962,12 +12043,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");
@@ -12120,6 +12201,17 @@ This opencode host runs background subagents, so \`mcp__opencode_proxy__task\` t
 - 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.
 - 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
+
+This opencode host runs background subagents, so \`mcp__opencode_proxy__task\` takes \`background: true\`.
+
+- 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.
+- 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;
+}
 var QUESTION_PROXY_HINT = `## Asking the operator questions
 
 Structured questions in this environment go through exactly one tool: \`mcp__opencode_proxy__question\`.
@@ -12720,7 +12812,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;
@@ -12729,18 +12827,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(
@@ -14667,13 +14794,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. */
@@ -15982,13 +16110,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;
@@ -16005,6 +16134,7 @@ var ClaudeCodeLanguageModel = class {
             };
             let enrichedProxy = resolvedProxy;
             let backgroundSubagentsSupported = false;
+            const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
             if (enrichedProxy && taskProxyEnabled) {
               enrichedProxy = overlayTaskProxyDescription(
                 enrichedProxy,
@@ -16019,7 +16149,6 @@ var ClaudeCodeLanguageModel = class {
                   )
                 )
               });
-              const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
               backgroundSubagentsSupported = liveTaskSupportsBackground(
                 liveToolInfo.taskParameters,
                 hostDialect
@@ -16096,6 +16225,7 @@ var ClaudeCodeLanguageModel = class {
               excludeServers,
               taskProxyEnabled,
               backgroundSubagentsSupported,
+              hostDialect,
               questionProxyActive,
               opencodeToolDefs,
               pluginCompressEnabled,
@@ -16161,7 +16291,7 @@ var ClaudeCodeLanguageModel = class {
                 // dispatch instead of calling the proxy (h #g74).
                 [
                   ...wiring.taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
-                  ...wiring.backgroundSubagentsSupported ? [BACKGROUND_SUBAGENT_HINT] : [],
+                  ...wiring.backgroundSubagentsSupported ? [backgroundSubagentHint(wiring.hostDialect)] : [],
                   ...wiring.questionProxyActive ? [QUESTION_PROXY_HINT] : []
                 ],
                 {
@@ -16275,6 +16405,7 @@ var ClaudeCodeLanguageModel = class {
                 excludeServers,
                 taskProxyEnabled,
                 backgroundSubagentsSupported,
+                hostDialect,
                 questionProxyActive,
                 opencodeToolDefs,
                 pluginCompressEnabled,
@@ -16292,7 +16423,7 @@ var ClaudeCodeLanguageModel = class {
                 [
                   ...extractSystemMessages(options.prompt),
                   ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
-                  ...backgroundSubagentsSupported ? [BACKGROUND_SUBAGENT_HINT] : [],
+                  ...backgroundSubagentsSupported ? [backgroundSubagentHint(hostDialect)] : [],
                   ...questionProxyActive ? [QUESTION_PROXY_HINT] : [],
                   ...self.config.hostApi === "v2" && options.tools?.some((t) => t.name === "execute") ? [codeModeProxyHint(opencodeToolDefs.some((t) => t.name === "execute"))] : []
                 ],
@@ -16842,6 +16973,9 @@ var ClaudeCodeLanguageModel = class {
                     recoveryRequired: channelClosed || state.unattendedTurnEnded
                   });
                 }
+                if (call.toolName === "task" || call.toolName === TASK_BATCH_TOOL_NAME) {
+                  noteBackgroundDispatchResult(sk, result);
+                }
                 resolvePendingProxyCallById(call.toolCallId, result);
               } else {
                 log.info(