@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-subagents/src/runs/background/subagent-wait.js

@@ -95,6 +95,11 @@ function waitForWake(ms, signal, deps) {
     sleep(ms, wakeController.signal).then(done);
   });
 }
+function wakeSignal(signal, deps) {
+  if (!deps.userInputSignal)
+    return signal;
+  return signal ? AbortSignal.any([signal, deps.userInputSignal]) : deps.userInputSignal;
+}
 function matchesId(run, id) {
   return run.id === id || run.id.startsWith(id);
 }
@@ -256,14 +261,18 @@ function windowElapsedResult(text, activeRunIds, activeProviderItems = []) {
     }
   };
 }
-function supervisorYieldResult(activeRunIds, activeProviderItems = []) {
+const WAIT_YIELD_TEXT = {
+  supervisor_request: "Wait yielded for a pending supervisor request. Background work remains active and will continue after the supervisor reply.",
+  user_input: "Wait yielded because the user sent a message. Background work remains active; read the message before waiting again."
+};
+function yieldResult(reason, activeRunIds, activeProviderItems = []) {
   return {
-    content: [{ type: "text", text: "Wait yielded for a pending supervisor request. Background work remains active and will continue after the supervisor reply." }],
+    content: [{ type: "text", text: WAIT_YIELD_TEXT[reason] }],
     details: {
       mode: "management",
       results: [],
       wait: {
-        reason: "supervisor_request",
+        reason,
         timedOut: false,
         activeRunIds,
         activeProviderItems: activeProviderItems.map(({ provider, id }) => ({ provider, id }))
@@ -271,7 +280,7 @@ function supervisorYieldResult(activeRunIds, activeProviderItems = []) {
     }
   };
 }
-function supervisorYieldForScope(scope, params, deps, nowMs) {
+function yieldForScope(reason, scope, params, deps, nowMs) {
   try {
     const activeAsyncIds = new Set(activeRunsForSession(params.id ? { id: params.id } : {}, deps).map((run) => run.id));
     const activeRunIds = new Set([...scope.asyncRunIds].filter((id) => activeAsyncIds.has(id)));
@@ -283,7 +292,7 @@ function supervisorYieldForScope(scope, params, deps, nowMs) {
         activeRunIds.add(initial.runId);
     }
     const activeProviderItems = scope.providerIds.size > 0 ? backgroundWorkForSession(deps, nowMs).items.filter((item) => scope.providerIds.has(backgroundWorkIdentity(item))) : [];
-    return supervisorYieldResult([...activeRunIds], activeProviderItems);
+    return yieldResult(reason, [...activeRunIds], activeProviderItems);
   } catch (error) {
     return result(error instanceof Error ? error.message : String(error), true);
   }
@@ -406,7 +415,8 @@ function detachedForegroundWaitUpdate(run, pendingIndices, nowMs, elapsedMs) {
   return result(lines.join(`
 `));
 }
-async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield) {
+async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait) {
+  const wake = wakeSignal(signal, deps);
   const initialDetachedIndices = new Set(run.children.filter((child) => child.status === "detached").map((child) => child.index));
   while (true) {
     if (deps.state.currentSessionId !== run.sessionId) {
@@ -417,7 +427,9 @@ async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, p
       return result(`Remembered foreground run "${run.runId}" disappeared before a terminal child result was recorded. Completion cannot be confirmed; do not launch a replacement without checking the originating child session.`, true);
     }
     if (deps.hasPendingSupervisorRequest?.())
-      return supervisorYield();
+      return yieldWait("supervisor_request");
+    if (deps.userInputSignal?.aborted)
+      return yieldWait("user_input");
     const pending = current.children.filter((child) => initialDetachedIndices.has(child.index) && child.status === "detached");
     const attention = foregroundChildrenNeedingAttention(current, initialDetachedIndices);
     if (attention.length > 0)
@@ -434,16 +446,16 @@ async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, p
     if (now() - startedAt >= timeoutMs) {
       return windowElapsedResult(`Wait window elapsed after ${formatDuration(timeoutMs)} with remembered foreground run "${run.runId}" still detached. Reply to any pending supervisor request, then call bg_wait({ id: "${run.runId}" }) again or inspect status; do not resume or launch a replacement while it remains detached.`, [run.runId]);
     }
-    await waitForWake(pollIntervalMs, signal, deps);
+    await waitForWake(pollIntervalMs, wake, deps);
   }
 }
-async function waitForSessionDetachedForegroundRuns(runs, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield) {
+async function waitForSessionDetachedForegroundRuns(runs, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait) {
   const texts = [];
   for (const run of runs) {
-    const one = await waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield);
+    const one = await waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait);
     if (one.isError)
       return one;
-    if (one.details.wait?.reason === "supervisor_request")
+    if (one.details.wait && one.details.wait.reason !== "window_elapsed")
       return one;
     if (one.details.wait?.reason === "window_elapsed") {
       const activeRunIds = runs.filter((initial) => {
@@ -543,13 +555,14 @@ ${references.join(`
     })),
     providerIds: initialProviderIds
   };
-  const supervisorYield = () => supervisorYieldForScope(initialScope, params, deps, now());
+  const yieldWait = (reason) => yieldForScope(reason, initialScope, params, deps, now());
+  const wake = wakeSignal(signal, deps);
   if (selectedForeground) {
-    return waitForDetachedForegroundRun(selectedForeground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield);
+    return waitForDetachedForegroundRun(selectedForeground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait);
   }
   if (active.length === 0 && providerActive.length === 0) {
     if (waitForAll && !params.id && foreground.length > 0) {
-      return waitForSessionDetachedForegroundRuns(foreground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield);
+      return waitForSessionDetachedForegroundRuns(foreground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait);
     }
     return result(params.id ? `No active run matched "${params.id}". Nothing to wait for.` : "No active async runs or registered provider work in this session. Nothing to wait for.");
   }
@@ -581,6 +594,8 @@ ${references.join(`
       ...activeInitialProviderItems.map((item) => `${item.provider}/${item.id}`)
     ].join(", ");
     deps.onUpdate?.(asyncWaitUpdate(activeInitialRuns, activeInitialProviderItems.length, now() - startedAt));
+    if (deps.userInputSignal?.aborted)
+      return yieldWait("user_input");
     if (signal?.aborted) {
       return result(`Wait aborted after ${formatDuration(now() - startedAt)}. Still active: ${stillActive}.`, true);
     }
@@ -588,7 +603,7 @@ ${references.join(`
       return windowElapsedResult(`Wait window elapsed after ${formatDuration(timeoutMs)} with ${activeInitialRuns.length} async run(s) and ${activeInitialProviderItems.length} provider item(s) still active: ${stillActive}. The work keeps going; call bg_wait again or inspect subagent status.`, activeInitialRuns.map((run) => run.id), activeInitialProviderItems);
     }
     try {
-      await waitForWake(pollIntervalMs, signal, deps);
+      await waitForWake(pollIntervalMs, wake, deps);
       if (deps.state.currentSessionId !== sessionId)
         return result("Wait stopped because the active session changed.", true);
       active = activeRunsForSession(waitParams, deps);
@@ -605,7 +620,7 @@ ${references.join(`
     }
   }
   if (supervisorBarrier) {
-    return supervisorYield();
+    return yieldWait("supervisor_request");
   }
   let terminalSummary;
   let finishedAsyncCount;
@@ -637,12 +652,10 @@ ${references.join(`
 `)}
 ` : "");
   if (waitForAll) {
-    const foregroundResult = !params.id && foreground.length > 0 && relevantAttention.length === 0 ? await waitForSessionDetachedForegroundRuns(foreground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield) : undefined;
+    const foregroundResult = !params.id && foreground.length > 0 && relevantAttention.length === 0 ? await waitForSessionDetachedForegroundRuns(foreground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, yieldWait) : undefined;
     if (foregroundResult?.isError)
       return foregroundResult;
-    if (foregroundResult?.details.wait?.reason === "supervisor_request")
-      return foregroundResult;
-    if (foregroundResult?.details.wait?.reason === "window_elapsed")
+    if (foregroundResult?.details.wait)
       return foregroundResult;
     const foregroundNote = foregroundResult ? `
 ${foregroundResult.content.map((part) => part.type === "text" ? part.text : "").join(`

package/extensions/dm-subagents/src/runs/background/terminal-run-index.js

@@ -3,9 +3,11 @@ import * as path from "node:path";
 import { readStatus } from "../../shared/utils.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { encodeIndexSegment } from "./index-segment.js";
+import { isSafeNestedPathId } from "../shared/nested-path.js";
 export const TERMINAL_RUN_INDEX_DIR = ".terminal-runs";
 const TERMINAL_RUN_INDEX_VERSION = 1;
 const TIMESTAMP_WIDTH = 16;
+const TOOL_CALL_INDEX_DIR = "@tool-calls";
 function isTerminalState(state) {
   return state === "complete" || state === "failed" || state === "partial" || state === "paused" || state === "stopped" || state === "rejected";
 }
@@ -15,6 +17,12 @@ function indexRoot(asyncDirRoot) {
 function sessionIndexDir(asyncDirRoot, sessionId) {
   return path.join(indexRoot(asyncDirRoot), encodeIndexSegment(sessionId));
 }
+function toolCallIndexDir(asyncDirRoot, toolCallId) {
+  return path.join(indexRoot(asyncDirRoot), TOOL_CALL_INDEX_DIR, encodeIndexSegment(toolCallId));
+}
+function toolCallMarkerName(runId) {
+  return `${encodeIndexSegment(runId, 250)}.json`;
+}
 function markerName(endedAt, runId) {
   return `${Math.max(0, Math.floor(endedAt)).toString().padStart(TIMESTAMP_WIDTH, "0")}-${encodeIndexSegment(runId)}.json`;
 }
@@ -41,6 +49,13 @@ export function updateTerminalRunIndex(asyncDir, status) {
     endedAt
   };
   writeAtomicJson(marker, entry);
+  if (status.toolCallId) {
+    try {
+      writeAtomicJson(path.join(toolCallIndexDir(path.dirname(asyncDir), status.toolCallId), toolCallMarkerName(entry.runId)), entry);
+    } catch (error) {
+      console.error(`Failed to write async terminal-run tool-call index for '${asyncDir}':`, error);
+    }
+  }
 }
 function removeInvalidMarker(marker) {
   try {
@@ -61,7 +76,7 @@ function sessionDirs(asyncDirRoot, sessionId) {
   if (sessionId)
     return [sessionIndexDir(asyncDirRoot, sessionId)];
   try {
-    return fs.readdirSync(indexRoot(asyncDirRoot), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(indexRoot(asyncDirRoot), entry.name));
+    return fs.readdirSync(indexRoot(asyncDirRoot), { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== TOOL_CALL_INDEX_DIR).map((entry) => path.join(indexRoot(asyncDirRoot), entry.name));
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT" || code === "ENOTDIR")
@@ -72,6 +87,32 @@ function sessionDirs(asyncDirRoot, sessionId) {
 function recentMarkerFiles(dirs, limit) {
   return dirs.flatMap(markerFiles).sort((left, right) => right.name.localeCompare(left.name)).slice(0, limit).map((marker) => path.join(marker.dir, marker.name));
 }
+export function readTerminalRunToolCallIndex(asyncDirRoot, toolCallId) {
+  const runIds = [];
+  for (const file of markerFiles(toolCallIndexDir(asyncDirRoot, toolCallId))) {
+    const marker = path.join(file.dir, file.name);
+    let entry;
+    try {
+      entry = parseEntry(JSON.parse(fs.readFileSync(marker, "utf-8")));
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      if (!(error instanceof SyntaxError))
+        throw error;
+    }
+    if (!entry || !isSafeNestedPathId(entry.runId) || file.name !== toolCallMarkerName(entry.runId)) {
+      removeInvalidMarker(marker);
+      continue;
+    }
+    const status = readStatus(path.join(asyncDirRoot, entry.runId));
+    if (!status || !isTerminalState(status.state) || status.runId !== entry.runId || status.sessionId !== entry.sessionId || status.toolCallId !== toolCallId) {
+      removeInvalidMarker(marker);
+      continue;
+    }
+    runIds.push(entry.runId);
+  }
+  return runIds;
+}
 export function readRecentTerminalRunIndex(asyncDirRoot, options = {}) {
   const limit = options.limit === undefined ? Number.POSITIVE_INFINITY : Math.max(0, Math.floor(options.limit));
   const candidates = recentMarkerFiles(sessionDirs(asyncDirRoot, options.sessionId), limit);

package/extensions/dm-subagents/src/runs/background/wait-completions.js

@@ -88,6 +88,7 @@ export function toWaitCompletion(data, runId) {
       ...sessionFile ? { sessionFile } : {},
       ...typeof child.success === "boolean" ? { success: child.success } : {},
       ...outputState ? { outputState } : {},
+      ...child.outputPartial === true ? { outputPartial: true } : {},
       ...structuredOutput !== undefined ? { structuredOutput } : {},
       ...structuredOutputPath ? { structuredOutputPath } : {},
       ...error ? { error } : {},

package/extensions/dm-subagents/src/runs/background/wait-tool.js

@@ -1,31 +1,41 @@
 import { SubagentWaitParams } from "../../extension/schemas.js";
 import { resolveWaitToolConfig, waitForSubagents } from "./subagent-wait.js";
 import { finalizeToolResult } from "../../extension/tool-result.js";
+import { registerPinnedTool } from "../../extension/declaration-pinning.js";
 export function registerWaitTool(dm, state, enabled = resolveWaitToolConfig().enabled, subscriptions, defaultTimeoutMs, child, hasPendingSupervisorRequest) {
-  const description = `Wait for background, provider, or detached work that has no native completion notification, then return.
-
-${child ? "This child runtime does not install the root session's native completion notifier. Use blocking bg_wait to collect your owned descendants during this turn, then read the returned result references before synthesizing findings. Automatic draining at agent_end keeps owned work alive but does not synthesize its results." : "Ordinary async subagent runs already notify this session natively when they complete or need attention. In an interactive chat, return control instead of calling this merely to wait. Use this tool for provider jobs, remembered detached foreground runs, or other background work without a native notification path. Headless runs auto-drain current-session subagent work at agent_end; use this tool only when the current turn must receive non-notifying background work results."}
-
-• { } — return when the first initially active async run or registered provider item finishes, or when a subagent needs attention.
-• { all: true } — wait for every async run, provider item, and remembered detached foreground descendant that was active when the call began.
-• { id: "..." } — wait for one async or remembered detached foreground subagent run (id or prefix). Named async runs that already finished return their terminal result references.
-• { id: "...", nonBlocking: true } — resolve the prefix once, persist an exact-run wake subscription, and return immediately. Use this for detached work without native completion delivery; the originating interactive session wakes on completion, failure, attention, reconciliation failure, or timeout.
-• { stopOnAttention: false } — for blocking waits only, keep waiting through idle or long-thinking attention; supervisor/contact requests still stop the wait.
-• { timeoutMs: 600000 } — stop waiting after N ms; active work keeps running. Omitted values use waitTool.defaultTimeoutMs, then 30 minutes. Window expiry returns a non-error window_elapsed result with active work identities.
-
-Non-blocking subscriptions are visible in subagent status and differ from disabling waitTool: waitTool.enabled=false returns immediately without registering any future wake. Provider jobs are session-scoped and identified exactly, so replacing one job with another cannot hide a completion. Provider extensions must be explicitly loaded in this process. In a child agent, keep \`bg_wait\` in the child tool allowlist and load each provider through the agent's extensions or subagentOnlyExtensions; this tool never loads providers or grants tools itself.${enabled ? "" : `
-
-Configured behavior: bg_wait is disabled by config.waitTool or DM_SUBAGENT_WAIT_TOOL_ENABLED and returns immediately without blocking.`}`;
-  const execute = async (_id, params, signal, onUpdate, ctx) => finalizeToolResult(await waitForSubagents(params, signal, {
-    state,
-    nestedRootRunId: child?.nestedRootRunId,
-    events: dm.events,
-    enabled,
-    hasPendingSupervisorRequest,
-    ...defaultTimeoutMs !== undefined ? { defaultTimeoutMs } : {},
-    onUpdate,
-    ...subscriptions && ctx?.hasUI ? { subscribe: (input) => subscriptions.arm(input) } : {}
-  }));
+  const description = `Wait for background work, then return. ${child ? "This child runtime has no native completion notifier: use blocking bg_wait to collect your owned descendants this turn and read their result references; agent_end draining does not synthesize results." : "Ordinary async subagent runs already wake this session natively; use bg_wait only for provider, detached, or other background work without native notification, when a same-turn result is needed."}
+{} — first active run or provider item to finish or need attention.
+{all:true} — all work active at call time.
+{id} — one run; a finished async run returns its result references.
+{id,nonBlocking:true} — subscribe to that run's wake and return now.
+Timeout or a user message ends the wait without error; work keeps running.${enabled ? "" : `
+Disabled by config.waitTool or DM_SUBAGENT_WAIT_TOOL_ENABLED: returns immediately.`}`;
+  const userInputWaits = new Set;
+  dm.on("input", (event) => {
+    if (event.source === "extension" || !event.streamingBehavior)
+      return;
+    for (const controller of userInputWaits)
+      controller.abort();
+  });
+  const execute = async (_id, params, signal, onUpdate, ctx) => {
+    const userInput = new AbortController;
+    userInputWaits.add(userInput);
+    try {
+      return finalizeToolResult(await waitForSubagents(params, signal, {
+        state,
+        nestedRootRunId: child?.nestedRootRunId,
+        events: dm.events,
+        enabled,
+        hasPendingSupervisorRequest,
+        userInputSignal: userInput.signal,
+        ...defaultTimeoutMs !== undefined ? { defaultTimeoutMs } : {},
+        onUpdate,
+        ...subscriptions && ctx?.hasUI ? { subscribe: (input) => subscriptions.arm(input) } : {}
+      }));
+    } finally {
+      userInputWaits.delete(userInput);
+    }
+  };
   const primaryTool = {
     name: "bg_wait",
     label: "Background Wait",
@@ -33,8 +43,8 @@ Configured behavior: bg_wait is disabled by config.waitTool or DM_SUBAGENT_WAIT_
     parameters: SubagentWaitParams,
     execute
   };
-  dm.registerTool(primaryTool);
-  dm.registerTool({
+  registerPinnedTool(dm, primaryTool);
+  registerPinnedTool(dm, {
     ...primaryTool,
     name: "wait",
     label: "Wait",

package/extensions/dm-subagents/src/runs/background/workflow-terminal-proof.js

@@ -11,36 +11,49 @@ export function readWorkflowChildProcessEvidence(workflowAsyncDir, steps) {
     return { state: "unknown", reason: "workflow child roster is missing" };
   const children = [];
   for (const step of steps) {
-    const label = step.workflowKey ?? step.agent;
-    if (typeof step.async !== "boolean")
-      return { state: "unknown", reason: `workflow child ${label} is missing async classification` };
-    if (!step.async)
+    const child = readWorkflowChildEvidence(workflowAsyncDir, step);
+    if (!child)
       continue;
-    if (!step.runId || path.basename(step.runId) !== step.runId)
-      return { state: "unknown", reason: `async workflow child ${label} is missing run id` };
-    const childDir = path.join(path.dirname(workflowAsyncDir), step.runId);
-    if (!fs.existsSync(childDir))
-      return { state: "unknown", reason: `async workflow child ${label} directory is missing` };
-    const childStatus = readStatus(childDir);
-    if (!childStatus)
-      return { state: "unknown", reason: `async workflow child ${label} status is missing or unreadable` };
-    if (!isTerminalAsyncState(childStatus.state))
-      return { state: "pending", reason: `async workflow child ${label} is still ${childStatus.state}` };
-    const recorded = childStatus.processTerminal;
-    if (!recorded?.runnerProcessInstanceId)
-      return { state: "unknown", reason: `async workflow child ${label} has no runner process identity` };
-    if (recorded.state === "not-started" && recorded.runId === step.runId && typeof childStatus.error === "string" && childStatus.error) {
-      children.push(recorded);
-      continue;
-    }
-    const proof = readProcessTerminal(childDir, { runId: step.runId, runnerProcessInstanceId: recorded.runnerProcessInstanceId });
-    if (proof?.state !== "observed" || proof.runId !== step.runId) {
-      return { state: !proof || proof.state === "pending" ? "pending" : "unknown", reason: `async workflow child ${label} process-terminal proof is ${proof?.state ?? "missing"}` };
-    }
-    children.push(proof);
+    if (child.state !== "resolved")
+      return { state: child.state, reason: child.reason };
+    children.push(child.proof);
   }
   return { state: "observed", children };
 }
+export function readWorkflowChildEvidence(workflowAsyncDir, step) {
+  const label = step.workflowKey ?? step.agent;
+  if (typeof step.async !== "boolean")
+    return { state: "unknown", reason: `workflow child ${label} is missing async classification` };
+  if (!step.async)
+    return;
+  if (!step.runId || path.basename(step.runId) !== step.runId)
+    return { state: "unknown", reason: `async workflow child ${label} is missing run id` };
+  const childDir = path.join(path.dirname(workflowAsyncDir), step.runId);
+  if (!fs.existsSync(childDir))
+    return { state: "unknown", reason: `async workflow child ${label} directory is missing` };
+  const childStatus = readStatus(childDir);
+  if (!childStatus)
+    return { state: "unknown", reason: `async workflow child ${label} status is missing or unreadable` };
+  if (!isTerminalAsyncState(childStatus.state))
+    return { state: "pending", reason: `async workflow child ${label} is still ${childStatus.state}` };
+  const recorded = childStatus.processTerminal;
+  if (!recorded?.runnerProcessInstanceId)
+    return { state: "unknown", reason: `async workflow child ${label} has no runner process identity` };
+  if (recorded.state === "not-started" && recorded.runId === step.runId && typeof childStatus.error === "string" && childStatus.error) {
+    return { state: "resolved", proof: recorded };
+  }
+  const proof = readProcessTerminal(childDir, { runId: step.runId, runnerProcessInstanceId: recorded.runnerProcessInstanceId });
+  if (proof?.state !== "observed" || proof.runId !== step.runId) {
+    const proofState = proof?.state ?? "missing";
+    const bound = childStatus.runId === step.runId && typeof recorded.runnerProcessInstanceId === "string";
+    return {
+      state: !proof || proof.state === "pending" ? "pending" : "unknown",
+      reason: `async workflow child ${label} process-terminal proof is ${proofState}`,
+      ...bound ? { unresolvedProof: { status: childStatus, proofState } } : {}
+    };
+  }
+  return { state: "resolved", proof };
+}
 function unresolved(runId, state, dispatchClosed, reason) {
   return { version: 1, kind: "workflow", runId, state, dispatchClosed, reason };
 }

package/extensions/dm-subagents/src/runs/foreground/async-stop-action.js

@@ -3,11 +3,12 @@ import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { DIRS } from "../../shared/types.js";
 import { updateActiveRunIndex } from "../background/active-run-index.js";
-import { deliverStopRequest } from "../background/control-channel.js";
+import { deliverStopRequest, stopInboxClosedPath } from "../background/control-channel.js";
 import { readProcessTerminal } from "../background/process-terminal.js";
-import { resultFilePath, resultPayloadPathForSessionRun, writeAsyncResultFile } from "../background/result-files.js";
+import { resultFilePath, resultPayloadFileForSessionRun, resultPayloadPathForSessionRun, writeAsyncResultFile } from "../background/result-files.js";
 import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
-import { isStoppableAsyncStatusStep, resolveAsyncStatusChild } from "../shared/child-identity.js";
+import { readStatus } from "../../shared/utils.js";
+import { isStoppableAsyncStatusStep, resolveAsyncStatusChild, stopStoppableAsyncStatusChildren } from "../shared/child-identity.js";
 function getAsyncStopTarget(state, runId, location) {
   if (location?.asyncDir) {
     return {
@@ -20,8 +21,8 @@ function getAsyncStopTarget(state, runId, location) {
   const direct = state.asyncJobs.get(runId);
   return direct ? { asyncId: direct.asyncId, asyncDir: direct.asyncDir } : undefined;
 }
-const STOP_MESSAGE = "Subagent stopped by user.";
-function sealPausedRun(asyncDir, status) {
+const STOP_MESSAGE = "Subagent stopped.";
+function sealPausedRun(asyncDir, status, resultsDir) {
   const runnerProcessInstanceId = status.processTerminal?.runnerProcessInstanceId;
   if (!runnerProcessInstanceId)
     return "runner process identity is missing";
@@ -31,17 +32,32 @@ function sealPausedRun(asyncDir, status) {
   }
   if (!status.sessionId)
     return "session identity is missing";
-  const existingResultPath = resultPayloadPathForSessionRun(DIRS.results, status.sessionId, status.runId);
-  if (!existingResultPath)
-    return "paused result is missing";
+  const existingResultPath = resultPayloadPathForSessionRun(resultsDir, status.sessionId, status.runId) ?? resultPayloadFileForSessionRun(resultsDir, status.sessionId, status.runId);
   let existingResult;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(existingResultPath, "utf-8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-      throw new Error("result is not an object");
-    existingResult = parsed;
-  } catch (error) {
-    return `paused result is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+  if (!existingResultPath) {
+    existingResult = {
+      id: status.runId,
+      mode: status.mode,
+      sessionId: status.sessionId,
+      asyncDir,
+      ...status.completionOwnerId ? { completionOwnerId: status.completionOwnerId } : {},
+      ...status.toolCallId ? { toolCallId: status.toolCallId } : {},
+      results: (status.steps ?? []).map((step) => ({
+        agent: step.agent,
+        success: step.status === "complete" || step.status === "completed",
+        ...step.error ? { error: step.error } : {},
+        ...step.exitCode !== undefined ? { exitCode: step.exitCode } : {}
+      }))
+    };
+  } else {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(existingResultPath, "utf-8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("result is not an object");
+      existingResult = parsed;
+    } catch (error) {
+      return `paused result is unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
   }
   const resultRunId = typeof existingResult.runId === "string" ? existingResult.runId : existingResult.id;
   if (resultRunId !== status.runId || existingResult.sessionId !== status.sessionId) {
@@ -91,12 +107,31 @@ function sealPausedRun(asyncDir, status) {
     steps
   };
   delete stoppedStatus.activityState;
-  writeAsyncResultFile(resultFilePath(DIRS.results, status.runId), stoppedResult);
+  writeAsyncResultFile(resultFilePath(resultsDir, status.runId), stoppedResult);
   writeAtomicJson(path.join(asyncDir, "status.json"), stoppedStatus);
   updateActiveRunIndex(asyncDir, "stopped", status.toolCallId, { retryCapacityErrors: true, terminalIndexBeforeRelease: true });
 }
+export function deliverAsyncRunStop(input) {
+  const { status, resultsDir = DIRS.results, ...delivery } = input;
+  const pausedWholeRun = status.state === "paused" && delivery.childId === undefined && delivery.targetIndex === undefined;
+  if (!(pausedWholeRun && fs.existsSync(stopInboxClosedPath(delivery.asyncDir))))
+    deliverStopRequest(delivery);
+  if (pausedWholeRun)
+    return sealPausedRun(delivery.asyncDir, status, resultsDir);
+}
 export function stopAsyncRun(state, runId, kill, location, childId) {
   const target = getAsyncStopTarget(state, runId, location);
+  const workflowRunId = target?.asyncId ?? runId;
+  const workflowController = childId === undefined && workflowRunId ? state.workflowControllers?.get(workflowRunId) : undefined;
+  const workflowAsyncDir = workflowController && workflowRunId ? target?.asyncDir ?? state.asyncJobs.get(workflowRunId)?.asyncDir : undefined;
+  const workflowStatus = workflowAsyncDir ? readStatus(workflowAsyncDir) : undefined;
+  const foreignWorkflow = Boolean(state.currentSessionId && workflowStatus && workflowStatus.sessionId !== state.currentSessionId);
+  if (workflowController && workflowRunId && !foreignWorkflow) {
+    if (workflowStatus)
+      stopStoppableAsyncStatusChildren(workflowStatus, state.workflowChildStops?.get(workflowRunId), "Workflow stopped.");
+    workflowController.abort(new Error("Workflow stopped."));
+    return { content: [{ type: "text", text: `Stop requested for async workflow ${workflowRunId}.` }], details: { mode: "management", results: [] } };
+  }
   if (!target)
     return null;
   const status = reconcileAsyncRun(target.asyncDir, { kill }).status;
@@ -135,16 +170,13 @@ export function stopAsyncRun(state, runId, kill, location, childId) {
     }
   }
   try {
-    deliverStopRequest({ asyncDir: target.asyncDir, pid: typeof status.pid === "number" ? status.pid : undefined, kill, source: "stop-action", targetIndex: child?.index, childId: child?.id ?? childId });
-    if (pausedWholeRun) {
-      const failure = sealPausedRun(target.asyncDir, status);
-      if (failure) {
-        return {
-          content: [{ type: "text", text: `Stop request persisted for paused async run ${target.asyncId}, but terminal proof is not ready (${failure}). Retry stop after runner shutdown is observed.` }],
-          isError: true,
-          details: { mode: "management", results: [] }
-        };
-      }
+    const failure = deliverAsyncRunStop({ asyncDir: target.asyncDir, status, pid: typeof status.pid === "number" ? status.pid : undefined, kill, source: "stop-action", targetIndex: child?.index, childId: child?.id ?? childId });
+    if (failure) {
+      return {
+        content: [{ type: "text", text: `Stop request persisted for paused async run ${target.asyncId}, but terminal proof is not ready (${failure}). Retry stop after runner shutdown is observed.` }],
+        isError: true,
+        details: { mode: "management", results: [] }
+      };
     }
     const tracked = state.asyncJobs.get(target.asyncId);
     if (tracked) {

package/extensions/dm-subagents/src/runs/foreground/command-action.js

@@ -0,0 +1,37 @@
+import { readStatus } from "../../shared/utils.js";
+import { supervisorChannelDir } from "../shared/child-tool-plan.js";
+import { controlChildCommand } from "../shared/child-commands.js";
+function commandChildren(state, target) {
+  if (!state.currentSessionId)
+    throw new Error("Command controls require an owning parent session.");
+  if (target.kind === "nested")
+    throw new Error("Command controls support direct local DM children only.");
+  if (target.kind === "foreground") {
+    const live = state.foregroundControls.get(target.id);
+    const retained = state.foregroundRuns?.get(target.id);
+    if ((live?.sessionId ?? retained?.sessionId) !== state.currentSessionId)
+      throw new Error("Run is not owned by this session.");
+    if (live?.activeChildren?.size)
+      return [...live.activeChildren.values()].map(({ index, agent }) => ({ index, agent }));
+    if (live?.currentAgent)
+      return [{ index: live.currentIndex ?? 0, agent: live.currentAgent }];
+    return retained?.children.map(({ index, agent }) => ({ index, agent })) ?? [];
+  }
+  const status = target.location.asyncDir ? readStatus(target.location.asyncDir) : undefined;
+  if (status?.sessionId !== state.currentSessionId)
+    throw new Error("Run is not owned by this session.");
+  return status.steps?.map((step, index) => ({ index, agent: step.agent })) ?? [];
+}
+export async function commandAction(input) {
+  const children = commandChildren(input.state, input.target);
+  if (input.index === undefined && children.length !== 1)
+    throw new Error("Command controls require an explicit child index for multi-child runs.");
+  const child = input.index === undefined ? children[0] : children.find(({ index }) => index === input.index);
+  if (!child)
+    throw new Error(`No child index ${input.index ?? 0} in this run.`);
+  const result = await controlChildCommand(supervisorChannelDir(input.target.id, child.agent, child.index), input.operation, input.toolCallId, input.signal);
+  return {
+    content: [{ type: "text", text: JSON.stringify({ runId: input.target.id, index: child.index, commands: result.commands, closed: result.closed }) }],
+    details: { mode: "management", results: [], commands: result.commands }
+  };
+}