@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-subagents/src/runs/background/async-job-tracker.js

@@ -13,12 +13,13 @@ import {
 import { readStatus, resolveWatchPath } from "../../shared/utils.js";
 import { normalizeParallelGroups } from "./parallel-groups.js";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
-import { findNestedRouteForRootId, hasLiveNestedDescendants, updateAsyncJobNestedProjection } from "../shared/nested-events.js";
+import { findNestedRouteForRootId, hasLiveNestedDescendants, retainNestedLookupRoute, updateAsyncJobNestedProjection } from "../shared/nested-events.js";
 import { listAsyncRuns } from "./async-status.js";
-import { EXTERNAL_JOB_BRIDGE_REQUEST_DIR, serviceExternalJobBridgeRequests } from "../shared/external-job-bridge.js";
+import { EXTERNAL_JOB_BRIDGE_REQUEST_DIR, externalJobBridgeEligibility, serviceExternalJobBridgeRequests } from "../shared/external-job-bridge.js";
 import { shouldUseNativeFsWatch } from "../../shared/watch-strategy.js";
 import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.js";
 import { validHostStepNodes } from "../shared/host-step-status.js";
+import { readProcessTerminal } from "./process-terminal.js";
 import { withCachedUiContext } from "../../shared/extension-context.js";
 const CONTROL_EVENT_READ_CHUNK_BYTES = 64 * 1024;
 const MAX_CONTROL_EVENT_LINE_BYTES = 1024 * 1024;
@@ -27,10 +28,11 @@ const MAX_RECENT_FLEET_JOBS = 20;
 const DEFAULT_LIVENESS_INTERVAL_MS = 5000;
 const EVENT_REFRESH_DEBOUNCE_MS = 25;
 const WATCH_ATTACHMENT_RETRY_MS = 100;
+const isTerminalJobStatus = (status) => status === "complete" || status === "failed" || status === "partial" || status === "paused" || status === "rejected" || status === "stopped";
 function rememberFleetJob(state, job) {
   state.fleetJobs ??= new Map;
   state.fleetJobs.set(job.asyncId, job);
-  const terminal = [...state.fleetJobs.values()].filter((candidate) => candidate.status === "complete" || candidate.status === "failed" || candidate.status === "paused" || candidate.status === "stopped").sort((left, right) => (right.updatedAt ?? right.startedAt ?? 0) - (left.updatedAt ?? left.startedAt ?? 0));
+  const terminal = [...state.fleetJobs.values()].filter((candidate) => isTerminalJobStatus(candidate.status)).sort((left, right) => (right.updatedAt ?? right.startedAt ?? 0) - (left.updatedAt ?? left.startedAt ?? 0));
   for (const stale of terminal.slice(MAX_RECENT_FLEET_JOBS))
     state.fleetJobs.delete(stale.asyncId);
 }
@@ -44,31 +46,12 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
   let widgetRerenderTimer;
   const runningJobIds = new Set;
   const externalJobBridgeRuns = new Set;
-  const externalJobBridgeEligibility = (steps) => {
-    if (!Array.isArray(steps))
-      return "unknown";
-    for (const step of steps) {
-      const runner = step?.runner;
-      if (runner === undefined)
-        continue;
-      if (!runner || typeof runner !== "object" || Array.isArray(runner))
-        return "unknown";
-      const runnerType = runner.type;
-      if (typeof runnerType !== "string")
-        return "unknown";
-      if (runnerType === "external-job")
-        return "required";
-      if (runnerType !== "dm" && runnerType !== "external-cli")
-        return "unknown";
-    }
-    return "not-required";
-  };
+  const terminalPublications = new Map;
   let rootWatcher;
   let nextLivenessAt = Date.now() + livenessIntervalMs;
   let nextWidgetAnimationAt = Date.now() + WIDGET_ANIMATION_INTERVAL_MS;
   const watch = options.watch ?? fs.watch;
   const useNativeWatcher = () => shouldUseNativeFsWatch("async-job-tracker", options.platform);
-  const terminalStatus = (status) => status === "complete" || status === "failed" || status === "paused" || status === "stopped";
   const withLastUiContext = (run) => {
     const cached = state.lastUiContext;
     return withCachedUiContext(cached, () => {
@@ -194,6 +177,8 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     const timer = setTimeout(() => {
       state.cleanupTimers.delete(asyncId);
       closeJobWatcher(asyncId);
+      const job = state.asyncJobs.get(asyncId);
+      retainNestedLookupRoute(state, job?.nestedRoute, job?.sessionId);
       state.asyncJobs.delete(asyncId);
       rerenderLastWidget();
     }, completionRetentionMs);
@@ -236,25 +221,29 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
           return;
         if (parsed.type === "subagent.child-status") {
           const event = parsed;
-          if (event.version !== 1 || typeof event.runId !== "string" || typeof event.childId !== "string" || event.status !== "stopping" && event.status !== "stopped" || typeof event.ts !== "number")
+          if (event.version !== 1 || typeof event.runId !== "string" || typeof event.childId !== "string" || event.status !== "started" && event.status !== "stopping" && event.status !== "stopped" || typeof event.ts !== "number")
             return;
-          dm.events.emit(SUBAGENT_CHILD_STATUS_EVENT, {
-            type: "subagent.child-status",
-            version: 1,
-            runId: event.runId,
-            childId: event.childId,
-            status: event.status,
-            ts: event.ts,
-            ...typeof event.reason === "string" ? { reason: event.reason } : {},
-            source: event.source === "rpc" ? "rpc" : "async",
-            asyncDir: job.asyncDir,
-            ...typeof event.stepIndex === "number" ? { stepIndex: event.stepIndex } : {},
-            ...typeof event.agent === "string" ? { agent: event.agent } : {},
-            ...typeof event.childRunId === "string" ? { childRunId: event.childRunId } : {},
-            ...typeof event.workflowKey === "string" ? { workflowKey: event.workflowKey } : {},
-            ...typeof event.phase === "string" ? { phase: event.phase } : {},
-            ...typeof event.label === "string" ? { label: event.label } : {}
-          });
+          try {
+            dm.events.emit(SUBAGENT_CHILD_STATUS_EVENT, {
+              type: "subagent.child-status",
+              version: 1,
+              runId: event.runId,
+              childId: event.childId,
+              status: event.status,
+              ts: event.ts,
+              ...typeof event.reason === "string" ? { reason: event.reason } : {},
+              source: event.source === "rpc" ? "rpc" : "async",
+              asyncDir: job.asyncDir,
+              ...typeof event.stepIndex === "number" ? { stepIndex: event.stepIndex } : {},
+              ...typeof event.agent === "string" ? { agent: event.agent } : {},
+              ...typeof event.childRunId === "string" ? { childRunId: event.childRunId } : {},
+              ...typeof event.workflowKey === "string" ? { workflowKey: event.workflowKey } : {},
+              ...typeof event.phase === "string" ? { phase: event.phase } : {},
+              ...typeof event.label === "string" ? { label: event.label } : {}
+            });
+          } catch (error) {
+            console.error("Failed to emit async child status event:", error);
+          }
           return;
         }
         if (parsed.type === "subagent.steering.notice") {
@@ -282,6 +271,16 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
         const record = parsed;
         if (!record.event || !Array.isArray(record.channels))
           return;
+        if (record.event.type === "needs_attention" && record.event.reason === "supervisor_request" && options.supervisorRequestState) {
+          let requestState = "unknown";
+          try {
+            requestState = options.supervisorRequestState(record.event);
+          } catch (error) {
+            console.error(`Failed to resolve supervisor request state for async control event in '${job.asyncDir}':`, error);
+          }
+          if (requestState === "resolved")
+            return;
+        }
         const payload = {
           event: record.event,
           source: "async",
@@ -366,6 +365,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     refreshTimers.delete(asyncId);
     runningJobIds.delete(asyncId);
     externalJobBridgeRuns.delete(asyncId);
+    terminalPublications.delete(asyncId);
   };
   const refreshJob = (job) => {
     const widgetExpanded = withLastUiContext((ctx) => ctx.ui.getToolsExpanded?.() ?? false) ?? false;
@@ -426,11 +426,13 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
       if (status) {
         const previousStatus = job.status;
         job.status = status.state;
+        if (!isTerminalJobStatus(job.status))
+          terminalPublications.delete(job.asyncId);
         if (job.status === "running")
           runningJobIds.add(job.asyncId);
         else
           runningJobIds.delete(job.asyncId);
-        if (job.status !== "complete" && job.status !== "failed" && job.status !== "paused" && job.status !== "stopped")
+        if (!isTerminalJobStatus(job.status))
           cancelCleanup(job.asyncId);
         job.sessionId = status.sessionId ?? job.sessionId;
         job.activityState = status.activityState;
@@ -485,11 +487,29 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
         job.turnBudgetExceeded = status.turnBudgetExceeded ?? job.turnBudgetExceeded;
         job.wrapUpRequested = status.wrapUpRequested ?? job.wrapUpRequested;
         job.sessionFile = status.sessionFile ?? job.sessionFile;
-        if (terminalStatus(job.status)) {
-          if (!terminalStatus(previousStatus))
+        if (isTerminalJobStatus(job.status)) {
+          let publication = terminalPublications.get(job.asyncId);
+          if (!publication && status.mode !== "workflow" && status.processTerminal?.state === "pending" && status.runId === job.asyncId && status.sessionId === state.currentSessionId && status.completionOwnerId && status.completionOwnerId === state.completionOwnerId) {
+            publication = { instanceId: status.processTerminal.runnerProcessInstanceId, pending: true };
+            terminalPublications.set(job.asyncId, publication);
+          }
+          const wasPending = publication?.pending;
+          if (publication?.pending) {
+            const published = reconciliation.resultPath && fs.existsSync(reconciliation.resultPath);
+            const closed = !published && readProcessTerminal(job.asyncDir, {
+              runId: job.asyncId,
+              runnerProcessInstanceId: publication.instanceId
+            })?.state === "observed";
+            if (published || closed) {
+              publication = { pending: false };
+              terminalPublications.set(job.asyncId, publication);
+            } else
+              cancelCleanup(job.asyncId);
+          }
+          if (!isTerminalJobStatus(previousStatus) || wasPending && !publication?.pending)
             options.onJobTerminal?.();
           rememberFleetJob(state, job);
-          if (!nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
+          if (!publication?.pending && !nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
             scheduleCleanup(job.asyncId);
           }
         }
@@ -516,7 +536,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
       }
       runningJobIds.delete(job.asyncId);
       rememberFleetJob(state, job);
-      if (!hasLiveNestedDescendants(job.nestedChildren) && !state.cleanupTimers.has(job.asyncId))
+      if (!terminalPublications.get(job.asyncId)?.pending && !hasLiveNestedDescendants(job.nestedChildren) && !state.cleanupTimers.has(job.asyncId))
         scheduleCleanup(job.asyncId);
     }
     return widgetRenderKey(job, widgetExpanded) !== widgetStateBefore;
@@ -667,9 +687,11 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     const firstGroup = validParallelGroups.find((group) => group.start === 0);
     const firstGroupCount = firstGroup?.count;
     const agents = firstGroupCount && firstGroupCount > 0 ? rawAgents?.slice(0, firstGroupCount) : rawAgents;
-    const sessionRoot = state.liveAsyncSessionRoots?.get(info.id);
+    const existingJob = state.asyncJobs.get(info.id);
+    const sessionRoot = state.liveAsyncSessionRoots?.get(info.id) ?? existingJob?.sessionRoot;
     state.liveAsyncSessionRoots?.delete(info.id);
     externalJobBridgeRuns.delete(info.id);
+    terminalPublications.delete(info.id);
     state.asyncJobs.set(info.id, {
       asyncId: info.id,
       asyncDir,
@@ -724,6 +746,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
         job.asyncDir = result.asyncDir;
         watchJob(job);
       }
+      terminalPublications.set(asyncId, { pending: false });
       try {
         updateAsyncJobNestedProjection(job);
       } catch (error) {
@@ -753,6 +776,7 @@ export function createAsyncJobTracker(dm, state, asyncDirRoot, options = {}) {
     widgetRerenderTimer = undefined;
     runningJobIds.clear();
     externalJobBridgeRuns.clear();
+    terminalPublications.clear();
   };
   const resetJobs = (ctx) => {
     dispose();

package/extensions/dm-subagents/src/runs/background/async-resume.js

@@ -2,17 +2,21 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { DIRS } from "../../shared/types.js";
 import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
+import { snapshotRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 import { normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
 import { validateAcceptanceInput } from "../shared/acceptance.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
-import { intersectSubagentCapabilityCeilings, parseSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
+import { intersectSubagentCapabilityCeilings, normalizeCapabilityCeilingAllowedAgents, parseSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { validateRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
 import { reconcileAsyncRun } from "./stale-run-reconciler.js";
 import { resultFilePath, resultPayloadPathForIndexedRun } from "./result-files.js";
 import { canScanAsyncRunPrefix, MIN_SAFE_ASYNC_RUN_PREFIX_LENGTH } from "./run-id-query.js";
 import { parallelHandoffPath, resolveRetainedWorktreeCwd } from "../shared/parallel-handoff.js";
+import { normalizeWorktreeBaseRef } from "../shared/worktree.js";
 import { intersectThinkingCeilings, parseThinkingLevel } from "../../shared/thinking-ceiling.js";
 import { assertWorkflowGraphHostSteps } from "../shared/host-step-status.js";
+import { validateIntercomBridgeConfig } from "../../intercom/intercom-bridge.js";
+import { validateModelResponseAliases } from "../../shared/model-response-aliases.js";
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -69,6 +73,7 @@ function validateResultFile(value, resultPath) {
     thinking: validateOptionalString(data, "thinking", resultPath),
     launchContractDigest: validateOptionalString(data, "launchContractDigest", resultPath),
     ...data.capabilityCeiling === undefined ? {} : { capabilityCeiling: parseSubagentCapabilityCeiling(data.capabilityCeiling, `async result file '${resultPath}' capabilityCeiling`) },
+    ...data.admissionCapabilityCeiling === undefined ? {} : { admissionCapabilityCeiling: parseSubagentCapabilityCeiling(data.admissionCapabilityCeiling, `async result file '${resultPath}' admissionCapabilityCeiling`) },
     ...typeof success === "boolean" ? { success } : {},
     ...results ? { results } : {}
   };
@@ -204,6 +209,8 @@ function validateStatusForResume(status, source) {
     throw new Error(`Invalid async status '${source}': sessionFile must be a string.`);
   if (status.capabilityCeiling !== undefined)
     status.capabilityCeiling = parseSubagentCapabilityCeiling(status.capabilityCeiling, `async status '${source}' capabilityCeiling`);
+  if (status.admissionCapabilityCeiling !== undefined)
+    status.admissionCapabilityCeiling = parseSubagentCapabilityCeiling(status.admissionCapabilityCeiling, `async status '${source}' admissionCapabilityCeiling`);
   if (status.steps !== undefined) {
     if (!Array.isArray(status.steps))
       throw new Error(`Invalid async status '${source}': steps must be an array.`);
@@ -239,7 +246,7 @@ function normalizeRecoveryAcceptance(value, descriptorPath) {
 export function asyncReviveRequiresRecoveryDescriptor(target) {
   if (target.recoveryDescriptor)
     return false;
-  return !(target.mode === "workflow" && Boolean(target.sessionFile));
+  return !(target.mode === "workflow" && target.sessionFile && target.capabilityCeiling);
 }
 function resumeTargetMode(status, result) {
   if (status?.mode)
@@ -264,6 +271,7 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': expected an object.`);
   const parsed = value;
   const allowedFields = new Set([
+    "modelResponseAliases",
     "version",
     "launchContractDigest",
     "sourceRunId",
@@ -274,14 +282,17 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     "model",
     "modelProvider",
     "modelOverrideFromParent",
-    "fallbackModels",
+    "modelOrigin",
+    "fast",
     "thinking",
     "thinkingCeiling",
     "tools",
     "allowNestedSubagents",
+    "allowedAgents",
     "extensions",
     "subagentOnlyExtensions",
     "mcpDirectTools",
+    "excludeTools",
     "mutationTools",
     "systemPrompt",
     "systemPromptMode",
@@ -291,7 +302,6 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     "skills",
     "skillPath",
     "agentFilePath",
-    "completionGuard",
     "memory",
     "outputPath",
     "outputMode",
@@ -313,7 +323,9 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     "launchResolvedExtensions",
     "runFanoutBudget",
     "lane",
-    "extensionBindings"
+    "baseRef",
+    "extensionBindings",
+    "requiredExtensions"
   ]);
   for (const field of Object.keys(parsed)) {
     if (!allowedFields.has(field))
@@ -331,12 +343,20 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
   } catch (error) {
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
   }
+  validateModelResponseAliases(parsed.modelResponseAliases, `async recovery descriptor '${descriptorPath}' modelResponseAliases`);
   if (parsed.capabilityCeiling !== undefined)
     parsed.capabilityCeiling = parseSubagentCapabilityCeiling(parsed.capabilityCeiling, `async recovery descriptor '${descriptorPath}' capabilityCeiling`);
   if (parsed.thinkingCeiling !== undefined)
     parsed.thinkingCeiling = parseThinkingLevel(parsed.thinkingCeiling, `async recovery descriptor '${descriptorPath}' thinkingCeiling`);
   if (parsed.extensionBindings !== undefined)
     parsed.extensionBindings = normalizeExtensionBindings(parsed.extensionBindings).value;
+  if (parsed.requiredExtensions !== undefined) {
+    try {
+      parsed.requiredExtensions = snapshotRequiredChildExtensions(parsed.requiredExtensions, "requiredExtensions");
+    } catch (error) {
+      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   if (parsed.lane !== undefined)
     parsed.lane = normalizeWorkflowLaneMetadata(parsed.lane, `Invalid async recovery descriptor '${descriptorPath}': lane`);
   if (parsed.agentContract !== undefined) {
@@ -354,6 +374,12 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': context is invalid.`);
   if (parsed.modelOverrideFromParent !== undefined && typeof parsed.modelOverrideFromParent !== "boolean")
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelOverrideFromParent must be a boolean.`);
+  if (parsed.fast !== undefined && typeof parsed.fast !== "boolean")
+    throw new Error(`Invalid async recovery descriptor '${descriptorPath}': fast must be a boolean.`);
+  if (parsed.modelOrigin !== undefined && parsed.modelOrigin !== "explicit" && parsed.modelOrigin !== "inherited" && parsed.modelOrigin !== "configured")
+    throw new Error(`Invalid async recovery descriptor '${descriptorPath}': modelOrigin must be 'explicit', 'inherited', or 'configured'.`);
+  if (parsed.modelOrigin === undefined && parsed.model !== undefined)
+    parsed.modelOrigin = parsed.modelOverrideFromParent ? "inherited" : "configured";
   for (const field of ["inheritProjectContext", "inheritSkills", "share"]) {
     if (typeof parsed[field] !== "boolean")
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${field} must be a boolean.`);
@@ -364,9 +390,16 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': inheritGlobalContext must be a boolean.`);
   if (parsed.allowNestedSubagents !== undefined && typeof parsed.allowNestedSubagents !== "boolean")
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': allowNestedSubagents must be a boolean.`);
+  if (parsed.allowedAgents !== undefined) {
+    try {
+      parsed.allowedAgents = normalizeCapabilityCeilingAllowedAgents(parsed.allowedAgents);
+    } catch (error) {
+      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   if (!Number.isInteger(parsed.maxSubagentDepth) || parsed.maxSubagentDepth < 0)
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': maxSubagentDepth must be a non-negative integer.`);
-  for (const field of ["fallbackModels", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "mutationTools", "skills", "skillPath"]) {
+  for (const field of ["tools", "excludeTools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "mutationTools", "skills", "skillPath"]) {
     const item = parsed[field];
     if (item !== undefined && (!Array.isArray(item) || item.some((entry) => typeof entry !== "string" || !entry.trim())))
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${field} must contain non-empty strings.`);
@@ -377,8 +410,15 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
     if (parsed[field] !== undefined && (typeof parsed[field] !== "string" || !parsed[field].trim()))
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${field} must be a non-empty string.`);
   }
-  if (parsed.completionGuard !== undefined && typeof parsed.completionGuard !== "boolean")
-    throw new Error(`Invalid async recovery descriptor '${descriptorPath}': completionGuard must be a boolean.`);
+  if (parsed.baseRef !== undefined) {
+    if (typeof parsed.baseRef !== "string")
+      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': baseRef must be a string.`);
+    try {
+      parsed.baseRef = normalizeWorktreeBaseRef(parsed.baseRef);
+    } catch (error) {
+      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   if (parsed.structuredOutputSchema !== undefined && (!parsed.structuredOutputSchema || typeof parsed.structuredOutputSchema !== "object" || Array.isArray(parsed.structuredOutputSchema)))
     throw new Error(`Invalid async recovery descriptor '${descriptorPath}': structuredOutputSchema must be an object.`);
   if (parsed.memory !== undefined) {
@@ -421,19 +461,9 @@ export function readAsyncRecoveryDescriptor(asyncDir) {
       throw new Error(`Invalid async recovery descriptor '${descriptorPath}': artifactConfig.cleanupDays must be a non-negative integer.`);
   }
   if (parsed.intercomBridge !== undefined) {
-    if (!parsed.intercomBridge || typeof parsed.intercomBridge !== "object" || Array.isArray(parsed.intercomBridge))
-      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': intercomBridge must be an object.`);
-    const bridge = parsed.intercomBridge;
-    for (const field of Object.keys(bridge)) {
-      if (field !== "mode" && field !== "instructionFile" && field !== "resultDelivery")
-        throw new Error(`Invalid async recovery descriptor '${descriptorPath}': intercomBridge.${field} is not supported.`);
-    }
-    if (bridge.mode !== undefined && bridge.mode !== "off" && bridge.mode !== "fork-only" && bridge.mode !== "always")
-      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': intercomBridge.mode is invalid.`);
-    if (bridge.instructionFile !== undefined && typeof bridge.instructionFile !== "string")
-      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': intercomBridge.instructionFile must be a string.`);
-    if (bridge.resultDelivery !== undefined && typeof bridge.resultDelivery !== "boolean")
-      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': intercomBridge.resultDelivery must be a boolean.`);
+    const bridge = validateIntercomBridgeConfig({ value: parsed.intercomBridge, label: "intercomBridge" });
+    if (!bridge.ok)
+      throw new Error(`Invalid async recovery descriptor '${descriptorPath}': ${bridge.error}`);
   }
   if (parsed.controlConfig !== undefined) {
     if (!parsed.controlConfig || typeof parsed.controlConfig !== "object" || Array.isArray(parsed.controlConfig))
@@ -579,7 +609,11 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
     throw new Error(`Async run '${runId}' index must be an integer.`);
   if (index < 0 || index >= stepCount)
     throw new Error(`Async run '${runId}' has ${stepCount} children. Index ${index} is out of range.`);
-  const agent = statusSteps[index]?.agent ?? resultSteps[index]?.agent ?? result?.agent;
+  const selectedStatusStep = statusSteps[index];
+  if (selectedStatusStep?.status === "stopped" || selectedStatusStep?.stopped === true) {
+    throw new Error(`Async run '${runId}' child ${index} was stopped and cannot be resumed. Start a new run instead.`);
+  }
+  const agent = selectedStatusStep?.agent ?? resultSteps[index]?.agent ?? result?.agent;
   if (!agent)
     throw new Error(`Could not determine child agent for async run '${runId}'.`);
   if (recoveryDescriptor && recoveryDescriptor.agent !== agent)
@@ -591,7 +625,7 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
   const stepModel = statusSteps[index]?.model ?? resultSteps[index]?.model ?? (stepCount === 1 ? result?.model : undefined);
   const stepThinking = statusSteps[index]?.thinking ?? resultSteps[index]?.thinking ?? (stepCount === 1 ? result?.thinking : undefined);
   const thinkingCeiling = statusSteps[index]?.thinkingCeiling ?? (stepCount === 1 ? recoveryDescriptor?.thinkingCeiling : undefined);
-  const capabilityCeiling = intersectSubagentCapabilityCeilings(status?.capabilityCeiling, statusSteps[index]?.capabilityCeiling, result?.capabilityCeiling, resultSteps[index]?.capabilityCeiling);
+  const capabilityCeiling = mode === "workflow" ? intersectSubagentCapabilityCeilings(status?.admissionCapabilityCeiling, result?.admissionCapabilityCeiling) : intersectSubagentCapabilityCeilings(status?.capabilityCeiling, statusSteps[index]?.capabilityCeiling, result?.capabilityCeiling, resultSteps[index]?.capabilityCeiling);
   const managedWorktreeCwd = location.asyncDir ? resolveRetainedWorktreeCwd(parallelHandoffPath(location.asyncDir), runId, index) : undefined;
   const resumeCwd = validateResumeCwd(runId, managedWorktreeCwd ?? status?.cwd ?? result?.cwd ?? recoveryDescriptor?.cwd);
   return {
@@ -604,6 +638,7 @@ export function resolveAsyncResumeTarget(params, deps = {}, options = {}) {
     ...statusSteps[index]?.sessionName ?? resultSteps[index]?.sessionName ? { sessionName: statusSteps[index]?.sessionName ?? resultSteps[index]?.sessionName } : {},
     index,
     ...resumeCwd ? { cwd: resumeCwd } : {},
+    ...managedWorktreeCwd ? { managedWorktree: true } : {},
     ...resolvedSessionFile ? { sessionFile: resolvedSessionFile } : {},
     ...stepModel ? { model: stepModel } : {},
     ...stepThinking ? { thinking: stepThinking } : {},
@@ -620,11 +655,12 @@ export function applySteeringRecoveryAgentConfig(agentConfig, descriptor) {
     ...agentConfig,
     model: descriptor.model,
     modelProvider: descriptor.modelProvider,
-    fallbackModels: descriptor.fallbackModels ? [...descriptor.fallbackModels] : undefined,
     thinking: descriptor.thinking,
     maxThinking: intersectThinkingCeilings(descriptor.thinkingCeiling, agentConfig.maxThinking),
     tools: descriptor.tools ? [...descriptor.tools] : undefined,
+    excludeTools: descriptor.excludeTools ? [...descriptor.excludeTools] : undefined,
     allowNestedSubagents: descriptor.allowNestedSubagents,
+    allowedAgents: descriptor.allowedAgents === undefined ? undefined : [...descriptor.allowedAgents],
     extensions: descriptor.extensions ? [...descriptor.extensions] : undefined,
     subagentOnlyExtensions: descriptor.subagentOnlyExtensions ? [...descriptor.subagentOnlyExtensions] : undefined,
     mcpDirectTools: descriptor.mcpDirectTools ? [...descriptor.mcpDirectTools] : undefined,
@@ -637,7 +673,6 @@ export function applySteeringRecoveryAgentConfig(agentConfig, descriptor) {
     skills: descriptor.skills ? [...descriptor.skills] : undefined,
     skillPath: descriptor.skillPath ? [...descriptor.skillPath] : undefined,
     filePath: descriptor.agentFilePath,
-    completionGuard: descriptor.completionGuard,
     memory: descriptor.memory ? { ...descriptor.memory } : undefined,
     output: descriptor.outputPath,
     toolBudget: descriptor.initialToolBudget,
@@ -652,7 +687,7 @@ export function buildRevivedAsyncTask(target, message) {
     `Original agent: ${target.agent}`,
     target.sessionFile ? `Original session file: ${target.sessionFile}` : undefined,
     "",
-    "Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child process is still alive.",
+    "Use the stored session context as background. Answer the orchestrator's follow-up below. Do not assume the original child session is still running.",
     "",
     "Follow-up:",
     message

package/extensions/dm-subagents/src/runs/background/async-retention.js

@@ -223,7 +223,15 @@ function readCursor(root) {
   const value = readJson(path.join(root, CURSOR_NAME));
   return value?.version === 1 ? value : { version: 1 };
 }
+let currentProcessStartIdentity = null;
 function processStartIdentity(pid) {
+  if (pid !== process.pid)
+    return computeProcessStartIdentity(pid);
+  if (currentProcessStartIdentity === null)
+    currentProcessStartIdentity = computeProcessStartIdentity(pid);
+  return currentProcessStartIdentity;
+}
+function computeProcessStartIdentity(pid) {
   if (process.platform === "linux") {
     try {
       const stat = fs.readFileSync(`/proc/${pid}/stat`).toString("utf8");

package/extensions/dm-subagents/src/runs/background/async-status-snapshot.js

@@ -1,14 +1,13 @@
 import {
-  projectAsyncStatusSnapshot
+  projectAsyncStatusSnapshot as buildAsyncStatusSnapshot
 } from "../shared/async-status-projection.js";
 export {
   ASYNC_STATUS_SNAPSHOT_KIND,
   ASYNC_STATUS_SNAPSHOT_VERSION
 } from "../shared/async-status-projection.js";
 export const ASYNC_STATUS_SNAPSHOT_WIDGET_PREFIX = "DM_SUBAGENT_ASYNC_JSON:";
-export function buildAsyncStatusSnapshot(jobs, options = {}) {
-  return projectAsyncStatusSnapshot(jobs, options);
-}
+
+export { buildAsyncStatusSnapshot };
 export function asyncStatusSnapshotJobsForState(state, sessionId) {
   if (!state || !sessionId || state.currentSessionId !== sessionId)
     return [];