@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

@@ -4,7 +4,9 @@ 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 { discoverAgentSnapshot, discoverAgents } from "../agents/agents.js";
+import { clearAgentDiscoveryCache, discoverAgentSnapshot, discoverAgents, discoverAgentsAll } from "../agents/agents.js";
+import { resolveGlobalNpmRoot } from "../agents/global-npm-root.js";
+import { appendAdvertisedAgentPrompt, buildAdvertisedAgentPrompt } from "../agents/advertised-agent-prompt.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";
@@ -14,8 +16,9 @@ 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, renderSubagentResult, renderSubagentSummary } from "../tui/render.js";
+import { clearLegacyResultAnimationTimer, renderSubagentResult, renderSubagentSummary, setInlineWorkflowCoverage } from "../tui/render.js";
 import { openSubagentFleet } from "../tui/fleet.js";
+import { createBuiltinInspectorPlugins } from "../inspectors/plugins.js";
 import { SubagentFleetStatus, resolveFleetViewPlacement } from "../tui/fleet-status.js";
 import { createSubagentParamsSchema } from "./schemas.js";
 import { createSubagentExecutor } from "../runs/foreground/subagent-executor.js";
@@ -31,20 +34,30 @@ import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template
 import { registerMainWatchdog } from "../watchdog/register-main.js";
 import { registerSlashSubagentBridge } from "../slash/slash-bridge.js";
 import { createNativeSupervisorChannel } from "../intercom/native-supervisor-channel.js";
+import {
+  renderSupervisorReply,
+  renderSupervisorRequest,
+  SUPERVISOR_REPLY_ENTRY_TYPE,
+  SUPERVISOR_REQUEST_MESSAGE_TYPE
+} from "../intercom/supervisor-ui.js";
 import { registerHerdrStatusBridge } from "../integrations/herdr-status.js";
+import { hasLiveSubagentWork, registerPiWebSessionLiveness } from "../integrations/dm-web-session-liveness.js";
+import { createRetainedNestedRouteTracker } from "../runs/background/retained-nested-route-tracker.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 { resolveWaitToolConfig } from "../runs/background/subagent-wait.js";
 import { registerWaitTool } from "../runs/background/wait-tool.js";
+import { registerSubagentToolActivation } from "./tool-activation.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 { SUBAGENT_CHILD_ENV, SUBAGENT_PARENT_SESSION_ENV } from "../runs/shared/child-runtime-config.js";
+import { disposeChildSessions } from "../runs/shared/child-session.js";
 import { resolveCurrentSubagentCapabilityCeiling } from "../runs/shared/capability-ceiling.js";
 import { formatDuration, shortenPath } from "../shared/formatters.js";
-import { applyModelExclusionsConfig, loadConfig, resolveAsyncByDefault, resolveScheduledStoreRoot } from "./config.js";
+import { 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";
@@ -274,14 +287,17 @@ function rebuildSlashResultContainer(container, result, options, theme, renderer
   box.addChild(renderSubagentResult(result, options, theme, undefined, rendererConfig, foregroundDetachShortcut));
   container.addChild(box);
 }
-function createSlashResultComponent(details, options, theme, rendererConfig, foregroundDetachShortcut) {
+function createSlashResultComponent(details, options, theme, rendererConfig, foregroundDetachShortcut, getCurrentTheme = () => theme) {
   const container = new Container;
   let lastVersion = -1;
+  let lastTheme;
   container.render = (width) => {
     const snapshot = getSlashRenderableSnapshot(details);
-    if (snapshot.version !== lastVersion || isSlashResultRunning(snapshot.result)) {
+    const currentTheme = getCurrentTheme();
+    if (snapshot.version !== lastVersion || currentTheme !== lastTheme || isSlashResultRunning(snapshot.result)) {
       lastVersion = snapshot.version;
-      rebuildSlashResultContainer(container, snapshot.result, options, theme, rendererConfig, foregroundDetachShortcut);
+      lastTheme = currentTheme;
+      rebuildSlashResultContainer(container, snapshot.result, options, currentTheme, rendererConfig, foregroundDetachShortcut);
     }
     return Container.prototype.render.call(container, width);
   };
@@ -351,7 +367,6 @@ export default function registerSubagentExtension(dm) {
   DIRS.async = ensureAccessibleDir(DIRS.async);
   cleanupOldChainDirs();
   const config = loadConfig();
-  applyModelExclusionsConfig(config);
   const waitToolConfig = resolveWaitToolConfig(config.waitTool);
   const asyncByDefault = resolveAsyncByDefault(config);
   const fleetViewEnabled = config.fleetView !== false;
@@ -361,14 +376,7 @@ export default function registerSubagentExtension(dm) {
   const tempArtifactsDir = getArtifactsDir(null);
   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?.();
+  let resultIndexCleanupTimer;
   const state = {
     baseCwd: "",
     currentSessionId: null,
@@ -413,17 +421,20 @@ export default function registerSubagentExtension(dm) {
         state.lastUiContext = null;
     }, run);
   };
-  const supervisorChannel = createNativeSupervisorChannel(dm, state);
+  const supervisorChannel = createNativeSupervisorChannel(dm, state, {
+    getCurrentOwnerStates: () => executor.getCurrentSupervisorOwnerStates()
+  });
   const waitSubscriptionManager = createWaitSubscriptionManager(dm, state);
   const mainWatchdog = registerMainWatchdog(dm);
   const resultDeliveryOwnership = createResultDeliveryOwnership(state);
   const completionNotifier = registerSubagentNotify(dm, state, { batchConfig: config.completionBatch, ownership: resultDeliveryOwnership });
+  let retainedNestedRouteTracker;
   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 });
+      await openSubagentFleet(ctx, state, { initialKey: itemKey, asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: config.fleetKeybindings, inspectorPlugins: createBuiltinInspectorPlugins() });
     } catch (error) {
       if (isStaleExtensionContextError(error)) {
         if (state.lastUiContext === ctx)
@@ -432,27 +443,72 @@ export default function registerSubagentExtension(dm) {
       }
       throw error;
     }
-  }, { placement: fleetViewPlacement }) : undefined;
+  }, { placement: fleetViewPlacement, onWorkflowCoverageChange: setInlineWorkflowCoverage }) : undefined;
   let executorScheduled;
   let goalTurnId = 0;
-  let parentSessionEnvValue = null;
+  let releaseHostSessionLiveness = () => {};
   const scheduledStoreRoot = config.scheduledRuns?.storeRoot === undefined ? undefined : resolveScheduledStoreRoot(config.scheduledRuns.storeRoot);
   const scheduledRunManager = createScheduledRunManager({
     config,
     storeRoot: scheduledStoreRoot,
-    launch: (params, ctx, signal) => {
+    launch: async (params, ctx, signal) => {
       if (!executorScheduled) {
-        return Promise.resolve({
+        return {
           content: [{ type: "text", text: "Scheduled subagent launch is unavailable (executor not ready)." }],
           isError: true,
           details: { mode: "management", results: [] }
-        });
+        };
       }
+      await waitForAdvertisement();
       return executorScheduled(randomUUID(), params, signal, ctx);
     },
     resolveCapabilityCeiling: (sessionId) => resolveCurrentSubagentCapabilityCeiling(sessionId)
   });
   let refreshResultDelivery = () => {};
+  let advertisedAgents = [];
+  let advertisedContext;
+  let advertisementGeneration = 0;
+  let globalRoot = null;
+  let advertisementReady = Promise.resolve();
+  let notifySessionChange = () => {};
+  let sessionChanged = Promise.resolve();
+  const waitForAdvertisement = async () => {
+    let pending;
+    do {
+      pending = advertisementReady;
+      const result = await Promise.race([pending, sessionChanged]);
+      if (pending === advertisementReady && result)
+        throw result.error;
+    } while (pending !== advertisementReady);
+  };
+  const refreshAdvertisedAgents = () => {
+    advertisedAgents = [];
+    if (!advertisedContext)
+      return;
+    clearAgentDiscoveryCache();
+    advertisedAgents = discoverAgents(advertisedContext.cwd, "both", advertisedContext.model?.provider, { globalNpmRoot: globalRoot }).agents.filter((agent) => agent.advertise === true);
+  };
+  const beginAdvertisement = (ctx) => {
+    const generation = ++advertisementGeneration;
+    notifySessionChange();
+    sessionChanged = new Promise((resolve) => {
+      notifySessionChange = resolve;
+    });
+    advertisedAgents = [];
+    advertisedContext = { cwd: ctx.cwd, model: ctx.model };
+    globalRoot = null;
+    advertisementReady = resolveGlobalNpmRoot().catch(() => null).then((root) => {
+      if (generation !== advertisementGeneration)
+        return;
+      globalRoot = root;
+      refreshAdvertisedAgents();
+    }).catch((error) => {
+      if (generation !== advertisementGeneration)
+        return;
+      console.error("Failed to refresh advertised agents:", error);
+      return { error };
+    });
+  };
   const hasResultDeliveryDemand = () => {
     if ([...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running"))
       return true;
@@ -464,8 +520,8 @@ export default function registerSubagentExtension(dm) {
   };
   const discoverAgentsForRuntime = (cwd, scope, preferredModelProvider) => {
     if (listRuntimeAgentConfigs(dm).length === 0)
-      return discoverAgents(cwd, scope, preferredModelProvider);
-    const snapshot = discoverAgentSnapshot(cwd, scope, preferredModelProvider, { includeChains: false });
+      return discoverAgents(cwd, scope, preferredModelProvider, { globalNpmRoot: globalRoot });
+    const snapshot = discoverAgentSnapshot(cwd, scope, preferredModelProvider, { includeChains: false, globalNpmRoot: globalRoot });
     const discovered = snapshot.effective;
     const all = snapshot.all;
     const configuredAgents = [
@@ -474,7 +530,7 @@ export default function registerSubagentExtension(dm) {
       ...all.user,
       ...all.project
     ];
-    const merged = mergeRuntimeAgents(dm, discovered, configuredAgents);
+    const merged = mergeRuntimeAgents(dm, discovered, configuredAgents, { cwd, scope, preferredModelProvider });
     if (discovered.maxThinking === undefined)
       return merged;
     return {
@@ -484,7 +540,8 @@ export default function registerSubagentExtension(dm) {
   };
   const { ensurePoller, refreshWidget, handleStarted, handleComplete, resetJobs, restoreActiveJobs, dispose: disposeAsyncJobTracker } = createAsyncJobTracker(dm, state, DIRS.async, {
     widgetEnabled: asyncWidgetEnabled,
-    onJobTerminal: () => refreshResultDelivery()
+    onJobTerminal: () => refreshResultDelivery(),
+    supervisorRequestState: supervisorChannel.getSupervisorRequestState
   });
   const resultWatcher = createResultWatcher(dm, state, DIRS.results, 10 * 60 * 1000, {
     notifier: completionNotifier,
@@ -498,24 +555,40 @@ export default function registerSubagentExtension(dm) {
   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);
+  let asyncRetentionTimer;
+  const startSessionMaintenance = () => {
+    if (!resultIndexCleanupTimer) {
+      resultIndexCleanupTimer = setTimeout(() => {
+        try {
+          cleanupResultIndexes(DIRS.results);
+        } catch (error) {
+          console.error("Failed to clean stale subagent result indexes:", error);
+        }
+      }, 30000);
+      resultIndexCleanupTimer.unref?.();
     }
-  }, ASYNC_RETENTION_DELAY_MS);
-  asyncRetentionTimer.unref?.();
-  const executor = createSubagentExecutor({
+    waitSubscriptionManager.start();
+    if (!asyncRetentionTimer) {
+      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 executorDeps = {
     dm,
     state,
     config,
@@ -528,15 +601,31 @@ export default function registerSubagentExtension(dm) {
     getSubagentSessionRoot,
     expandTilde,
     discoverAgents: discoverAgentsForRuntime,
+    discoverAgentsAll: (cwd, provider) => discoverAgentsAll(cwd, provider, { globalNpmRoot: globalRoot }),
+    onAgentsChanged: () => {
+      try {
+        refreshAdvertisedAgents();
+      } catch (error) {
+        console.error("Failed to refresh advertised agents; catalog withdrawn until refresh:", error);
+      }
+    },
     activateSupervisorTransport: () => supervisorChannel.activateTransport(),
-    refreshResultDelivery: () => refreshResultDelivery()
-  });
+    findPendingAsks: (target) => supervisorChannel.findPendingAsks(target),
+    refreshResultDelivery: () => refreshResultDelivery(),
+    trackRetainedNestedRoute: undefined
+  };
+  const executor = createSubagentExecutor(executorDeps);
   executorScheduled = executor.executeScheduled;
+  dm.registerMessageRenderer(SUPERVISOR_REQUEST_MESSAGE_TYPE, renderSupervisorRequest);
+  const registerEntryRenderer = dm.registerEntryRenderer;
+  if (typeof registerEntryRenderer === "function") {
+    registerEntryRenderer.call(dm, SUPERVISOR_REPLY_ENTRY_TYPE, renderSupervisorReply);
+  }
   dm.registerMessageRenderer(SLASH_RESULT_TYPE, (message, options, theme) => {
     const details = resolveSlashMessageDetails(message.details);
     if (!details)
       return;
-    return createSlashResultComponent(details, options, theme, config.mainWindowRenderer, config.foregroundDetachShortcut);
+    return createSlashResultComponent(details, options, theme, config.mainWindowRenderer, config.foregroundDetachShortcut, () => state.lastUiContext?.ui.theme ?? 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(`
@@ -602,10 +691,14 @@ export default function registerSubagentExtension(dm) {
     const content = typeof message.content === "string" ? message.content : undefined;
     return new SubagentControlNoticeComponent({ ...details, noticeText: formatSubagentControlNotice(details, content) }, theme);
   });
+  const executeSubagentReady = async (id, params, signal, onUpdate, ctx) => {
+    await waitForAdvertisement();
+    return executor.executePublic(id, params, signal, onUpdate, ctx);
+  };
   const executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => {
     if (ctx.hasUI)
       ctx.ui.setToolsExpanded(false);
-    return executor.executePublic(id, params, signal, onUpdate, ctx);
+    return executeSubagentReady(id, params, signal, onUpdate, ctx);
   };
   const slashBridge = registerSlashSubagentBridge({
     events: dm.events,
@@ -616,16 +709,17 @@ export default function registerSubagentExtension(dm) {
     events: dm.events,
     getContext: () => state.lastUiContext,
     execute: (requestId, params, signal, ctx, onUpdate) => executeSubagentCollapsed(requestId, params, signal, onUpdate, ctx),
-    executeStructured: (requestId, params, signal, ctx, onUpdate) => {
+    executeStructured: async (requestId, params, signal, ctx, onUpdate) => {
       if (ctx.hasUI)
         ctx.ui.setToolsExpanded(false);
+      await waitForAdvertisement();
       return executor.executeDelegated(requestId, params, signal, onUpdate, ctx);
     }
   });
   const rpcBridge = registerSubagentRpcBridge({
     events: dm.events,
     getContext: () => state.lastUiContext,
-    execute: (id, params, signal, onUpdate, ctx) => executor.executePublic(id, params, signal, onUpdate, ctx),
+    execute: executeSubagentReady,
     state
   });
   const parameters = createSubagentParamsSchema();
@@ -659,10 +753,19 @@ export default function registerSubagentExtension(dm) {
     }
   };
   dm.registerTool(tool);
-  registerWaitTool(dm, state, waitToolConfig.enabled, waitSubscriptionManager, waitToolConfig.defaultTimeoutMs);
+  dm.on("before_agent_start", async (event, ctx) => {
+    await waitForAdvertisement();
+    const selectedTools = event.systemPromptOptions?.selectedTools ?? (typeof dm.getActiveTools === "function" ? dm.getActiveTools() : []);
+    const sessionId = state.currentSessionId ?? resolveCurrentSessionId(ctx.sessionManager);
+    const advertisedPrompt = Array.isArray(selectedTools) && selectedTools.includes("subagent") ? buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(sessionId)) : undefined;
+    const systemPrompt = appendAdvertisedAgentPrompt(event.systemPrompt, advertisedPrompt);
+    if (systemPrompt !== event.systemPrompt)
+      return { systemPrompt };
+  });
+  registerWaitTool(dm, state, waitToolConfig.enabled, waitSubscriptionManager, waitToolConfig.defaultTimeoutMs, undefined, supervisorChannel.hasPendingRequests);
   dm.on("agent_end", async (_event, ctx) => {
     if (!ctx.hasUI)
-      await drainOutstandingWork({ state, events: dm.events });
+      await drainOutstandingWork({ state, events: dm.events, hasPendingSupervisorRequest: supervisorChannel.hasPendingRequests });
     const ownerSessionId = state.currentSessionId;
     if (!ownerSessionId)
       return;
@@ -786,6 +889,7 @@ export default function registerSubagentExtension(dm) {
     const previousRuntimeSessionId = state.currentSessionId;
     resultDeliveryOwnership.claimPredecessor(previousSessionFile, previousRuntimeSessionId);
     state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
+    state.supervisorOwnerSessionId = ctx.sessionManager.getSessionId() || null;
     transitionResultDelivery();
     state.parentSessionFile = ctx.sessionManager.getSessionFile();
     state.trustedSessionFileRoot = state.parentSessionFile ? path.join(getAgentDir(), "sessions") : undefined;
@@ -803,11 +907,7 @@ export default function registerSubagentExtension(dm) {
     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;
-      }
+      delete process.env[SUBAGENT_PARENT_SESSION_ENV];
     }
     state.lastUiContext = ctx;
     let phaseStartedAt = Date.now();
@@ -817,6 +917,9 @@ export default function registerSubagentExtension(dm) {
     cleanupSessionArtifacts(ctx);
     logSlowPhase("session-artifact-cleanup", phaseStartedAt);
     state.foregroundControls.clear();
+    retainedNestedRouteTracker?.clear();
+    retainedNestedRouteTracker = undefined;
+    executorDeps.trackRetainedNestedRoute = undefined;
     state.lastForegroundControlId = null;
     phaseStartedAt = Date.now();
     resetJobs(ctx);
@@ -831,7 +934,7 @@ export default function registerSubagentExtension(dm) {
     scheduledRunManager.bindSession(ctx);
     logSlowPhase("scheduled-runs", phaseStartedAt);
     phaseStartedAt = Date.now();
-    restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
+    restoreSlashFinalSnapshots(ctx.sessionManager.getBranch?.() ?? ctx.sessionManager.getEntries?.() ?? []);
     logSlowPhase("slash-snapshots", phaseStartedAt);
     phaseStartedAt = Date.now();
     waitSubscriptionManager.restore();
@@ -852,7 +955,8 @@ export default function registerSubagentExtension(dm) {
       if (runtimeCleaned)
         return;
       runtimeCleaned = true;
-      const shuttingDownParentSession = parentSessionEnvValue;
+      releaseHostSessionLiveness();
+      releaseHostSessionLiveness = () => {};
       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."));
@@ -860,8 +964,12 @@ export default function registerSubagentExtension(dm) {
       state.workflowControllers?.clear();
       state.workflowChildStops?.clear();
       clearRuntimeAgentsForPi(dm);
-      clearTimeout(resultIndexCleanupTimer);
-      clearTimeout(asyncRetentionTimer);
+      if (resultIndexCleanupTimer)
+        clearTimeout(resultIndexCleanupTimer);
+      resultIndexCleanupTimer = undefined;
+      if (asyncRetentionTimer)
+        clearTimeout(asyncRetentionTimer);
+      asyncRetentionTimer = undefined;
       asyncRetentionAbort.abort();
       stopResultWatcher();
       resultDeliveryOwnership.clear();
@@ -876,6 +984,9 @@ export default function registerSubagentExtension(dm) {
         clearTimeout(timer);
       state.cleanupTimers.clear();
       state.asyncJobs.clear();
+      retainedNestedRouteTracker?.clear();
+      retainedNestedRouteTracker = undefined;
+      executorDeps.trackRetainedNestedRoute = undefined;
       for (const unsubscribe of eventUnsubscribes) {
         try {
           unsubscribe();
@@ -888,12 +999,9 @@ export default function registerSubagentExtension(dm) {
       promptTemplateBridge.dispose();
       state.widgetsSuspended = false;
       state.currentSessionId = null;
+      state.supervisorOwnerSessionId = 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);
       }
@@ -946,7 +1054,9 @@ export default function registerSubagentExtension(dm) {
     if (event.reason !== "manual")
       suspendWidgetsForCompaction();
   });
-  dm.on("session_compact", () => {
+  dm.on("session_compact", (event) => {
+    if (event.reason !== "manual")
+      return;
     const hasActiveAsyncWork = [...state.asyncJobs.values()].some((job) => job.status === "queued" || job.status === "running");
     if (!hasActiveAsyncWork || !withLastUiContext(() => true))
       return;
@@ -958,8 +1068,22 @@ export default function registerSubagentExtension(dm) {
   });
   dm.on("session_start", (event, ctx) => {
     installRuntime(ctx);
+    startSessionMaintenance();
     const recovering = event.reason === "startup" || event.reason === "reload" || event.reason === "resume";
     resetSessionState(ctx, recovering, event.previousSessionFile);
+    releaseHostSessionLiveness();
+    const sessionId = ctx.sessionManager.getSessionId();
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    const liveness = sessionId ? registerPiWebSessionLiveness({
+      sessionId,
+      ...sessionFile ? { sessionFile } : {},
+      isActive: () => hasLiveSubagentWork(state) || completionNotifier.hasPendingDelivery()
+    }) : { registered: false, release: () => {} };
+    releaseHostSessionLiveness = liveness.release;
+    if (liveness.registered) {
+      retainedNestedRouteTracker = createRetainedNestedRouteTracker(state);
+      executorDeps.trackRetainedNestedRoute = retainedNestedRouteTracker.track;
+    }
     herdrStatusBridge.sessionStarted({
       hasUI: ctx.hasUI === true,
       runs: activeHerdrRuns()
@@ -970,6 +1094,18 @@ export default function registerSubagentExtension(dm) {
   });
   dm.on("session_shutdown", async () => {
     runtimeEntry.cleanup();
+    try {
+      await disposeChildSessions();
+    } catch (error) {
+      console.error("Failed to dispose in-process child sessions:", error);
+    }
     await herdrStatusBridge.flush();
   });
+  dm.on("session_start", (_event, ctx) => beginAdvertisement(ctx));
+  registerSubagentToolActivation(dm, {
+    advertisedPrompt: async () => {
+      await waitForAdvertisement();
+      return buildAdvertisedAgentPrompt(advertisedAgents, resolveCurrentSubagentCapabilityCeiling(state.currentSessionId ?? undefined));
+    }
+  });
 }

package/extensions/dm-subagents/src/extension/public-execution.js

@@ -1,12 +1,57 @@
+import { normalizeWorktreeBaseRef } from "../runs/shared/worktree.js";
+export function validateWorkflowCapacityOverrides(params) {
+  for (const [name, value] of [
+    ["globalConcurrencyLimit", params.globalConcurrencyLimit],
+    ["maxSubagentSpawnsPerRun", params.maxSubagentSpawnsPerRun]
+  ]) {
+    if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0))
+      return `${name} must be a positive safe integer.`;
+  }
+}
 export function normalizePublicSubagentExecution(params) {
+  for (const field of ["resource", "resourceProvenance", "workflowResource", "workflowResourceProvenance", "workflowResourcePermit", "resourcePermit", "permit"]) {
+    if (Object.hasOwn(params, field) && params[field] !== undefined) {
+      return { ok: false, error: "Public execution does not accept workflow resource provenance or permit fields.", mode: params.action === undefined ? "workflow" : "management" };
+    }
+  }
+  if (params.baseRef !== undefined) {
+    try {
+      normalizeWorktreeBaseRef(params.baseRef);
+    } catch (error) {
+      return { ok: false, error: error instanceof Error ? error.message : String(error), mode: params.action === undefined ? "workflow" : "management" };
+    }
+  }
   if (params.workflowScript !== undefined && params.workflowScriptPath !== undefined) {
     return { ok: false, error: "workflowScript and workflowScriptPath are mutually exclusive.", mode: "workflow" };
   }
-  const hasWorkflowInput = params.workflowScript !== undefined || params.workflowScriptPath !== undefined;
+  const hasNamedWorkflow = params.workflow !== undefined;
+  if (hasNamedWorkflow && (typeof params.workflow !== "string" || !params.workflow.trim())) {
+    return { ok: false, error: "workflow must be a non-empty named workflow resource.", mode: "workflow" };
+  }
+  if (hasNamedWorkflow && (params.workflowScript !== undefined || params.workflowScriptPath !== undefined)) {
+    return { ok: false, error: "workflow is mutually exclusive with workflowScript and workflowScriptPath.", mode: "workflow" };
+  }
+  const hasWorkflowInput = params.workflowScript !== undefined || params.workflowScriptPath !== undefined || hasNamedWorkflow;
+  if (!hasWorkflowInput && params.args !== undefined) {
+    return { ok: false, error: "args requires workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
+  }
+  const hasCapacityOverride = params.globalConcurrencyLimit !== undefined || params.maxSubagentSpawnsPerRun !== undefined;
+  if (hasCapacityOverride) {
+    const capacityOverrideError = validateWorkflowCapacityOverrides(params);
+    if (capacityOverrideError)
+      return { ok: false, error: capacityOverrideError, mode: params.action === undefined ? "workflow" : "management" };
+    const validatesSpawnBudget = typeof params.action === "string" && params.action.trim() === "validate" && params.globalConcurrencyLimit === undefined && params.maxSubagentSpawnsPerRun !== undefined;
+    if (params.action !== undefined && !validatesSpawnBudget || hasNamedWorkflow || params.workflowScript === undefined && params.workflowScriptPath === undefined) {
+      return { ok: false, error: "Workflow capacity overrides are only supported on top-level workflowScript or workflowScriptPath calls; validate accepts maxSubagentSpawnsPerRun for static budget checks.", mode: params.action === undefined ? "workflow" : "management" };
+    }
+  }
   if (params.preflight !== undefined && !hasWorkflowInput) {
     return { ok: false, error: "preflight requires workflowScript or workflowScriptPath.", mode: params.action === undefined ? "workflow" : "management" };
   }
-  const hasValidWorkflowInput = typeof params.workflowScript === "string" && Boolean(params.workflowScript.trim()) || typeof params.workflowScriptPath === "string" && Boolean(params.workflowScriptPath.trim());
+  if (params.preflight !== undefined && hasNamedWorkflow && params.workflowScript === undefined && params.workflowScriptPath === undefined) {
+    return { ok: false, error: "preflight is not supported with named workflow resources.", mode: "workflow" };
+  }
+  const hasValidWorkflowInput = typeof params.workflowScript === "string" && Boolean(params.workflowScript.trim()) || typeof params.workflowScriptPath === "string" && Boolean(params.workflowScriptPath.trim()) || typeof params.workflow === "string" && Boolean(params.workflow.trim());
   if (params.isolation !== undefined) {
     if (params.isolation !== "none" && params.isolation !== "worktree") {
       return { ok: false, error: "isolation must be 'none' or 'worktree'.", mode: hasWorkflowInput ? "workflow" : "management" };
@@ -29,6 +74,12 @@ export function normalizePublicSubagentExecution(params) {
     return { ok: false, error: "action must be a non-empty management/control action, or omit action and use workflowScript.", mode: "management" };
   }
   const normalizedAction = typeof action === "string" ? action.trim() : undefined;
+  if (params.baseRef !== undefined && normalizedAction !== undefined && normalizedAction !== "resume" && normalizedAction !== "schedule.create") {
+    return { ok: false, error: "baseRef is only supported for child execution, resume, and schedule.create.", mode: "management" };
+  }
+  if (normalizedAction !== undefined && hasNamedWorkflow) {
+    return { ok: false, error: "Named workflow resource execution must omit action.", mode: "management" };
+  }
   if (params.clarify !== undefined) {
     return { ok: false, error: "Public workflowScript execution does not support clarify UI.", mode: "workflow" };
   }
@@ -89,7 +140,7 @@ export function normalizePublicSubagentExecution(params) {
     return { ok: false, error: "step is not a public execution field; use workflowScript for orchestration.", mode: "workflow" };
   }
   if (hasWorkflowInput && (params.agent !== undefined || params.task !== undefined)) {
-    return { ok: false, error: "Structured single-child execution cannot be combined with workflowScript or workflowScriptPath.", mode: "workflow" };
+    return { ok: false, error: "Structured single-child execution cannot be combined with workflow, workflowScript, or workflowScriptPath.", mode: "workflow" };
   }
   if (params.agent !== undefined || params.task !== undefined) {
     if (typeof params.agent !== "string" || !params.agent.trim()) {
@@ -108,7 +159,7 @@ export function normalizePublicSubagentExecution(params) {
     };
   }
   if (!hasValidWorkflowInput) {
-    return { ok: false, error: "Execution requires either { agent, task? } for one child or a non-empty workflowScript or workflowScriptPath for orchestration.", mode: "workflow" };
+    return { ok: false, error: "Execution requires either { agent, task? } for one child, a named workflow resource, or a non-empty workflowScript or workflowScriptPath for orchestration.", mode: "workflow" };
   }
   return { ok: true, params };
 }