@dreb/coding-agent 2.57.0 → 2.58.0

package/dist/core/tools/subagent.js

@@ -11,6 +11,7 @@ import { keyHint } from "../../modes/interactive/components/keybinding-hints.js"
 import { attachJsonlLineReader, serializeJsonLine } from "../../modes/rpc/jsonl.js";
 import { log } from "../logger.js";
 import { resolveCliModel } from "../model-resolver.js";
+import { DEFAULT_MAX_CONCURRENT_SUBAGENTS } from "../settings-manager.js";
 import { resolveEffectiveThinkingLevel, thinkingLevelToReasoning, validateThinkingLevelForModel } from "../thinking.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
@@ -915,33 +916,43 @@ function formatSkippedModelFailureDetails(skippedModels) {
     return `Skipped models:\n${skippedModels.map((s) => `- ${s.model}: ${s.reason}`).join("\n")}`;
 }
 const MAX_PARALLEL_TASKS = 8;
-const MAX_CONCURRENCY = 4;
 const MAX_TASK_LENGTH = 32_768; // 32 KB — prevent E2BIG from oversized argv
+/**
+ * Create a concurrency gate limited to `maxConcurrent` simultaneous holders. The count lives in
+ * this closure, so a single gate instance shared across tool rebuilds keeps counting in-flight
+ * children accurately, while distinct instances stay fully isolated from one another.
+ */
+export function createSubagentConcurrencyGate(maxConcurrent) {
+    if (!Number.isSafeInteger(maxConcurrent) || maxConcurrent < 1) {
+        throw new Error("Subagent tool concurrency must be a positive whole number");
+    }
+    let running = 0;
+    const waiters = [];
+    return {
+        acquire() {
+            if (running < maxConcurrent) {
+                running++;
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                waiters.push(() => {
+                    running++;
+                    resolve();
+                });
+            });
+        },
+        release() {
+            running--;
+            const next = waiters.shift();
+            if (next)
+                next();
+        },
+    };
+}
 /** Resolve per-task thinking precedence for parallel and chain modes. */
 export function resolveSubagentThinkingOverride(taskThinking, topLevelThinking) {
     return taskThinking ?? topLevelThinking;
 }
-// Semaphore for background task concurrency — shared across all background launches
-let bgRunning = 0;
-const bgWaiters = [];
-async function bgAcquire() {
-    if (bgRunning < MAX_CONCURRENCY) {
-        bgRunning++;
-        return;
-    }
-    return new Promise((resolve) => {
-        bgWaiters.push(() => {
-            bgRunning++;
-            resolve();
-        });
-    });
-}
-function bgRelease() {
-    bgRunning--;
-    const next = bgWaiters.shift();
-    if (next)
-        next();
-}
 /**
  * Resolve a per-task cwd.
  * Accepts absolute paths as-is. Resolves relative paths against the parent cwd,
@@ -1743,6 +1754,18 @@ export function createSubagentToolDefinition(cwd, options) {
     const arbitrate = options?.arbitrate;
     const onArbitration = options?.onArbitration;
     const getDefaultThinkingLevel = options?.defaultThinkingLevel;
+    const maxConcurrentSubagents = options?.maxConcurrentSubagents ?? DEFAULT_MAX_CONCURRENT_SUBAGENTS;
+    if (!Number.isSafeInteger(maxConcurrentSubagents) || maxConcurrentSubagents < 1) {
+        throw new Error("Subagent tool concurrency must be a positive whole number");
+    }
+    // The concurrency gate is owned by the caller (e.g. AgentSession) so that it survives
+    // runtime rebuilds/reloads: the tool definition is recreated on every `/reload`, but the
+    // gate must keep counting in-flight children launched before the reload. When no gate is
+    // supplied (external SDK callers, tests) the tool owns a fresh per-instance gate, which
+    // still keeps separately embedded sessions from coupling through module-global state.
+    const concurrencyGate = options?.concurrencyGate ?? createSubagentConcurrencyGate(maxConcurrentSubagents);
+    const acquireBackgroundSlot = () => concurrencyGate.acquire();
+    const releaseBackgroundSlot = () => concurrencyGate.release();
     // Discover agents at definition time to build the prompt guidelines.
     // This is cheap (reads .md files) and the same call happens on every execute().
     const knownAgents = discoverAgentTypes(cwd);
@@ -1758,7 +1781,7 @@ export function createSubagentToolDefinition(cwd, options) {
         label: "subagent",
         description: "Run focused, independent work in a child agent when the task matches that agent's defined role " +
             "(Explore for concrete evidence gathering, Sandbox for isolated /tmp-only analysis). " +
-            "Supports `task` for a single task, `tasks` for parallel execution in one call (up to 8, max 4 concurrent), " +
+            `Supports \`task\` for a single task, \`tasks\` for parallel execution in one call (up to 8, max ${maxConcurrentSubagents} concurrent), ` +
             "and `chain` for a sequential pipeline with {previous} substitution. " +
             "All subagents run in background — returns immediately, notifies on completion.",
         promptSnippet: "Run role-matched work in independent child agents",
@@ -1878,7 +1901,7 @@ export function createSubagentToolDefinition(cwd, options) {
                         }
                     };
                     const run = async () => {
-                        await bgAcquire();
+                        await acquireBackgroundSlot();
                         try {
                             const result = await runFn(bgSignal, onChildEvent, onArbitrationRecord, onControlAvailable);
                             const entry = backgroundAgentRegistry.get(agentId);
@@ -1905,7 +1928,7 @@ export function createSubagentToolDefinition(cwd, options) {
                         }
                         finally {
                             backgroundControlClients.delete(agentId);
-                            bgRelease();
+                            releaseBackgroundSlot();
                         }
                     };
                     run().catch((err) => {