@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/extension/index.js

@@ -4,46 +4,251 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { keyText } from "@duckmind/dm-coding-agent";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@duckmind/dm-tui";
-import { discoverAgents } from "../agents/agents.js";
+import { discoverAgentSnapshot, discoverAgents } from "../agents/agents.js";
+import { clearRuntimeAgentsForPi, listRuntimeAgentConfigs, mergeRuntimeAgents } from "../agents/runtime-agent-registry.js";
+import { registerRuntimeAgentEventListener } from "../agents/runtime-agent-events.js";
+import { ensureAccessibleDir } from "../shared/accessible-dir.js";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.js";
 import { resolveCurrentSessionId } from "../shared/session-identity.js";
+import { getAgentDir } from "../shared/utils.js";
+import { isStaleExtensionContextError, withCachedUiContext } from "../shared/extension-context.js";
+import { currentCompletionOwnerId } from "../shared/completion-owner.js";
 import { cleanupOldChainDirs } from "../shared/settings.js";
-import { clearLegacyResultAnimationTimer, renderWidget, renderSubagentResult } from "../tui/render.js";
-import { SubagentParams, WaitParams } from "./schemas.js";
+import { clearLegacyResultAnimationTimer, renderSubagentResult, renderSubagentSummary } from "../tui/render.js";
+import { openSubagentFleet } from "../tui/fleet.js";
+import { SubagentFleetStatus, resolveFleetViewPlacement } from "../tui/fleet-status.js";
+import { createSubagentParamsSchema } from "./schemas.js";
 import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
 import { createAsyncJobTracker } from "../runs/background/async-job-tracker.js";
+import { getActiveAsyncCapacitySnapshot, resolveAbandonedSlotReleaseAfterMs, resolveMaxActiveAsyncRunsPerSession } from "../runs/background/active-async-capacity.js";
+import { cleanupResultIndexes, missionObserverResultCandidateFiles } from "../runs/background/result-files.js";
+import { ASYNC_RETENTION_DELAY_MS, cleanupAsyncRetention } from "../runs/background/async-retention.js";
 import { createResultWatcher } from "../runs/background/result-watcher.js";
+import { createResultDeliveryOwnership } from "../runs/background/result-delivery-ownership.js";
 import { createScheduledRunManager } from "../runs/background/scheduled-runs.js";
 import { registerSlashCommands } from "../slash/slash-commands.js";
 import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.js";
+import { registerMainWatchdog } from "../watchdog/register-main.js";
 import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
 import { createNativeSupervisorChannel } from "../intercom/native-supervisor-channel.js";
+import { registerHerdrStatusBridge } from "../integrations/herdr-status.js";
+import { listHerdrProjectPaneRoots, restoreHerdrProjectPaneSnapshots } from "../inspectors/herdr/project-panes.js";
 import { registerSubagentRpcBridge } from "./rpc.js";
 import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots } from "../slash/slash-live-state.js";
-import { waitForSubagents } from "../runs/background/wait.js";
-import registerSubagentNotify from "../runs/background/notify.js";
+import { resolveWaitToolConfig } from "../runs/background/subagent-wait.js";
+import { registerWaitTool } from "../runs/background/wait-tool.js";
+import { createWaitSubscriptionManager } from "../runs/background/wait-subscriptions.js";
+import { drainOutstandingWork } from "../runs/background/auto-drain.js";
+import registerSubagentNotify, { parseSubagentNotifyContent } from "../runs/background/notify.js";
+import { formatSteeringNotice, handleSubagentSteeringNotice, SUBAGENT_STEERING_MESSAGE_TYPE } from "./steering-notices.js";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../runs/shared/dm-args.js";
+import { resolveCurrentSubagentCapabilityCeiling } from "../runs/shared/capability-ceiling.js";
 import { formatDuration, shortenPath } from "../shared/formatters.js";
-import { loadConfig } from "./config.js";
-import { buildSubagentToolDescription } from "./tool-description.js";
+import { applyModelExclusionsConfig, loadConfig, resolveAsyncByDefault, resolveScheduledStoreRoot } from "./config.js";
+import { buildSubagentToolDescription, buildSubagentToolPromptMetadata } from "./tool-description.js";
+import { formatWorkflowPreflightSummary, normalizeWorkflowPreflight } from "../workflows/workflow-preflight.js";
+import { finalizeToolResult } from "./tool-result.js";
+import { collectGoalContinuationNotices } from "../missions/goal-driver.js";
+import { restoreForegroundRunHistory } from "../runs/foreground/foreground-history.js";
+import { resolveMissionStoreLocation } from "../missions/store.js";
+import { listRetainedChildren } from "../runs/background/retained-children.js";
 import {
-  ASYNC_DIR,
+  DIRS,
   DEFAULT_ARTIFACT_CONFIG,
-  RESULTS_DIR,
   SLASH_RESULT_TYPE,
   SLASH_TEXT_RESULT_TYPE,
   SUBAGENT_ASYNC_COMPLETE_EVENT,
   SUBAGENT_ASYNC_STARTED_EVENT,
+  SUBAGENT_PROCESS_TERMINAL_EVENT,
   SUBAGENT_CONTROL_EVENT,
-  WIDGET_KEY
+  SUBAGENT_STEERING_NOTICE_EVENT,
+  WIDGET_KEY,
+  resolveMaxSubagentSpawnsPerSession
 } from "../shared/types.js";
 import {
-  clearPendingForegroundControlNotices,
   formatSubagentControlNotice,
   handleSubagentControlNotice,
   SUBAGENT_CONTROL_MESSAGE_TYPE
 } from "./control-notices.js";
-export { loadConfig } from "./config.js";
+export { loadConfig, resolveAsyncByDefault } from "./config.js";
+const SLOW_RELOAD_PHASE_MS = 250;
+const RUNTIME_REGISTRY_STORE_KEY = "__piSubagentRuntimeRegistry";
+function getRuntimeRegistry() {
+  const globalStore = globalThis;
+  const existing = globalStore[RUNTIME_REGISTRY_STORE_KEY];
+  if (existing?.bySessionManager instanceof WeakMap && existing.activeEntries instanceof Set) {
+    if (!(existing.visibleControlNoticesBySessionManager instanceof WeakMap)) {
+      existing.visibleControlNoticesBySessionManager = new WeakMap;
+    }
+    return existing;
+  }
+  const registry = {
+    bySessionManager: new WeakMap,
+    visibleControlNoticesBySessionManager: new WeakMap,
+    activeEntries: new Set
+  };
+  globalStore[RUNTIME_REGISTRY_STORE_KEY] = registry;
+  return registry;
+}
+function logSlowPhase(label, startedAt) {
+  const elapsed = Date.now() - startedAt;
+  if (elapsed >= SLOW_RELOAD_PHASE_MS)
+    console.error(`Subagent reload phase '${label}' took ${elapsed}ms.`);
+}
+function workflowLaneKeys(script) {
+  const keys = [];
+  const seen = new Set;
+  const add = (key) => {
+    if (!seen.has(key)) {
+      seen.add(key);
+      keys.push(key);
+    }
+  };
+  const isIdentifier = (char) => char !== undefined && /[\w$]/.test(char);
+  const skipTrivia = (start) => {
+    let index = start;
+    while (index < script.length) {
+      if (/\s/.test(script[index]))
+        index += 1;
+      else if (script.startsWith("//", index)) {
+        const end = script.indexOf(`
+`, index + 2);
+        index = end === -1 ? script.length : end + 1;
+      } else if (script.startsWith("/*", index)) {
+        const end = script.indexOf("*/", index + 2);
+        index = end === -1 ? script.length : end + 2;
+      } else
+        break;
+    }
+    return index;
+  };
+  const readLiteral = (start) => {
+    const quote = script[start];
+    if (quote !== "'" && quote !== '"' && quote !== "`")
+      return;
+    let index = start + 1;
+    let dynamicTemplate = false;
+    while (index < script.length) {
+      if (script[index] === "\\") {
+        index += 2;
+        continue;
+      }
+      if (quote === "`" && script.startsWith("${", index))
+        dynamicTemplate = true;
+      if (script[index] === quote)
+        return { key: dynamicTemplate ? undefined : script.slice(start + 1, index), end: index + 1 };
+      if (quote !== "`" && /[\r\n]/.test(script[index]))
+        return { end: index + 1 };
+      index += 1;
+    }
+    return { end: script.length };
+  };
+  const collectRunsAllKeys = (start) => {
+    let index = skipTrivia(start);
+    if (script[index] !== "(")
+      return start;
+    index = skipTrivia(index + 1);
+    if (script[index] !== "[")
+      return start;
+    let arrayDepth = 1;
+    let objectDepth = 0;
+    let directChildObject = false;
+    let expectingElement = true;
+    for (index += 1;index < script.length; index += 1) {
+      index = skipTrivia(index);
+      const literal = readLiteral(index);
+      if (literal) {
+        index = literal.end - 1;
+        continue;
+      }
+      if (script[index] === "[") {
+        arrayDepth += 1;
+        expectingElement = false;
+        continue;
+      }
+      if (script[index] === "]") {
+        arrayDepth -= 1;
+        if (arrayDepth === 0)
+          return index + 1;
+        continue;
+      }
+      if (script[index] === "{") {
+        objectDepth += 1;
+        if (objectDepth === 1)
+          directChildObject = arrayDepth === 1 && expectingElement;
+        expectingElement = false;
+        continue;
+      }
+      if (script[index] === "}") {
+        objectDepth -= 1;
+        if (objectDepth === 0)
+          directChildObject = false;
+        continue;
+      }
+      if (script[index] === "," && arrayDepth === 1 && objectDepth === 0) {
+        expectingElement = true;
+        continue;
+      }
+      if (directChildObject && objectDepth === 1 && !isIdentifier(script[index - 1]) && script.startsWith("key", index) && !isIdentifier(script[index + 3])) {
+        const colon = skipTrivia(index + 3);
+        const key = script[colon] === ":" ? readLiteral(skipTrivia(colon + 1)) : undefined;
+        if (key) {
+          const next = skipTrivia(key.end);
+          if (key.key !== undefined && (script[next] === "," || script[next] === "}"))
+            add(key.key);
+          index = key.end - 1;
+        }
+      }
+    }
+    return index;
+  };
+  for (let index = 0;index < script.length; ) {
+    index = skipTrivia(index);
+    const literal = readLiteral(index);
+    if (literal) {
+      index = literal.end;
+      continue;
+    }
+    if (!isIdentifier(script[index - 1]) && script.startsWith("runs.run", index) && !isIdentifier(script[index + 8])) {
+      const open = skipTrivia(index + 8);
+      const key = script[open] === "(" ? readLiteral(skipTrivia(open + 1)) : undefined;
+      if (key) {
+        const next = skipTrivia(key.end);
+        if (key.key !== undefined && (script[next] === "," || script[next] === ")"))
+          add(key.key);
+        index = key.end;
+        continue;
+      }
+    }
+    if (!isIdentifier(script[index - 1]) && script.startsWith("runs.all", index) && !isIdentifier(script[index + 8])) {
+      index = collectRunsAllKeys(index + 8);
+      continue;
+    }
+    index += 1;
+  }
+  return keys;
+}
+function formatWorkflowPreflightCall(input) {
+  if (input === undefined)
+    return "";
+  try {
+    return formatWorkflowPreflightSummary(normalizeWorkflowPreflight(input));
+  } catch (error) {
+    return `preflight · rejected: ${error instanceof Error ? error.message : String(error)}`;
+  }
+}
+function formatWorkflowManifest(script, async, clarify, preflightInput) {
+  if (clarify === true)
+    return "workflow script · rejected: clarify UI unsupported";
+  const keys = workflowLaneKeys(script);
+  const mode = async === false ? "foreground" : "background";
+  const preflight = formatWorkflowPreflightCall(preflightInput);
+  if (keys.length === 0)
+    return `workflow script · ${mode}${preflight ? ` · ${preflight}` : ""}`;
+  const visibleKeys = keys.slice(0, 4).join(", ");
+  const remainder = keys.length > 4 ? `, +${keys.length - 4}` : "";
+  return `workflow · ${mode} · ${keys.length} lane${keys.length === 1 ? "" : "s"}: ${visibleKeys}${remainder}${preflight ? ` · ${preflight}` : ""}`;
+}
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
     const baseName = path.basename(parentSessionFile, ".jsonl");
@@ -55,100 +260,33 @@ function getSubagentSessionRoot(parentSessionFile) {
 function expandTilde(p) {
   return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : p;
 }
-function ensureAccessibleDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-  try {
-    fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-  } catch {
-    try {
-      fs.rmSync(dirPath, { recursive: true, force: true });
-    } catch {}
-    fs.mkdirSync(dirPath, { recursive: true });
-    fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
-  }
-}
 function isSlashResultRunning(result) {
   return result.details?.progress?.some((entry) => entry.status === "running") || result.details?.results.some((entry) => entry.progress?.status === "running") || false;
 }
-function subagentResultIsRunning(result) {
-  return result.details?.progress?.some((entry) => entry.status === "running") || result.details?.results.some((entry) => entry.progress?.status === "running") || false;
-}
-function ensureSubagentResultAnimation(context) {
-  const state = context.state;
-  if (state.subagentResultAnimationTimer)
-    return;
-  if (typeof context.invalidate !== "function")
-    return;
-  if (state.frame === undefined)
-    state.frame = 0;
-  state.subagentResultAnimationTimer = setInterval(() => {
-    state.frame = ((state.frame ?? 0) + 1) % 10;
-    try {
-      context.invalidate();
-    } catch {}
-  }, 80);
-}
 function isSlashResultError(result) {
   return result.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || false;
 }
-function isStaleExtensionContextError(error) {
-  return error instanceof Error && error.message.includes("Extension context no longer active");
-}
-function rebuildSlashResultContainer(container, result, options, theme) {
+function rebuildSlashResultContainer(container, result, options, theme, rendererConfig, foregroundDetachShortcut) {
   container.clear();
   container.addChild(new Spacer(1));
   const boxTheme = isSlashResultRunning(result) ? "toolPendingBg" : isSlashResultError(result) ? "toolErrorBg" : "toolSuccessBg";
   const box = new Box(1, 1, (text) => theme.bg(boxTheme, text));
-  box.addChild(renderSubagentResult(result, options, theme));
+  box.addChild(renderSubagentResult(result, options, theme, undefined, rendererConfig, foregroundDetachShortcut));
   container.addChild(box);
 }
-function createSlashResultComponent(details, options, theme) {
+function createSlashResultComponent(details, options, theme, rendererConfig, foregroundDetachShortcut) {
   const container = new Container;
   let lastVersion = -1;
   container.render = (width) => {
     const snapshot = getSlashRenderableSnapshot(details);
     if (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) {
       lastVersion = snapshot.version;
-      rebuildSlashResultContainer(container, snapshot.result, options, theme);
+      rebuildSlashResultContainer(container, snapshot.result, options, theme, rendererConfig, foregroundDetachShortcut);
     }
     return Container.prototype.render.call(container, width);
   };
   return container;
 }
-function parseSubagentNotifyContent(content) {
-  const lines = content.split(`
-`);
-  const header = lines[0] ?? "";
-  const match = header.match(/^Background task (completed|failed|paused): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/);
-  if (!match)
-    return;
-  const body = lines.slice(2);
-  let sessionIndex = -1;
-  for (let i = body.length - 1;i >= 1; i--) {
-    if (body[i - 1]?.trim() === "" && /^(Session|Session file|Session share error):\s+/.test(body[i])) {
-      sessionIndex = i;
-      break;
-    }
-  }
-  const sessionLine = sessionIndex >= 0 ? body[sessionIndex] : undefined;
-  const resultLines = sessionIndex >= 0 ? body.slice(0, sessionIndex) : body;
-  const resultPreview = resultLines.join(`
-`).trim() || "(no output)";
-  let sessionLabel;
-  let sessionValue;
-  if (sessionLine) {
-    const separator = sessionLine.indexOf(":");
-    sessionLabel = sessionLine.slice(0, separator).toLowerCase();
-    sessionValue = sessionLine.slice(separator + 1).trim();
-  }
-  return {
-    agent: match[2],
-    status: match[1],
-    ...match[3] ? { taskInfo: match[3] } : {},
-    resultPreview,
-    ...sessionLabel && sessionValue ? { sessionLabel, sessionValue } : {}
-  };
-}
 
 class SubagentControlNoticeComponent {
   details;
@@ -177,39 +315,90 @@ class SubagentControlNoticeComponent {
     return lines;
   }
 }
-export default function registerSubagentExtension(pi) {
+export function projectActiveHerdrRuns(state) {
+  const active = (status) => status === "queued" || status === "running";
+  const foregroundChildrenByWorkflow = new Map;
+  for (const control of state.foregroundControls.values()) {
+    if (!control.parentWorkflowRunId)
+      continue;
+    const children = control.activeChildren?.size ? [...control.activeChildren.values()].map((child) => ({
+      agent: child.agent,
+      needsAttention: child.currentActivityState === "needs_attention"
+    })) : control.currentAgent ? [{ agent: control.currentAgent, needsAttention: control.currentActivityState === "needs_attention" }] : [];
+    if (children.length === 0)
+      continue;
+    const existing = foregroundChildrenByWorkflow.get(control.parentWorkflowRunId) ?? [];
+    existing.push(...children);
+    foregroundChildrenByWorkflow.set(control.parentWorkflowRunId, existing);
+  }
+  return [...state.asyncJobs.values()].filter((job) => active(job.status)).map((job) => {
+    const children = job.mode === "workflow" ? foregroundChildrenByWorkflow.get(job.asyncId) : undefined;
+    const currentStep = job.steps?.find((step) => step.status === "running") ?? (job.currentStep !== undefined ? job.steps?.[job.currentStep] : undefined) ?? job.steps?.find((step) => step.status === "pending");
+    return {
+      id: job.asyncId,
+      agents: children?.length ? children.map((child) => child.agent) : job.agents,
+      ...currentStep?.label ? { taskLabel: currentStep.label } : {},
+      needsAttention: job.activityState === "needs_attention" || children?.some((child) => child.needsAttention)
+    };
+  });
+}
+export default function registerSubagentExtension(dm) {
   if (process.env[SUBAGENT_CHILD_ENV] === "1") {
     return;
   }
-  const globalStore = globalThis;
-  const runtimeCleanupStoreKey = "__piSubagentRuntimeCleanup";
-  const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];
-  if (typeof previousRuntimeCleanup === "function") {
-    try {
-      previousRuntimeCleanup();
-    } catch {}
-  }
-  ensureAccessibleDir(RESULTS_DIR);
-  ensureAccessibleDir(ASYNC_DIR);
+  const runtimeRegistry = getRuntimeRegistry();
+  DIRS.results = ensureAccessibleDir(DIRS.results);
+  DIRS.async = ensureAccessibleDir(DIRS.async);
   cleanupOldChainDirs();
   const config = loadConfig();
-  const asyncByDefault = config.asyncByDefault === true;
+  applyModelExclusionsConfig(config);
+  const waitToolConfig = resolveWaitToolConfig(config.waitTool);
+  const asyncByDefault = resolveAsyncByDefault(config);
+  const fleetViewEnabled = config.fleetView !== false;
+  const fleetViewPlacement = resolveFleetViewPlacement(config.fleetViewPlacement);
+  const asyncWidgetEnabled = config.asyncWidget !== false;
+  const summaryInlineToolDisplay = config.inlineToolDisplay === "summary";
   const tempArtifactsDir = getArtifactsDir(null);
-  cleanupAllArtifactDirs(DEFAULT_ARTIFACT_CONFIG.cleanupDays);
+  const artifactCleanupDays = config.artifactConfig?.cleanupDays ?? DEFAULT_ARTIFACT_CONFIG.cleanupDays;
+  cleanupAllArtifactDirs(artifactCleanupDays);
+  const resultIndexCleanupTimer = setTimeout(() => {
+    try {
+      cleanupResultIndexes(DIRS.results);
+    } catch (error) {
+      console.error("Failed to clean stale subagent result indexes:", error);
+    }
+  }, 30000);
+  resultIndexCleanupTimer.unref?.();
   const state = {
     baseCwd: "",
     currentSessionId: null,
+    statusProjectionSessionId: null,
+    completionOwnerId: currentCompletionOwnerId(),
+    artifactDirPreference: config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir,
+    ...config.authorityPolicy ? { authorityPolicy: config.authorityPolicy } : {},
+    ...config.missions ? { missionStoreConfig: config.missions } : {},
+    parentSessionFile: null,
+    trustedSessionRoots: [],
     subagentInProgress: false,
-    subagentSpawns: { sessionId: null, count: 0 },
+    subagentSpawns: {
+      sessionId: null,
+      count: 0,
+      configuredLimit: resolveMaxSubagentSpawnsPerSession(config.maxSubagentSpawnsPerSession) ?? null,
+      granted: 0,
+      grantHistory: []
+    },
+    activeAsyncCapacity: { used: 0, limit: resolveMaxActiveAsyncRunsPerSession(config.maxActiveAsyncRunsPerSession) ?? 0 },
+    herdrProjectPanes: new Map,
     asyncJobs: new Map,
+    fleetJobs: new Map,
     foregroundRuns: new Map,
     foregroundControls: new Map,
     lastForegroundControlId: null,
-    pendingForegroundControlNotices: new Map,
     cleanupTimers: new Map,
     lastUiContext: null,
     poller: null,
     completionSeen: new Map,
+    widgetsSuspended: false,
     watcher: null,
     watcherRestartTimer: null,
     resultFileCoalescer: {
@@ -217,60 +406,144 @@ export default function registerSubagentExtension(pi) {
       clear: () => {}
     }
   };
-  const supervisorChannel = createNativeSupervisorChannel(pi, state);
-  const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(pi, state, RESULTS_DIR, 10 * 60 * 1000);
-  startResultWatcher();
-  primeExistingResults();
-  const runtimeCleanup = () => {
-    stopResultWatcher();
-    scheduledRunManager.stop();
-    supervisorChannel.dispose();
-    clearPendingForegroundControlNotices(state);
-    if (state.poller) {
-      clearInterval(state.poller);
-      state.poller = null;
-    }
+  const withLastUiContext = (run) => {
+    const cached = state.lastUiContext;
+    return withCachedUiContext(cached, () => {
+      if (state.lastUiContext === cached)
+        state.lastUiContext = null;
+    }, run);
   };
-  globalStore[runtimeCleanupStoreKey] = runtimeCleanup;
-  const { ensurePoller, handleStarted, handleComplete, resetJobs, restoreActiveJobs } = createAsyncJobTracker(pi, state, ASYNC_DIR);
-  let executorExecute;
+  const supervisorChannel = createNativeSupervisorChannel(dm, state);
+  const waitSubscriptionManager = createWaitSubscriptionManager(dm, state);
+  const mainWatchdog = registerMainWatchdog(dm);
+  const resultDeliveryOwnership = createResultDeliveryOwnership(state);
+  const completionNotifier = registerSubagentNotify(dm, state, { batchConfig: config.completionBatch, ownership: resultDeliveryOwnership });
+  const fleetStatus = fleetViewEnabled ? new SubagentFleetStatus(state, async (itemKey) => {
+    const ctx = withLastUiContext((current) => current);
+    if (!ctx)
+      return;
+    try {
+      await openSubagentFleet(ctx, state, { initialKey: itemKey, asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: config.fleetKeybindings });
+    } catch (error) {
+      if (isStaleExtensionContextError(error)) {
+        if (state.lastUiContext === ctx)
+          state.lastUiContext = null;
+        return;
+      }
+      throw error;
+    }
+  }, { placement: fleetViewPlacement }) : undefined;
+  let executorScheduled;
+  let goalTurnId = 0;
+  let parentSessionEnvValue = null;
+  const scheduledStoreRoot = config.scheduledRuns?.storeRoot === undefined ? undefined : resolveScheduledStoreRoot(config.scheduledRuns.storeRoot);
   const scheduledRunManager = createScheduledRunManager({
     config,
+    storeRoot: scheduledStoreRoot,
     launch: (params, ctx, signal) => {
-      if (!executorExecute) {
+      if (!executorScheduled) {
         return Promise.resolve({
           content: [{ type: "text", text: "Scheduled subagent launch is unavailable (executor not ready)." }],
           isError: true,
           details: { mode: "management", results: [] }
         });
       }
-      return executorExecute(randomUUID(), params, signal, undefined, ctx);
-    }
+      return executorScheduled(randomUUID(), params, signal, ctx);
+    },
+    resolveCapabilityCeiling: (sessionId) => resolveCurrentSubagentCapabilityCeiling(sessionId)
+  });
+  let refreshResultDelivery = () => {};
+  const hasResultDeliveryDemand = () => {
+    if ([...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running"))
+      return true;
+    if (state.foregroundControls.size > 0)
+      return true;
+    if (scheduledRunManager.observedCompletionRunIds().size > 0)
+      return true;
+    return missionObserverResultCandidateFiles(DIRS.results).length > 0;
+  };
+  const discoverAgentsForRuntime = (cwd, scope, preferredModelProvider) => {
+    if (listRuntimeAgentConfigs(dm).length === 0)
+      return discoverAgents(cwd, scope, preferredModelProvider);
+    const snapshot = discoverAgentSnapshot(cwd, scope, preferredModelProvider, { includeChains: false });
+    const discovered = snapshot.effective;
+    const all = snapshot.all;
+    const configuredAgents = [
+      ...all.builtin,
+      ...all.package,
+      ...all.user,
+      ...all.project
+    ];
+    const merged = mergeRuntimeAgents(dm, discovered, configuredAgents);
+    if (discovered.maxThinking === undefined)
+      return merged;
+    return {
+      ...merged,
+      agents: merged.agents.map((agent) => agent.maxThinking === discovered.maxThinking ? agent : { ...agent, maxThinking: discovered.maxThinking })
+    };
+  };
+  const { ensurePoller, refreshWidget, handleStarted, handleComplete, resetJobs, restoreActiveJobs, dispose: disposeAsyncJobTracker } = createAsyncJobTracker(dm, state, DIRS.async, {
+    widgetEnabled: asyncWidgetEnabled,
+    onJobTerminal: () => refreshResultDelivery()
   });
+  const resultWatcher = createResultWatcher(dm, state, DIRS.results, 10 * 60 * 1000, {
+    notifier: completionNotifier,
+    ownership: resultDeliveryOwnership,
+    observeCompletion: (result) => scheduledRunManager.handleAsyncCompletion(result),
+    observedCompletionRunIds: () => scheduledRunManager.observedCompletionRunIds(),
+    hasDeliveryDemand: hasResultDeliveryDemand,
+    deliverIntercomResults: config.intercomBridge?.resultDelivery === true,
+    resultScanLogging: config.resultScanLogging
+  });
+  const { startResultWatcher, transitionResultDelivery, primeExistingResults, stopResultWatcher } = resultWatcher;
+  refreshResultDelivery = resultWatcher.refreshResultDelivery;
+  const asyncRetentionAbort = new AbortController;
+  const asyncRetentionTimer = setTimeout(async () => {
+    try {
+      await cleanupAsyncRetention({
+        asyncDirRoot: DIRS.async,
+        resultsDir: DIRS.results,
+        signal: asyncRetentionAbort.signal,
+        protectedRunIds: new Set([
+          ...state.asyncJobs.keys(),
+          ...state.workflowControllers?.keys() ?? [],
+          ...scheduledRunManager.referencedAsyncRunIds()
+        ])
+      });
+    } catch (error) {
+      console.error("Failed to clean retained async subagent state:", error);
+    }
+  }, ASYNC_RETENTION_DELAY_MS);
+  asyncRetentionTimer.unref?.();
   const executor = createSubagentExecutor({
-    pi,
+    dm,
     state,
     config,
     asyncByDefault,
+    waitToolEnabled: waitToolConfig.enabled,
+    waitToolDefaultTimeoutMs: waitToolConfig.defaultTimeoutMs,
     handleScheduledRunAction: (params, ctx) => scheduledRunManager.handleToolCall(params, ctx),
+    watchdog: mainWatchdog,
     tempArtifactsDir,
     getSubagentSessionRoot,
     expandTilde,
-    discoverAgents
+    discoverAgents: discoverAgentsForRuntime,
+    activateSupervisorTransport: () => supervisorChannel.activateTransport(),
+    refreshResultDelivery: () => refreshResultDelivery()
   });
-  executorExecute = executor.execute;
-  pi.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
+  executorScheduled = executor.executeScheduled;
+  dm.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
     const details = resolveSlashMessageDetails(message.details);
     if (!details)
       return;
-    return createSlashResultComponent(details, options, theme);
+    return createSlashResultComponent(details, options, theme, config.mainWindowRenderer, config.foregroundDetachShortcut);
   });
-  pi.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
+  dm.registerMessageRenderer(SLASH_TEXT_RESULT_TYPE, (message, _options, _theme) => {
     const content = typeof message.content === "string" ? message.content : message.content.filter((entry) => entry.type === "text").map((entry) => entry.text).join(`
 `);
     return new Text(content, 0, 0);
   });
-  pi.registerMessageRenderer("subagent-notify", (message, options, theme) => {
+  dm.registerMessageRenderer("subagent-notify", (message, options, theme) => {
     const content = typeof message.content === "string" ? message.content : "";
     const details = message.details ?? parseSubagentNotifyContent(content);
     if (!details)
@@ -297,6 +570,18 @@ export default function registerSubagentExtension(pi) {
       const expandKey = keyText("app.tools.expand");
       text += `
   ${theme.fg("dim", `${expandKey} full notification`)}`;
+    }
+    if (details.workflowRunId) {
+      text += `
+  ${theme.fg("muted", `workflow: ${details.workflowRunId}`)}`;
+    }
+    if (details.childRuns?.length) {
+      text += `
+  ${theme.fg("muted", `children: ${details.childRuns.map((child) => `${child.workflowKey ?? child.agent ?? "child"}=${child.runId}`).join(", ")}`)}`;
+    }
+    if (details.reconciledFromDetachedChild) {
+      text += `
+  ${theme.fg("muted", `reconciled child: ${details.reconciledFromDetachedChild}`)}`;
     }
     if (details.sessionLabel && details.sessionValue) {
       text += `
@@ -304,7 +589,13 @@ export default function registerSubagentExtension(pi) {
     }
     return new Text(text, 0, 0);
   });
-  pi.registerMessageRenderer(SUBAGENT_CONTROL_MESSAGE_TYPE, (message, _options, theme) => {
+  dm.registerMessageRenderer(SUBAGENT_STEERING_MESSAGE_TYPE, (message, _options, theme) => {
+    const details = message.details;
+    if (!details)
+      return;
+    return new Text(theme.fg(details.state === "recovered" ? "warning" : "error", formatSteeringNotice(details)), 0, 0);
+  });
+  dm.registerMessageRenderer(SUBAGENT_CONTROL_MESSAGE_TYPE, (message, _options, theme) => {
     const details = message.details;
     if (!details?.event)
       return;
@@ -314,144 +605,148 @@ export default function registerSubagentExtension(pi) {
   const executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => {
     if (ctx.hasUI)
       ctx.ui.setToolsExpanded(false);
-    return executor.execute(id, params, signal, onUpdate, ctx);
+    return executor.executePublic(id, params, signal, onUpdate, ctx);
   };
   const slashBridge = registerSlashSubagentBridge({
-    events: pi.events,
+    events: dm.events,
     getContext: () => state.lastUiContext,
     execute: (id, params, signal, onUpdate, ctx) => executeSubagentCollapsed(id, params, signal, onUpdate, ctx)
   });
   const promptTemplateBridge = registerPromptTemplateDelegationBridge({
-    events: pi.events,
+    events: dm.events,
     getContext: () => state.lastUiContext,
-    execute: async (requestId, request, signal, ctx, onUpdate) => {
-      if (request.tasks && request.tasks.length > 0) {
-        return executeSubagentCollapsed(requestId, {
-          tasks: request.tasks,
-          context: request.context,
-          cwd: request.cwd,
-          worktree: request.worktree,
-          async: false,
-          clarify: false
-        }, signal, onUpdate, ctx);
-      }
-      return executeSubagentCollapsed(requestId, {
-        agent: request.agent,
-        task: request.task,
-        context: request.context,
-        cwd: request.cwd,
-        model: request.model,
-        async: false,
-        clarify: false
-      }, signal, onUpdate, ctx);
+    execute: (requestId, params, signal, ctx, onUpdate) => executeSubagentCollapsed(requestId, params, signal, onUpdate, ctx),
+    executeStructured: (requestId, params, signal, ctx, onUpdate) => {
+      if (ctx.hasUI)
+        ctx.ui.setToolsExpanded(false);
+      return executor.executeDelegated(requestId, params, signal, onUpdate, ctx);
     }
   });
   const rpcBridge = registerSubagentRpcBridge({
-    events: pi.events,
+    events: dm.events,
     getContext: () => state.lastUiContext,
-    execute: (id, params, signal, onUpdate, ctx) => executor.execute(id, params, signal, onUpdate, ctx)
+    execute: (id, params, signal, onUpdate, ctx) => executor.executePublic(id, params, signal, onUpdate, ctx),
+    state
   });
-  function effectiveParallelTaskCount(tasks) {
-    if (!tasks || tasks.length === 0)
-      return 0;
-    return tasks.reduce((total, task) => {
-      const count = typeof task.count === "number" && Number.isInteger(task.count) && task.count >= 1 ? task.count : 1;
-      return total + count;
-    }, 0);
-  }
+  const parameters = createSubagentParamsSchema();
   const tool = {
     name: "subagent",
     label: "Subagent",
     description: buildSubagentToolDescription(config),
-    parameters: SubagentParams,
-    execute(id, params, signal, onUpdate, ctx) {
-      return executeSubagentCollapsed(id, params, signal, onUpdate, ctx);
+    ...buildSubagentToolPromptMetadata(config),
+    parameters,
+    async execute(id, params, signal, onUpdate, ctx) {
+      return finalizeToolResult(await executeSubagentCollapsed(id, params, signal ?? new AbortController().signal, onUpdate, ctx));
     },
     renderCall(args, theme) {
+      const gap = " ".repeat(config.mainWindowRenderer?.horizontalSpacing ?? 1);
+      const title = theme.fg("toolTitle", theme.bold("subagent"));
       if (args.action) {
-        const target = args.agent || args.chainName || "";
-        return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${args.action}${target ? ` ${theme.fg("accent", target)}` : ""}`, 0, 0);
+        const target = args.agent || "";
+        return new Text(`${title}${gap}${args.action}${target ? `${gap}${theme.fg("accent", target)}` : ""}`, 0, 0);
       }
-      const isParallel = (args.tasks?.length ?? 0) > 0;
-      const parallelCount = effectiveParallelTaskCount(args.tasks);
-      const asyncLabel = args.async === true && args.clarify !== true ? theme.fg("warning", " [async]") : "";
-      if (args.chain?.length)
-        return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}chain (${args.chain.length})${asyncLabel}`, 0, 0);
-      if (isParallel)
-        return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}parallel (${parallelCount})${asyncLabel}`, 0, 0);
-      return new Text(`${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("accent", args.agent || "?")}${asyncLabel}`, 0, 0);
+      if (args.workflowScript)
+        return new Text(`${title}${gap}${formatWorkflowManifest(args.workflowScript, args.async, false, args.preflight)}`, 0, 0);
+      if (args.workflowScriptPath)
+        return new Text(`${title}${gap}${theme.fg("accent", args.workflowScriptPath)}${args.async === true ? `${gap}${theme.fg("warning", "[async]")}` : ""}${args.preflight !== undefined ? `${gap}${theme.fg("dim", formatWorkflowPreflightCall(args.preflight))}` : ""}`, 0, 0);
+      const asyncLabel = args.async === true ? `${gap}${theme.fg("warning", "[async]")}` : "";
+      return new Text(`${title}${gap}${theme.fg("accent", args.agent || "?")}${asyncLabel}`, 0, 0);
     },
     renderResult(result, options, theme, context) {
-      if (subagentResultIsRunning(result)) {
-        ensureSubagentResultAnimation(context);
-      } else {
-        clearLegacyResultAnimationTimer(context);
-      }
-      const frame = context.state?.frame ?? 0;
-      return renderSubagentResult(result, options, theme, frame);
+      clearLegacyResultAnimationTimer(context);
+      const renderedResult = { ...result, isError: context.isError };
+      return summaryInlineToolDisplay ? renderSubagentSummary(renderedResult, options, theme) : renderSubagentResult(renderedResult, options, theme, undefined, config.mainWindowRenderer, config.foregroundDetachShortcut);
     }
   };
-  pi.registerTool(tool);
-  const waitTool = {
-    name: "wait",
-    label: "Wait",
-    description: `Block until background (async) subagent runs started in this session finish, then return.
-
-Use this after launching async subagents when you have no independent work left and must not end your turn — for example inside a skill that has to run to completion, or any non-interactive run (\`dm --print ...\`) where the whole task is a single turn and ending it would abandon the still-running children.
-
-• { } — return as soon as the FIRST active run finishes (default). Ideal for a rolling fleet: launch N, wait, spawn a replacement for the one that finished, wait again — keeping N in flight.
-• { all: true } — block until EVERY active run in this session is finished.
-• { id: "..." } — wait for one specific run (id or prefix) to finish.
-• { timeoutMs: 600000 } — stop waiting after N ms (the runs keep going regardless; default 30 min)
-
-wait also returns when a run needs attention (a child that went idle or blocked for a decision), not only on completion — so a stuck child never stalls the loop; the summary names the run(s) to inspect/nudge/resume/interrupt. It wakes the instant a completion or control event arrives (subscribed to DM's event bus, with a poll fallback that reconciles crashed runners), keeps the turn alive for normal notification delivery, and resolves early if the turn is aborted.`,
-    parameters: WaitParams,
-    execute(_id, params, signal, _onUpdate, _ctx) {
-      return waitForSubagents(params, signal, { state, events: pi.events });
+  dm.registerTool(tool);
+  registerWaitTool(dm, state, waitToolConfig.enabled, waitSubscriptionManager, waitToolConfig.defaultTimeoutMs);
+  dm.on("agent_end", async (_event, ctx) => {
+    if (!ctx.hasUI)
+      await drainOutstandingWork({ state, events: dm.events });
+    const ownerSessionId = state.currentSessionId;
+    if (!ownerSessionId)
+      return;
+    goalTurnId += 1;
+    try {
+      const location = resolveMissionStoreLocation({ projectRoot: state.baseCwd, ...config.missions ? { config: config.missions } : {} });
+      const retainedChildren = listRetainedChildren(DIRS.async, ownerSessionId);
+      for (const notice of collectGoalContinuationNotices({ location, ownerSessionId, retainedChildren, turnId: goalTurnId })) {
+        handleSubagentControlNotice({
+          dm,
+          state,
+          visibleControlNotices: new Set,
+          details: { source: "goal", event: notice.event, noticeText: notice.message }
+        });
+      }
+    } catch (error) {
+      console.error("Failed to evaluate goal missions:", error);
     }
-  };
-  pi.registerTool(waitTool);
-  registerSlashCommands(pi, state);
-  const eventUnsubscribeStoreKey = "__piSubagentEventUnsubscribes";
-  const controlNoticeSeenStoreKey = "__piSubagentVisibleControlNotices";
-  const previousEventUnsubscribes = globalStore[eventUnsubscribeStoreKey];
-  if (Array.isArray(previousEventUnsubscribes)) {
-    for (const unsubscribe of previousEventUnsubscribes) {
-      if (typeof unsubscribe !== "function")
-        continue;
-      try {
-        unsubscribe();
-      } catch {}
+  });
+  const disposeSlashCommands = registerSlashCommands(dm, state, {
+    fleetKeybindings: config.fleetKeybindings,
+    foregroundDetachShortcut: config.foregroundDetachShortcut
+  });
+  let visibleControlNotices = new Set;
+  const activeHerdrRuns = () => projectActiveHerdrRuns(state);
+  const herdrStatusBridge = registerHerdrStatusBridge({
+    events: dm.events,
+    getRuns: activeHerdrRuns,
+    getProjectPaneCount: () => [...state.herdrProjectPanes?.values() ?? []].filter((pane) => pane.state === "open").length,
+    async runHerdr(args) {
+      await dm.exec(process.env.HERDR_BIN || "herdr", [...args], { timeout: 5000 });
     }
-  }
-  registerSubagentNotify(pi, state, { batchConfig: config.completionBatch });
-  const existingVisibleControlNotices = globalStore[controlNoticeSeenStoreKey];
-  const visibleControlNotices = existingVisibleControlNotices instanceof Set ? existingVisibleControlNotices : new Set;
-  globalStore[controlNoticeSeenStoreKey] = visibleControlNotices;
+  });
   const controlEventHandler = (payload) => {
     handleSubagentControlNotice({
-      pi,
+      dm,
       state,
       visibleControlNotices,
       details: payload
     });
   };
+  const steeringNoticeHandler = (payload) => {
+    handleSubagentSteeringNotice({ dm, state, details: payload });
+  };
+  const asyncStartedHandler = (payload) => {
+    handleStarted(payload);
+    supervisorChannel.activateTransport();
+    refreshResultDelivery();
+    fleetStatus?.refresh();
+  };
+  const asyncCompleteHandler = (payload) => {
+    handleComplete(payload);
+    refreshResultDelivery();
+    refreshActiveAsyncCapacity();
+    scheduledRunManager.handleAsyncCompletion(payload);
+    fleetStatus?.refresh();
+  };
   const eventUnsubscribes = [
-    pi.events.on(SUBAGENT_ASYNC_STARTED_EVENT, handleStarted),
-    pi.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, handleComplete),
-    pi.events.on(SUBAGENT_CONTROL_EVENT, controlEventHandler),
+    registerRuntimeAgentEventListener(dm),
+    dm.events.on(SUBAGENT_ASYNC_STARTED_EVENT, asyncStartedHandler),
+    dm.events.on(SUBAGENT_ASYNC_COMPLETE_EVENT, asyncCompleteHandler),
+    dm.events.on(SUBAGENT_PROCESS_TERMINAL_EVENT, () => {
+      refreshActiveAsyncCapacity();
+      fleetStatus?.refresh();
+    }),
+    dm.events.on(SUBAGENT_CONTROL_EVENT, controlEventHandler),
+    dm.events.on(SUBAGENT_STEERING_NOTICE_EVENT, steeringNoticeHandler),
+    herdrStatusBridge.dispose,
     rpcBridge.dispose
   ];
-  globalStore[eventUnsubscribeStoreKey] = eventUnsubscribes;
-  pi.on("tool_result", (event, ctx) => {
+  dm.on("tool_result", (event, ctx) => {
     if (event.toolName !== "subagent")
       return;
     if (!ctx.hasUI)
       return;
     state.lastUiContext = ctx;
+    const activeJobCount = state.asyncJobs.size;
+    restoreActiveJobs(ctx);
+    if (state.asyncJobs.size > activeJobCount)
+      herdrStatusBridge.syncRuns();
+    fleetStatus?.setContext(ctx);
+    fleetStatus?.refresh();
     if (state.asyncJobs.size > 0) {
-      renderWidget(ctx, Array.from(state.asyncJobs.values()));
-      ctx.ui.requestRender?.();
+      refreshWidget(ctx);
       ensurePoller();
     }
   });
@@ -459,71 +754,222 @@ wait also returns when a run needs attention (a child that went idle or blocked
     try {
       const sessionFile = ctx.sessionManager.getSessionFile();
       if (sessionFile) {
-        cleanupOldArtifacts(getArtifactsDir(sessionFile), DEFAULT_ARTIFACT_CONFIG.cleanupDays);
+        cleanupOldArtifacts(getArtifactsDir(sessionFile), artifactCleanupDays);
       }
     } catch {}
   };
-  const resetSessionState = (ctx) => {
+  const suspendWidgetsForCompaction = () => {
+    if (state.widgetsSuspended)
+      return;
+    state.widgetsSuspended = true;
+    withLastUiContext((ctx) => ctx.ui.setWidget(WIDGET_KEY, undefined));
+    fleetStatus?.refresh();
+  };
+  const resumeWidgetsAfterCompaction = () => {
+    if (!state.widgetsSuspended)
+      return;
+    state.widgetsSuspended = false;
+    withLastUiContext((ctx) => refreshWidget(ctx));
+    fleetStatus?.refresh();
+  };
+  const refreshActiveAsyncCapacity = () => {
+    if (!state.currentSessionId) {
+      state.activeAsyncCapacity = { used: 0, limit: resolveMaxActiveAsyncRunsPerSession(config.maxActiveAsyncRunsPerSession) ?? 0 };
+      return;
+    }
+    state.activeAsyncCapacity = getActiveAsyncCapacitySnapshot(state.currentSessionId, resolveMaxActiveAsyncRunsPerSession(config.maxActiveAsyncRunsPerSession), { liveWorkflowRunIds: new Set(state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(config.capacity?.abandonedSlotReleaseAfterMs) });
+  };
+  const resetSessionState = (ctx, recovering, previousSessionFile) => {
+    state.widgetsSuspended = false;
     state.baseCwd = ctx.cwd;
+    goalTurnId = 0;
+    const previousRuntimeSessionId = state.currentSessionId;
+    resultDeliveryOwnership.claimPredecessor(previousSessionFile, previousRuntimeSessionId);
     state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
-    state.subagentSpawns = { sessionId: state.currentSessionId, count: 0 };
+    transitionResultDelivery();
+    state.parentSessionFile = ctx.sessionManager.getSessionFile();
+    state.trustedSessionFileRoot = state.parentSessionFile ? path.join(getAgentDir(), "sessions") : undefined;
+    state.trustedSessionRoots = [...new Set([
+      ...config.defaultSessionDir ? [path.resolve(expandTilde(config.defaultSessionDir))] : [],
+      ...state.parentSessionFile ? [getSubagentSessionRoot(state.parentSessionFile)] : []
+    ])];
+    state.subagentSpawns = {
+      sessionId: state.currentSessionId,
+      count: 0,
+      configuredLimit: resolveMaxSubagentSpawnsPerSession(config.maxSubagentSpawnsPerSession) ?? null,
+      granted: 0,
+      grantHistory: []
+    };
+    const projectPaneOwnerRoot = path.resolve(ctx.cwd);
+    restoreHerdrProjectPaneSnapshots(state, [...new Set([...state.herdrProjectPanes?.keys() ?? [], ...listHerdrProjectPaneRoots(projectPaneOwnerRoot), projectPaneOwnerRoot])]);
     if (!process.env[SUBAGENT_CHILD_ENV]) {
       const sessionId = ctx.sessionManager.getSessionId();
       if (sessionId) {
         process.env[SUBAGENT_PARENT_SESSION_ENV] = sessionId;
+        parentSessionEnvValue = sessionId;
       }
     }
     state.lastUiContext = ctx;
+    let phaseStartedAt = Date.now();
+    refreshActiveAsyncCapacity();
+    logSlowPhase("active-capacity", phaseStartedAt);
+    phaseStartedAt = Date.now();
     cleanupSessionArtifacts(ctx);
-    clearPendingForegroundControlNotices(state);
+    logSlowPhase("session-artifact-cleanup", phaseStartedAt);
+    state.foregroundControls.clear();
+    state.lastForegroundControlId = null;
+    phaseStartedAt = Date.now();
     resetJobs(ctx);
+    logSlowPhase("reset-jobs", phaseStartedAt);
+    phaseStartedAt = Date.now();
+    restoreForegroundRunHistory(state, { resultsDir: DIRS.results });
+    logSlowPhase("foreground-history", phaseStartedAt);
+    phaseStartedAt = Date.now();
     restoreActiveJobs(ctx);
+    logSlowPhase("active-job-restore", phaseStartedAt);
+    phaseStartedAt = Date.now();
     scheduledRunManager.bindSession(ctx);
+    logSlowPhase("scheduled-runs", phaseStartedAt);
+    phaseStartedAt = Date.now();
     restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
-    primeExistingResults();
+    logSlowPhase("slash-snapshots", phaseStartedAt);
+    phaseStartedAt = Date.now();
+    waitSubscriptionManager.restore();
+    logSlowPhase("wait-subscriptions", phaseStartedAt);
+    phaseStartedAt = Date.now();
+    startResultWatcher();
+    logSlowPhase("result-watcher-start", phaseStartedAt);
+    phaseStartedAt = Date.now();
+    primeExistingResults({ triggerTurn: !recovering });
+    logSlowPhase("result-prime", phaseStartedAt);
+    fleetStatus?.setContext(ctx);
   };
-  pi.on("session_start", (_event, ctx) => {
-    resetSessionState(ctx);
-    rpcBridge.emitReady(ctx);
-    supervisorChannel.start();
-  });
-  pi.on("session_shutdown", () => {
-    delete process.env[SUBAGENT_PARENT_SESSION_ENV];
-    for (const unsubscribe of eventUnsubscribes) {
+  let runtimeCleaned = false;
+  const runtimeEntry = {
+    sessionManager: null,
+    visibleControlNotices,
+    cleanup() {
+      if (runtimeCleaned)
+        return;
+      runtimeCleaned = true;
+      const shuttingDownParentSession = parentSessionEnvValue;
+      for (const controller of state.workflowControllers?.values() ?? []) {
+        if (!controller.signal.aborted)
+          controller.abort(new Error("Workflow stopped because the extension session was replaced or reloaded."));
+      }
+      state.workflowControllers?.clear();
+      state.workflowChildStops?.clear();
+      clearRuntimeAgentsForPi(dm);
+      clearTimeout(resultIndexCleanupTimer);
+      clearTimeout(asyncRetentionTimer);
+      asyncRetentionAbort.abort();
+      stopResultWatcher();
+      resultDeliveryOwnership.clear();
+      completionNotifier.dispose();
+      mainWatchdog.dispose();
+      scheduledRunManager.stop();
+      supervisorChannel.dispose();
+      waitSubscriptionManager.dispose();
+      fleetStatus?.dispose();
+      disposeAsyncJobTracker();
+      for (const timer of state.cleanupTimers.values())
+        clearTimeout(timer);
+      state.cleanupTimers.clear();
+      state.asyncJobs.clear();
+      for (const unsubscribe of eventUnsubscribes) {
+        try {
+          unsubscribe();
+        } catch {}
+      }
+      disposeSlashCommands.dispose();
+      slashBridge.cancelAll();
+      slashBridge.dispose();
+      promptTemplateBridge.cancelAll();
+      promptTemplateBridge.dispose();
+      state.widgetsSuspended = false;
+      state.currentSessionId = null;
+      state.statusProjectionSessionId = null;
+      state.parentSessionFile = null;
+      parentSessionEnvValue = null;
+      if (shuttingDownParentSession && process.env[SUBAGENT_PARENT_SESSION_ENV] === shuttingDownParentSession) {
+        delete process.env[SUBAGENT_PARENT_SESSION_ENV];
+      }
+      if (runtimeEntry.sessionManager && runtimeRegistry.bySessionManager.get(runtimeEntry.sessionManager) === runtimeEntry) {
+        runtimeRegistry.bySessionManager.delete(runtimeEntry.sessionManager);
+      }
+      runtimeRegistry.activeEntries.delete(runtimeEntry);
+      if (runtimeRegistry.activeEntries.size === 0)
+        clearSlashSnapshots();
       try {
-        unsubscribe();
-      } catch {}
+        if (state.lastUiContext?.hasUI)
+          state.lastUiContext.ui.setWidget(WIDGET_KEY, undefined);
+      } catch (error) {
+        if (!isStaleExtensionContextError(error))
+          throw error;
+      }
+      state.lastUiContext = null;
     }
-    if (globalStore[eventUnsubscribeStoreKey] === eventUnsubscribes) {
-      delete globalStore[eventUnsubscribeStoreKey];
-    }
-    stopResultWatcher();
-    scheduledRunManager.stop();
-    if (state.poller)
-      clearInterval(state.poller);
-    state.poller = null;
-    clearPendingForegroundControlNotices(state);
-    for (const timer of state.cleanupTimers.values()) {
-      clearTimeout(timer);
-    }
-    state.cleanupTimers.clear();
-    state.asyncJobs.clear();
-    clearSlashSnapshots();
-    slashBridge.cancelAll();
-    slashBridge.dispose();
-    promptTemplateBridge.cancelAll();
-    promptTemplateBridge.dispose();
-    supervisorChannel.dispose();
-    if (globalStore[runtimeCleanupStoreKey] === runtimeCleanup) {
-      delete globalStore[runtimeCleanupStoreKey];
+  };
+  const installRuntime = (ctx) => {
+    if (runtimeCleaned) {
+      throw new Error("Cannot restart a cleaned dm-subagents extension runtime; register a new extension instance.");
     }
-    try {
-      if (state.lastUiContext?.hasUI) {
-        state.lastUiContext.ui.setWidget(WIDGET_KEY, undefined);
-      }
-    } catch (error) {
-      if (!isStaleExtensionContextError(error))
-        throw error;
+    const sessionManager = ctx.sessionManager;
+    const previousRuntime = runtimeRegistry.bySessionManager.get(sessionManager);
+    const existingVisibleControlNotices = runtimeRegistry.visibleControlNoticesBySessionManager.get(sessionManager);
+    if (existingVisibleControlNotices) {
+      visibleControlNotices = existingVisibleControlNotices;
+    } else {
+      runtimeRegistry.visibleControlNoticesBySessionManager.set(sessionManager, visibleControlNotices);
     }
+    runtimeEntry.visibleControlNotices = visibleControlNotices;
+    if (runtimeEntry.sessionManager && runtimeEntry.sessionManager !== sessionManager && runtimeRegistry.bySessionManager.get(runtimeEntry.sessionManager) === runtimeEntry) {
+      runtimeRegistry.bySessionManager.delete(runtimeEntry.sessionManager);
+    }
+    runtimeEntry.sessionManager = sessionManager;
+    runtimeRegistry.bySessionManager.set(sessionManager, runtimeEntry);
+    runtimeRegistry.activeEntries.add(runtimeEntry);
+    if (previousRuntime && previousRuntime !== runtimeEntry) {
+      try {
+        previousRuntime.cleanup();
+      } catch {}
+    }
+  };
+  dm.on("agent_start", () => {
+    resumeWidgetsAfterCompaction();
+    herdrStatusBridge.agentStarted();
+  });
+  dm.on("agent_end", () => {
+    resumeWidgetsAfterCompaction();
+  });
+  dm.on("session_before_compact", (event) => {
+    if (event.reason !== "manual")
+      suspendWidgetsForCompaction();
+  });
+  dm.on("session_compact", () => {
+    const hasActiveAsyncWork = [...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running");
+    if (!hasActiveAsyncWork || !withLastUiContext(() => true))
+      return;
+    dm.sendMessage({
+      customType: "subagent-compaction-resume",
+      content: "Compaction is complete. Resume the parent task now; background subagent results will arrive separately when ready.",
+      display: false
+    }, { triggerTurn: true });
+  });
+  dm.on("session_start", (event, ctx) => {
+    installRuntime(ctx);
+    const recovering = event.reason === "startup" || event.reason === "reload" || event.reason === "resume";
+    resetSessionState(ctx, recovering, event.previousSessionFile);
+    herdrStatusBridge.sessionStarted({
+      hasUI: ctx.hasUI === true,
+      runs: activeHerdrRuns()
+    });
+    rpcBridge.emitReady(ctx);
+    supervisorChannel.start();
+    supervisorChannel.activateTransport();
+  });
+  dm.on("session_shutdown", async () => {
+    runtimeEntry.cleanup();
+    await herdrStatusBridge.flush();
   });
 }