@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/background/notify.js

@@ -1,3 +1,5 @@
+import { statSync } from "node:fs";
+import { debuglog } from "node:util";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.js";
 import {
   createCompletionBatcher,
@@ -10,6 +12,8 @@ import { isUnexplainedProcessSignal } from "../shared/process-signal.js";
 const CHILD_OUTPUT_PREVIEW_MAX_BYTES = 4 * 1024;
 const CHILD_OUTPUT_PREVIEW_COUNT = 8;
 const PREVIEW_TRUNCATION_MARKER = "...[preview truncated]";
+const COMPLETION_SEND_TTL_MS = 10 * 60 * 1000;
+const COMPLETION_SEND_REGISTRY_CAP = 4096;
 function truncateUtf8Head(value, maxBytes) {
   const bytes = Buffer.from(value, "utf8");
   if (bytes.length <= maxBytes)
@@ -37,8 +41,29 @@ function outputPathFromReference(value) {
 function childSavedOutputPath(child) {
   return outputPathFromReference(child.outputReference);
 }
+function nonemptyPath(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function retainedChildPath(value, producerConfirmed = false) {
+  const path = nonemptyPath(value);
+  if (!path)
+    return { status: "unavailable" };
+  if (producerConfirmed)
+    return { status: "verified", path };
+  try {
+    return statSync(path).isFile() ? { status: "verified", path } : { status: "unavailable" };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : undefined;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return { status: "unavailable" };
+    return { status: "error", error: { path, ...code ? { code } : {}, message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function formatRetainedPathError(label, error) {
+  return `  ${label} verification failed: stat ${error.code ? boundedSafeText(error.code, 32) : "unknown"}; path=${boundedSafeText(error.path, 384)}; ${boundedSafeText(error.message, 512)}`;
+}
 function childStatus(child, workflowState) {
-  const knownStatus = child.status === "complete" ? "completed" : child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached" ? child.status : undefined;
+  const knownStatus = child.status === "complete" ? "completed" : child.status === "running" || child.status === "completed" || child.status === "failed" || child.status === "paused" || child.status === "stopped" || child.status === "detached" ? child.status : undefined;
   if (knownStatus)
     return knownStatus;
   return resolveSubagentResultStatus({
@@ -63,11 +88,14 @@ function structuredOutputText(value) {
     return;
   }
 }
+function isDegenerateOutput(text) {
+  return !text.trim() || text.trim() === "</think>";
+}
 function childInlinePreview(child) {
   const output = typeof child.output === "string" ? child.output : "";
   const outputReference = childSavedOutputPath(child);
   const referenceOnly = Boolean(outputReference && output.trim().startsWith("Output saved to:"));
-  const raw = child.outputState === "absent" || referenceOnly ? structuredOutputText(child.structuredOutput) : output || structuredOutputText(child.structuredOutput);
+  const raw = child.outputState === "absent" || referenceOnly ? structuredOutputText(child.structuredOutput) : isDegenerateOutput(output) ? structuredOutputText(child.structuredOutput) ?? output : output;
   if (!raw?.trim()) {
     return { unavailableReason: referenceOnly ? "saved output is file-only" : "no safe inline output" };
   }
@@ -88,6 +116,16 @@ function formatChildOutputBlock(children) {
     const status = boundedSafeText(child.status) || "unavailable";
     lines.push(`- key=${key} run=${runId} status=${status}`);
     lines.push(`  Saved output: ${child.savedOutputPath ? boundedSafeText(child.savedOutputPath) : "unavailable"}`);
+    if (child.outputArtifactPath)
+      lines.push(`  Output artifact (retention-managed): ${boundedSafeText(child.outputArtifactPath)}`);
+    if (child.structuredOutputPath)
+      lines.push(`  Structured output (retention-managed): ${boundedSafeText(child.structuredOutputPath)}`);
+    if (child.outputArtifactError)
+      lines.push(formatRetainedPathError("Output artifact", child.outputArtifactError));
+    if (child.structuredOutputError)
+      lines.push(formatRetainedPathError("Structured output", child.structuredOutputError));
+    if (child.previewTruncated && !child.savedOutputPath && !child.outputArtifactPath)
+      lines.push("  Full output unavailable");
     if (index >= CHILD_OUTPUT_PREVIEW_COUNT) {
       lines.push("  Preview: unavailable (notice preview budget exceeded)");
       continue;
@@ -126,22 +164,42 @@ function formatChildRun(child) {
 }
 function formatCorrelationLines(details) {
   return [
+    details.asyncDir ? `Retention-managed async directory: ${boundedSafeText(details.asyncDir)}` : undefined,
     details.workflowRunId ? `Workflow run: ${details.workflowRunId}` : undefined,
     details.childRuns?.length ? `Child runs: ${details.childRuns.map(formatChildRun).join(", ")}` : undefined,
     details.reconciledFromDetachedChild ? `Reconciled detached child: ${details.reconciledFromDetachedChild}` : undefined
   ].filter((line) => line !== undefined);
 }
+const WATCHDOG_BLOCKERS_HEADING = "Watchdog blockers:";
+function formatWatchdogBlockerLines(details) {
+  if (!details.watchdogBlockers?.length)
+    return [];
+  return [WATCHDOG_BLOCKERS_HEADING, ...details.watchdogBlockers.map((blocker) => `- ${blocker.agent}: ${blocker.summary} (${blocker.stalemate ? "stalemate" : blocker.addressed ? "addressed" : "unaddressed"})`)];
+}
+function parseWatchdogBlockerLines(lines) {
+  const blockers = [];
+  for (const line of lines) {
+    const match = line.match(/^- (.+?): (.+) \((addressed|unaddressed|stalemate)\)$/);
+    if (!match)
+      break;
+    blockers.push({ agent: match[1], summary: match[2], addressed: match[3] === "addressed", stalemate: match[3] === "stalemate" });
+  }
+  return blockers;
+}
 export function formatSingleCompletion(details) {
   const sessionLine = formatSessionLine(details);
   const correlationLines = formatCorrelationLines(details);
+  const watchdogLines = formatWatchdogBlockerLines(details);
   const taskKind = details.source === "foreground" ? "Detached foreground task" : "Background task";
   const scheduleLine = details.scheduleOrigin ? `Scheduled run from **${details.scheduleOrigin.name ?? details.scheduleOrigin.id}** (schedule ${details.scheduleOrigin.id}).` : undefined;
   return [
     `${taskKind} ${details.status}: **${details.agent}**${details.taskInfo ?? ""}`,
+    details.workflowReceiptPath ? `Workflow receipt: ${details.workflowReceiptPath}` : undefined,
     "",
     scheduleLine,
     scheduleLine ? "" : undefined,
     formatResultPreview(details),
+    ...watchdogLines.length ? ["", ...watchdogLines] : [],
     details.handoffPath ? "" : undefined,
     details.handoffPath ? `Parallel handoff: ${details.handoffPath}` : undefined,
     correlationLines.length && !details.handoffPath ? "" : undefined,
@@ -151,13 +209,36 @@ export function formatSingleCompletion(details) {
   ].filter((line) => line !== undefined).join(`
 `);
 }
+export function scheduledCompletionTriggersTurn(origin, outcome) {
+  return !(origin?.quiet === true && outcome === "completed");
+}
+export function incrementalChildCompletionTriggersTurn(child, origin) {
+  if (child.workflowRunning && child.outcome === "completed")
+    return false;
+  return scheduledCompletionTriggersTurn(origin, child.outcome);
+}
+export function formatIncrementalChildCompletion(child) {
+  const statusText = child.outcome === "completed" ? "completed" : child.outcome === "failed" ? "failed" : child.outcome === "paused" ? "paused (needs attention)" : "stopped";
+  const workflowStatus = child.workflowRunning ? "workflow still running" : "workflow finished";
+  return [
+    `Workflow child ${statusText}: **${child.childKey}**`,
+    `Workflow run: ${child.workflowRunId}`,
+    ...child.childRunId ? [`Child run: ${child.childRunId}`] : [],
+    ...child.outputReference ? [`Output: ${child.outputReference}`] : [],
+    ...child.error ? [`Error: ${child.error}`] : [],
+    `Status: ${workflowStatus}`
+  ].join(`
+`);
+}
 export function parseSubagentNotifyContent(content) {
   const lines = content.split(`
 `);
   const match = (lines[0] ?? "").match(/^(Background task|Detached foreground task) (completed|failed|paused|stopped): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
   if (!match)
     return;
-  let body = lines.slice(2);
+  const receiptHeader = lines[1]?.startsWith("Workflow receipt: ") && lines[2] === "";
+  const workflowReceiptPath = receiptHeader ? lines[1].slice("Workflow receipt: ".length) : undefined;
+  let body = lines.slice(receiptHeader ? 3 : 2);
   const scheduleMatch = (body[0] ?? "").match(/^Scheduled run from \*\*(.+?)\*\* \(schedule (.+?)\)\.$/);
   let parsedScheduleOrigin;
   if (scheduleMatch) {
@@ -178,7 +259,9 @@ export function parseSubagentNotifyContent(content) {
   const workflowRunIndex = body.findIndex((line) => line.startsWith("Workflow run: "));
   const childRunsIndex = body.findIndex((line) => line.startsWith("Child runs: "));
   const reconciledIndex = body.findIndex((line) => line.startsWith("Reconciled detached child: "));
-  const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex].filter((index) => index >= 0);
+  const watchdogIndex = body.findIndex((line) => line === WATCHDOG_BLOCKERS_HEADING);
+  const watchdogBlockers = watchdogIndex >= 0 ? parseWatchdogBlockerLines(body.slice(watchdogIndex + 1)) : [];
+  const metadataIndexes = [sessionIndex, handoffIndex, workflowRunIndex, childRunsIndex, reconciledIndex, watchdogIndex].filter((index) => index >= 0);
   const firstMetadataIndex = metadataIndexes.length ? Math.min(...metadataIndexes) : body.length;
   const resultEnd = firstMetadataIndex > 0 && body[firstMetadataIndex - 1]?.trim() === "" ? firstMetadataIndex - 1 : firstMetadataIndex;
   const resultPreview = body.slice(0, resultEnd).join(`
@@ -206,11 +289,13 @@ export function parseSubagentNotifyContent(content) {
     ...match[1] === "Detached foreground task" ? { source: "foreground" } : {},
     ...match[4] ? { taskInfo: match[4] } : {},
     ...parsedScheduleOrigin ? { scheduleOrigin: parsedScheduleOrigin } : {},
+    ...workflowReceiptPath ? { workflowReceiptPath } : {},
     resultPreview,
     ...handoffPath ? { handoffPath } : {},
     ...workflowRunId ? { workflowRunId } : {},
     ...childRuns?.length ? { childRuns } : {},
     ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
+    ...watchdogBlockers.length ? { watchdogBlockers } : {},
     ...sessionLabel && sessionValue ? { sessionLabel, sessionValue } : {}
   };
 }
@@ -223,7 +308,10 @@ export function formatGroupedCompletion(details) {
       continue;
     const sessionLine = formatSessionLine(detail);
     blocks.push(`${index + 1}. ${detail.agent}${detail.taskInfo ?? ""}${detail.scheduleOrigin ? ` — scheduled run from ${detail.scheduleOrigin.name ?? detail.scheduleOrigin.id} (schedule ${detail.scheduleOrigin.id})` : ""}`);
+    if (detail.workflowReceiptPath)
+      blocks.push(`Workflow receipt: ${detail.workflowReceiptPath}`);
     blocks.push(formatResultPreview(detail));
+    blocks.push(...formatWatchdogBlockerLines(detail));
     if (detail.handoffPath)
       blocks.push(`Parallel handoff: ${detail.handoffPath}`);
     blocks.push(...formatCorrelationLines(detail));
@@ -234,6 +322,69 @@ export function formatGroupedCompletion(details) {
   return blocks.join(`
 `).trimEnd();
 }
+const notificationDebug = debuglog("dm-subagents-notify");
+function traceIdentity(result) {
+  const identity = (value) => typeof value === "string" ? value.slice(0, 128).replace(/[^a-zA-Z0-9_.:-]/g, "_") : undefined;
+  return { id: identity(result.id), runId: identity(result.runId), source: result.source === "foreground" ? "foreground" : "async" };
+}
+function traceNotification(reason, result) {
+  if (!notificationDebug.enabled)
+    return;
+  try {
+    notificationDebug("%s", JSON.stringify({ reason, ...result ? traceIdentity(result) : {} }));
+  } catch {}
+}
+export function createCompletionSendRegistry(ttlMs = COMPLETION_SEND_TTL_MS, cap = COMPLETION_SEND_REGISTRY_CAP) {
+  const entries = new Map;
+  const prune = (now) => {
+    for (const [key, entry] of entries) {
+      if (entry.deliveredAt !== undefined && now - entry.deliveredAt > ttlMs)
+        entries.delete(key);
+    }
+    if (entries.size <= cap)
+      return;
+    for (const [key, entry] of entries) {
+      if (entries.size <= cap)
+        break;
+      if (entry.deliveredAt !== undefined)
+        entries.delete(key);
+    }
+  };
+  return {
+    claim(key, now) {
+      prune(now);
+      const existing = entries.get(key);
+      if (existing)
+        return { owned: false, outcome: existing.outcome };
+      let resolve;
+      const entry = {
+        outcome: new Promise((settle) => {
+          resolve = settle;
+        }),
+        resolve: (accepted) => resolve(accepted)
+      };
+      entries.set(key, entry);
+      return {
+        owned: true,
+        outcome: entry.outcome,
+        settle(accepted) {
+          if (entries.get(key) !== entry)
+            return;
+          if (accepted) {
+            entry.deliveredAt = now;
+            prune(now);
+          } else {
+            entries.delete(key);
+          }
+          entry.resolve(accepted);
+        }
+      };
+    }
+  };
+}
+const completionSendRegistrySymbol = Symbol.for("dm-subagents.completion-send-registry.v1");
+const processGlobal = globalThis;
+const processCompletionSendRegistry = processGlobal[completionSendRegistrySymbol] ?? (processGlobal[completionSendRegistrySymbol] = createCompletionSendRegistry());
 function sendCompletion(dm, items) {
   if (items.length === 0)
     return true;
@@ -264,11 +415,26 @@ export function buildCompletionDetails(result) {
   const stopped = result.stopped === true || result.state === "stopped" || result.success !== true && result.exitCode !== 0 && isUnexplainedProcessSignal(result) || result.results?.some((child) => child.stopped === true || child.status === "stopped" || child.success !== true && child.exitCode !== 0 && isUnexplainedProcessSignal(child)) === true;
   const paused = !stopped && !result.success && (result.exitCode === 0 || result.state === "paused" || result.interrupted === true || summary.startsWith("Paused after interrupt."));
   const status = stopped ? "stopped" : paused ? "paused" : result.success ? "completed" : "failed";
-  const taskInfo = result.taskIndex !== undefined && result.totalTasks !== undefined ? ` (${result.taskIndex + 1}/${result.totalTasks})` : undefined;
+  const runningChildren = result.mode === "workflow" || agent === "workflow" ? result.results?.filter((child) => childStatus(child) === "running").length ?? 0 : 0;
+  const taskInfo = runningChildren > 0 ? ` (${status === "completed" ? "dispatch complete; " : ""}${runningChildren} ${runningChildren === 1 ? "child" : "children"} running or uncollected)` : result.taskIndex !== undefined && result.totalTasks !== undefined ? ` (${result.taskIndex + 1}/${result.totalTasks})` : undefined;
   const parallelHandoff = result.parallelHandoff && typeof result.parallelHandoff === "object" ? result.parallelHandoff : undefined;
   const handoffPath = typeof parallelHandoff?.path === "string" ? parallelHandoff.path : undefined;
+  const receipt = result.workflowReceipt;
+  const receiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt) ? receipt.path : undefined;
+  const workflowReceiptPath = typeof receiptPath === "string" && receiptPath ? receiptPath : undefined;
   const rawRunId = typeof result.runId === "string" ? result.runId : typeof result.id === "string" ? result.id : undefined;
   const workflowRunId = (result.mode === "workflow" || agent === "workflow") && rawRunId ? rawRunId : undefined;
+  const directChild = !workflowRunId && result.results?.length === 1 ? result.results[0] : undefined;
+  const directStructuredPreview = directChild ? childInlinePreview(directChild).preview : undefined;
+  const directSummary = summary.trim();
+  const directAgent = typeof directChild?.agent === "string" ? directChild.agent : agent;
+  const directSummaryBody = directAgent && summary.trimStart().startsWith(`${directAgent}:
+`) ? summary.trimStart().slice(directAgent.length + 2) : directSummary;
+  const directDegenerateSummary = directChild && isDegenerateOutput(typeof directChild.output === "string" ? directChild.output : "") && isDegenerateOutput(directSummaryBody) && structuredOutputText(directChild.structuredOutput) !== undefined;
+  const directNoOutputSummary = directChild && (!directSummary || directSummary === "(no output)" || directAgent && directSummary === `${directAgent}:
+(no output)`);
+  const resultPreview = directStructuredPreview && (directNoOutputSummary || directDegenerateSummary) ? `Structured output:
+${directStructuredPreview}` : summary;
   const childRuns = result.results?.flatMap((child) => {
     const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
     const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
@@ -286,18 +452,42 @@ export function buildCompletionDetails(result) {
     const workflowKey = typeof child.workflowKey === "string" && child.workflowKey.trim() ? child.workflowKey.trim() : undefined;
     const runId = typeof child.runId === "string" && child.runId.trim() ? child.runId.trim() : undefined;
     const savedOutputPath = childSavedOutputPath(child);
+    const outputArtifact = child.artifactOutputSaveFailed === true ? { status: "unavailable" } : retainedChildPath(child.artifactPaths?.outputPath);
+    const structuredOutput = child.stopped === true || child.timedOut === true ? { status: "unavailable" } : retainedChildPath(child.structuredOutputPath, child.structuredOutput !== undefined);
     return {
       ...workflowKey ? { workflowKey } : {},
       ...runId ? { runId } : {},
       ...typeof child.agent === "string" ? { agent: child.agent } : {},
       status: childStatus(child, result.state),
       ...savedOutputPath ? { savedOutputPath } : {},
+      ...outputArtifact.status === "verified" ? { outputArtifactPath: outputArtifact.path } : {},
+      ...structuredOutput.status === "verified" ? { structuredOutputPath: structuredOutput.path } : {},
+      ...outputArtifact.status === "error" ? { outputArtifactError: outputArtifact.error } : {},
+      ...structuredOutput.status === "error" ? { structuredOutputError: structuredOutput.error } : {},
       ...inline.preview ? { preview: inline.preview } : { preview: "" },
       ...inline.truncated ? { previewTruncated: true } : {},
       ...inline.unavailableReason ? { previewUnavailableReason: inline.unavailableReason } : {}
     };
   }) : undefined;
   const reconciledFromDetachedChild = typeof result.reconciledFromDetachedChild === "string" ? result.reconciledFromDetachedChild : undefined;
+  const asyncDir = nonemptyPath(result.asyncDir);
+  const watchdogBlockers = [];
+  const watchdogConcerns = [];
+  const collectWatchdogFindings = (owner, progress) => {
+    for (const warning of progress?.warnings ?? []) {
+      if (warning.importance !== "high")
+        continue;
+      if (warning.severity === "blocker")
+        watchdogBlockers.push({ agent: owner, summary: warning.summary, addressed: warning.addressed, stalemate: warning.stalemate });
+      else
+        watchdogConcerns.push(`${owner}: ${warning.summary}
+Evidence: ${warning.evidence}
+Recommended action: ${warning.recommendedAction}`);
+    }
+  };
+  collectWatchdogFindings(agent, result.watchdog);
+  for (const child of result.results ?? [])
+    collectWatchdogFindings(typeof child.agent === "string" ? child.agent : agent, child.watchdog);
   const session = result.shareUrl ? { label: "Session", value: result.shareUrl } : result.shareError ? { label: "Session share error", value: result.shareError } : result.sessionFile ? { label: "Session file", value: result.sessionFile } : undefined;
   const rawOrigin = result.scheduleOrigin;
   const scheduleOrigin = rawOrigin && typeof rawOrigin.id === "string" ? { id: rawOrigin.id, ...typeof rawOrigin.name === "string" ? { name: rawOrigin.name } : {} } : undefined;
@@ -305,29 +495,39 @@ export function buildCompletionDetails(result) {
     agent,
     status,
     ...scheduleOrigin ? { scheduleOrigin } : {},
+    ...workflowReceiptPath ? { workflowReceiptPath } : {},
+    ...asyncDir ? { asyncDir } : {},
     ...result.source ? { source: result.source } : {},
     ...taskInfo ? { taskInfo } : {},
-    resultPreview: summary,
+    resultPreview: watchdogConcerns.length ? `${resultPreview}
+
+High-importance watchdog concerns:
+${watchdogConcerns.map((warning) => `- ${warning}`).join(`
+`)}` : resultPreview,
     ...typeof result.durationMs === "number" ? { durationMs: result.durationMs } : {},
     ...handoffPath ? { handoffPath } : {},
     ...workflowRunId ? { workflowRunId } : {},
     ...childRuns.length ? { childRuns } : {},
     ...childOutputs?.length ? { childOutputs } : {},
     ...reconciledFromDetachedChild ? { reconciledFromDetachedChild } : {},
+    ...watchdogBlockers.length ? { watchdogBlockers } : {},
     ...session ? { sessionLabel: session.label, sessionValue: session.value } : {}
   };
 }
 export default function registerSubagentNotify(dm, state, options = {}) {
   const seen = new Map;
   const pending = new Map;
-  const ttlMs = 10 * 60 * 1000;
+  const ttlMs = COMPLETION_SEND_TTL_MS;
   const now = options.now ?? Date.now;
+  const sendRegistry = options.sendRegistry ?? processCompletionSendRegistry;
   const batchConfig = resolveCompletionBatchConfig(options.batchConfig);
   const batchers = new Map;
   let disposed = false;
   const ownsResult = options.ownership?.owns ?? ((sessionId, completionOwnerId) => sessionId === state.currentSessionId && typeof completionOwnerId === "string" && completionOwnerId === state.completionOwnerId);
-  const settle = (items, accepted) => {
+  const settle = (items, accepted, reason) => {
     for (const item of items) {
+      if (reason)
+        traceNotification(reason, item.trace);
       pending.delete(item.key);
       if (accepted)
         markSeenWithTtl(seen, item.key, now(), ttlMs);
@@ -339,10 +539,26 @@ export default function registerSubagentNotify(dm, state, options = {}) {
     const rejected = [];
     for (const item of items) {
       const owned = item.details.source === "foreground" ? item.sessionId === state.currentSessionId : ownsResult(item.sessionId, item.completionOwnerId);
+      if (!owned)
+        traceNotification(item.details.source === "foreground" ? "emit_foreground_session_mismatch" : "emit_not_owned", item.trace);
       (owned ? accepted : rejected).push(item);
     }
     settle(rejected, false);
-    settle(accepted, sendCompletion(dm, accepted));
+    const claimed = [];
+    for (const item of accepted) {
+      const claim = sendRegistry.claim(item.key, now());
+      if (claim.owned) {
+        claimed.push({ item, claim });
+        continue;
+      }
+      traceNotification("send_joined", item.trace);
+      claim.outcome.then((outcome) => settle([item], outcome, outcome ? undefined : "send_failed"));
+    }
+    const claimedItems = claimed.map(({ item }) => item);
+    const sent = sendCompletion(dm, claimedItems);
+    for (const { claim } of claimed)
+      claim.settle?.(sent);
+    settle(claimedItems, sent, sent ? "send_accepted" : "send_failed");
   };
   const getBatcher = (result) => {
     const key = completionBatchKey(result);
@@ -359,24 +575,36 @@ export default function registerSubagentNotify(dm, state, options = {}) {
     return batcher;
   };
   const deliver = (result) => {
-    if (disposed || typeof result.sessionId !== "string")
+    if (disposed || typeof result.sessionId !== "string") {
+      traceNotification(disposed ? "disposed" : "missing_session", result);
       return Promise.resolve(false);
+    }
     if (result.source === "foreground") {
-      if (result.sessionId !== state.currentSessionId)
+      if (result.sessionId !== state.currentSessionId) {
+        traceNotification("foreground_session_mismatch", result);
         return Promise.resolve(false);
-    } else if (!ownsResult(result.sessionId, result.completionOwnerId))
+      }
+    } else if (!ownsResult(result.sessionId, result.completionOwnerId)) {
+      traceNotification("not_owned", result);
       return Promise.resolve(false);
-    if (result.intercomDelivered === true)
+    }
+    if (result.intercomDelivered === true) {
+      traceNotification("intercom_delivered", result);
       return Promise.resolve(true);
+    }
     const key = buildCompletionKey(result, "notify");
     const seenAt = seen.get(key);
-    if (seenAt !== undefined && now() - seenAt <= ttlMs)
+    if (seenAt !== undefined && now() - seenAt <= ttlMs) {
+      traceNotification("deduped_ttl", result);
       return Promise.resolve(true);
+    }
     if (seenAt !== undefined)
       seen.delete(key);
     const inFlight = pending.get(key);
-    if (inFlight)
+    if (inFlight) {
+      traceNotification("deduped_pending", result);
       return inFlight;
+    }
     const details = buildCompletionDetails(result);
     let resolve;
     const completion = new Promise((settleCompletion) => {
@@ -388,9 +616,11 @@ export default function registerSubagentNotify(dm, state, options = {}) {
       details,
       sessionId: result.sessionId,
       completionOwnerId: result.completionOwnerId,
-      triggerTurn: result.triggerTurn !== false,
+      triggerTurn: result.triggerTurn !== false && scheduledCompletionTriggersTurn(result.scheduleOrigin, details.status),
       resolve
     };
+    if (notificationDebug.enabled)
+      item.trace = traceIdentity(result);
     if (details.source === "foreground") {
       emit([item]);
       return completion;
@@ -401,10 +631,14 @@ export default function registerSubagentNotify(dm, state, options = {}) {
       emit([item]);
       return completion;
     }
+    if (batchConfig.enabled)
+      traceNotification("batch_deferred", item.trace);
     batcher.push(item);
     return completion;
   };
   const unsubscribeAsync = dm.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, (data) => {
+    if (data.awaitedByWorkflow === true)
+      return;
     deliver(data);
   });
   const unsubscribeForeground = dm.events.on(SUBAGENT_FOREGROUND_COMPLETE_EVENT, (data) => {
@@ -412,12 +646,13 @@ export default function registerSubagentNotify(dm, state, options = {}) {
   });
   return {
     deliver,
+    hasPendingDelivery: () => pending.size > 0,
     dispose() {
       if (disposed)
         return;
       disposed = true;
       for (const batcher of batchers.values())
-        settle(batcher.dispose(), false);
+        settle(batcher.dispose(), false, "dispose_pending");
       batchers.clear();
       for (const unsubscribe of [unsubscribeAsync, unsubscribeForeground]) {
         try {

package/extensions/dm-subagents/src/runs/background/owned-process-tree.js

@@ -30,6 +30,27 @@ function activeProcessGroupMembers(processGroupId) {
   }
   return members;
 }
+function knownDetachedDescendants(processGroupId) {
+  const result = spawnSync("ps", ["-axo", "pid=,ppid=,pgid=,stat="], { encoding: "utf-8" });
+  if (result.error || result.status !== 0)
+    return [];
+  const owned = new Set;
+  const outside = [];
+  for (const line of result.stdout.split(`
+`)) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/.exec(line);
+    if (!match || match[4].startsWith("Z"))
+      continue;
+    const pid = Number(match[1]);
+    const ppid = Number(match[2]);
+    const pgid = Number(match[3]);
+    if (pgid === processGroupId)
+      owned.add(pid);
+    else
+      outside.push({ pid, ppid });
+  }
+  return outside.filter((row) => owned.has(row.ppid)).map((row) => row.pid);
+}
 async function waitUntilGroupTerminal(processGroupId, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (true) {
@@ -48,6 +69,15 @@ async function waitUntilGroupTerminal(processGroupId, timeoutMs) {
 function observed(processGroupId) {
   return { state: "observed", mechanism: "posix-process-group", processGroupId, verifiedAt: Date.now() };
 }
+function observedUnlessLiveDetached(processGroupId, detached) {
+  const live = detached.filter((pid) => {
+    const result = spawnSync("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf-8" });
+    return result.status === 0 && Boolean(result.stdout.trim()) && !result.stdout.trim().startsWith("Z");
+  });
+  if (live.length === 0)
+    return observed(processGroupId);
+  return { state: "unknown", reason: "verification-failed", diagnostic: `Owned detached descendant(s) still active: ${live.join(", ")}.` };
+}
 export function createOwnedProcessTreeController(pid, options = {}) {
   let termination;
   const posixGroupOwned = process.platform !== "win32";
@@ -60,13 +90,14 @@ export function createOwnedProcessTreeController(pid, options = {}) {
         signalProcess(target, "SIGTERM");
         return { state: "unknown", reason: "unsupported-platform" };
       }
+      const detached = knownDetachedDescendants(pid);
       const term = signalProcess(target, "SIGTERM");
       if (term !== "sent" && term !== "absent") {
         return { state: "unknown", reason: "signal-failed", diagnostic: term.diagnostic };
       }
       const termExit = await waitUntilGroupTerminal(pid, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS);
       if (termExit === false)
-        return observed(pid);
+        return observedUnlessLiveDetached(pid, detached);
       const kill = signalProcess(target, "SIGKILL");
       if (kill !== "sent" && kill !== "absent") {
         const members = activeProcessGroupMembers(pid);
@@ -78,7 +109,7 @@ export function createOwnedProcessTreeController(pid, options = {}) {
       if (killExit !== false) {
         return { state: "unknown", reason: "verification-failed", diagnostic: killExit.diagnostic };
       }
-      return observed(pid);
+      return observedUnlessLiveDetached(pid, detached);
     })();
     return termination;
   };

package/extensions/dm-subagents/src/runs/background/process-terminal-candidate.js

@@ -0,0 +1,88 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+export function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function validProcessInstance(value, kind) {
+  if (!isRecord(value))
+    return false;
+  if (typeof value.processInstanceId !== "string" || value.processInstanceId.length === 0)
+    return false;
+  if (kind ? value.kind !== kind : value.kind !== "runner" && value.kind !== "dm-writer")
+    return false;
+  if (typeof value.closeObservedAt !== "number" || !Number.isFinite(value.closeObservedAt))
+    return false;
+  if (typeof value.exitCode !== "number" && value.exitCode !== null)
+    return false;
+  if (typeof value.signal !== "string" && value.signal !== null)
+    return false;
+  if (value.kind === "runner")
+    return value.attempt === undefined;
+  if (typeof value.attempt !== "number" || !Number.isInteger(value.attempt) || value.attempt < 0 || !isRecord(value.processTree))
+    return false;
+  if (value.processTree.state === "observed") {
+    return value.processTree.mechanism === "posix-process-group" && typeof value.processTree.processGroupId === "number" && Number.isInteger(value.processTree.processGroupId) && value.processTree.processGroupId > 0 && typeof value.processTree.verifiedAt === "number" && Number.isFinite(value.processTree.verifiedAt);
+  }
+  return value.processTree.state === "unknown" && ["unsupported-platform", "signal-failed", "verification-failed"].includes(String(value.processTree.reason)) && (value.processTree.diagnostic === undefined || typeof value.processTree.diagnostic === "string");
+}
+function validInstance(value) {
+  return validProcessInstance(value, "dm-writer");
+}
+export function processTerminalCandidatePath(asyncDir) {
+  return path.join(asyncDir, "process-terminal-candidate.json");
+}
+export function readProcessTerminalCandidate(asyncDir) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(processTerminalCandidatePath(asyncDir), "utf-8"));
+    if (!isRecord(raw) || raw.version !== 1 || typeof raw.runId !== "string" || typeof raw.runnerProcessInstanceId !== "string" || !isRecord(raw.writers)) {
+      throw new Error(`Invalid process-terminal candidate in '${asyncDir}'.`);
+    }
+    const writers = {};
+    for (const [index, entries] of Object.entries(raw.writers)) {
+      if (!Array.isArray(entries) || !entries.every(validInstance))
+        throw new Error(`Invalid writer process records for child '${index}'.`);
+      writers[index] = entries;
+    }
+    let expectedWriters;
+    if (raw.expectedWriters !== undefined) {
+      if (!isRecord(raw.expectedWriters))
+        throw new Error("Invalid expected writer process records.");
+      expectedWriters = {};
+      for (const [index, count] of Object.entries(raw.expectedWriters)) {
+        if (typeof count !== "number" || !Number.isInteger(count) || count < 0)
+          throw new Error(`Invalid expected writer count for child '${index}'.`);
+        expectedWriters[index] = count;
+      }
+    }
+    if (raw.sessionFile !== undefined && typeof raw.sessionFile !== "string")
+      throw new Error("Invalid process-terminal candidate sessionFile.");
+    if (raw.revivalLeaseToken !== undefined && typeof raw.revivalLeaseToken !== "string")
+      throw new Error("Invalid process-terminal candidate lease token.");
+    if (raw.revivalLeaseReleaseAcknowledged !== undefined && typeof raw.revivalLeaseReleaseAcknowledged !== "boolean")
+      throw new Error("Invalid process-terminal lease release acknowledgement.");
+    return {
+      version: 1,
+      runId: raw.runId,
+      runnerProcessInstanceId: raw.runnerProcessInstanceId,
+      writers,
+      ...expectedWriters ? { expectedWriters } : {},
+      ...typeof raw.sessionFile === "string" && raw.sessionFile ? { sessionFile: raw.sessionFile } : {},
+      ...typeof raw.revivalLeaseToken === "string" && raw.revivalLeaseToken ? { revivalLeaseToken: raw.revivalLeaseToken } : {},
+      ...typeof raw.revivalLeaseReleaseAcknowledged === "boolean" ? { revivalLeaseReleaseAcknowledged: raw.revivalLeaseReleaseAcknowledged } : {}
+    };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+export function writeProcessTerminalCandidate(asyncDir, candidate) {
+  writePrivateAtomicJson(processTerminalCandidatePath(asyncDir), candidate);
+}
+export function markProcessTerminalCandidateLeaseRelease(asyncDir, token, acknowledged) {
+  const candidate = readProcessTerminalCandidate(asyncDir);
+  if (!candidate || candidate.revivalLeaseToken !== token)
+    return;
+  writeProcessTerminalCandidate(asyncDir, { ...candidate, revivalLeaseReleaseAcknowledged: acknowledged });
+}