@duckmind/dm-linux-x64 0.61.5 → 0.61.9

package/extensions/dm-subagents/src/extension/doctor.js

@@ -2,20 +2,26 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { discoverAgentsAll } from "../agents/agents.js";
 import { isAsyncAvailable } from "../runs/background/async-execution.js";
+import { formatSpawnBudgetSummary, getSpawnBudgetSnapshot } from "../runs/shared/spawn-budget.js";
+import { getActiveAsyncCapacitySnapshot, resolveAbandonedSlotReleaseAfterMs, resolveMaxActiveAsyncRunsPerSession } from "../runs/background/active-async-capacity.js";
+import { decodeRunFanoutBudgetDescriptor, formatRunFanoutBudget, getRunFanoutBudgetSnapshot, RUN_FANOUT_BUDGET_ENV } from "../runs/shared/run-fanout-budget.js";
 import { diagnoseIntercomBridge } from "../intercom/intercom-bridge.js";
 import { discoverAvailableSkills } from "../agents/skills.js";
 import {
-  ASYNC_DIR,
+  DIRS,
   CHAIN_RUNS_DIR,
-  RESULTS_DIR,
-  TEMP_ROOT_DIR
+  TEMP_ROOT_DIR,
+  normalizeMaxSubagentSpawnsPerRun,
+  resolveMaxSubagentSpawnsPerRun
 } from "../shared/types.js";
-const DEFAULT_PATHS = {
-  tempRootDir: TEMP_ROOT_DIR,
-  asyncDir: ASYNC_DIR,
-  resultsDir: RESULTS_DIR,
-  chainRunsDir: CHAIN_RUNS_DIR
-};
+function defaultPaths() {
+  return {
+    tempRootDir: TEMP_ROOT_DIR,
+    asyncDir: DIRS.async,
+    resultsDir: DIRS.results,
+    chainRunsDir: CHAIN_RUNS_DIR
+  };
+}
 const DEFAULT_DEPS = {
   isAsyncAvailable,
   discoverAgentsAll,
@@ -89,21 +95,19 @@ function formatSessionLines(input) {
 }
 function formatDiscovery(input, deps) {
   return [
-    lineFromCheck("agents/chains", () => {
+    lineFromCheck("agents", () => {
       const discovered = deps.discoverAgentsAll(input.cwd);
       const agentCounts = {
         builtin: discovered.builtin.length,
         package: discovered.package?.length ?? 0,
         user: discovered.user.length,
-        project: discovered.project.length
+        project: discovered.project.length,
+        runtime: 0
       };
-      const chainCounts = discovered.chains.reduce((counts, chain) => {
-        counts[chain.source] += 1;
-        return counts;
-      }, { builtin: 0, package: 0, user: 0, project: 0 });
+      const diagnostics = discovered.agentDiagnostics ?? [];
       return [
         `- agents: total ${agentCounts.builtin + agentCounts.package + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
-        `- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`
+        ...diagnostics.map((diagnostic) => `- invalid agent ${diagnostic.name ?? diagnostic.filePath} (${diagnostic.source}): ${diagnostic.error}`)
       ].join(`
 `);
     }),
@@ -122,6 +126,38 @@ function formatIntercomDiagnostic(diagnostic, context) {
   ];
   return lines;
 }
+function formatSpawnBudgetSection(input) {
+  const snapshot = getSpawnBudgetSnapshot(input.state, input.config, input.currentSessionId ?? input.state.currentSessionId);
+  return [
+    `- usage: ${formatSpawnBudgetSummary(snapshot)}`,
+    `- recent grants: ${snapshot.grantHistory.length === 0 ? "none" : snapshot.grantHistory.map((grant) => `+${grant.amount} at ${new Date(grant.grantedAt).toISOString()} (${grant.previousLimit} → ${grant.limit})`).join("; ")}`,
+    "- reset boundary: a new parent session resets usage and grants; compaction does not"
+  ];
+}
+function formatRunFanoutSection(input) {
+  try {
+    const inherited = decodeRunFanoutBudgetDescriptor(process.env[RUN_FANOUT_BUDGET_ENV]);
+    if (inherited) {
+      return [`- usage: ${formatRunFanoutBudget(getRunFanoutBudgetSnapshot(inherited)).replace(/^Run fan-out: /, "")}`, `- root run: ${inherited.rootRunId}`, "- reset boundary: cumulative claims are never released; a new top-level run creates a new budget"];
+    }
+  } catch (error) {
+    return [`- inherited budget: invalid — ${errorText(error)}`];
+  }
+  const configured = resolveMaxSubagentSpawnsPerRun(input.config.maxSubagentSpawnsPerRun);
+  const source = normalizeMaxSubagentSpawnsPerRun(process.env.DM_SUBAGENT_MAX_SPAWNS_PER_RUN) !== undefined ? "environment" : normalizeMaxSubagentSpawnsPerRun(input.config.maxSubagentSpawnsPerRun) !== undefined ? "config" : "default";
+  return [`- configured limit: ${configured} (${source})`, "- usage: available after a run starts", "- reset boundary: cumulative claims are never released; a new top-level run creates a new budget"];
+}
+function formatActiveAsyncCapacitySection(input) {
+  const limit = resolveMaxActiveAsyncRunsPerSession(input.config.maxActiveAsyncRunsPerSession);
+  const sessionId = input.currentSessionId ?? input.state.currentSessionId;
+  const snapshot = sessionId ? getActiveAsyncCapacitySnapshot(sessionId, limit, { liveWorkflowRunIds: new Set(input.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(input.config.capacity?.abandonedSlotReleaseAfterMs) }) : { used: 0, limit: limit ?? 0 };
+  input.state.activeAsyncCapacity = snapshot;
+  return [
+    `- usage: ${snapshot.used}/${snapshot.limit || "unlimited"} used`,
+    "- scope: top-level async runs in the current parent session; foreground and nested workflow children are not charged again",
+    "- release: terminal state plus matching observed process-terminal proof, or abandoned-timeout for failed runs with a dead runner PID and stale activity when enabled; false keeps unknown-proof slots"
+  ];
+}
 function formatPermissionSystemSection() {
   const lines = [];
   const parentSession = process.env["DM_SUBAGENT_PARENT_SESSION"] ?? "";
@@ -135,8 +171,14 @@ function formatPermissionSystemSection() {
   lines.push(`- subagent process: ${isChild ? "yes (DM_SUBAGENT_CHILD=1)" : "no"}`);
   return lines;
 }
+function formatWorkflowScriptSection() {
+  return [
+    "- helpers: runs.run, runs.all, runs.steer, runs.status, runs.ref/refs, emit, console",
+    "- recovery: if runs.all is missing, reload or update dm-subagents; await Promise.all([runs.run(...)]) is also supported"
+  ];
+}
 export function buildDoctorReport(input) {
-  const paths = input.paths ?? DEFAULT_PATHS;
+  const paths = input.paths ?? defaultPaths();
   const deps = { ...DEFAULT_DEPS, ...input.deps };
   const lines = [
     "Subagents doctor report",
@@ -155,6 +197,18 @@ export function buildDoctorReport(input) {
     "Discovery",
     ...formatDiscovery(input, deps),
     "",
+    "Spawn budget",
+    ...formatSpawnBudgetSection(input),
+    "",
+    "Run fan-out budget",
+    ...formatRunFanoutSection(input),
+    "",
+    "Active async capacity",
+    ...formatActiveAsyncCapacitySection(input),
+    "",
+    "Workflow script",
+    ...formatWorkflowScriptSection(),
+    "",
     "Permission system",
     ...formatPermissionSystemSection(),
     "",

package/extensions/dm-subagents/src/extension/fanout-child.js

@@ -4,12 +4,14 @@ import * as path from "node:path";
 import { discoverAgents } from "../agents/agents.js";
 import { getArtifactsDir } from "../shared/artifacts.js";
 import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
+import { resolveWaitToolConfig } from "../runs/background/wait-config.js";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/dm-args.js";
 import { readNestedControlRequests, resolveNestedRouteFromEnv, writeNestedControlResult } from "../runs/shared/nested-events.js";
 import { deliverSubagentIntercomMessageEvent } from "../intercom/result-intercom.js";
 import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
-import { SubagentParams } from "./schemas.js";
-import { loadConfig } from "./config.js";
+import { createSubagentParamsSchema } from "./schemas.js";
+import { finalizeToolResult } from "./tool-result.js";
+import { loadConfig, resolveAsyncByDefault } from "./config.js";
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
     const baseName = path.basename(parentSessionFile, ".jsonl");
@@ -31,7 +33,6 @@ function createChildSafeState() {
     foregroundRuns: new Map,
     foregroundControls: new Map,
     lastForegroundControlId: null,
-    pendingForegroundControlNotices: new Map,
     cleanupTimers: new Map,
     lastUiContext: null,
     poller: null,
@@ -44,27 +45,29 @@ function createChildSafeState() {
     }
   };
 }
-function startNestedControlInboxListener(pi, state) {
-  let route;
+function resolveNestedControlRoute() {
   try {
-    route = resolveNestedRouteFromEnv();
+    return resolveNestedRouteFromEnv();
   } catch {
     return;
   }
-  if (!route)
-    return;
-  const seen = new Set;
-  const inFlight = new Set;
-  const pendingResults = new Map;
+}
+function nestedControlRouteKey(route) {
+  return route.controlInbox;
+}
+function createNestedControlInboxState() {
+  return { seen: new Set, inFlight: new Set, pendingResults: new Map };
+}
+function startNestedControlInboxListener(dm, state, route, inboxState) {
   const timer = setInterval(() => {
     try {
       for (const request of readNestedControlRequests(route)) {
-        if (seen.has(request.requestId) || inFlight.has(request.requestId))
+        if (inboxState.seen.has(request.requestId) || inboxState.inFlight.has(request.requestId))
           continue;
-        inFlight.add(request.requestId);
+        inboxState.inFlight.add(request.requestId);
         (async () => {
           try {
-            let result = pendingResults.get(request.requestId);
+            let result = inboxState.pendingResults.get(request.requestId);
             if (!result) {
               let ok = false;
               let message = "Control request failed.";
@@ -82,7 +85,7 @@ function startNestedControlInboxListener(pi, state) {
                 } else {
                   const index = control.currentIndex ?? 0;
                   const target = resolveSubagentIntercomTarget(request.targetRunId, control.currentAgent, index);
-                  ok = await deliverSubagentIntercomMessageEvent(pi.events, target, `Follow-up for nested run ${request.targetRunId} (${control.currentAgent}):
+                  ok = await deliverSubagentIntercomMessageEvent(dm.events, target, `Follow-up for nested run ${request.targetRunId} (${control.currentAgent}):
 
 ${request.message.trim()}`, 500, { source: "nested-resume", runId: request.targetRunId, agent: control.currentAgent, index });
                   message = ok ? `Delivered follow-up to live nested run ${request.targetRunId}.` : `Nested child intercom target is not registered: ${target}`;
@@ -95,17 +98,17 @@ ${request.message.trim()}`, 500, { source: "nested-resume", runId: request.targe
             try {
               writeNestedControlResult(route, result);
             } catch (error) {
-              pendingResults.set(request.requestId, result);
+              inboxState.pendingResults.set(request.requestId, result);
               console.error(`Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${route.controlInbox}'; keeping request for retry:`, error);
               return;
             }
-            pendingResults.delete(request.requestId);
-            seen.add(request.requestId);
+            inboxState.pendingResults.delete(request.requestId);
+            inboxState.seen.add(request.requestId);
             try {
               fs.unlinkSync(request.filePath);
             } catch {}
           } finally {
-            inFlight.delete(request.requestId);
+            inboxState.inFlight.delete(request.requestId);
           }
         })();
       }
@@ -114,45 +117,59 @@ ${request.message.trim()}`, 500, { source: "nested-resume", runId: request.targe
     }
   }, 200);
   timer.unref?.();
-  return timer;
+  return () => clearInterval(timer);
 }
-export default function registerFanoutChildSubagentExtension(pi) {
+export default function registerFanoutChildSubagentExtension(dm) {
   if (process.env[SUBAGENT_CHILD_ENV] !== "1" || process.env[SUBAGENT_FANOUT_CHILD_ENV] !== "1")
     return;
   const globalStore = globalThis;
   const registeredKey = "__piSubagentFanoutChildRegisteredApis";
   const registeredApis = globalStore[registeredKey] instanceof WeakSet ? globalStore[registeredKey] : new WeakSet;
   globalStore[registeredKey] = registeredApis;
-  if (registeredApis.has(pi))
+  if (registeredApis.has(dm))
     return;
-  registeredApis.add(pi);
+  registeredApis.add(dm);
   const config = loadConfig();
+  const waitToolConfig = resolveWaitToolConfig(config.waitTool);
   const state = createChildSafeState();
   const executor = createSubagentExecutor({
-    pi,
+    dm,
     state,
     config,
-    asyncByDefault: config.asyncByDefault === true,
+    asyncByDefault: resolveAsyncByDefault(config),
+    waitToolEnabled: waitToolConfig.enabled,
+    waitToolDefaultTimeoutMs: waitToolConfig.defaultTimeoutMs,
     tempArtifactsDir: getArtifactsDir(null),
     getSubagentSessionRoot,
     expandTilde,
     discoverAgents,
     allowMutatingManagementActions: false
   });
+  const params = createSubagentParamsSchema();
   const tool = {
     name: "subagent",
     label: "Subagent",
     description: [
       "Delegate to subagents from child-safe fanout mode.",
-      "Allowed management/control actions: list, get, status, interrupt, resume, steer, append-step, doctor.",
-      "Agent config mutation actions (create, update, delete, eject, disable, enable, reset) are blocked in this mode."
+      "Allowed management/control actions: list, get, status, lane.status, interrupt, resume, steer, doctor.",
+      "Mutating management actions (create, update, delete, eject, disable, enable, reset, grant-spawn-budget, lane.recordMerge, lane.recordSupersession) are blocked in this mode."
     ].join(`
 `),
-    parameters: SubagentParams,
-    execute(id, params, signal, onUpdate, ctx) {
-      return executor.execute(id, params, signal, onUpdate, ctx);
+    parameters: params,
+    async execute(id, params, signal, onUpdate, ctx) {
+      return finalizeToolResult(await executor.executePublic(id, params, signal ?? new AbortController().signal, onUpdate, ctx));
     }
   };
-  pi.registerTool(tool);
-  startNestedControlInboxListener(pi, state);
+  dm.registerTool(tool);
+  const route = resolveNestedControlRoute();
+  if (!route)
+    return;
+  const listenerCleanupKey = "__piSubagentFanoutChildNestedControlInboxCleanups";
+  const listenerCleanups = globalStore[listenerCleanupKey] instanceof Map ? globalStore[listenerCleanupKey] : new Map;
+  globalStore[listenerCleanupKey] = listenerCleanups;
+  const routeKey = nestedControlRouteKey(route);
+  const previous = listenerCleanups.get(routeKey);
+  previous?.cleanup();
+  const inboxState = previous?.state ?? createNestedControlInboxState();
+  listenerCleanups.set(routeKey, { state: inboxState, cleanup: startNestedControlInboxListener(dm, state, route, inboxState) });
 }