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

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"];
@@ -5927,9 +5927,20 @@ function backgroundTaskIdsIn(text) {
   }
   return [...ids];
 }
+var BATCH_SECTION = /^## task \d+ of \d+: /m;
+function acceptedBackgroundTaskIds(result) {
+  if (result.kind !== "text") return [];
+  if (result.isError !== true) return backgroundTaskIdsIn(result.text);
+  const ids = /* @__PURE__ */ new Set();
+  for (const section of result.text.split(BATCH_SECTION).slice(1)) {
+    const body = section.slice(section.indexOf("\n") + 1);
+    if (body.startsWith("[error] ") || body.startsWith("[missing] ")) continue;
+    for (const id of backgroundTaskIdsIn(body)) ids.add(id);
+  }
+  return [...ids];
+}
 function noteBackgroundDispatchResult(sessionKey2, result, now = Date.now()) {
-  if (result.kind !== "text" || result.isError === true) return;
-  for (const taskId of backgroundTaskIdsIn(result.text)) {
+  for (const taskId of acceptedBackgroundTaskIds(result)) {
     started.delete(taskId);
     started.set(taskId, { sessionKey: sessionKey2, at: now });
     while (started.size > MAX_STARTED) {
@@ -5941,23 +5952,9 @@ function noteBackgroundDispatchResult(sessionKey2, result, now = Date.now()) {
 }
 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 cancelledIds = cancelledTaskIds();
   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";
-      }
-    })
+    entries.map(([taskId]) => backgroundTaskState(taskId, cancelledIds))
   );
   return {
     running: states.filter((state) => state === "running").length,
@@ -5965,6 +5962,87 @@ async function countRunningBackgroundTasks() {
     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") return result;
+  const dispatched = acceptedBackgroundTaskIds(result);
+  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 };
@@ -12200,6 +12278,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
 
@@ -12208,6 +12287,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;
@@ -16956,8 +17036,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,
@@ -16973,9 +17059,6 @@ 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(