@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -1,4 +1,5 @@
 import * as fs from "node:fs";
+import * as path from "node:path";
 import {
   listBackgroundWorkWakeChannels,
   snapshotBackgroundWork
@@ -13,6 +14,7 @@ import {
   SUBAGENT_CONTROL_INTERCOM_EVENT,
   SUBAGENT_RESULT_INTERCOM_EVENT
 } from "../../shared/types.js";
+import { nestedRunScope } from "../shared/nested-events.js";
 import { formatDuration, shortenPath } from "../../shared/formatters.js";
 import { toAgentToolUsage } from "../../shared/utils.js";
 import { collectWaitCompletions } from "./wait-completions.js";
@@ -97,12 +99,13 @@ function matchesId(run, id) {
   return run.id === id || run.id.startsWith(id);
 }
 function activeDetachedForegroundRuns(params, deps) {
-  if (!params.id || !deps.state.foregroundRuns)
-    return [];
   const sessionId = deps.state.currentSessionId;
-  if (!sessionId)
+  if (!sessionId || !deps.state.foregroundRuns)
     return [];
-  return [...deps.state.foregroundRuns.values()].filter((run) => (run.runId === params.id || run.runId.startsWith(params.id)) && run.sessionId === sessionId && run.children.some((child) => child.status === "detached"));
+  const runs = [...deps.state.foregroundRuns.values()].filter((run) => run.sessionId === sessionId && run.children.some((child) => child.status === "detached"));
+  if (params.id)
+    return runs.filter((run) => run.runId === params.id || run.runId.startsWith(params.id));
+  return params.all === true ? runs : [];
 }
 function summarizeForegroundChildren(run, indices) {
   const counts = new Map;
@@ -135,27 +138,36 @@ function backgroundWorkForSession(deps, nowMs) {
     throw new Error("bg_wait requires an active session identity to scope background work safely.");
   return deps.backgroundWork?.snapshot(sessionId, nowMs) ?? snapshotBackgroundWork(sessionId, nowMs);
 }
-function activeRunsForSession(params, deps) {
-  const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
-  const resultsDir = deps.resultsDir ?? DIRS.results;
-  const runs = listAsyncRuns(asyncDirRoot, {
-    states: [...ACTIVE_STATES],
+export function waitRunScopes(deps) {
+  return [
+    { asyncDirRoot: deps.asyncDirRoot ?? DIRS.async, resultsDir: deps.resultsDir ?? DIRS.results },
+    ...deps.nestedRootRunId ? [nestedRunScope(deps.nestedRootRunId)] : []
+  ];
+}
+function collectScopedCompletions(terminal, deps, references) {
+  const completions = waitRunScopes(deps).flatMap((scope) => collectWaitCompletions(terminal.filter((run) => path.resolve(path.dirname(run.asyncDir)) === path.resolve(scope.asyncDirRoot)), deps.state, scope.resultsDir, (reference) => references.push(reference)) ?? []);
+  return completions.length ? completions : undefined;
+}
+function runsForSession(params, deps, activeOnly = true) {
+  const runs = waitRunScopes(deps).flatMap(({ asyncDirRoot, resultsDir }) => listAsyncRuns(asyncDirRoot, {
+    states: activeOnly ? [...ACTIVE_STATES] : undefined,
     sessionId: deps.state.currentSessionId ?? undefined,
     resultsDir,
     kill: deps.kill,
     now: deps.now,
     includeNested: false,
     ...params.id ? { runId: params.id } : {}
-  });
+  }));
   return params.id ? runs.filter((run) => matchesId(run, params.id)) : runs;
 }
+function activeRunsForSession(params, deps) {
+  return runsForSession(params, deps);
+}
 function attentionRunsForSession(params, deps, initialIds) {
   return activeRunsForSession(params, deps).filter((run) => needsAttention(run) && initialIds.has(run.id));
 }
 function runsForIds(runIds, deps) {
-  const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
-  const resultsDir = deps.resultsDir ?? DIRS.results;
-  return [...runIds].flatMap((runId) => listAsyncRuns(asyncDirRoot, {
+  return waitRunScopes(deps).flatMap(({ asyncDirRoot, resultsDir }) => [...runIds].flatMap((runId) => listAsyncRuns(asyncDirRoot, {
     sessionId: deps.state.currentSessionId ?? undefined,
     resultsDir,
     kill: deps.kill,
@@ -163,7 +175,7 @@ function runsForIds(runIds, deps) {
     includeNested: false,
     runId,
     exactRunId: true
-  }));
+  })));
 }
 function summarizeTerminalRuns(runs, providerFinishedCount = 0) {
   if (runs.length === 0 && providerFinishedCount === 0)
@@ -207,6 +219,11 @@ function completionUsage(completions) {
 }
 function result(text, isError = false, completions) {
   const usage = completionUsage(completions);
+  for (const completion of completions ?? []) {
+    if (completion.workflowReceiptPath)
+      text += `
+Workflow receipt [${completion.runId}]: ${completion.workflowReceiptPath}`;
+  }
   return {
     content: [{ type: "text", text }],
     ...isError ? { isError: true } : {},
@@ -239,6 +256,38 @@ function windowElapsedResult(text, activeRunIds, activeProviderItems = []) {
     }
   };
 }
+function supervisorYieldResult(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." }],
+    details: {
+      mode: "management",
+      results: [],
+      wait: {
+        reason: "supervisor_request",
+        timedOut: false,
+        activeRunIds,
+        activeProviderItems: activeProviderItems.map(({ provider, id }) => ({ provider, id }))
+      }
+    }
+  };
+}
+function supervisorYieldForScope(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)));
+    for (const initial of scope.foregroundRuns) {
+      const current = deps.state.foregroundRuns?.get(initial.runId);
+      if (!current || current.sessionId !== initial.sessionId)
+        continue;
+      if (current.children.some((child) => initial.detachedIndices.has(child.index) && child.status === "detached"))
+        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);
+  } catch (error) {
+    return result(error instanceof Error ? error.message : String(error), true);
+  }
+}
 function asyncWaitUpdate(runs, providerCount, elapsedMs) {
   const activity = runs.flatMap((run) => {
     const activeSteps = run.steps.filter((step) => step.status === "pending" || step.status === "running");
@@ -357,7 +406,7 @@ function detachedForegroundWaitUpdate(run, pendingIndices, nowMs, elapsedMs) {
   return result(lines.join(`
 `));
 }
-async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs) {
+async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield) {
   const initialDetachedIndices = new Set(run.children.filter((child) => child.status === "detached").map((child) => child.index));
   while (true) {
     if (deps.state.currentSessionId !== run.sessionId) {
@@ -367,6 +416,8 @@ async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, p
     if (!current || current.sessionId !== run.sessionId) {
       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();
     const pending = current.children.filter((child) => initialDetachedIndices.has(child.index) && child.status === "detached");
     const attention = foregroundChildrenNeedingAttention(current, initialDetachedIndices);
     if (attention.length > 0)
@@ -386,6 +437,30 @@ async function waitForDetachedForegroundRun(run, signal, deps, startedAt, now, p
     await waitForWake(pollIntervalMs, signal, deps);
   }
 }
+async function waitForSessionDetachedForegroundRuns(runs, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield) {
+  const texts = [];
+  for (const run of runs) {
+    const one = await waitForDetachedForegroundRun(run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield);
+    if (one.isError)
+      return one;
+    if (one.details.wait?.reason === "supervisor_request")
+      return one;
+    if (one.details.wait?.reason === "window_elapsed") {
+      const activeRunIds = runs.filter((initial) => {
+        const current = deps.state.foregroundRuns?.get(initial.runId);
+        if (!current || current.sessionId !== initial.sessionId)
+          return false;
+        return initial.children.some((child) => child.status === "detached" && current.children.some((candidate) => candidate.index === child.index && candidate.status === "detached"));
+      }).map((activeRun) => activeRun.runId);
+      return windowElapsedResult(one.content.map((part) => part.type === "text" ? part.text : "").join(`
+`), activeRunIds);
+    }
+    texts.push(one.content.map((part) => part.type === "text" ? part.text : "").join(`
+`).trim());
+  }
+  return result(texts.filter(Boolean).join(`
+`) || `Waited ${formatDuration(now() - startedAt)} for remembered detached foreground run(s); done.`);
+}
 export async function waitForSubagents(params, signal, deps) {
   if (deps.enabled === false) {
     return result('bg_wait is disabled by config.waitTool or DM_SUBAGENT_WAIT_TOOL_ENABLED; returning immediately without blocking background work. Active work keeps going, and you can inspect subagents with subagent({ action: "status" }) or rely on completion notifications.');
@@ -397,6 +472,7 @@ export async function waitForSubagents(params, signal, deps) {
   const pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
   const timeoutMs = params.timeoutMs !== undefined && params.timeoutMs > 0 ? params.timeoutMs : deps.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
   const startedAt = now();
+  const sessionId = deps.state.currentSessionId;
   const waitForAll = params.id ? true : params.all === true;
   if (params.nonBlocking && !params.id) {
     return result("Non-blocking wait subscriptions require id so the registration can bind one exact run identity.", true);
@@ -408,12 +484,16 @@ export async function waitForSubagents(params, signal, deps) {
   let foreground;
   let providerSnapshot;
   try {
-    active = activeRunsForSession(params, deps);
-    foreground = activeDetachedForegroundRuns(params, deps);
+    active = runsForSession(params, deps, !params.id);
+    foreground = activeDetachedForegroundRuns(params, deps).map((run) => ({
+      ...run,
+      children: run.children.map((child) => ({ ...child }))
+    }));
     providerSnapshot = params.id ? { providers: [], items: [] } : backgroundWorkForSession(deps, startedAt);
   } catch (error) {
     return result(error instanceof Error ? error.message : String(error), true);
   }
+  let selectedForeground;
   if (params.id) {
     const candidates = [
       ...active.map((run) => ({ kind: "async", id: run.id, run })),
@@ -422,9 +502,20 @@ export async function waitForSubagents(params, signal, deps) {
     const exact = candidates.filter((candidate) => candidate.id === params.id);
     const matches = exact.length > 0 ? exact : candidates;
     if (matches.length > 1) {
-      return result(`Ambiguous subagent run id prefix "${params.id}" matched ${matches.length} active runs: ${matches.map((candidate) => candidate.id).join(", ")}. Pass a longer id.`, true);
+      return result(`Ambiguous subagent run id prefix "${params.id}" matched ${matches.length} runs: ${matches.map((candidate) => candidate.id).join(", ")}. Pass a longer id.`, true);
     }
     const selected = matches[0];
+    if (selected?.kind === "async" && !ACTIVE_STATES.includes(selected.run.state)) {
+      try {
+        const references = [];
+        const completions = collectScopedCompletions([selected.run], deps, references);
+        return result(`Run "${selected.id}" is terminal. Outcome: ${summarizeTerminalRuns([selected.run])}.${formatCompletionRecovery(completions)}${references.length ? `
+${references.join(`
+`)}` : ""}`, deps.failOnFailedRuns === true && (selected.run.state === "failed" || selected.run.state === "partial"), completions);
+      } catch (error) {
+        return result(error instanceof Error ? error.message : String(error), true);
+      }
+    }
     if (selected && params.nonBlocking) {
       if (!deps.subscribe) {
         return result("Non-blocking wait subscriptions require a long-lived interactive subagent runtime; this runtime can only use blocking bg_wait calls.", true);
@@ -436,23 +527,43 @@ export async function waitForSubagents(params, signal, deps) {
         return result(error instanceof Error ? error.message : String(error), true);
       }
     }
-    if (selected?.kind === "foreground") {
-      return waitForDetachedForegroundRun(selected.run, signal, deps, startedAt, now, pollIntervalMs, timeoutMs);
-    }
+    selectedForeground = selected?.kind === "foreground" ? selected.run : undefined;
     active = selected?.kind === "async" ? [selected.run] : [];
   }
   let providerActive = providerSnapshot.items;
+  const scopedForeground = selectedForeground ? [selectedForeground] : params.id ? [] : foreground;
+  const initialAsyncIds = new Set(active.map((run) => run.id));
+  const initialProviderIds = new Set(providerActive.map(backgroundWorkIdentity));
+  const initialScope = {
+    asyncRunIds: initialAsyncIds,
+    foregroundRuns: scopedForeground.map((run) => ({
+      runId: run.runId,
+      sessionId: run.sessionId,
+      detachedIndices: new Set(run.children.filter((child) => child.status === "detached").map((child) => child.index))
+    })),
+    providerIds: initialProviderIds
+  };
+  const supervisorYield = () => supervisorYieldForScope(initialScope, params, deps, now());
+  if (selectedForeground) {
+    return waitForDetachedForegroundRun(selectedForeground, signal, deps, startedAt, now, pollIntervalMs, timeoutMs, supervisorYield);
+  }
   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 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.");
   }
   const waitParams = params.id ? { ...params, id: active[0].id } : params;
-  const initialAsyncIds = new Set(active.map((run) => run.id));
-  const initialProviderIds = new Set(providerActive.map(backgroundWorkIdentity));
   const initialProviderNames = new Set(providerActive.map((item) => item.provider));
   const initialCount = initialAsyncIds.size + initialProviderIds.size;
   const stopOnAttention = params.stopOnAttention ?? deps.stopOnAttention !== false;
   let attention = active.filter((run) => needsAttention(run));
+  let supervisorBarrier = false;
   const isDone = () => {
+    if (deps.hasPendingSupervisorRequest?.()) {
+      supervisorBarrier = true;
+      return true;
+    }
     if (attention.some((run) => initialAsyncIds.has(run.id) && (stopOnAttention || hasSupervisorTool(run))))
       return true;
     const activeAsyncIds = new Set(active.map((run) => run.id));
@@ -478,6 +589,8 @@ export async function waitForSubagents(params, signal, deps) {
     }
     try {
       await waitForWake(pollIntervalMs, signal, deps);
+      if (deps.state.currentSessionId !== sessionId)
+        return result("Wait stopped because the active session changed.", true);
       active = activeRunsForSession(waitParams, deps);
       attention = attentionRunsForSession(waitParams, deps, initialAsyncIds);
       providerSnapshot = params.id ? providerSnapshot : backgroundWorkForSession(deps, now());
@@ -491,11 +604,15 @@ export async function waitForSubagents(params, signal, deps) {
       return result(error instanceof Error ? error.message : String(error), true);
     }
   }
+  if (supervisorBarrier) {
+    return supervisorYield();
+  }
   let terminalSummary;
   let finishedAsyncCount;
   let failedAsyncCount;
   let completions;
   let resumeGuidance = "";
+  const references = [];
   const activeProviderIds = new Set(providerActive.map(backgroundWorkIdentity));
   const providerFinishedCount = [...initialProviderIds].filter((id) => !activeProviderIds.has(id)).length;
   try {
@@ -505,7 +622,7 @@ export async function waitForSubagents(params, signal, deps) {
     failedAsyncCount = terminal.filter((run) => run.state === "failed" || run.state === "partial").length;
     terminalSummary = summarizeTerminalRuns(terminal, providerFinishedCount);
     resumeGuidance = formatResumeFirstFailedRunsNote(terminal);
-    completions = collectWaitCompletions(terminal, deps.state, deps.resultsDir ?? DIRS.results);
+    completions = collectScopedCompletions(terminal, deps, references);
   } catch (error) {
     return result(error instanceof Error ? error.message : String(error), true);
   }
@@ -515,11 +632,24 @@ export async function waitForSubagents(params, signal, deps) {
   const stillRunning = active.filter((run) => initialAsyncIds.has(run.id)).length + providerActive.filter((item) => initialProviderIds.has(backgroundWorkIdentity(item))).length;
   const elapsed = formatDuration(now() - startedAt);
   const outcome = terminalSummary ? ` Outcome: ${terminalSummary}.` : "";
-  const recoveryNote = formatCompletionRecovery(completions);
+  const recoveryNote = formatCompletionRecovery(completions) + (references.length ? `
+${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;
+    if (foregroundResult?.isError)
+      return foregroundResult;
+    if (foregroundResult?.details.wait?.reason === "supervisor_request")
+      return foregroundResult;
+    if (foregroundResult?.details.wait?.reason === "window_elapsed")
+      return foregroundResult;
+    const foregroundNote = foregroundResult ? `
+${foregroundResult.content.map((part) => part.type === "text" ? part.text : "").join(`
+`)}` : "";
     const scope = params.id ? `run "${params.id}"` : initialProviderIds.size === 0 ? `${initialAsyncIds.size} async run(s)` : `${initialAsyncIds.size} async run(s) and ${initialProviderIds.size} provider item(s)`;
     const status = relevantAttention.length > 0 ? "attention required" : "done";
-    return result(`Waited ${elapsed} for ${scope}; ${status}.${outcome}${recoveryNote}${resumeGuidance}${attentionNote} Completion/control events have been observed; inspect status if a notification is not visible yet.`, deps.failOnFailedRuns === true && failedAsyncCount > 0 || deps.failOnAttention === true && relevantAttention.length > 0, completions);
+    return result(`Waited ${elapsed} for ${scope}; ${status}.${outcome}${recoveryNote}${resumeGuidance}${attentionNote}${foregroundNote} Completion/control events have been observed; inspect status if a notification is not visible yet.`, deps.failOnFailedRuns === true && failedAsyncCount > 0 || deps.failOnAttention === true && relevantAttention.length > 0, completions);
   }
   const finishedCount = finishedAsyncCount + providerFinishedCount;
   const subject = initialProviderIds.size === 0 ? "run(s)" : "item(s)";

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

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import { readCompletionReplay, writeCompletionReplay } from "./completion-replay.js";
-import { fallbackResultPayloadPathForSessionRun, resultFilePath, resultPayloadPathForSessionRun } from "./result-files.js";
+import { fallbackResultPayloadPathForSessionRun, resultFilePath, resultPayloadMatchesSessionRun, resultPayloadPathForSessionRun } from "./result-files.js";
 import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.js";
 import { projectTimeoutRecovery } from "../shared/mutation-evidence.js";
 function asNonEmptyString(value) {
@@ -33,6 +33,37 @@ function isAccessDenied(error) {
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
+const STRUCTURED_OUTPUT_INLINE_LIMIT_BYTES = 4 * 1024;
+function waitResultPayloadCandidate(resultsDir, run) {
+  const publicPath = resultFilePath(resultsDir, run.id);
+  if (!run.sessionId)
+    return publicPath;
+  try {
+    const indexedPath = resultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id);
+    return indexedPath ?? publicPath;
+  } catch (error) {
+    if (!isAccessDenied(error))
+      throw error;
+    const pendingPath = fallbackResultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id);
+    return pendingPath ?? publicPath;
+  }
+}
+function readWaitResultPayload(candidatePath, run) {
+  if (!run.sessionId)
+    return;
+  const payload = JSON.parse(fs.readFileSync(candidatePath, "utf-8"));
+  if (!resultPayloadMatchesSessionRun(payload, run.sessionId, run.id))
+    return;
+  return payload;
+}
+export function projectStructuredOutput(value) {
+  if (value === undefined)
+    return;
+  const serialized = JSON.stringify(value);
+  if (typeof serialized !== "string")
+    throw new Error("Structured output must be JSON-serializable");
+  return Buffer.byteLength(serialized, "utf8") <= STRUCTURED_OUTPUT_INLINE_LIMIT_BYTES ? JSON.parse(serialized) : undefined;
+}
 export function toWaitCompletion(data, runId) {
   const results = Array.isArray(data.results) ? data.results.flatMap((entry) => {
     if (entry === null || typeof entry !== "object")
@@ -46,6 +77,8 @@ export function toWaitCompletion(data, runId) {
     const sessionFile = asNonEmptyString(child.sessionFile);
     const error = asNonEmptyString(child.error);
     const model = asNonEmptyString(child.model);
+    const structuredOutput = projectStructuredOutput(child.structuredOutput);
+    const structuredOutputPath = asNonEmptyString(child.structuredOutputPath);
     const contextOverflow = child.contextOverflow === true;
     const timeoutRecovery = projectTimeoutRecovery(child.timeoutRecovery);
     return [{
@@ -55,6 +88,8 @@ export function toWaitCompletion(data, runId) {
       ...sessionFile ? { sessionFile } : {},
       ...typeof child.success === "boolean" ? { success: child.success } : {},
       ...outputState ? { outputState } : {},
+      ...structuredOutput !== undefined ? { structuredOutput } : {},
+      ...structuredOutputPath ? { structuredOutputPath } : {},
       ...error ? { error } : {},
       ...model ? { model } : {},
       ...contextOverflow ? { contextOverflow: true } : {},
@@ -63,6 +98,8 @@ export function toWaitCompletion(data, runId) {
     }];
   }) : undefined;
   const agent = asNonEmptyString(data.agent);
+  const receipt = data.workflowReceipt;
+  const workflowReceiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt) ? asNonEmptyString(receipt.path) : undefined;
   const mode = asNonEmptyString(data.mode);
   const state = asNonEmptyString(data.state);
   const workflowChildren = parseWorkflowChildSummary(data.workflowChildren);
@@ -72,6 +109,7 @@ export function toWaitCompletion(data, runId) {
     runId,
     ...agent ? { agent } : {},
     ...mode ? { mode } : {},
+    ...workflowReceiptPath ? { workflowReceiptPath } : {},
     ...state ? { state } : {},
     ...typeof data.success === "boolean" ? { success: data.success } : {},
     ...results && results.length > 0 ? { results } : {},
@@ -79,6 +117,11 @@ export function toWaitCompletion(data, runId) {
   };
 }
 export function recordWaitCompletion(state, runId, data, now, ttlMs, persistence) {
+  const sessionId = asNonEmptyString(data.sessionId);
+  if (!sessionId || !resultPayloadMatchesSessionRun(data, sessionId, runId))
+    return false;
+  if (persistence && persistence.sessionId !== sessionId)
+    return false;
   const store = state.completedResults ??= new Map;
   for (const [key, entry] of store) {
     if (now - entry.seenAt > ttlMs)
@@ -99,51 +142,76 @@ export function recordWaitCompletion(state, runId, data, now, ttlMs, persistence
       console.error(`Failed to persist completion replay for '${runId}':`, error);
     }
   }
-  store.set(runId, { seenAt: now, completion });
+  store.set(runId, { sessionId, seenAt: now, completion });
+  return completion.archivePath !== undefined;
 }
-export function collectWaitCompletions(terminal, state, resultsDir) {
+export function collectWaitCompletions(terminal, state, resultsDir, onReference) {
   if (terminal.length === 0)
     return;
   const completions = [];
+  const add = (completion, resultPath) => {
+    completions.push(completion);
+    const reference = completion.archivePath ?? resultPath;
+    if (reference)
+      onReference?.(`Result [${completion.runId}]: ${reference}`);
+  };
   for (const run of terminal) {
     const recorded = state.completedResults?.get(run.id);
-    if (recorded) {
-      completions.push(recorded.completion);
+    if (recorded && recorded.sessionId === run.sessionId) {
+      if (recorded.completion.archivePath) {
+        add(recorded.completion);
+        continue;
+      }
+      try {
+        const candidatePath = waitResultPayloadCandidate(resultsDir, run);
+        if (!readWaitResultPayload(candidatePath, run)) {
+          const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+          add(replay?.completion ?? recorded.completion);
+          continue;
+        }
+        add(recorded.completion, candidatePath);
+        continue;
+      } catch (error) {
+        if (errorCode(error) !== "ENOENT")
+          throw error;
+      }
+      const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+      add(replay?.completion ?? recorded.completion);
       continue;
     }
-    const publicResultPath = resultFilePath(resultsDir, run.id);
-    let resultPath = publicResultPath;
+    let candidatePath;
     try {
-      resultPath = run.sessionId ? resultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath : publicResultPath;
+      candidatePath = waitResultPayloadCandidate(resultsDir, run);
     } catch (error) {
-      if (!isAccessDenied(error) || !run.sessionId)
-        throw error;
-      try {
-        resultPath = fallbackResultPayloadPathForSessionRun(resultsDir, run.sessionId, run.id) ?? publicResultPath;
-      } catch (fallbackError) {
-        throw new Error(`Failed to read subagent result '${publicResultPath}': ${errorMessage(fallbackError)}`, {
-          cause: fallbackError instanceof Error ? fallbackError : undefined
-        });
-      }
+      const publicResultPath = resultFilePath(resultsDir, run.id);
+      throw new Error(`Failed to read subagent result '${publicResultPath}': ${errorMessage(error)}`, {
+        cause: error instanceof Error ? error : undefined
+      });
     }
     try {
-      const raw = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
-      completions.push(toWaitCompletion(raw, run.id));
+      const payload = readWaitResultPayload(candidatePath, run);
+      if (!payload) {
+        const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
+        if (replay)
+          add(replay.completion);
+        continue;
+      }
+      add(toWaitCompletion(payload, run.id), candidatePath);
     } catch (error) {
       if (errorCode(error) !== "ENOENT") {
-        throw new Error(`Failed to read subagent result '${resultPath}': ${errorMessage(error)}`, {
+        throw new Error(`Failed to read subagent result '${candidatePath}': ${errorMessage(error)}`, {
           cause: error instanceof Error ? error : undefined
         });
       }
       const late = state.completedResults?.get(run.id);
-      if (late) {
-        completions.push(late.completion);
+      if (late && late.sessionId === run.sessionId) {
+        add(late.completion);
         continue;
       }
       try {
         const replay = readCompletionReplay(resultsDir, run.id, { sessionId: run.sessionId });
         if (replay)
-          completions.push(replay.completion);
+          add(replay.completion);
       } catch (replayError) {
         throw new Error(`Failed to read completion replay for '${run.id}': ${errorMessage(replayError)}`, {
           cause: replayError instanceof Error ? replayError : undefined

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

@@ -55,6 +55,7 @@ export function createWaitSubscriptionManager(dm, state, options = {}) {
   state.waitSubscriptions = subscriptions;
   const unresolvedRestoredForegroundTokens = new Set;
   let disposed = false;
+  let interval;
   let lastForeignSweepAt = 0;
   const sweepExpiredForeignSubscriptions = (force = false) => {
     const sweptAt = now();
@@ -208,9 +209,13 @@ export function createWaitSubscriptionManager(dm, state, options = {}) {
     SUBAGENT_RESULT_INTERCOM_EVENT
   ];
   const unsubscribes = wakeChannels.map((channel) => dm.events.on(channel, reconcile));
-  const interval = setInterval(reconcile, options.pollIntervalMs ?? RECONCILE_INTERVAL_MS);
-  interval.unref?.();
   return {
+    start() {
+      if (disposed || interval)
+        return;
+      interval = setInterval(reconcile, options.pollIntervalMs ?? RECONCILE_INTERVAL_MS);
+      interval.unref?.();
+    },
     arm(input) {
       const sessionId = state.currentSessionId;
       if (!sessionId)
@@ -266,7 +271,9 @@ export function createWaitSubscriptionManager(dm, state, options = {}) {
       if (disposed)
         return;
       disposed = true;
-      clearInterval(interval);
+      if (interval)
+        clearInterval(interval);
+      interval = undefined;
       for (const unsubscribe of unsubscribes) {
         try {
           unsubscribe();

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

@@ -1,25 +1,27 @@
 import { SubagentWaitParams } from "../../extension/schemas.js";
 import { resolveWaitToolConfig, waitForSubagents } from "./subagent-wait.js";
 import { finalizeToolResult } from "../../extension/tool-result.js";
-export function registerWaitTool(dm, state, enabled = resolveWaitToolConfig().enabled, subscriptions, defaultTimeoutMs) {
+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.
 
-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.
+${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 and provider item that was active when the call began.
-• { id: "..." } — wait for one async or remembered detached foreground subagent run (id or prefix).
+• { 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\` (or the deprecated \`subagent_wait\` compatibility alias) 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 ? "" : `
+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 and its subagent_wait compatibility alias are disabled by config.waitTool or DM_SUBAGENT_WAIT_TOOL_ENABLED and return immediately without blocking.`}`;
+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) } : {}
@@ -38,10 +40,4 @@ Configured behavior: bg_wait and its subagent_wait compatibility alias are disab
     label: "Wait",
     description: "Compatibility alias for `bg_wait`."
   });
-  dm.registerTool({
-    ...primaryTool,
-    name: "subagent_wait",
-    label: "Subagent Wait (deprecated)",
-    description: "Deprecated compatibility alias for `bg_wait`. Use `bg_wait` for background, provider, or detached work without a native completion notification. It has the same parameters and behavior."
-  });
 }