@duckmind/dm-windows-x64 0.61.4 → 0.61.9

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

@@ -0,0 +1,31 @@
+import {
+  projectAsyncStatusSnapshot
+} 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 function asyncStatusSnapshotJobsForState(state, sessionId) {
+  if (!state || !sessionId || state.currentSessionId !== sessionId)
+    return [];
+  const jobs = new Map;
+  for (const job of state.asyncJobs.values()) {
+    if (job.sessionId === sessionId)
+      jobs.set(job.asyncId, job);
+  }
+  for (const job of state.fleetJobs?.values() ?? []) {
+    if (job.sessionId === sessionId && !jobs.has(job.asyncId))
+      jobs.set(job.asyncId, job);
+  }
+  return [...jobs.values()];
+}
+export function buildAsyncStatusSnapshotForState(state, sessionId, options = {}) {
+  return buildAsyncStatusSnapshot(asyncStatusSnapshotJobsForState(state, sessionId), options);
+}
+export function encodeAsyncStatusSnapshotWidget(jobs, options = {}) {
+  return [`${ASYNC_STATUS_SNAPSHOT_WIDGET_PREFIX}${JSON.stringify(buildAsyncStatusSnapshot(jobs, options))}`];
+}

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

@@ -1,12 +1,27 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.js";
+import { previewDisplayText } from "../../shared/display-text.js";
 import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.js";
 import { readStatus } from "../../shared/utils.js";
-import { attachRootChildrenToSteps, buildNestedRouteIndex, projectNestedEvents } from "../shared/nested-events.js";
+import { attachRootChildrenToSteps, buildNestedRouteIndex, findNestedRouteForRootId, projectNestedEvents } from "../shared/nested-events.js";
 import { formatNestedRunStatusLines } from "../shared/nested-render.js";
+import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.js";
+import { contextModeLabel, summarizeContextModes } from "../shared/context-mode.js";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
+import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.js";
+import { ACTIVE_RUN_INDEX_DIR, DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS, activeRunMarkerAgeMs, isActiveAsyncState, readActiveRunIndex, releaseActiveRunIndex, updateActiveRunIndex } from "./active-run-index.js";
+import { readRecentTerminalRunIndex, TERMINAL_RUN_INDEX_DIR } from "./terminal-run-index.js";
+import { canScanAsyncRunPrefix } from "./run-id-query.js";
+import { asyncStatusChildIdentity } from "../shared/child-identity.js";
+import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.js";
+import { assertWorkflowGraphHostSteps, hostStepReportName, hostStepVerdictLabel, validHostStepNodes } from "../shared/host-step-status.js";
+import { projectAsyncWorkflowRows } from "../shared/async-status-projection.js";
+import { validateAsyncStatusLaneMetadata } from "../shared/lane-metadata.js";
+import { formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary } from "../../workflows/workflow-preflight.js";
+import { workflowGraphStageNodes } from "../shared/workflow-graph.js";
+import { formatTimeoutRecoveryLines, projectTimeoutRecovery } from "../shared/mutation-evidence.js";
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -25,6 +40,41 @@ function isAsyncRunDir(root, entry) {
     });
   }
 }
+export function resolveTargetedAsyncRun(asyncDirRoot, id, sessionId) {
+  if (!id || id === "." || id === ".." || id === ACTIVE_RUN_INDEX_DIR || id === TERMINAL_RUN_INDEX_DIR || path.basename(id) !== id)
+    return { kind: "reject" };
+  const asyncDir = path.join(asyncDirRoot, id);
+  let entryStat;
+  try {
+    entryStat = fs.lstatSync(asyncDir);
+  } catch (error) {
+    if (isNotFoundError(error))
+      return canScanAsyncRunPrefix(id) ? { kind: "prefix" } : { kind: "reject" };
+    throw new Error(`Failed to inspect async run path '${asyncDir}': ${getErrorMessage(error)}`, {
+      cause: error instanceof Error ? error : undefined
+    });
+  }
+  if (!entryStat.isDirectory() || entryStat.isSymbolicLink())
+    return { kind: "reject" };
+  try {
+    const canonicalRoot = fs.realpathSync(asyncDirRoot);
+    const canonicalDir = fs.realpathSync(asyncDir);
+    if (canonicalDir !== canonicalRoot && !canonicalDir.startsWith(`${canonicalRoot}${path.sep}`))
+      return { kind: "reject" };
+  } catch (error) {
+    if (isNotFoundError(error))
+      return { kind: "reject" };
+    throw new Error(`Failed to resolve async run path '${asyncDir}': ${getErrorMessage(error)}`, {
+      cause: error instanceof Error ? error : undefined
+    });
+  }
+  if (sessionId !== undefined) {
+    const status = readStatus(asyncDir);
+    if (status?.sessionId !== sessionId)
+      return canScanAsyncRunPrefix(id) ? { kind: "prefix" } : { kind: "reject" };
+  }
+  return { kind: "exact", id };
+}
 function outputFileMtime(outputFile) {
   if (!outputFile)
     return;
@@ -45,19 +95,35 @@ function deriveAsyncActivityState(asyncDir, status) {
   const currentStep = typeof status.currentStep === "number" ? status.steps?.[status.currentStep] : undefined;
   return {
     activityState: status.activityState,
-    lastActivityAt: status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? currentStep?.startedAt ?? status.startedAt
+    lastActivityAt: status.lastActivityAt ?? outputFileMtime(outputPath) ?? currentStep?.lastActivityAt ?? (status.mode === "workflow" ? undefined : currentStep?.startedAt ?? status.startedAt)
   };
 }
 function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
+  validateAsyncStatusLaneMetadata(status, `Invalid async status '${path.join(asyncDir, "status.json")}'`);
+  const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
+  if (workflowChildren && workflowChildren.workflowRunId !== status.runId)
+    throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': workflowChildren.workflowRunId does not match.`);
+  assertWorkflowGraphHostSteps(status.workflowGraph, path.join(asyncDir, "status.json"), status.runId);
+  const hostSteps = validHostStepNodes(status.workflowGraph);
   if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
     throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
   }
   const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
+  const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }) ?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path.join(asyncDir, "status.json"));
+  const nestedProjectionAllowed = nestedWarnings.length === 0;
+  let runFanoutBudget = status.runFanoutBudget;
+  try {
+    const runFanoutBudgetDescriptor = readRunFanoutBudgetDescriptor(asyncDir);
+    if (runFanoutBudgetDescriptor)
+      runFanoutBudget = getRunFanoutBudgetSnapshot(runFanoutBudgetDescriptor);
+  } catch (error) {
+    nestedWarnings.push(`Run fan-out status unavailable: ${getErrorMessage(error)}`);
+  }
   const steps = status.steps ?? [];
   const chainStepCount = status.chainStepCount ?? steps.length;
   const parallelGroups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
   let nestedChildren = [];
-  if (nestedWarnings.length === 0 && nestedRoute) {
+  if (nestedProjectionAllowed && nestedRoute) {
     try {
       nestedChildren = projectNestedEvents(nestedRoute)?.children ?? [];
     } catch (error) {
@@ -67,14 +133,25 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
   const summarizedSteps = steps.map((step, index) => {
     const stepActivityState = step.activityState;
     const stepLastActivityAt = step.lastActivityAt;
+    const timeoutRecovery = projectTimeoutRecovery(step.timeoutRecovery);
     return {
       index,
+      childId: asyncStatusChildIdentity(step, index),
       agent: step.agent,
+      ...step.sessionName ? { sessionName: step.sessionName } : {},
+      ...step.context ? { context: step.context } : {},
       ...step.label ? { label: step.label } : {},
+      ...step.description ? { description: step.description } : {},
       ...step.phase ? { phase: step.phase } : {},
+      ...step.workflowKey ? { workflowKey: step.workflowKey } : {},
+      ...step.lane ? { lane: step.lane } : {},
+      ...step.worktreePath ? { worktreePath: step.worktreePath } : {},
+      ...step.branch ? { branch: step.branch } : {},
+      ...step.runId ? { runId: step.runId } : {},
       ...step.outputName ? { outputName: step.outputName } : {},
       ...step.structured ? { structured: step.structured } : {},
       status: step.status,
+      ...step.runner ? { runner: step.runner } : {},
       ...stepActivityState ? { activityState: stepActivityState } : {},
       ...stepLastActivityAt ? { lastActivityAt: stepLastActivityAt } : {},
       ...step.currentTool ? { currentTool: step.currentTool } : {},
@@ -85,20 +162,40 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
       ...step.recentOutput ? { recentOutput: [...step.recentOutput] } : {},
       ...step.turnCount !== undefined ? { turnCount: step.turnCount } : {},
       ...step.toolCount !== undefined ? { toolCount: step.toolCount } : {},
-      ...step.steerCount !== undefined ? { steerCount: step.steerCount } : {},
-      ...step.lastSteerAt !== undefined ? { lastSteerAt: step.lastSteerAt } : {},
+      ...step.steering ? { steering: step.steering } : {},
       ...step.durationMs !== undefined ? { durationMs: step.durationMs } : {},
       ...step.tokens ? { tokens: step.tokens } : {},
       ...step.totalCost ? { totalCost: step.totalCost } : {},
       ...step.skills ? { skills: step.skills } : {},
       ...step.model ? { model: step.model } : {},
+      ...step.contextLimit !== undefined ? { contextLimit: step.contextLimit } : {},
       ...step.thinking ? { thinking: step.thinking } : {},
+      ...step.thinkingCeiling ? { thinkingCeiling: step.thinkingCeiling } : {},
       ...step.attemptedModels ? { attemptedModels: step.attemptedModels } : {},
+      ...step.sessionFile ? { sessionFile: step.sessionFile } : {},
+      ...step.transcriptPath ? { transcriptPath: step.transcriptPath } : {},
       ...step.error ? { error: step.error } : {},
       ...step.timedOut !== undefined ? { timedOut: step.timedOut } : {},
+      ...step.stopped !== undefined ? { stopped: step.stopped } : {},
+      ...step.stopRequested !== undefined ? { stopRequested: step.stopRequested } : {},
+      ...step.stopRequestedAt !== undefined ? { stopRequestedAt: step.stopRequestedAt } : {},
       ...step.turnBudget ? { turnBudget: step.turnBudget } : {},
       ...step.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: step.turnBudgetExceeded } : {},
+      ...step.toolBudgetBlocked !== undefined ? { toolBudgetBlocked: step.toolBudgetBlocked } : {},
       ...step.wrapUpRequested !== undefined ? { wrapUpRequested: step.wrapUpRequested } : {},
+      ...step.acceptance ? { acceptance: step.acceptance } : {},
+      ...step.agentContract ? { agentContract: step.agentContract } : {},
+      ...step.launchContractDigest ? { launchContractDigest: step.launchContractDigest } : {},
+      ...step.launchResolvedExtensions ? { launchResolvedExtensions: step.launchResolvedExtensions } : {},
+      ...step.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: step.runtimeAcknowledgedExtensions } : {},
+      ...step.execution ? { execution: step.execution } : {},
+      ...step.review ? { review: step.review } : {},
+      ...step.effects ? { effects: step.effects } : {},
+      ...step.watchdog ? { watchdog: step.watchdog } : {},
+      ...step.processTerminal ? { processTerminal: sanitizeProcessTerminal(step.processTerminal, { runId: status.runId, runnerProcessInstanceId: step.processTerminal.runnerProcessInstanceId }, `${path.join(asyncDir, "status.json")} step ${index}`) } : {},
+      ...timeoutRecovery ? { timeoutRecovery } : {},
+      ...step.capabilityCeiling ? { capabilityCeiling: step.capabilityCeiling } : {},
+      ...step.capabilityAudit ? { capabilityAudit: step.capabilityAudit } : {},
       ...step.children?.length ? { children: step.children } : {}
     };
   });
@@ -106,6 +203,7 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
   return {
     id: status.runId || path.basename(asyncDir),
     asyncDir,
+    ...status.toolCallId ? { toolCallId: status.toolCallId } : {},
     ...status.sessionId ? { sessionId: status.sessionId } : {},
     state: status.state,
     ...status.error ? { error: status.error } : {},
@@ -116,16 +214,18 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
     currentPath: status.currentPath,
     turnCount: status.turnCount,
     toolCount: status.toolCount,
-    steerCount: status.steerCount,
-    lastSteerAt: status.lastSteerAt,
+    steering: status.steering,
     mode: status.mode,
+    ...summarizeContextModes(summarizedSteps.map((step) => step.context)) ? { context: summarizeContextModes(summarizedSteps.map((step) => step.context)) } : {},
     cwd: status.cwd,
+    ...status.sessionRoot ? { sessionRoot: status.sessionRoot } : {},
     startedAt: status.startedAt,
     lastUpdate: status.lastUpdate,
     endedAt: status.endedAt,
     ...status.timeoutMs !== undefined ? { timeoutMs: status.timeoutMs } : {},
     ...status.deadlineAt !== undefined ? { deadlineAt: status.deadlineAt } : {},
     ...status.timedOut !== undefined ? { timedOut: status.timedOut } : {},
+    ...status.stopped !== undefined ? { stopped: status.stopped } : {},
     ...status.turnBudget ? { turnBudget: status.turnBudget } : {},
     ...status.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: status.turnBudgetExceeded } : {},
     ...status.wrapUpRequested !== undefined ? { wrapUpRequested: status.wrapUpRequested } : {},
@@ -133,16 +233,35 @@ function statusToSummary(asyncDir, status, nestedWarnings = [], nestedRoute) {
     ...status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {},
     ...status.pendingAppends !== undefined ? { pendingAppends: status.pendingAppends } : {},
     ...parallelGroups.length ? { parallelGroups } : {},
+    ...hostSteps.length ? { hostSteps } : {},
+    ...status.mode === "workflow" && status.workflowGraph ? { workflowGraph: status.workflowGraph } : {},
     steps: summarizedSteps,
     ...nestedChildren.length ? { nestedChildren } : {},
     ...nestedWarnings.length ? { nestedWarnings } : {},
+    ...processTerminal ? { processTerminal } : {},
+    ...runFanoutBudget ? { runFanoutBudget } : {},
+    ...status.launchContractDigest ? { launchContractDigest: status.launchContractDigest } : {},
+    ...status.launchResolvedExtensions ? { launchResolvedExtensions: status.launchResolvedExtensions } : {},
+    ...status.runtimeAcknowledgedExtensions ? { runtimeAcknowledgedExtensions: status.runtimeAcknowledgedExtensions } : {},
+    ...status.capabilityCeiling ? { capabilityCeiling: status.capabilityCeiling } : {},
+    ...status.capabilityAudit ? { capabilityAudit: status.capabilityAudit } : {},
+    ...status.parentWorkflowRunId ? { parentWorkflowRunId: status.parentWorkflowRunId } : {},
+    ...status.workflowKey ? { workflowKey: status.workflowKey } : {},
+    ...status.lane ? { lane: status.lane } : {},
+    ...status.workflow ? { workflow: status.workflow } : {},
+    ...workflowChildren ? { workflowChildren } : {},
+    ...status.preflight ? { preflight: status.preflight } : {},
     ...status.sessionDir ? { sessionDir: status.sessionDir } : {},
     ...status.outputFile ? { outputFile: status.outputFile } : {},
     ...status.totalTokens ? { totalTokens: status.totalTokens } : {},
     ...status.totalCost ? { totalCost: status.totalCost } : {},
+    ...status.usageBudget ? { usageBudget: status.usageBudget } : {},
     ...status.sessionFile ? { sessionFile: status.sessionFile } : {}
   };
 }
+export function summarizeAsyncStatus(asyncDir, status) {
+  return statusToSummary(asyncDir, status);
+}
 function sortRuns(runs) {
   const rank = (state) => {
     switch (state) {
@@ -152,10 +271,16 @@ function sortRuns(runs) {
         return 1;
       case "failed":
         return 2;
+      case "partial":
+        return 2;
+      case "stopped":
+        return 2;
       case "paused":
         return 2;
       case "complete":
         return 3;
+      default:
+        return 4;
     }
   };
   return [...runs].sort((a, b) => {
@@ -169,8 +294,34 @@ function sortRuns(runs) {
 }
 export function listAsyncRuns(asyncDirRoot, options = {}) {
   let entries;
+  const activeEntries = new Set;
+  const wantsActive = options.states === undefined || options.states.some(isActiveAsyncState);
+  const wantsTerminal = options.states === undefined || options.states.some((state) => !isActiveAsyncState(state));
+  const includeNested = options.includeNested !== false;
   try {
-    entries = fs.readdirSync(asyncDirRoot).filter((entry) => isAsyncRunDir(asyncDirRoot, entry));
+    if (options.runId !== undefined) {
+      const resolution = resolveTargetedAsyncRun(asyncDirRoot, options.runId, options.sessionId);
+      entries = resolution.kind === "exact" ? [resolution.id] : resolution.kind === "prefix" && options.exactRunId !== true ? fs.readdirSync(asyncDirRoot).filter((entry) => (entry === options.runId || entry.startsWith(options.runId)) && resolveTargetedAsyncRun(asyncDirRoot, entry, options.sessionId).kind === "exact") : [];
+    } else if (options.repairScan === true) {
+      entries = fs.readdirSync(asyncDirRoot).filter((entry) => entry !== ACTIVE_RUN_INDEX_DIR && entry !== TERMINAL_RUN_INDEX_DIR && isAsyncRunDir(asyncDirRoot, entry));
+    } else {
+      const indexed = new Set;
+      if (wantsActive) {
+        for (const entry of readActiveRunIndex(asyncDirRoot) ?? []) {
+          if (resolveTargetedAsyncRun(asyncDirRoot, entry).kind === "exact") {
+            indexed.add(entry);
+            activeEntries.add(entry);
+          } else {
+            updateActiveRunIndex(path.join(asyncDirRoot, entry), "failed");
+          }
+        }
+      }
+      if (wantsTerminal) {
+        for (const entry of readRecentTerminalRunIndex(asyncDirRoot, { sessionId: options.sessionId, ...options.entryLimit !== undefined ? { limit: options.entryLimit } : {} }))
+          indexed.add(entry);
+      }
+      entries = [...indexed];
+    }
   } catch (error) {
     if (isNotFoundError(error))
       return [];
@@ -182,6 +333,10 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
   const runs = [];
   let nestedRouteIndex;
   const resolveNestedRoute = (rootRunId) => {
+    if (!includeNested)
+      return;
+    if (activeEntries.has(rootRunId))
+      return findNestedRouteForRootId(rootRunId);
     if (!nestedRouteIndex)
       nestedRouteIndex = buildNestedRouteIndex();
     return nestedRouteIndex.get(rootRunId);
@@ -190,7 +345,17 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
     const asyncDir = path.join(asyncDirRoot, entry);
     const reconciliation = options.reconcile === false ? undefined : reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
     const status = reconciliation?.status ?? readStatus(asyncDir);
-    if (!status)
+    if (!status) {
+      if (activeEntries.has(entry))
+        updateActiveRunIndex(asyncDir, "failed");
+      continue;
+    }
+    if (activeEntries.has(entry) && !isActiveAsyncState(status.state)) {
+      const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId });
+      if (processTerminal?.state === "observed" || (activeRunMarkerAgeMs(asyncDir, options.now?.()) ?? 0) > DEFAULT_STALE_TERMINAL_ACTIVE_MARKER_MS)
+        releaseActiveRunIndex(asyncDir);
+    }
+    if (status.displayDismissedAt !== undefined)
       continue;
     if (allowedStates && !allowedStates.has(status.state))
       continue;
@@ -198,12 +363,14 @@ export function listAsyncRuns(asyncDirRoot, options = {}) {
       continue;
     const nestedWarnings = [];
     let nestedRoute;
-    try {
-      nestedRoute = resolveNestedRoute(status.runId || path.basename(asyncDir));
-      if (nestedRoute)
-        reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
-    } catch (error) {
-      nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
+    if (options.reconcile !== false && includeNested) {
+      try {
+        nestedRoute = resolveNestedRoute(status.runId || path.basename(asyncDir));
+        if (nestedRoute)
+          reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
+      } catch (error) {
+        nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
+      }
     }
     const summary = statusToSummary(asyncDir, status, nestedWarnings, nestedRoute);
     runs.push(summary);
@@ -223,23 +390,24 @@ function formatActivityFacts(input) {
     facts.push(`${input.turnCount} turns`);
   if (input.turnBudgetExceeded && input.turnBudget)
     facts.push(`turn budget exceeded ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}+${input.turnBudget.graceTurns}`);
+  else if (input.turnBudget?.outcome === "termination-deferred")
+    facts.push(`turn-budget termination deferred ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}+${input.turnBudget.graceTurns}`);
   else if (input.wrapUpRequested && input.turnBudget)
     facts.push(`wrap-up requested ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}`);
   else if (input.turnBudget)
     facts.push(`turn budget ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}+${input.turnBudget.graceTurns}`);
   if (input.toolCount !== undefined)
     facts.push(`${input.toolCount} tools`);
-  if (input.steerCount !== undefined)
-    facts.push(`${input.steerCount} steers`);
-  if (typeof input.lastSteerAt === "number" && Number.isFinite(input.lastSteerAt))
-    facts.push(`last steer ${new Date(input.lastSteerAt).toISOString()}`);
+  if (input.steering)
+    facts.push(`steering ${input.steering.scheduled} scheduled, ${input.steering.pending} pending, ${input.steering.delivered} delivered, ${input.steering.failed} failed, ${input.steering.recovered} recovered`);
   const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
   return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
 }
 function formatStepLine(step) {
-  const display = step.label ? `${step.label} (${step.agent})` : step.agent;
+  const display = step.sessionName?.trim() || (step.label ? `${step.label} (${step.agent})` : step.agent);
+  const context = contextModeLabel(step.context);
   const phase = step.phase ? `[${step.phase}] ` : "";
-  const parts = [`${step.index + 1}. ${phase}${display}`, step.status];
+  const parts = [`${step.index + 1}. ${phase}${display}${context ? ` ${context}` : ""}`, step.status];
   const activity = formatActivityFacts(step);
   if (activity)
     parts.push(activity);
@@ -250,14 +418,62 @@ function formatStepLine(step) {
     parts.push(formatDuration(step.durationMs));
   if (step.tokens)
     parts.push(`${formatTokens(step.tokens.total)} tok`);
+  if (step.lane)
+    parts.push(`lane ${step.lane.key}`);
+  if (step.worktreePath)
+    parts.push(`worktree ${shortenPath(step.worktreePath)} · branch ${step.branch ?? "unknown"}`);
   return parts.join(" | ");
 }
+function formatHostStepLine(row) {
+  if (!row.kind)
+    return "";
+  const state = hostStepVerdictLabel(row.state, row.verdict);
+  const details = [
+    row.provider ? `provider:${row.provider}` : undefined,
+    row.role ? `role:${row.role}` : undefined,
+    row.target,
+    row.detail,
+    row.reasonCode ? `reason:${row.reasonCode}` : undefined,
+    row.freshness?.stale ? "stale" : row.freshness?.observedRef ? `ref:${row.freshness.observedRef}` : undefined,
+    row.reportPath ? `out:${hostStepReportName(row.reportPath)}` : undefined
+  ].filter((value) => Boolean(value));
+  return `host ${row.kind}: ${row.name} | ${state}${details.length ? ` | ${details.join(" | ")}` : ""}`;
+}
+function workflowStageStateLabel(status) {
+  switch (status) {
+    case "completed":
+      return "complete";
+    case "detached":
+      return "paused";
+    default:
+      return status;
+  }
+}
+export function formatWorkflowStageLine(node, index, total) {
+  const state = workflowStageStateLabel(node.status);
+  const id = previewDisplayText(node.id, 160);
+  const label = node.label ? previewDisplayText(node.label, 160) : "";
+  const display = label && label !== id ? ` | ${label}` : "";
+  const agent = node.agent ? ` | ${previewDisplayText(node.agent, 80)}` : "";
+  const error = node.error ? ` | ${previewDisplayText(node.error, 240)}` : "";
+  return `stage ${index + 1}/${total}: ${id}${display}${agent} | ${state}${error}`;
+}
 export function formatAsyncRunOutputPath(run) {
   if (!run.outputFile)
     return;
   return path.isAbsolute(run.outputFile) ? run.outputFile : path.join(run.asyncDir, run.outputFile);
 }
 export function formatAsyncRunProgressLabel(run) {
+  const graphStages = run.mode === "workflow" ? workflowGraphStageNodes(run.workflowGraph) : [];
+  if (graphStages.length > 0) {
+    const currentNode = graphStages.find((node) => node.id === run.workflowGraph?.currentNodeId);
+    if (currentNode && currentNode.status !== "completed")
+      return `stage ${graphStages.indexOf(currentNode) + 1}/${graphStages.length}`;
+    const activeNode = graphStages.find((node) => node.status === "running") ?? graphStages.find((node) => node.status !== "completed");
+    if (activeNode)
+      return `stage ${graphStages.indexOf(activeNode) + 1}/${graphStages.length}`;
+    return `stage ${graphStages.length}/${graphStages.length}`;
+  }
   const stepCount = run.steps.length || 1;
   const chainStepCount = run.chainStepCount ?? stepCount;
   const groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, chainStepCount);
@@ -282,7 +498,9 @@ function formatRunHeader(run) {
   const cwd = run.cwd ? shortenPath(run.cwd) : shortenPath(run.asyncDir);
   const activity = formatActivityFacts(run);
   const pending = run.pendingAppends ? ` | ${run.pendingAppends} pending append${run.pendingAppends === 1 ? "" : "s"}` : "";
-  return `${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode} | ${stepLabel}${pending} | ${cwd}`;
+  const context = contextModeLabel(run.context);
+  const lane = run.lane ? ` | lane ${run.lane.key}` : "";
+  return `${run.id} | ${run.state}${activity ? ` | ${activity}` : ""} | ${run.mode}${context ? ` ${context}` : ""} | ${stepLabel}${pending}${lane} | ${cwd}`;
 }
 export function formatAsyncRunList(runs, heading = "Active async runs") {
   if (runs.length === 0)
@@ -290,13 +508,32 @@ export function formatAsyncRunList(runs, heading = "Active async runs") {
   const lines = [`${heading}: ${runs.length}`, ""];
   for (const run of runs) {
     lines.push(`- ${formatRunHeader(run)}`);
+    if (run.preflight)
+      lines.push(formatWorkflowPreflightPlanSummary(run.preflight, { indent: "  " }));
+    const preflightWarning = formatWorkflowPreflightWarningSummary(run.workflow?.preflightWarnings, { indent: "  " });
+    if (preflightWarning)
+      lines.push(preflightWarning);
     for (const step of run.steps) {
       lines.push(`  ${formatStepLine(step)}`);
+      lines.push(...formatTimeoutRecoveryLines(step.timeoutRecovery, "    "));
       lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", maxLines: 12 }));
     }
+    const loadedWorkflowKeys = new Set(run.steps.flatMap((step) => step.workflowKey ? [step.workflowKey] : []));
+    const graphStages = run.mode === "workflow" ? workflowGraphStageNodes(run.workflowGraph) : [];
+    for (const [index, node] of graphStages.entries()) {
+      if (!loadedWorkflowKeys.has(node.id))
+        lines.push(`  ${formatWorkflowStageLine(node, index, graphStages.length)}`);
+    }
+    for (const row of projectAsyncWorkflowRows([], run.hostSteps)) {
+      const line = formatHostStepLine(row);
+      if (line)
+        lines.push(`  ${line}`);
+    }
     const attached = new Set(run.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
     const unattached = run.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
     lines.push(...formatNestedRunStatusLines(unattached, { indent: "  ", maxLines: 12 }));
+    if (run.runFanoutBudget)
+      lines.push(`  ${formatRunFanoutBudget(run.runFanoutBudget)}`);
     if (run.error)
       lines.push(`  Error: ${run.error}`);
     for (const warning of run.nestedWarnings ?? [])

package/extensions/dm-subagents/src/runs/background/auto-drain.js

@@ -0,0 +1,46 @@
+import { snapshotBackgroundWork } from "../../api/background-work.js";
+import { DIRS } from "../../shared/types.js";
+import { listAsyncRuns } from "./async-status.js";
+import { waitForSubagents } from "./subagent-wait.js";
+export const DEFAULT_AUTO_DRAIN_TIMEOUT_MS = 30 * 60 * 1000;
+function resultText(value) {
+  return value.content.map((part) => part.type === "text" ? part.text : "").join(" ").trim();
+}
+function hasOutstandingWork(sessionId, nowMs) {
+  const asyncRuns = listAsyncRuns(DIRS.async, {
+    states: ["queued", "running"],
+    sessionId,
+    resultsDir: DIRS.results,
+    now: () => nowMs
+  });
+  return asyncRuns.length > 0 || snapshotBackgroundWork(sessionId, nowMs).items.length > 0;
+}
+export async function drainOutstandingWork(deps) {
+  const sessionId = deps.state.currentSessionId;
+  if (!sessionId)
+    throw new Error("Cannot auto-drain background work without an active session identity.");
+  const now = deps.now ?? Date.now;
+  const timeoutMs = deps.timeoutMs ?? DEFAULT_AUTO_DRAIN_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error("Auto-drain timeoutMs must be a positive finite number.");
+  const deadlineAt = now() + timeoutMs;
+  const hasWork = deps.hasWork ?? hasOutstandingWork;
+  const wait = deps.wait ?? waitForSubagents;
+  while (hasWork(sessionId, now())) {
+    const remainingMs = deadlineAt - now();
+    if (remainingMs <= 0) {
+      throw new Error(`Auto-drain timed out after ${timeoutMs}ms with background work still active in session '${sessionId}'.`);
+    }
+    const waitResult = await wait({ all: true, timeoutMs: remainingMs }, undefined, {
+      state: deps.state,
+      events: deps.events,
+      now,
+      stopOnAttention: false,
+      failOnFailedRuns: true,
+      failOnAttention: true
+    });
+    if (waitResult.isError) {
+      throw new Error(`Auto-drain failed for session '${sessionId}': ${resultText(waitResult) || "bg_wait returned an error without details"}.`);
+    }
+  }
+}