@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-subagents/src/runs/foreground/subagent-executor.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { discoverAgents, findBlockingAgentDiagnostic, formatUnknownAgentError, resolveAgentName, unknownAgentDiagnosticContext } from "../../agents/agents.js";
+import { discoverAgents, findBlockingAgentDiagnostic, formatAvailableAgentLines, formatUnknownAgentError, resolveAgentName, suggestAgentName, unknownAgentDiagnosticContext } from "../../agents/agents.js";
 import { getArtifactsDir, getProjectArtifactPackagingWarning, getProjectSubagentsDir } from "../../shared/artifacts.js";
 import { writeAtomicJson } from "../../shared/atomic-json.js";
 import { createCapacityResilientJsonWriter } from "../../shared/capacity-resilient-json.js";
@@ -16,17 +16,20 @@ import {
 } from "./foreground-control.js";
 import { getLivePromptAudit, rewritePromptWithGuidance, updateLiveEffectivePrompt } from "./prompt-audit.js";
 import { persistForegroundRunHistory, MAX_REMEMBERED_FOREGROUND_RUNS } from "./foreground-history.js";
-import { resolveExecutionAgentScope } from "../../agents/agent-scope.js";
+import { projectScopeRequiresTrustMessage, resolveExecutionAgentScope } from "../../agents/agent-scope.js";
 import { handleManagementAction } from "../../agents/agent-management.js";
 import { handleRefinementAction } from "../../agents/agent-refinements.js";
 import { buildDoctorReport } from "../../extension/doctor.js";
 import { readSubagentGuide } from "../../extension/subagent-guide.js";
-import { normalizePublicSubagentExecution, validateWorkflowCapacityOverrides } from "../../extension/public-execution.js";
+import { isWorkflowScriptPath, normalizePublicSubagentExecution, validateWorkflowCapacityOverrides } from "../../extension/public-execution.js";
+import { readReplyWorkflowScript } from "../../extension/reply-workflow-script.js";
+import { disabledFeatureNotice, disabledFeatureUseError, resolveDisabledFeatureSurface } from "../../shared/disabled-features.js";
 import { runSync } from "./execution.js";
+import { commandAction } from "./command-action.js";
 import { handleWatchdogToolAction, WATCHDOG_TOOL_ACTIONS } from "../../watchdog/tool-actions.js";
 import { applyWatchdogLaunchRules } from "../../watchdog/rules.js";
 import { childWatchdogProgressForModel } from "../../watchdog/child-status.js";
-import { normalizeParentModel, resolveEffectiveSubagentModel, resolveModelOrigin } from "../shared/model-resolution.js";
+import { normalizeParentModel, resolveEffectiveSubagentModel, resolveModelOrigin, scopedModelIdsFromContext } from "../shared/model-resolution.js";
 import { projectChainOutputSchemas, resolveEffectiveOutputSchema } from "../shared/child-launch-plan.js";
 import { formatRetainedChildren, listRetainedChildren } from "../background/retained-children.js";
 import { resolveModelScopesForAgent } from "../shared/model-scope.js";
@@ -57,16 +60,17 @@ import { formatControlIntercomMessage, formatControlNoticeMessage, resolveContro
 import { formatSpawnBudget, getSpawnBudgetSnapshot, grantSpawnBudget, preflightSpawnBudget, preflightSpawnBudgetGrant, reserveSpawnBudget } from "../shared/spawn-budget.js";
 import { claimRunFanoutBatch, claimRunFanoutBatchWithCommit, createRunFanoutBudget, formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor, RunFanoutLimitError, writeRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
 import { retainLiveForegroundNestedRoute } from "../../integrations/dm-web-session-liveness.js";
+import { HERDR_FOREGROUND_CONTROL_CHANGED_EVENT } from "../../integrations/herdr-status.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
 import { usageBudgetExceededMessage, usageBudgetState, validateUsageBudgetConfig } from "../shared/usage-budget.js";
-import { intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
+import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { isAgentContract } from "../shared/agent-contract.js";
 import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
-import { resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
-import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, outputPathMappingFromTask, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { assertRequiredChildExtensionsAdmitted, hasMandatoryRequiredChildExtensions, readRetainedRequiredChildExtensions, resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
+import { capInlineOutput, finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, outputPathMappingFromTask, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import { assertJsonSchemaObject, cleanupStructuredOutputRuntime, createStructuredOutputRuntime } from "../shared/structured-output.js";
-import { compactForegroundDetails, getSingleResultOutput, PROMPT_REDACTED, readStatus, resolveChildCwd, sumResultsCost, sumResultsUsage } from "../../shared/utils.js";
-import { discardPreservedWorktrees, formatParallelHandoffError, formatParallelHandoffReference, formatStoredParallelHandoffCleanup, parallelHandoffPath, readParallelHandoffManifest, recordParallelHandoffMerge, recordParallelHandoffSupersession, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
+import { compactForegroundDetails, getSingleResultOutput, PROMPT_REDACTED, readStatus, resolveChildCwd, sumResultsCost, sumResultsUsage, toAgentToolUsage } from "../../shared/utils.js";
+import { discardPreservedWorktrees, formatParallelHandoffError, formatParallelHandoffReference, protectRetainedWorktreeForResume, formatStoredParallelHandoffCleanup, parallelHandoffPath, readParallelHandoffManifest, recordParallelHandoffMerge, recordParallelHandoffSupersession, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
 import { summarizeContextModes } from "../shared/context-mode.js";
 import {
   attachNestedChildrenToResultChildren,
@@ -90,16 +94,18 @@ import { dismissRecoveredWorkflow } from "./async-dismiss-action.js";
 import { promotePausedWorkflowIfSettled, reconcileDetachedWorkflowChildCompletion } from "./workflow-detach-reconcile.js";
 import { reconcileAsyncRun } from "../background/stale-run-reconciler.js";
 import { resolveAsyncRootResultPath, waitForImportedAsyncRoot } from "../background/chain-root-attachment.js";
-import { fallbackResultPayloadPathForSessionRun, removeResultIndex, resultFilePath, writeAsyncResultFile } from "../background/result-files.js";
-import { attachRootChildrenToSteps, createNestedRoute, findNestedControlResult, inheritedNestedParentAddressOf, inheritedNestedRouteOf, nestedRunScope, resolveNestedAsyncDir, retainNestedLookupRoute, snapshotNestedEventFiles, updateForegroundNestedProjection, writeNestedControlRequest, writeNestedEvent } from "../shared/nested-events.js";
+import { awaitExistingAsyncRun, claimWorkflowAwaitedResult } from "../background/await-async-run.js";
+import { fallbackResultPayloadPathForSessionRun, resultFilePath, retireResultSnapshot, writeAsyncResultFile } from "../background/result-files.js";
+import { attachRootChildrenToSteps, createNestedRoute, findNestedControlResult, inheritedNestedParentAddressOf, inheritedNestedRouteOf, nestedRunNotActiveMessage, nestedRunScope, resolveNestedAsyncDir, retainNestedLookupRoute, snapshotNestedEventFiles, updateForegroundNestedProjection, writeNestedControlRequest, writeNestedEvent } from "../shared/nested-events.js";
 import { resolveSubagentRunId } from "../background/run-id-resolver.js";
 import { formatNestedRunStatusLines } from "../shared/nested-render.js";
-import { isStoppableAsyncStatusStep, resolveAsyncStatusChild, stopStoppableAsyncStatusChildren } from "../shared/child-identity.js";
+import { isStoppableAsyncStatusStep, resolveAsyncStatusChild } from "../shared/child-identity.js";
 import { inspectSubagentStatus } from "../background/run-status.js";
 import { getExternalJobProvider } from "../../api/external-job-provider.js";
 import { externalJobFollowUpRequestDigest, externalJobFollowUpRequestId, externalJobFollowUpRunId, externalJobPromptDigest, externalJobStableJson } from "../shared/external-job-runner.js";
 import { externalCliReceiptMetadata, normalizeExternalCliRunnerStatus } from "../shared/external-cli-contract.js";
 import { formatHerdrMachineRunnerUnsupported, resolveHerdrMachinePlacement } from "../shared/herdr-machine.js";
+import { lookupRunnerLauncher, resolveAgentRunnerLauncher } from "../shared/runner-launcher.js";
 import { applyForceTopLevelAsyncOverride } from "../background/top-level-async.js";
 import { handleMissionAction, MISSION_ACTIONS } from "../../missions/actions.js";
 import { attachMissionToLaunchResult, prepareMissionLaunch, writeMissionAsyncBinding } from "../../missions/lifecycle.js";
@@ -107,12 +113,14 @@ import { MissionNotFoundError, updateMission } from "../../missions/store.js";
 import { createMissionWorkflowState } from "../../missions/workflow-state.js";
 import { resolveAuthorityDecision } from "../../policy/authority.js";
 import { handleInspectorAction, INSPECTOR_ACTIONS } from "../../inspectors/actions.js";
-import { createBuiltinInspectorPlugins } from "../../inspectors/plugins.js";
+import { getInspectorPlugins } from "../../inspectors/plugins.js";
 import { handleHerdrProjectPaneAction, HERDR_PROJECT_PANE_ACTIONS } from "../../inspectors/herdr/project-panes.js";
 import { previewSimpleWorkflowRun, runWorkflowScript, validateWorkflowScript, WorkflowScriptError } from "../../workflows/scripted-workflow.js";
 import { formatIncrementalChildCompletion, incrementalChildCompletionTriggersTurn } from "../background/notify.js";
+import { appendWorkflowChildJournal, findWorkflowReuseSource, matchWorkflowReuse, workflowChildFingerprint, workflowScriptDigest, workflowStopCause, WORKFLOW_RUNTIME_REPLACED_RELAUNCH_NOTICE } from "../../workflows/workflow-reuse.js";
 import { executeWorkflowHostCommand, resolveWorkflowHostOutputClaimPath } from "../../workflows/host-command.js";
 import { buildWorkflowReceipt, readWorkflowReceipt, workflowReceiptPath, resolveWorkflowReceiptResumeEntry, writeWorkflowReceipt } from "../../workflows/workflow-receipt.js";
+import { formatWorkflowKeyRevival, recordWorkflowRevival, withWorkflowRevivals } from "../../workflows/workflow-revival.js";
 import { upsertHostStep, validHostStepNodes } from "../shared/host-step-status.js";
 import { assertWorkflowLaneKey, normalizeWorkflowLaneMetadata } from "../shared/lane-metadata.js";
 import { parseWorkflowChildSummary, workflowChildProgress, workflowChildSummary } from "../../workflows/workflow-child-summary.js";
@@ -124,7 +132,7 @@ import {
   consumeWorkflowResourcePermit,
   validateWorkflowChildPermitRoot
 } from "../../shared/workflow-child-permit.js";
-import { deepFreezeWorkflowArgs, normalizeWorkflowArgs, resolveWorkflowResource } from "../../workflows/workflow-resources.js";
+import { deepFreezeWorkflowArgs, normalizeWorkflowArgs, resolveStructuredWorkflowResource, resolveWorkflowResource } from "../../workflows/workflow-resources.js";
 import { stableJsonDigest } from "../../shared/launch-contract.js";
 import {
   cleanupWorktrees,
@@ -134,10 +142,12 @@ import {
   diffWorktrees,
   formatWorktreeDiffSummary
 } from "../shared/worktree.js";
+import { applyReviewedCleanupPlan, formatCleanupReceipt, loadReviewedCleanupPlan } from "../shared/worktree-cleanup-apply.js";
 import { createWorktreeCleanupPlan, formatWorktreeCleanupPlan } from "../shared/worktree-cleanup-plan.js";
 import {
   DIRS,
   DEFAULT_ARTIFACT_CONFIG,
+  DEFAULT_MAX_OUTPUT,
   DEFAULT_FORK_PREAMBLE,
   SUBAGENT_ACTIONS,
   SUBAGENT_ASYNC_STARTED_EVENT,
@@ -150,36 +160,20 @@ import {
   resolveChildMaxSubagentDepth,
   resolveCurrentMaxSubagentDepth,
   resolveMaxSubagentSpawnsPerRun,
+  truncateOutput,
   wrapForkTask
 } from "../../shared/types.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
-const MUTATING_MANAGEMENT_ACTIONS = new Set(["create", "update", "delete", "eject", "disable", "enable", "reset", "grant-spawn-budget", "watchdog.configure", "mission.create", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "inspector.open", "inspector.close", "project.open", "project.close", "worktree.discard", "worktree.cleanup", "lane.recordMerge", "lane.recordSupersession", "refine", "refine.rollback", "dismiss", "schedule.create", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"]);
-const DESTRUCTIVE_MANAGEMENT_ACTIONS = new Set(["delete", "eject", "disable", "reset", "mission.close", "worktree.discard", "refine.rollback", "inspector.close", "project.close", "stop", "interrupt", "schedule.delete"]);
+import { editDistance, hasSingleAdjacentTransposition } from "../../shared/edit-distance.js";
+const MUTATING_MANAGEMENT_ACTIONS = new Set(["command.yield", "command.cancel", "create", "update", "delete", "eject", "disable", "enable", "reset", "grant-spawn-budget", "watchdog.configure", "mission.create", "mission.update", "mission.resolve-decision", "mission.attach-run", "mission.close", "inspector.open", "inspector.close", "project.open", "project.close", "worktree.discard", "worktree.cleanup", "lane.recordMerge", "lane.recordSupersession", "refine", "refine.rollback", "dismiss", "schedule.create", "schedule.pause", "schedule.resume", "schedule.run", "schedule.run-due", "schedule.delete"]);
+const DESTRUCTIVE_MANAGEMENT_ACTIONS = new Set(["command.cancel", "delete", "eject", "disable", "reset", "mission.close", "worktree.discard", "refine.rollback", "inspector.close", "project.close", "stop", "interrupt", "schedule.delete"]);
 function resolveSteerDeliveryMode(mode) {
   return mode === "steer" || mode === "follow_up" || mode === "auto" ? mode : undefined;
 }
-function editDistance(left, right) {
-  const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-  for (let leftIndex = 1;leftIndex <= left.length; leftIndex += 1) {
-    let diagonal = previous[0];
-    previous[0] = leftIndex;
-    for (let rightIndex = 1;rightIndex <= right.length; rightIndex += 1) {
-      const above = previous[rightIndex];
-      previous[rightIndex] = left[leftIndex - 1] === right[rightIndex - 1] ? diagonal : Math.min(diagonal, above, previous[rightIndex - 1]) + 1;
-      diagonal = above;
-    }
-  }
-  return previous[right.length];
-}
-function hasSingleAdjacentTransposition(left, right) {
-  if (left.length !== right.length)
-    return false;
-  const mismatch = [...left].findIndex((character, index) => character !== right[index]);
-  return mismatch >= 0 && left[mismatch] === right[mismatch + 1] && left[mismatch + 1] === right[mismatch] && left.slice(mismatch + 2) === right.slice(mismatch + 2);
-}
-export function unknownSubagentActionMessage(action) {
+export function unknownSubagentActionMessage(action, disabled) {
   const requested = action.toLowerCase();
-  const suggestion = SUBAGENT_ACTIONS.find((candidate) => {
+  const enabledActions = SUBAGENT_ACTIONS.filter((candidate) => !disabled?.actions.has(candidate));
+  const suggestion = enabledActions.find((candidate) => {
     const distance = editDistance(requested, candidate);
     const closeMatch = distance <= Math.max(1, Math.floor(candidate.length / 4)) || hasSingleAdjacentTransposition(requested, candidate);
     if (DESTRUCTIVE_MANAGEMENT_ACTIONS.has(candidate))
@@ -187,7 +181,7 @@ export function unknownSubagentActionMessage(action) {
     return closeMatch;
   });
   const nextStep = 'Use subagent({ action: "status" }) to inspect runs or subagent({ action: "list" }) to inspect agents.';
-  const validActions = `Valid: ${SUBAGENT_ACTIONS.join(", ")}.`;
+  const validActions = `Valid: ${enabledActions.join(", ")}.`;
   return suggestion ? `Unknown action: ${action}. Did you mean ${suggestion}? ${nextStep} ${validActions}` : `Unknown action: ${action}. ${nextStep} ${validActions}`;
 }
 function omitUndefinedProperties(value) {
@@ -227,20 +221,17 @@ function inheritedRunFanoutBudget(deps) {
 function resolveRequestedCwd(runtimeCwd, requestedCwd) {
   return requestedCwd ? path.resolve(runtimeCwd, requestedCwd) : runtimeCwd;
 }
-function loadWorkflowScriptPath(params, runtimeCwd) {
-  if (params.workflowScriptPath === undefined)
-    return { params };
-  const scriptPath = path.resolve(resolveRequestedCwd(runtimeCwd, params.cwd), params.workflowScriptPath);
-  let workflowScript;
+function readWorkflowScriptFile(requestedPath, requestedCwd, runtimeCwd) {
+  const scriptPath = path.resolve(resolveRequestedCwd(runtimeCwd, requestedCwd), requestedPath);
+  let script;
   try {
-    workflowScript = fs.readFileSync(scriptPath, "utf8");
+    script = fs.readFileSync(scriptPath, "utf8");
   } catch (error) {
-    return { error: `Failed to read workflowScriptPath '${scriptPath}': ${error instanceof Error ? error.message : String(error)}` };
+    return { error: `Failed to read workflow script '${scriptPath}': ${error instanceof Error ? error.message : String(error)}` };
   }
-  if (!workflowScript.trim())
-    return { error: `workflowScriptPath file '${scriptPath}' is empty.` };
-  const { workflowScriptPath: _workflowScriptPath, ...rest } = params;
-  return { params: { ...rest, workflowScript } };
+  if (!script.trim())
+    return { error: `Workflow script file '${scriptPath}' is empty.` };
+  return { script };
 }
 export function removeForegroundControlIfIdle(state, runId, trackRetainedNestedRoute) {
   const control = state.foregroundControls.get(runId);
@@ -334,6 +325,22 @@ function trustedSessionRootsForStatus(ctx, deps) {
     roots.push(deps.getSubagentSessionRoot(parentSessionFile));
   return [...new Set(roots)];
 }
+function sessionProjectTrust(ctx) {
+  return typeof ctx.isProjectTrusted === "function" ? ctx.isProjectTrusted() : undefined;
+}
+function withSessionProjectTrust(deps, ctx) {
+  if (sessionProjectTrust(ctx) !== false)
+    return deps;
+  return { ...deps, discoverAgents: (cwd, scope, preferredModelProvider) => deps.discoverAgents(cwd, scope, preferredModelProvider, { projectTrusted: false }) };
+}
+function projectScopeTrustError(params, ctx) {
+  if (sessionProjectTrust(ctx) !== false || resolveExecutionAgentScope(params.agentScope) !== "project")
+    return;
+  const action = typeof params.action === "string" ? params.action.trim() : undefined;
+  if (action !== undefined && action !== "resume" && action !== "validate" && action !== "append-step")
+    return;
+  return buildRequestedModeError(params, projectScopeRequiresTrustMessage(resolveRequestedCwd(ctx.cwd, params.cwd)));
+}
 function spawnBudgetErrorResult(message, mode) {
   return {
     content: [{ type: "text", text: message }],
@@ -490,6 +497,7 @@ function rememberForegroundRun(state, input) {
         ...result.error ? { error: result.error } : {},
         ...result.finalOutput ? { finalOutput: result.finalOutput } : {},
         ...result.outputState ? { outputState: result.outputState } : {},
+        ...result.outputPartial ? { outputPartial: true } : {},
         ...result.outputMode ? { outputMode: result.outputMode } : {},
         ...result.savedOutputPath ? { savedOutputPath: result.savedOutputPath } : {},
         ...result.outputSaveError ? { outputSaveError: result.outputSaveError } : {},
@@ -574,6 +582,7 @@ function updateRememberedForegroundChild(state, input) {
     ...input.result.error ? { error: input.result.error } : {},
     ...input.result.finalOutput ? { finalOutput: input.result.finalOutput } : {},
     outputState: input.result.outputState,
+    outputPartial: input.result.outputPartial,
     outputMode: input.result.outputMode,
     savedOutputPath: input.result.savedOutputPath,
     outputSaveError: input.result.outputSaveError,
@@ -832,7 +841,7 @@ function emitControlNotification(input) {
   }
 }
 function interruptAsyncRun(state, runId, kill, location) {
-  const target = getAsyncInterruptTarget(state, runId, location);
+  const target = getAsyncInterruptTarget(state, runId, location, { fallbackToNewest: runId === undefined });
   if (!target)
     return null;
   const status = reconcileAsyncRun(target.asyncDir, omitUndefinedProperties({ kill })).status;
@@ -970,6 +979,16 @@ function appendStepToAsyncChain(input) {
       details: { mode: "management", results: [] }
     };
   }
+  let retainedRequiredExtensions;
+  try {
+    retainedRequiredExtensions = readRetainedRequiredChildExtensions(resolved.location.asyncDir);
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Cannot append step to run '${resolved.id}': ${error instanceof Error ? error.message : String(error)}` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
   const pendingAppendRequests = readPendingChainAppendRequests(resolved.location.asyncDir);
   const reservedOutputNames = new Set([
     ...Object.keys(status.outputs ?? {}),
@@ -1010,14 +1029,25 @@ function appendStepToAsyncChain(input) {
     cwd: input.ctx.cwd,
     currentSessionId: resolveCurrentSessionId(input.ctx.sessionManager),
     parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
+    parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
     currentModelProvider: parentModel?.provider,
     currentModel: parentModel,
+    scopedModelIds: scopedModelIdsFromContext(input.ctx),
     modelScope: discoveredForAppend.modelScope,
     modelResponseAliases: input.deps.config.modelResponseAliases,
     interactive: input.ctx.hasUI,
     permissions: input.deps.config.permissions,
     childRuntime: input.deps.childRuntime
   });
+  const appendedLaunchers = new Set(chain.flatMap(getStepAgents).map((name) => agents.find((agent) => agent.name === name)?.launcher));
+  const appendedLauncher = [...appendedLaunchers][0];
+  if (appendedLaunchers.size === 1 && appendedLauncher !== status.launcher?.name) {
+    return {
+      content: [{ type: "text", text: `Cannot append step to run '${resolved.id}': its runner uses ${status.launcher ? `launcher '${status.launcher.name}'` : "no launcher"}, but the appended agents use ${appendedLauncher ? `launcher '${appendedLauncher}'` : "no launcher"}.` }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
   const built = buildAsyncRunnerSteps(resolved.id, compactOptional({
     chain: wrapChainTasksForFork(chain, contextPolicy),
     task: input.params.task,
@@ -1038,7 +1068,8 @@ function appendStepToAsyncChain(input) {
     worktreeBranchPrefix: input.deps.config.worktreeBranchPrefix,
     asyncDir: resolved.location.asyncDir,
     validateOutputBindings: false,
-    capabilityCeiling: intersectSubagentCapabilityCeilings(status.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(asyncCtx.currentSessionId))
+    capabilityCeiling: intersectSubagentCapabilityCeilings(status.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(asyncCtx.currentSessionId)),
+    requiredExtensions: retainedRequiredExtensions
   }));
   if ("error" in built) {
     return {
@@ -1309,11 +1340,14 @@ async function interruptNestedRun(target) {
   if (run.state === "paused")
     return { content: [{ type: "text", text: `Nested run ${run.id} is already paused.` }], isError: true, details: { mode: "management", results: [] } };
   const result = await sendNestedControlRequest(target, "interrupt");
-  if (result)
+  const missingForegroundRoute = result?.ok === false && result.message === nestedRunNotActiveMessage(run.id);
+  if (result && !missingForegroundRoute)
     return { content: [{ type: "text", text: result.message }], ...result.ok ? {} : { isError: true }, details: { mode: "management", results: [] } };
   const direct = directNestedAsyncInterrupt(target);
   if (direct)
     return direct;
+  if (result)
+    return { content: [{ type: "text", text: result.message }], isError: true, details: { mode: "management", results: [] } };
   return { content: [{ type: "text", text: `Nested run ${run.id} owner is not reachable and no safe direct async interrupt fallback is available.` }], isError: true, details: { mode: "management", results: [] } };
 }
 async function resumeLiveNestedRun(input) {
@@ -1436,13 +1470,16 @@ async function resumeExternalJobFollowUp(input) {
       cwd: input.requestCwd,
       currentSessionId,
       parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
+      parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
       currentModelProvider: parentModel?.provider,
       currentModel: parentModel,
+      scopedModelIds: scopedModelIdsFromContext(input.ctx),
       modelScope: input.modelScope,
       modelResponseAliases: input.deps.config.modelResponseAliases,
       interactive: input.ctx.hasUI,
       permissions: input.deps.config.permissions,
-      childRuntime: input.deps.childRuntime
+      childRuntime: input.deps.childRuntime,
+      projectTrusted: sessionProjectTrust(input.ctx)
     }),
     cwd: input.effectiveCwd,
     artifactsDir,
@@ -1511,6 +1548,14 @@ async function resumeAsyncRun(input) {
       details: { mode: "management", results: [] }
     };
   }
+  const timeoutOverflowError = timerDelayOverflowError("timeoutMs", input.params.timeoutMs);
+  if (timeoutOverflowError) {
+    return {
+      content: [{ type: "text", text: timeoutOverflowError }],
+      isError: true,
+      details: { mode: "management", results: [] }
+    };
+  }
   if (input.params.model !== undefined) {
     return {
       content: [{ type: "text", text: "action='resume' reuses the persisted child model and does not accept a model override." }],
@@ -1544,7 +1589,7 @@ async function resumeAsyncRun(input) {
         type: "text",
         text: [
           `Async child '${target.runId}' index ${target.index} is still running. action='resume' only revives paused, completed, or failed children.`,
-          `Send live input with subagent({ action: "steer", id: "${target.runId}", index: ${target.index}, message: "..." }).`
+          `Send live input with subagent({ action: "steer", id: "${target.runId}", message: "...", options: { index: ${target.index} } }).`
         ].join(`
 `)
       }],
@@ -1602,6 +1647,18 @@ async function resumeAsyncRun(input) {
     const message = runner ? `External adapter '${runner.adapter.id}' cannot resume: ${runner.nonResumableReason}` : "External runners do not persist DM sessions and cannot be resumed.";
     return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
   }
+  if (input.params.baseRef !== undefined && "managedWorktree" in target && target.managedWorktree === true) {
+    return { content: [{ type: "text", text: "Cannot resume with baseRef: retained managed-worktree children continue in their existing worktree. Start a new worktree run from that base ref instead." }], isError: true, details: { mode: "management", results: [] } };
+  }
+  if (target.source === "async" && target.managedWorktree && target.asyncDir) {
+    try {
+      const protectedCwd = await protectRetainedWorktreeForResume(parallelHandoffPath(target.asyncDir), target.runId, target.index, input.signal);
+      if (path.resolve(protectedCwd) !== path.resolve(effectiveCwd))
+        throw new Error("Retained worktree cwd changed during resume admission.");
+    } catch (error) {
+      return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+    }
+  }
   if (target.source === "async" && target.runner?.type === "external-job") {
     if (attachChain)
       return { content: [{ type: "text", text: "External-job follow-up does not support chain attachment. Use action='resume' with message instead." }], isError: true, details: { mode: "management", results: [] } };
@@ -1667,7 +1724,7 @@ async function resumeAsyncRun(input) {
     const chain = wrapChainTasksForFork(attachChain, contextPolicy);
     const normalized = normalizeSkillInput(input.params.skill);
     const parentModel = input.parentModel;
-    const result = executeAsyncChain(runId, compactOptional({
+    const result = await executeAsyncChain(runId, compactOptional({
       chain,
       task: workflowTask,
       goal,
@@ -1686,13 +1743,17 @@ async function resumeAsyncRun(input) {
         cwd: input.requestCwd,
         currentSessionId: input.deps.state.currentSessionId,
         parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
+        parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
         currentModelProvider: parentModel?.provider,
         currentModel: parentModel,
+        scopedModelIds: scopedModelIdsFromContext(input.ctx),
         modelScope,
         modelResponseAliases: input.deps.config.modelResponseAliases,
+        runnerLaunchers: input.deps.config.runnerLaunchers,
         interactive: input.ctx.hasUI,
         permissions: input.deps.config.permissions,
-        childRuntime: input.deps.childRuntime
+        childRuntime: input.deps.childRuntime,
+        projectTrusted: sessionProjectTrust(input.ctx)
       }),
       availableModels,
       cwd: effectiveCwd,
@@ -1749,16 +1810,13 @@ async function resumeAsyncRun(input) {
   if (!revivalSessionFile) {
     return { content: [{ type: "text", text: `Async run '${target.runId}' child ${target.index} does not have a persisted session file to resume from.` }], isError: true, details: { mode: "management", results: [] } };
   }
-  if (input.params.baseRef !== undefined && "managedWorktree" in target && target.managedWorktree === true) {
-    return { content: [{ type: "text", text: "Cannot resume with baseRef: retained managed-worktree children continue in their existing worktree. Start a new worktree run from that base ref instead." }], isError: true, details: { mode: "management", results: [] } };
-  }
   if (target.source === "async" && asyncReviveRequiresRecoveryDescriptor(target)) {
     return { content: [{ type: "text", text: `Async child '${target.runId}' is missing its required run fan-out recovery identity. Start a new run instead.` }], isError: true, details: { mode: "management", results: [] } };
   }
   if (target.source === "nested" && !target.recoveryDescriptor) {
     return { content: [{ type: "text", text: `Nested child '${target.runId}' is missing its required recovery identity. Start a new run instead.` }], isError: true, details: { mode: "management", results: [] } };
   }
-  const recoveryAgentConfig = recoveryDescriptor ? applySteeringRecoveryAgentConfig(baseAgentConfig, recoveryDescriptor) : baseAgentConfig;
+  const recoveryAgentConfig = recoveryDescriptor ? applySteeringRecoveryAgentConfig(baseAgentConfig, recoveryDescriptor) : { ...baseAgentConfig, launcher: undefined };
   const agentConfig = intercomBridge.active ? applyIntercomBridgeToAgent(recoveryAgentConfig, intercomBridge) : recoveryAgentConfig;
   const foregroundContract = target.source === "foreground" ? target.resumeContract : undefined;
   const outputSchema = Object.hasOwn(input.params, "outputSchema") ? input.params.outputSchema : Object.hasOwn(foregroundContract ?? {}, "outputSchema") ? foregroundContract?.outputSchema : recoveryDescriptor?.structuredOutputSchema;
@@ -1767,6 +1825,9 @@ async function resumeAsyncRun(input) {
   if (acceptanceErrors.length > 0) {
     return { content: [{ type: "text", text: `Cannot resume: ${acceptanceErrors.join(" ")}` }], isError: true, details: { mode: "management", results: [] } };
   }
+  if (agentConfig.launcher !== undefined && !lookupRunnerLauncher(input.deps.config.runnerLaunchers, agentConfig.launcher)) {
+    return { content: [{ type: "text", text: `Cannot resume: run '${target.runId}' was launched with launcher '${agentConfig.launcher}', which is no longer defined in runnerLaunchers in the user subagent config.` }], isError: true, details: { mode: "management", results: [] } };
+  }
   const runId = randomUUID();
   const topLevelResume = depth === 0 && !inheritedNestedRoute(input.deps) && !input.params.workflowParentRunId;
   let activeAsyncCapacity;
@@ -1806,13 +1867,17 @@ async function resumeAsyncRun(input) {
       cwd: input.requestCwd,
       currentSessionId: input.deps.state.currentSessionId,
       parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
+      parentSessionFile: input.ctx.sessionManager.getSessionFile() ?? undefined,
       currentModelProvider: parentModel?.provider,
       currentModel: parentModel,
+      scopedModelIds: scopedModelIdsFromContext(input.ctx),
       modelScope,
       modelResponseAliases: recoveryDescriptor ? recoveryDescriptor.modelResponseAliases : foregroundContract?.modelResponseAliases,
+      runnerLaunchers: input.deps.config.runnerLaunchers,
       interactive: input.ctx.hasUI,
       permissions: input.deps.config.permissions,
-      childRuntime: input.deps.childRuntime
+      childRuntime: input.deps.childRuntime,
+      projectTrusted: sessionProjectTrust(input.ctx)
     }),
     cwd: effectiveCwd,
     maxOutput: input.params.maxOutput ?? recoveryDescriptor?.maxOutput,
@@ -1904,68 +1969,33 @@ async function resumeAsyncRun(input) {
   if (input.params.workflowParentRunId !== undefined && result.details.asyncDir) {
     const asyncDir = result.details.asyncDir;
     const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
-    const stopOnAbort = () => {
-      stopAsyncRun(input.deps.state, revivedId, input.deps.kill, { asyncDir, resolvedId: revivedId });
-    };
-    if (input.signal?.aborted)
-      stopOnAbort();
-    else
-      input.signal?.addEventListener("abort", stopOnAbort, { once: true });
-    let completed;
-    try {
-      completed = await waitForImportedAsyncRoot({ runId: revivedId, asyncDir, resultPath, index: 0 });
-    } finally {
-      input.signal?.removeEventListener("abort", stopOnAbort);
-    }
-    if (completed.importedPublication)
-      removeWorkflowAwaitedResult(asyncDir, resultPath, revivedId, completed.importedPublication);
-    emitWorkflowAwaitedChildComplete(input.deps.dm, input.deps.state, revivedId, asyncDir, input.params.workflowParentRunId, completed);
-    const usage = importedAsyncRootUsage(completed);
-    const childResult = {
-      index: 0,
-      agent: completed.agent,
-      ...completed.sessionName ? { sessionName: completed.sessionName } : {},
-      task: effectiveFollowUp,
-      exitCode: completed.exitCode,
-      usage,
-      finalOutput: completed.output,
-      outputState: completed.output.trim() ? "present" : "absent",
-      ...completed.error ? { error: completed.error } : {},
-      ...completed.timedOut ? { timedOut: true } : {},
-      ...completed.stopped ? { stopped: true } : {},
-      ...completed.sessionFile ? { sessionFile: completed.sessionFile } : {},
-      ...completed.model ? { model: completed.model } : {},
-      ...completed.requestedModel ? { requestedModel: completed.requestedModel } : {},
-      ...completed.contextOverflow ? { contextOverflow: true } : {},
-      ...completed.structuredOutput !== undefined ? { structuredOutput: completed.structuredOutput } : {},
-      ...completed.structuredOutputPath ? { structuredOutputPath: completed.structuredOutputPath } : {},
-      ...completed.structuredOutputSchemaPath ? { structuredOutputSchemaPath: completed.structuredOutputSchemaPath } : {},
-      ...completed.acceptance ? { acceptance: completed.acceptance } : {},
-      ...completed.artifactPaths ? { artifactPaths: completed.artifactPaths } : {},
-      ...completed.savedOutputPath ? { savedOutputPath: completed.savedOutputPath } : {},
-      ...completed.outputSaveError ? { outputSaveError: completed.outputSaveError } : {},
-      ...completed.transcriptPath ? { transcriptPath: completed.transcriptPath } : {},
-      ...completed.transcriptError ? { transcriptError: completed.transcriptError } : {}
-    };
-    return {
-      content: [{ type: "text", text: completed.success ? completed.output || completed.error || `Revived ${target.source} subagent ${revivedId} completed without output.` : completed.error || completed.output || `Revived ${target.source} subagent ${revivedId} completed without output.` }],
-      ...completed.success ? {} : { isError: true },
-      details: {
-        ...result.details,
-        runId: revivedId,
-        results: [childResult],
-        ...target.launchContractDigest ? { sourceLaunchContractDigest: target.launchContractDigest } : {}
-      }
-    };
+    const stopListener = stopAwaitedAsyncChildOnAbort(input.signal, input.deps.state, revivedId, asyncDir, input.deps.kill);
+    const completed = await waitForImportedAsyncRoot({ runId: revivedId, asyncDir, resultPath, index: 0 }, {
+      shouldAbort: () => input.signal?.aborted === true,
+      timeoutMessage: "Workflow stopped before async child completed.",
+      abortedAsStopped: true
+    }).finally(stopListener.remove);
+    const details = { ...result.details };
+    if (target.launchContractDigest)
+      details.sourceLaunchContractDigest = target.launchContractDigest;
+    return importWorkflowAwaitedChildResult(completed, { runId: revivedId, asyncDir, resultPath, task: effectiveFollowUp, parentWorkflowRunId: input.params.workflowParentRunId, details, emptyOutputText: `Revived ${target.source} subagent ${revivedId} completed without output.`, state: input.deps.state, dm: input.deps.dm });
   }
   const revivedTarget = intercomBridge.active ? resolveSubagentIntercomTarget(revivedId, target.agent, 0) : undefined;
   const sourceLabel = target.source;
+  let workflowRevivalWarning;
+  try {
+    if (target.source === "async")
+      recordWorkflowRevival(DIRS.async, target.runId, revivedId);
+  } catch (error) {
+    workflowRevivalWarning = `Warning: workflow key link not recorded: ${error instanceof Error ? error.message : String(error)}`;
+  }
   const lines = [
     `Revived ${sourceLabel} subagent from ${target.runId}.`,
     `Revived run: ${revivedId}`,
     `Agent: ${target.agent}`,
     `Session: ${target.sessionFile}`,
     result.details.asyncDir ? `Async dir: ${result.details.asyncDir}` : undefined,
+    workflowRevivalWarning,
     revivedTarget ? `Intercom target: ${revivedTarget} (if registered)` : undefined,
     `Status if needed: subagent({ action: "status", id: "${revivedId}" })`
   ].filter((line) => Boolean(line));
@@ -1992,10 +2022,12 @@ function formatFailedSingleRunOutput(result, displayOutput) {
   const error = result.error || "Failed";
   const output = displayOutput.trim();
   const lines = [error];
+  let cappedOutput = output;
   if (output && output !== error.trim()) {
-    lines.push("", "Output:", output);
+    cappedOutput = capInlineOutput(output, { artifactPath: result.artifactPaths?.outputPath, savedPath: result.savedOutputPath });
+    lines.push("", "Output:", cappedOutput);
   }
-  if (result.artifactPaths?.outputPath && fs.existsSync(result.artifactPaths.outputPath)) {
+  if (cappedOutput === output && result.artifactPaths?.outputPath && fs.existsSync(result.artifactPaths.outputPath)) {
     lines.push("", `Output artifact: ${result.artifactPaths.outputPath}`);
   }
   return lines.join(`
@@ -2050,6 +2082,7 @@ async function emitForegroundResultIntercom(input) {
     ...result.sessionName ? { sessionName: result.sessionName } : {},
     status: foregroundResultIntercomStatus(result),
     outputState: result.outputState ?? "unknown",
+    ...result.outputPartial ? { outputPartial: true } : {},
     summary: resultSummaryForIntercom(result),
     index,
     artifactPath: result.artifactPaths?.outputPath,
@@ -2107,6 +2140,30 @@ function canonicalizeAgentName(name, agents, diagnostics, context) {
     return { error: formatUnknownAgentError(name, context) };
   return { name: resolved.agent.name };
 }
+function workflowValidationOptions(deps, params, runtimeCwd, parentModelProvider) {
+  const cwd = resolveRequestedCwd(runtimeCwd, params.cwd);
+  const scope = resolveExecutionAgentScope(params.agentScope);
+  let discovered;
+  let listedAgents = false;
+  return {
+    maxSubagentSpawnsPerRun: params.maxSubagentSpawnsPerRun ?? resolveMaxSubagentSpawnsPerRun(deps.config.maxSubagentSpawnsPerRun),
+    agentNameError: (name) => {
+      discovered ??= deps.discoverAgents(cwd, scope, parentModelProvider());
+      const { agents } = discovered;
+      const resolved = resolveAgentName(name, agents);
+      if (resolved.agent || resolved.error)
+        return canonicalizeAgentName(name, agents, discovered.agentDiagnostics, diagnosticContextFromDiscovery(discovered, cwd, scope)).error;
+      const disabled = discovered.disabledAgents?.includes(name.trim()) === true;
+      const suggestion = disabled ? undefined : suggestAgentName(name, agents);
+      const problem = disabled ? `Agent '${name}' is disabled by a settings override.` : `Unknown agent '${name}'.${suggestion ? ` Did you mean '${suggestion}'?` : ""}`;
+      if (listedAgents)
+        return problem;
+      listedAgents = true;
+      return [`${problem} Available agents:`, ...formatAvailableAgentLines(agents)].join(`
+`);
+    }
+  };
+}
 function canonicalizeExecutionParams(params, agents, diagnostics, context) {
   const resolve = (name, location) => {
     const result = canonicalizeAgentName(name, agents, diagnostics, context);
@@ -2475,6 +2532,9 @@ export const DEFAULT_FOREGROUND_TIMEOUT_MS = 30 * 60 * 1000;
 
 export { DEFAULT_ASYNC_TIMEOUT_MS };
 const MAX_TIMER_DELAY_MS = 2147483647;
+function timerDelayOverflowError(name, value) {
+  return typeof value === "number" && value > MAX_TIMER_DELAY_MS ? `${name} must be a positive integer no larger than ${MAX_TIMER_DELAY_MS}.` : undefined;
+}
 export function resolveConfigDefaultTimeoutMs(raw) {
   if (typeof raw !== "number" || !Number.isInteger(raw) || raw <= 0 || raw > MAX_TIMER_DELAY_MS)
     return;
@@ -2492,6 +2552,9 @@ export function resolveForegroundTimeout(params, defaultTimeoutMs) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
       return { error: `${name} must be a positive integer.` };
     }
+    const overflowError = timerDelayOverflowError(name, value);
+    if (overflowError)
+      return { error: overflowError };
   }
   if (rawTimeout !== undefined && rawMaxRuntime !== undefined && rawTimeout !== rawMaxRuntime) {
     return { error: "timeoutMs and maxRuntimeMs are aliases; provide only one value or use the same value for both." };
@@ -2605,7 +2668,7 @@ function withAggregatedToolUsage(result) {
   if (projected.details.results.length === 0)
     return projected;
   const usage = sumResultsUsage(projected.details.results);
-  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0 ? { ...projected, details: { ...projected.details, totalChildUsage: usage } } : projected;
+  return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0 ? { ...projected, usage: toAgentToolUsage(usage) } : projected;
 }
 function toExecutionErrorResult(params, error, contextSummary) {
   const message = error instanceof Error ? error.message : String(error);
@@ -2618,7 +2681,7 @@ function toExecutionErrorResult(params, error, contextSummary) {
 function resolveStaticLaunchSummary(input) {
   const agentConfig = input.agents.find((agent) => agent.name === input.agent);
   const externalRunner = agentConfig?.runner?.type === "external-cli" || agentConfig?.runner?.type === "external-job";
-  const modelScopes = resolveModelScopesForAgent(input.modelScope, input.agent, input.parentModel);
+  const modelScopes = resolveModelScopesForAgent(input.modelScope, input.agent, input.parentModel, input.scopedModelIds);
   const model = externalRunner ? undefined : resolveEffectiveSubagentModel(input.explicitModel, agentConfig?.model, input.parentModel, input.availableModels, agentConfig?.modelProvider ?? input.currentProvider, modelScopes.length === 0 ? {} : { scope: modelScopes });
   const thinkingOverride = externalRunner ? undefined : input.thinkingOverrideForTask();
   const thinking = externalRunner ? undefined : resolveEffectiveThinking(model, thinkingOverride ?? agentConfig?.thinking);
@@ -2635,6 +2698,7 @@ function collectStaticLaunchSummaries(input) {
     explicitModel,
     agents: input.agents,
     parentModel: input.parentModel,
+    scopedModelIds: input.scopedModelIds,
     availableModels: input.availableModels,
     currentProvider: input.currentProvider,
     modelScope: input.modelScope,
@@ -2774,9 +2838,10 @@ function importedAsyncRootUsage(completed) {
 }
 function removeWorkflowAwaitedResult(asyncDir, resultPath, runId, publication) {
   try {
-    fs.rmSync(resultPath, { force: true });
-  } catch {}
-  removeResultIndex(asyncDir, publication.sessionId, runId, publication.toolCallId);
+    retireResultSnapshot(workflowAwaitedAsyncResultPath(asyncDir), { ...publication, runId }, resultPath);
+  } catch (error) {
+    console.error(`Failed to remove imported workflow child result '${resultPath}'; leaving it in place:`, error);
+  }
 }
 function emitWorkflowAwaitedChildComplete(dm, state, runId, asyncDir, parentWorkflowRunId, completed) {
   let status;
@@ -2801,30 +2866,10 @@ function emitWorkflowAwaitedChildComplete(dm, state, runId, asyncDir, parentWork
     parentWorkflowRunId
   });
 }
-async function waitForWorkflowAsyncSingleResult(params, launchResult, options) {
-  if (params.workflowAwaitAsync !== true || !launchResult.details.asyncDir)
-    return launchResult;
-  const asyncDir = launchResult.details.asyncDir;
-  const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
-  const stopOnAbort = () => {
-    stopAsyncRun(options.state, options.runId, options.kill, { asyncDir, resolvedId: options.runId });
-  };
-  if (options.signal?.aborted)
-    stopOnAbort();
-  else
-    options.signal?.addEventListener("abort", stopOnAbort, { once: true });
-  let completed;
-  try {
-    completed = await waitForImportedAsyncRoot({ runId: options.runId, asyncDir, resultPath, index: 0 }, omitUndefinedProperties({
-      shouldAbort: () => options.signal?.aborted === true,
-      timeoutMessage: "Workflow stopped before async child completed."
-    }));
-  } finally {
-    options.signal?.removeEventListener("abort", stopOnAbort);
-  }
+function importWorkflowAwaitedChildResult(completed, options) {
   if (completed.importedPublication)
-    removeWorkflowAwaitedResult(asyncDir, resultPath, options.runId, completed.importedPublication);
-  emitWorkflowAwaitedChildComplete(options.dm, options.state, options.runId, asyncDir, params.workflowParentRunId, completed);
+    removeWorkflowAwaitedResult(options.asyncDir, options.resultPath, options.runId, completed.importedPublication);
+  emitWorkflowAwaitedChildComplete(options.dm, options.state, options.runId, options.asyncDir, options.parentWorkflowRunId, completed);
   const usage = importedAsyncRootUsage(completed);
   const childResult = omitUndefinedProperties({
     index: 0,
@@ -2853,15 +2898,52 @@ async function waitForWorkflowAsyncSingleResult(params, launchResult, options) {
     ...completed.transcriptError ? { transcriptError: completed.transcriptError } : {}
   });
   return {
-    content: [{ type: "text", text: completed.success ? completed.output || completed.error || `Async workflow child ${options.runId} completed without output.` : completed.error || completed.output || `Async workflow child ${options.runId} completed without output.` }],
+    content: [{ type: "text", text: (completed.success ? completed.output || completed.error : completed.error || completed.output) || (options.emptyOutputText ?? `Async workflow child ${options.runId} completed without output.`) }],
     ...completed.success ? {} : { isError: true },
     details: {
-      ...launchResult.details,
+      ...options.details,
       runId: options.runId,
       results: [childResult]
     }
   };
 }
+function stopAwaitedAsyncChildOnAbort(signal, state, runId, asyncDir, kill) {
+  const stopOnAbort = () => {
+    if (!workflowStopCause(signal?.reason))
+      stopAsyncRun(state, runId, kill, { asyncDir, resolvedId: runId });
+  };
+  if (signal?.aborted)
+    stopOnAbort();
+  else
+    signal?.addEventListener("abort", stopOnAbort, { once: true });
+  return { remove: () => signal?.removeEventListener("abort", stopOnAbort) };
+}
+function resolveLiveWorkflowRunId(deps, id) {
+  const controllers = deps.state.workflowControllers;
+  if (!controllers?.size)
+    return;
+  if (controllers.has(id))
+    return id;
+  try {
+    const resolved = resolveSubagentRunId(id, omitUndefinedProperties({ state: deps.state, nested: nestedResolutionScopeForExecutor(deps) }));
+    return resolved?.kind === "async" && controllers.has(resolved.id) ? resolved.id : undefined;
+  } catch {
+    return;
+  }
+}
+async function waitForWorkflowAsyncSingleResult(params, launchResult, options) {
+  if (params.workflowAwaitAsync !== true || !launchResult.details.asyncDir)
+    return launchResult;
+  const asyncDir = launchResult.details.asyncDir;
+  const resultPath = workflowAwaitedAsyncResultPath(asyncDir);
+  const stopListener = stopAwaitedAsyncChildOnAbort(options.signal, options.state, options.runId, asyncDir, options.kill);
+  const completed = await waitForImportedAsyncRoot({ runId: options.runId, asyncDir, resultPath, index: 0 }, omitUndefinedProperties({
+    shouldAbort: () => options.signal?.aborted === true,
+    timeoutMessage: "Workflow stopped before async child completed.",
+    abortedAsStopped: true
+  })).finally(stopListener.remove);
+  return importWorkflowAwaitedChildResult(completed, { runId: options.runId, asyncDir, resultPath, task: options.task, parentWorkflowRunId: params.workflowParentRunId, details: launchResult.details, state: options.state, dm: options.dm });
+}
 async function runAsyncPath(data, deps) {
   const {
     params,
@@ -2900,13 +2982,17 @@ async function runAsyncPath(data, deps) {
     cwd: ctx.cwd,
     currentSessionId: data.parentSessionId,
     parentSessionId: data.parentPiSessionId,
+    parentSessionFile: ctx.sessionManager.getSessionFile() ?? undefined,
     currentModelProvider: parentModel?.provider,
     currentModel: parentModel,
+    scopedModelIds: data.scopedModelIds,
     modelScope: data.modelScope,
     modelResponseAliases: deps.config.modelResponseAliases,
+    runnerLaunchers: deps.config.runnerLaunchers,
     interactive: ctx.hasUI,
     permissions: deps.config.permissions,
-    childRuntime: deps.childRuntime
+    childRuntime: deps.childRuntime,
+    projectTrusted: sessionProjectTrust(ctx)
   });
   const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
   const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth, deps.childRuntime);
@@ -2932,7 +3018,7 @@ async function runAsyncPath(data, deps) {
     if ((a.runner?.type === "external-cli" || a.runner?.type === "external-job") && (params.fast ?? a.fast) === true) {
       return buildRequestedModeError(params, `Agent '${a.name}' uses runner.type='${a.runner.type}' and does not support fast mode.`);
     }
-    const modelScopes = resolveModelScopesForAgent(data.modelScope, a.name, parentModel);
+    const modelScopes = resolveModelScopesForAgent(data.modelScope, a.name, parentModel, data.scopedModelIds);
     const modelOrigin = resolveModelOrigin({
       storedOrigin: params.modelOrigin,
       explicitModel: params.model,
@@ -2948,11 +3034,13 @@ async function runAsyncPath(data, deps) {
     if (launchRuleError)
       return toExecutionErrorResult(params, new Error(launchRuleError), data.contextPolicy.contextSummary);
     const asyncResult = await executeAsyncSingle(id, compactOptional({
+      toolCallId: data.toolCallId,
       agent: params.agent,
       task: shouldForkAgent(contextPolicy, params.agent) ? wrapForkTask(params.task ?? "") : params.task ?? "",
       goal: params.task ?? "",
       agentConfig: a,
       recoveryAgentConfig: data.recoveryAgents.find((agent) => agent.name === params.agent),
+      requiredExtensions: data.requiredExtensions,
       ctx: asyncCtx,
       availableModels,
       cwd: effectiveCwd,
@@ -3095,6 +3183,39 @@ function appendWorkflowOutputWarning(text, warning) {
 
 ${warning}` : text;
 }
+const WORKFLOW_TRACE_ERROR_MAX_CHARS = 500;
+function formatWorkflowResultText(input) {
+  const traceSection = (error) => input.trace.length > 0 ? [`Call trace:
+${input.trace.map((entry) => `${entry.line}${entry.error ? ` — ${error(entry.error)}` : ""}`).join(`
+`)}`] : [];
+  const fullText = [...input.head, ...input.script, ...traceSection((error) => error), ...input.tail].join(`
+
+`);
+  const outputWarning = writeWorkflowAggregateOutput(input.aggregateOutputPath, fullText, input.producedChildOutputPaths);
+  const scriptText = input.script.join(`
+
+`);
+  const config = { ...DEFAULT_MAX_OUTPUT, ...input.maxOutput };
+  const scriptCut = truncateOutput(scriptText, config).truncated;
+  const traceCut = input.trace.some((entry) => (entry.error?.length ?? 0) > WORKFLOW_TRACE_ERROR_MAX_CHARS);
+  let shownScriptText = scriptText;
+  let saveWarning;
+  let savedPath;
+  if (scriptCut || traceCut) {
+    const aggregateHoldsFullText = input.aggregateOutputPath !== undefined && !outputWarning && !input.producedChildOutputPaths.has(resolveWorkflowHostOutputClaimPath(input.aggregateOutputPath));
+    if (!aggregateHoldsFullText)
+      saveWarning = writeWorkflowAggregateOutput(input.fullResultPath, fullText, new Set);
+    savedPath = aggregateHoldsFullText ? input.aggregateOutputPath : saveWarning ? undefined : input.fullResultPath;
+    if (scriptCut)
+      shownScriptText = truncateOutput(scriptText, config, savedPath).text;
+  }
+  const shownTrace = traceSection((error) => error.length > WORKFLOW_TRACE_ERROR_MAX_CHARS ? `${error.slice(0, WORKFLOW_TRACE_ERROR_MAX_CHARS)}… (+${error.length - WORKFLOW_TRACE_ERROR_MAX_CHARS} chars)` : error);
+  const traceNote = traceCut && !scriptCut && savedPath ? [`[TRUNCATED: trace errors shortened - full output at ${savedPath}]`] : [];
+  const text = [...input.head, ...shownScriptText ? [shownScriptText] : [], ...shownTrace, ...input.tail, ...traceNote].join(`
+
+`);
+  return appendWorkflowOutputWarning(appendWorkflowOutputWarning(text, outputWarning), saveWarning);
+}
 export function resolveWorkflowChildLocalCwd(input) {
   if (input.params.machine !== undefined)
     return input.workflowCwd;
@@ -3118,7 +3239,11 @@ function resolveWorkflowChildOutputPath(input) {
       id: input.params.resume.trim(),
       ...typeof index === "number" && Number.isInteger(index) ? { index } : {}
     }, input.state);
-    return { path: "recoveryDescriptor" in target ? target.recoveryDescriptor?.outputPath : undefined, inherited: false };
+    const recoveryOutput = "recoveryDescriptor" in target ? target.recoveryDescriptor?.outputPath : undefined;
+    if (hasExplicitOutput)
+      return { path: recoveryOutput, inherited: false };
+    const foregroundOutput = target.source === "foreground" ? target.resumeContract?.output : undefined;
+    return { path: recoveryOutput, inherited: false, resumedOutput: recoveryOutput ?? (typeof foregroundOutput === "string" && path.isAbsolute(foregroundOutput) ? foregroundOutput : undefined) };
   }
   const childCwd = resolveWorkflowChildLocalCwd(input);
   let agentOutput;
@@ -3150,7 +3275,8 @@ function workflowChildOutputClaims(input) {
   }
   const overrides = new Map;
   for (const entry of resolvedEntries) {
-    if (entry.inherited && entry.path && (paths.get(resolveWorkflowHostOutputClaimPath(entry.path)) ?? 0) > 1) {
+    const resumeCollides = entry.resumedOutput !== undefined && input.claimedOutputPaths.has(resolveWorkflowHostOutputClaimPath(entry.resumedOutput));
+    if (resumeCollides || entry.inherited && entry.path && (paths.get(resolveWorkflowHostOutputClaimPath(entry.path)) ?? 0) > 1) {
       const output = workflowChildDefaultOutput(input.aggregateOutputPath, input.artifactsDir, input.workflowRunId, entry.key);
       overrides.set(entry.key, output);
       entry.path = output;
@@ -3168,6 +3294,15 @@ function workflowChildOutputClaims(input) {
     claims.set(claimPath, key);
     childClaims.set(key, claimPath);
   }
+  for (const { key, path: resolved, resumedOutput } of resolvedEntries) {
+    if (resolved || !resumedOutput)
+      continue;
+    const claimPath = resolveWorkflowHostOutputClaimPath(resumedOutput);
+    if (claims.has(claimPath))
+      continue;
+    claims.set(claimPath, key);
+    childClaims.set(key, claimPath);
+  }
   return { claims, childClaims, overrides };
 }
 function applyWorkflowChildOutputClaims(target, claims) {
@@ -3178,7 +3313,7 @@ function applyWorkflowChildOutputClaims(target, claims) {
 function prepareWorkflowChildLaunchParams(input) {
   let childParams = input.childParams;
   const usesDefaultOutput = input.childParams.output === undefined && input.childParams.resume === undefined;
-  if (usesDefaultOutput && input.outputOverride !== undefined) {
+  if (input.childParams.output === undefined && input.outputOverride !== undefined) {
     childParams = { ...input.childParams, output: input.outputOverride };
   } else if (usesDefaultOutput && input.aggregateOutputPath !== undefined) {
     childParams = { ...input.childParams, output: workflowChildDefaultOutput(input.aggregateOutputPath, input.artifactsDir, input.parentWorkflowRunId, input.workflowKey) };
@@ -3191,7 +3326,7 @@ function prepareWorkflowChildLaunchParams(input) {
   const agentScope = resolveExecutionAgentScope(childParams.agentScope ?? input.workflowAgentScope);
   const discoveredAgents = input.discoverAgents(childCwd, agentScope).agents;
   const agent = typeof childParams.agent === "string" ? resolveAgentName(childParams.agent, discoveredAgents).agent ?? resolveAgentName(childParams.agent, input.agents).agent : undefined;
-  const externalAsyncRequired = agent?.runner?.type === "external-cli" || agent?.runner?.type === "external-job";
+  const externalAsyncRequired = agent?.runner?.type === "external-cli" || agent?.runner?.type === "external-job" || agent?.launcher !== undefined;
   return prepareWorkflowLaunchParams(input.workflowDefaults, childParams, input.parentWorkflowRunId, input.workflowKey, { ...input.options, externalAsyncRequired, outputClaimPath: input.outputClaimPath });
 }
 async function finalizeSingleWorktreeHandoff(input) {
@@ -3328,8 +3463,10 @@ async function runSinglePath(data, deps) {
   }
   let foregroundMachine;
   const requestedMachine = params.machine ?? agentConfig.machine;
+  const requiredExtensions = data.requiredExtensions ?? deps.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(data.parentPiSessionId);
   if (requestedMachine) {
     try {
+      assertRequiredChildExtensionsAdmitted([requiredExtensions], { agent: agentConfig.name, runnerType: agentConfig.runner?.type, machine: requestedMachine });
       foregroundMachine = resolveHerdrMachinePlacement({ machine: requestedMachine, cwd: ctx.cwd, stepCwd: params.machineCwd }).machine;
     } catch (error) {
       return toExecutionErrorResult(params, error instanceof Error ? error : new Error(String(error)), data.contextPolicy.contextSummary);
@@ -3341,7 +3478,7 @@ async function runSinglePath(data, deps) {
   const parentModel = data.parentModel;
   const currentProvider = parentModel?.provider;
   const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
-  const modelScopes = resolveModelScopesForAgent(data.modelScope, agentConfig.name, parentModel);
+  const modelScopes = resolveModelScopesForAgent(data.modelScope, agentConfig.name, parentModel, data.scopedModelIds);
   let task = typeof params.task === "string" ? params.task : "";
   const modelOrigin = resolveModelOrigin({
     storedOrigin: params.modelOrigin,
@@ -3449,7 +3586,25 @@ async function runSinglePath(data, deps) {
   const interruptController = new AbortController;
   let detachForeground;
   let childSessionControls;
+  let pendingRuntimeStop;
   const foregroundControl = deps.state.foregroundControls.get(runId);
+  const syncHerdrForegroundChild = () => {
+    if (!foregroundControl?.parentWorkflowRunId)
+      return;
+    try {
+      deps.dm.events.emit(HERDR_FOREGROUND_CONTROL_CHANGED_EVENT, { runId: foregroundControl.parentWorkflowRunId });
+    } catch (error) {
+      console.error("Failed to sync Herdr foreground child:", error);
+    }
+  };
+  const finishTrackedForegroundChild = () => {
+    if (!foregroundControl)
+      return;
+    const wasActive = foregroundControl.activeChildren?.has(0) === true;
+    finishForegroundChild(foregroundControl, 0);
+    if (wasActive)
+      syncHerdrForegroundChild();
+  };
   if (foregroundControl) {
     const thinking = resolveEffectiveThinking(modelOverride, thinkingOverrideForTask());
     beginForegroundChild(foregroundControl, omitUndefinedProperties({
@@ -3487,6 +3642,7 @@ async function runSinglePath(data, deps) {
     }));
     if (deps.childRuntime?.fanoutChild)
       deps.activateSupervisorTransport?.();
+    syncHerdrForegroundChild();
   }
   const modelResponseAliases = deps.config.modelResponseAliases === undefined ? undefined : structuredClone(deps.config.modelResponseAliases);
   const forwardSingleUpdate = onUpdate ? (update) => {
@@ -3495,24 +3651,28 @@ async function runSinglePath(data, deps) {
     onUpdate(update);
   } : undefined;
   const deadlineAt = data.deadlineAt ?? (data.timeoutMs !== undefined ? Date.now() + data.timeoutMs : undefined);
-  const requiredExtensions = deps.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(data.parentPiSessionId);
   let r;
   let resolveDetachedWorkflowChild;
   const detachedWorkflowChild = params.workflowAwaitDetached === true ? new Promise((resolve) => {
     resolveDetachedWorkflowChild = resolve;
   }) : undefined;
   try {
+    const childSessionFile = sessionFileForTask(params.agent, 0, modelOverride, modelOverrideFromParent, modelOrigin);
     const launched = await runSync(ctx.cwd, agents, params.agent, task, compactOptional({
       machine: foregroundMachine,
       parentProviderRegistry: ctx.modelRegistry,
+      projectTrusted: sessionProjectTrust(ctx),
       remoteReads: foregroundMachine ? readsOverride : undefined,
       permissions: deps.config.permissions,
       runtimeSnapshotHost: deps.dm,
       parentSessionId: ctx.sessionManager.getSessionId() ?? undefined,
+      parentSessionFile: ctx.sessionManager.getSessionFile() ?? undefined,
       requiredExtensions,
       childRuntime: deps.childRuntime,
       onChildSession: (controls) => {
         childSessionControls = controls;
+        if (pendingRuntimeStop)
+          controls.stop(pendingRuntimeStop);
       },
       context: data.contextPolicy.contextForAgent(params.agent),
       unknownAgentDiagnosticContext: data.unknownAgentDiagnosticContext,
@@ -3520,12 +3680,13 @@ async function runSinglePath(data, deps) {
       cwd: singleCwd,
       requestedCwd: data.requestedCwd,
       signal,
+      abortedAsStopped: params.workflowParentRunId !== undefined,
       interruptSignal: interruptController.signal,
       allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
       intercomEvents: deps.dm.events,
       runId,
       sessionDir: sessionDirForIndex(0),
-      sessionFile: sessionFileForTask(params.agent, 0, modelOverride, modelOverrideFromParent, modelOrigin),
+      sessionFile: childSessionFile,
       share: shareEnabled,
       artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
       artifactConfig,
@@ -3566,6 +3727,8 @@ async function runSinglePath(data, deps) {
         detachForeground = detach;
       },
       onDetachedExit: async (result) => {
+        if (foregroundControl)
+          foregroundControl.stopForRuntimeReplacement = undefined;
         if (resolveDetachedWorkflowChild) {
           resolveDetachedWorkflowChild(result);
           return;
@@ -3594,8 +3757,7 @@ async function runSinglePath(data, deps) {
               cleanupStructuredOutputRuntime(structuredRuntime);
           } finally {
             try {
-              if (foregroundControl)
-                finishForegroundChild(foregroundControl, 0);
+              finishTrackedForegroundChild();
             } finally {
               removeForegroundControlIfIdle(deps.state, runId, deps.trackRetainedNestedRoute);
             }
@@ -3612,6 +3774,17 @@ async function runSinglePath(data, deps) {
       capabilityCeiling: data.capabilityCeiling,
       allowZeroToolBudget: data.allowZeroToolBudget && effectiveToolBudget.toolBudget === data.toolBudget
     }));
+    if (launched.detached && foregroundControl) {
+      foregroundControl.stopForRuntimeReplacement = () => {
+        const sessionFile = childSessionFile && fs.existsSync(childSessionFile) ? childSessionFile : undefined;
+        const stopped = { ...launched, detached: undefined, stopped: true, exitCode: 1, error: RUNTIME_REPLACED_STOP_ERROR, finalOutput: RUNTIME_REPLACED_STOP_ERROR, sessionFile };
+        rememberForegroundRun(deps.state, { modelResponseAliases, runId, mode: "single", cwd: singleCwd, sessionId: data.parentSessionId, results: [stopped], params, effectiveOutput, effectiveOutputMode, extensionBindings: params.extensionBindings, requiredExtensions });
+        if (childSessionControls)
+          childSessionControls.stop(RUNTIME_REPLACED_STOP_ERROR);
+        else
+          pendingRuntimeStop = RUNTIME_REPLACED_STOP_ERROR;
+      };
+    }
     r = launched.detached && detachedWorkflowChild ? await detachedWorkflowChild : launched;
   } catch (error) {
     await cleanupSingleWorktree();
@@ -3620,8 +3793,7 @@ async function runSinglePath(data, deps) {
     if (!r?.detached) {
       if (!artifactConfig.enabled)
         cleanupStructuredOutputRuntime(structuredRuntime);
-      if (foregroundControl)
-        finishForegroundChild(foregroundControl, 0);
+      finishTrackedForegroundChild();
     }
   }
   if (!r.detached) {
@@ -3714,12 +3886,12 @@ ${worktreeHandoff.suffix}` : "";
       isError: true
     };
   return {
-    content: [{ type: "text", text: `${finalizedOutput.displayOutput || "(no output)"}${worktreeSuffix}` }],
+    content: [{ type: "text", text: `${capInlineOutput(finalizedOutput.displayOutput, { artifactPath: r.artifactPaths?.outputPath, savedPath: finalizedOutput.savedPath }) || "(no output)"}${worktreeSuffix}` }],
     details
   };
 }
 function inferExecutionMode(params) {
-  if (params.workflowScript !== undefined)
+  if (params.workflowScript !== undefined || params.workflow !== undefined)
     return "workflow";
   if ((params.chain?.length ?? 0) > 0)
     return "chain";
@@ -3739,6 +3911,7 @@ function duplicateSubagentCallResult(params) {
 }
 const workflowLaunchObservers = new WeakMap;
 const workflowOwnedUsageBudgets = new WeakMap;
+const workflowRetainedRequiredExtensions = new WeakMap;
 const missionsMissingFromStore = new Set;
 function recordMissionWorkflowChild(binding, workflowRunId, key, update) {
   if (!binding || missionsMissingFromStore.has(binding.missionId))
@@ -3793,7 +3966,8 @@ function workflowChildResult(key, result, childParams = {}, resumeState, forcedT
 `);
   const output = running ? "" : result.details.results.length === 1 && result.details.results[0]?.finalOutput !== undefined ? result.details.results[0].finalOutput : receiptOutput;
   const childError = result.details.results.map((child) => child.error).find((error) => Boolean(error));
-  const failureErrorBase = childError && receiptOutput ? receiptOutput.includes(childError) ? receiptOutput : `${childError}
+  const stopped = result.details.results.some((child) => child.stopped);
+  const failureErrorBase = stopped && childError ? childError : childError && receiptOutput ? receiptOutput.includes(childError) ? receiptOutput : `${childError}
 
 ${receiptOutput}` : childError || receiptOutput || output || "Child run failed.";
   const savedOutputEvidence = [...new Set(result.details.results.map((child) => child.savedOutputPath).filter((value) => Boolean(value)))].filter((savedOutputPath) => !failureErrorBase.includes(savedOutputPath)).map((savedOutputPath) => `Saved output: ${savedOutputPath}`);
@@ -3801,7 +3975,6 @@ ${receiptOutput}` : childError || receiptOutput || output || "Child run failed."
 `);
   const detached = result.details.results.some((child) => child.detached);
   const interrupted = result.details.results.some((child) => child.interrupted);
-  const stopped = result.details.results.some((child) => child.stopped);
   const terminalOutcome = forcedTerminalOutcome ?? (result.details.results.some((child) => child.timedOut) ? { state: "partial", reason: "timeout" } : result.details.usageBudget?.exhausted || result.details.results.some((child) => child.turnBudgetExceeded || child.toolBudgetBlocked) ? { state: "partial", reason: "budget_exhausted" } : undefined);
   const acceptanceRecovery = result.details.results.find((child) => child.acceptance?.recovery)?.acceptance?.recovery;
   const ok = result.isError !== true && !running && !detached && !interrupted && !stopped && acceptanceRecovery === undefined;
@@ -3892,9 +4065,9 @@ function workflowRunningChildrenSummary(children) {
   return running.length ? `${running.length} child ${running.length === 1 ? "run remains" : "runs remain"} running or uncollected: ${running.map((child) => `${child.key}=${child.runId}`).join(", ")}. These launch receipts contain no final child results.` : "";
 }
 function workflowResultChildren(children, status, includeFailureFields) {
-  return children.map((child) => {
+  return withWorkflowRevivals(DIRS.async, status.runId, children).map((child) => {
     const sessionName = status.steps?.find((step) => step.workflowKey === child.key)?.sessionName;
-    return { workflowKey: child.key, ...child.agent ? { agent: child.agent } : {}, ...child.runId ? { runId: child.runId } : {}, ...sessionName ? { sessionName } : {}, ...workflowChildAccountingFields(child), output: child.output, outputState: child.output.trim() || child.structuredOutput !== undefined ? "present" : "absent", structuredOutput: child.structuredOutput, ...child.state === "running" ? { state: "running" } : { success: child.ok }, ...child.asyncDir ? { asyncDir: child.asyncDir } : {}, ...child.outputReference ? { outputReference: child.outputReference } : {}, ...includeFailureFields && child.terminalOutcome ? { terminalOutcome: child.terminalOutcome } : {}, ...child.outputPathMapping ? { outputPathMapping: child.outputPathMapping } : {}, ...child.stopped ? { stopped: true } : {}, ...child.interrupted ? { interrupted: true } : {}, ...includeFailureFields && child.detached && status.state !== "complete" ? { detached: true } : {}, ...child.outputArtifactPath || child.outputReference ? { artifactPaths: { outputPath: child.outputArtifactPath ?? child.outputReference } } : {} };
+    return { workflowKey: child.key, ...child.agent ? { agent: child.agent } : {}, ...child.runId ? { runId: child.runId } : {}, ...child.revival ? { revival: formatWorkflowKeyRevival(child.revival) } : {}, ...sessionName ? { sessionName } : {}, ...workflowChildAccountingFields(child), output: child.output, outputState: child.output.trim() || child.structuredOutput !== undefined ? "present" : "absent", structuredOutput: child.structuredOutput, ...child.state === "running" ? { state: "running" } : { success: child.ok }, ...!child.ok && child.error ? { error: child.error } : {}, ...child.asyncDir ? { asyncDir: child.asyncDir } : {}, ...child.outputReference ? { outputReference: child.outputReference } : {}, ...includeFailureFields && child.terminalOutcome ? { terminalOutcome: child.terminalOutcome } : {}, ...child.outputPathMapping ? { outputPathMapping: child.outputPathMapping } : {}, ...child.stopped ? { stopped: true } : {}, ...child.interrupted ? { interrupted: true } : {}, ...includeFailureFields && child.detached && status.state !== "complete" ? { detached: true } : {}, ...child.outputArtifactPath || child.outputReference ? { artifactPaths: { outputPath: child.outputArtifactPath ?? child.outputReference } } : {} };
   });
 }
 function workflowOutputPathMappingSummary(children) {
@@ -3902,7 +4075,11 @@ function workflowOutputPathMappingSummary(children) {
   return mappings.length > 0 ? ` Output path mappings: ${mappings.join("; ")}.` : "";
 }
 function workflowDetailsResults(children) {
-  return children.flatMap((child) => (child.results ?? []).map((result) => result.workflowKey ? result : { ...result, workflowKey: child.key }));
+  return children.flatMap((child) => (child.results ?? []).map((result) => ({
+    ...result,
+    workflowKey: result.workflowKey ?? child.key,
+    ...child.runId && !result.runId ? { runId: child.runId } : {}
+  })));
 }
 function workflowSteerReceipt(key, result) {
   const steering = result.details.steering;
@@ -3921,6 +4098,7 @@ function workflowSteerReceipt(key, result) {
   };
 }
 const CHILD_SESSION_NOT_RUNNING_YET = "Child session is not running yet.";
+const RUNTIME_REPLACED_STOP_ERROR = "Subagent stopped because the dm-subagents runtime that ran it was replaced (reload or session switch).";
 const MAX_WORKFLOW_RESUME_HINT_BYTES = 1024;
 const MAX_WORKFLOW_CHILD_RUN_ID_BYTES = 256;
 const WORKFLOW_RESUME_HINT_PARENT_STATES = new Set(["complete", "failed", "partial"]);
@@ -4017,7 +4195,7 @@ function resolveWorkflowResume(reference, deps, parentSessionFile, index) {
   }
 }
 function terminalWorkflowReceipt(workflowRunId, state, children, workflowChildren, terminalOutcome, hostSteps, resource, argsDigest) {
-  return buildWorkflowReceipt({ workflowRunId, state, children, workflowChildren, terminalOutcome, hostSteps, resource, ...argsDigest ? { argsDigest } : {} });
+  return buildWorkflowReceipt({ workflowRunId, state, children: withWorkflowRevivals(DIRS.async, workflowRunId, children), workflowChildren, terminalOutcome, hostSteps, resource, ...argsDigest ? { argsDigest } : {} });
 }
 function workflowFailureTerminalOutcome(error, _children, usageBudget) {
   if (usageBudget?.exhausted)
@@ -4373,6 +4551,7 @@ function createScheduledOwnerState(source, ownerSessionId, ctx) {
   };
 }
 export function createSubagentExecutor(deps) {
+  const executorDeps = deps;
   const delegatedThinkingOverrides = new WeakMap;
   const delegatedZeroToolBudgets = new WeakSet;
   const delegatedExecutions = new WeakSet;
@@ -4381,9 +4560,28 @@ export function createSubagentExecutor(deps) {
   const workflowPermitContexts = new WeakMap;
   const warnedArtifactPackageDirs = new Set;
   const scheduledOwnerExecutors = new Map;
+  const disabledFeatures = resolveDisabledFeatureSurface(deps.config);
+  const disabledFeatureResult = (params) => {
+    const error = disabledFeatureUseError(params, disabledFeatures);
+    if (!error)
+      return;
+    return { content: [{ type: "text", text: error }], isError: true, details: { mode: params.action === undefined ? inferExecutionMode(params) : "management", results: [] } };
+  };
+  const admitEnabledWorkflowChildren = (calls) => {
+    for (const call of calls) {
+      const error = disabledFeatureUseError(call.params, disabledFeatures, `workflow child '${call.key}'`);
+      if (error)
+        throw new Error(error);
+    }
+  };
   const execute = async (_id, params, signal, onUpdate, ctx, preserveActiveSession = false, parentModelOverride) => {
+    const projectScopeError = projectScopeTrustError(params, ctx);
+    if (projectScopeError)
+      return projectScopeError;
+    const deps = withSessionProjectTrust(executorDeps, ctx);
     const workflowLaunchObserver = workflowLaunchObservers.get(params);
     const inheritedUsageBudget = workflowOwnedUsageBudgets.get(params);
+    const retainedRequiredExtensions = workflowRetainedRequiredExtensions.get(params);
     const delegatedThinkingOverride = delegatedThinkingOverrides.get(params);
     const allowZeroToolBudget = delegatedZeroToolBudgets.has(params);
     const delegatedExecution = delegatedExecutions.has(params);
@@ -4405,9 +4603,18 @@ export function createSubagentExecutor(deps) {
     if (capacityOverrideError)
       return buildRequestedModeError(requestParams, capacityOverrideError);
     let workflowPreflight;
+    const resolveWorkflowParentModel = () => parentModelOverride !== undefined ? parentModelOverride : (() => {
+      const currentParentModel = normalizeParentModel(ctx.model);
+      return (preserveActiveSession ? currentParentModel : rememberParentModel(deps.state, resolveCurrentSessionId(ctx.sessionManager), currentParentModel)) ?? null;
+    })();
+    const validateWorkflowRequest = () => {
+      const validation = validateWorkflowScript(requestParams.workflowScript ?? "", workflowValidationOptions(deps, requestParams, ctx.cwd, () => resolveWorkflowParentModel()?.provider));
+      const normalizedArgs = normalizeWorkflowArgs(requestParams.args);
+      return "error" in normalizedArgs ? { ...validation, ok: false, errors: [...validation.errors, { message: normalizedArgs.error }] } : validation;
+    };
     try {
-      if (requestParams.preflight !== undefined && requestParams.workflowScript === undefined && requestParams.workflowScriptPath === undefined) {
-        throw new Error("preflight requires workflowScript or workflowScriptPath.");
+      if (requestParams.preflight !== undefined && requestParams.workflowScript === undefined) {
+        throw new Error("preflight requires workflow: true or a workflow script path.");
       }
       workflowPreflight = normalizeWorkflowPreflight(requestParams.preflight);
       if (workflowPreflight)
@@ -4415,9 +4622,7 @@ export function createSubagentExecutor(deps) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (requestParams.action?.trim() === "validate") {
-        const validation = validateWorkflowScript(requestParams.workflowScript ?? "", {
-          maxSubagentSpawnsPerRun: requestParams.maxSubagentSpawnsPerRun ?? resolveMaxSubagentSpawnsPerRun(deps.config.maxSubagentSpawnsPerRun)
-        });
+        const validation = validateWorkflowRequest();
         const invalidValidation = { ...validation, ok: false, errors: [...validation.errors, { message }] };
         return {
           content: [{ type: "text", text: JSON.stringify(invalidValidation) }],
@@ -4428,10 +4633,7 @@ export function createSubagentExecutor(deps) {
       return buildRequestedModeError(requestParams, message);
     }
     if (requestParams.action?.trim() === "validate") {
-      const validation = validateWorkflowScript(requestParams.workflowScript ?? "", {
-        maxSubagentSpawnsPerRun: requestParams.maxSubagentSpawnsPerRun ?? resolveMaxSubagentSpawnsPerRun(deps.config.maxSubagentSpawnsPerRun)
-      });
-      return buildWorkflowValidationResult(validation, "management", workflowPreflight);
+      return buildWorkflowValidationResult(validateWorkflowRequest(), "management", workflowPreflight);
     }
     const normalizedAction = typeof requestParams.action === "string" ? requestParams.action.trim() : requestParams.action;
     if (normalizedAction === "resume" && requestParams.extensionBindings !== undefined)
@@ -4449,20 +4651,24 @@ export function createSubagentExecutor(deps) {
       const workflowArgsEvidence = requestParams.args === undefined ? undefined : { args: requestParams.args, argsDigest: stableJsonDigest(requestParams.args) };
       const workflowArgs = workflowArgsEvidence?.args;
       const workflowArgsDigest = workflowArgsEvidence?.argsDigest;
-      const workflowValidation = validateWorkflowScript(requestParams.workflowScript, {
-        maxSubagentSpawnsPerRun: requestParams.maxSubagentSpawnsPerRun ?? resolveMaxSubagentSpawnsPerRun(deps.config.maxSubagentSpawnsPerRun)
-      });
+      const workflowParentModel = resolveWorkflowParentModel();
+      const workflowValidation = validateWorkflowScript(requestParams.workflowScript, workflowValidationOptions(deps, requestParams, ctx.cwd, () => workflowParentModel?.provider));
       if (!workflowValidation.ok && publicExecution)
         return buildWorkflowValidationResult(workflowValidation, "workflow", workflowPreflight);
-      const spawnBudgetErrors = workflowValidation.errors.filter((error) => error.kind === "spawn-budget");
-      if (spawnBudgetErrors.length > 0) {
-        return buildRequestedModeError(requestParams, `Workflow '${_id}' validation failed before child launch; no children launched. ${spawnBudgetErrors.map((error) => error.message).join(" ")}`);
+      const launchBlockingErrors = workflowValidation.errors.filter((error) => error.kind === "spawn-budget" || error.kind === "agent");
+      if (launchBlockingErrors.length > 0) {
+        return buildRequestedModeError(requestParams, `Workflow '${_id}' validation failed before child launch; no children launched. ${launchBlockingErrors.map((error) => error.message).join(" ")}`);
+      }
+      const structuredResource = workflowResource?.provenance.name === "chain" || workflowResource?.provenance.name === "tasks";
+      for (const warning of workflowValidation.warnings ?? []) {
+        if (!(structuredResource && warning.kind === "dynamic-spawn-count"))
+          console.warn(`[dm-subagents] ${warning.message}`);
       }
-      for (const warning of workflowValidation.warnings ?? [])
-        console.warn(`[dm-subagents] ${warning.message}`);
       const acceptanceErrors = validateAcceptanceInput(requestParams.acceptance);
       if (acceptanceErrors.length > 0)
         return buildRequestedModeError(requestParams, acceptanceErrors.join(" "));
+      const admittedRequiredExtensions = retainedRequiredExtensions ?? deps.childRuntime?.requiredExtensions ?? resolveRequiredChildExtensions(ctx.sessionManager.getSessionId() ?? undefined);
+      const workflowRequiredExtensions = hasMandatoryRequiredChildExtensions(admittedRequiredExtensions) ? admittedRequiredExtensions : undefined;
       const foregroundWorkflowRunId = encodeIndexSegment(_id);
       if (delegatedWorkflowPermit) {
         const permitError = validateWorkflowChildPermitRoot(delegatedWorkflowPermit, foregroundWorkflowRunId);
@@ -4471,10 +4677,6 @@ export function createSubagentExecutor(deps) {
         if (requestParams.async !== false)
           return buildRequestedModeError(requestParams, "Workflow child permit supports foreground workflow roots only; set async:false.");
       }
-      const workflowParentModel = parentModelOverride !== undefined ? parentModelOverride : (() => {
-        const currentParentModel = normalizeParentModel(ctx.model);
-        return (preserveActiveSession ? currentParentModel : rememberParentModel(deps.state, resolveCurrentSessionId(ctx.sessionManager), currentParentModel)) ?? null;
-      })();
       if (requestParams.extensionBindings !== undefined) {
         try {
           requestParams.extensionBindings = normalizeExtensionBindings(requestParams.extensionBindings).value;
@@ -4483,6 +4685,13 @@ export function createSubagentExecutor(deps) {
         }
       }
       const parentCwd = ctx.cwd;
+      for (const [name, value] of [["timeoutMs", requestParams.timeoutMs], ["maxRuntimeMs", requestParams.maxRuntimeMs]]) {
+        if (value === undefined)
+          continue;
+        const overflowError = timerDelayOverflowError(name, value);
+        if (overflowError)
+          return buildRequestedModeError(requestParams, overflowError);
+      }
       const timeout = requestParams.timeoutMs ?? requestParams.maxRuntimeMs ?? (requestParams.async === false ? resolveConfigDefaultTimeoutMs(deps.config.timeoutMs) ?? DEFAULT_FOREGROUND_TIMEOUT_MS : undefined);
       const workflowUsageBudget = validateUsageBudgetConfig(requestParams.usageBudget ?? deps.config.usageBudget, requestParams.usageBudget ? "usageBudget" : "config.usageBudget");
       if (workflowUsageBudget.error)
@@ -4583,6 +4792,12 @@ export function createSubagentExecutor(deps) {
         const workflowCapabilityCeiling = intersectSubagentCapabilityCeilings(requestParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(currentSessionId));
         const completionOwnerId = deps.state.completionOwnerId ?? currentCompletionOwnerId();
         deps.state.completionOwnerId = completionOwnerId;
+        const workflowScriptSourceDigest = workflowScriptDigest(requestParams.workflowScript);
+        const workflowReuseSource = findWorkflowReuseSource(DIRS.async, currentSessionId, workflowScriptSourceDigest, workflowArgsDigest);
+        const workflowRunEvidence = { ...workflowArgsEvidence, scriptDigest: workflowScriptSourceDigest };
+        if (workflowReuseSource)
+          workflowRunEvidence.reusedFrom = workflowReuseSource.runId;
+        const workflowJournalFingerprints = new Map;
         try {
           fs.mkdirSync(asyncDir, { recursive: true });
           writeRunFanoutBudgetDescriptor(asyncDir, workflowFanoutBudget);
@@ -4615,7 +4830,7 @@ export function createSubagentExecutor(deps) {
           ...workflowCapabilityCeiling ? { admissionCapabilityCeiling: workflowCapabilityCeiling } : {},
           steps: [],
           ...workflowPreflight ? { preflight: workflowPreflight } : {},
-          workflow: { trace: [], emits: [], console: [], ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {} },
+          workflow: { trace: [], emits: [], console: [], ...workflowRunEvidence, ...workflowResource ? { resource: workflowResource.provenance } : {} },
           workflowChildren: workflowChildSummary({ parentToolCallId: toolCallId, workflowRunId, workflowState: "running", inventoryComplete: false }),
           runFanoutBudget: getRunFanoutBudgetSnapshot(workflowFanoutBudget)
         };
@@ -4662,7 +4877,7 @@ export function createSubagentExecutor(deps) {
           if (deps.state.currentSessionId !== currentSessionId || deps.state.completionOwnerId !== completionOwnerId)
             return false;
           try {
-            deps.dm.sendMessage({
+            (deps.parentWake ?? deps.dm).sendMessage({
               customType: "subagent-workflow-result-write-failed",
               content: message,
               display: true
@@ -5099,6 +5314,8 @@ export function createSubagentExecutor(deps) {
                 workflowSteps.set(entry.key, step);
               }
               const projectedStep = workflowSteps.get(entry.key);
+              if (entry.reused && projectedStep)
+                projectedStep.reused = true;
               if (entry.state === "stopped" && projectedStep) {
                 appendWorkflowEvent({
                   type: "subagent.child-status",
@@ -5132,7 +5349,7 @@ export function createSubagentExecutor(deps) {
               timeoutMs: timeout,
               signal: controller.signal,
               continueAfterAbortWhenChildrenSettled: (abortError) => {
-                if (abortError.message !== "Workflow stopped because the extension session was replaced or reloaded.")
+                if (!workflowStopCause(abortError))
                   return false;
                 const activeAsyncChild = [...deps.state.asyncJobs?.values() ?? []].some((job) => job.parentWorkflowRunId === workflowRunId && (job.status === "queued" || job.status === "running"));
                 const activeForegroundChild = [...deps.state.foregroundControls.values()].some((control) => control.parentWorkflowRunId === workflowRunId && (control.activeChildren?.size ?? 0) > 0);
@@ -5147,6 +5364,18 @@ export function createSubagentExecutor(deps) {
               ...workflowState ? { state: workflowState } : {},
               onTrace: updateTrace,
               onChildSettled: (notification) => {
+                const journalFingerprint = workflowJournalFingerprints.get(notification.childKey);
+                if (journalFingerprint)
+                  appendWorkflowChildJournal(asyncDir, { type: "settle", key: notification.childKey, fingerprint: journalFingerprint, result: notification.result });
+                const settledResults = notification.result.results ?? [];
+                const settledStep = settledResults.length ? status.steps?.find((candidate) => candidate.workflowKey === notification.childKey) : undefined;
+                if (settledStep) {
+                  const usage = sumResultsUsage(settledResults);
+                  settledStep.tokens = { input: usage.input, output: usage.output, total: usage.input + usage.output };
+                  if (usage.turns > 0)
+                    settledStep.turnCount = usage.turns;
+                  persist({ tolerateStatusWriteFailure: true });
+                }
                 appendWorkflowEvent({
                   type: "subagent.workflow.child_settled",
                   childKey: notification.childKey,
@@ -5155,10 +5384,11 @@ export function createSubagentExecutor(deps) {
                   workflowRunning: notification.workflowRunning
                 });
                 try {
-                  deps.dm.sendMessage({
+                  (deps.parentWake ?? deps.dm).sendMessage({
                     customType: "subagent-incremental-child-notify",
                     content: formatIncrementalChildCompletion(notification),
-                    display: notification.outcome !== "completed"
+                    display: notification.outcome !== "completed",
+                    details: { childKey: notification.childKey, outcome: notification.outcome }
                   }, { triggerTurn: incrementalChildCompletionTriggersTurn(notification, requestParams.scheduleOrigin) });
                 } catch (sendError) {
                   console.error(`Failed to send incremental child completion notification for '${notification.childKey}':`, sendError);
@@ -5178,6 +5408,7 @@ export function createSubagentExecutor(deps) {
                 } });
               },
               admit: async (calls, admissionSignal) => {
+                admitEnabledWorkflowChildren(calls);
                 await preflightWorkflowWorktrees({ workflowDefaults: workflowChildDefaults, defaultWorktree: deps.config.worktree, calls, ctxCwd: parentCwd, signal: admissionSignal, deadlineAt: workflowDeadlineAt });
                 const outputClaims = workflowChildOutputClaims({ ctxCwd: parentCwd, workflowCwd, artifactsDir: workflowArtifactsDir, workflowRunId, aggregateOutputPath: workflowAggregateOutputPath, configuredOutputBaseDir, discoverAgents: discoverWorkflowAgents, agents: workflowAgents, workflowAgentScope: workflowChildDefaults.agentScope, state: deps.state, claimedOutputPaths, entries: calls });
                 if (outputClaims.error)
@@ -5199,6 +5430,30 @@ export function createSubagentExecutor(deps) {
                 appendWorkflowEvent({ type: "subagent.workflow.emit", value: emits.at(-1) });
               },
               launch: async (key, childParams, workflowSignal, admission) => {
+                const journalFingerprint = workflowJournalFingerprints.get(key) ?? workflowChildFingerprint(childParams);
+                workflowJournalFingerprints.set(key, journalFingerprint);
+                const priorChild = workflowReuseSource ? matchWorkflowReuse(workflowReuseSource, key, journalFingerprint) : undefined;
+                if (priorChild?.kind === "settled") {
+                  if (priorChild.result.runId)
+                    workflowChildRunIds.set(key, priorChild.result.runId);
+                  return { ...priorChild.result, reused: true };
+                }
+                if (priorChild?.kind === "started") {
+                  const priorRunId = priorChild.runId;
+                  const priorAsyncDir = path.join(DIRS.async, priorRunId);
+                  appendWorkflowChildJournal(asyncDir, { type: "start", key, fingerprint: journalFingerprint, runId: priorRunId });
+                  const stopListener = stopAwaitedAsyncChildOnAbort(workflowSignal, deps.state, priorRunId, priorAsyncDir, deps.kill);
+                  const reattached = await awaitExistingAsyncRun(priorAsyncDir, priorRunId, workflowSignal).finally(stopListener.remove);
+                  const claimedPath = reattached.status === "settled" ? claimWorkflowAwaitedResult(priorAsyncDir, workflowRunId, { ...reattached.result.importedPublication, runId: priorRunId }) : undefined;
+                  if (reattached.status === "settled" && claimedPath) {
+                    const imported = importWorkflowAwaitedChildResult(reattached.result, { runId: priorRunId, asyncDir: priorAsyncDir, resultPath: claimedPath, task: typeof childParams.task === "string" ? childParams.task : "", parentWorkflowRunId: workflowReuseSource?.runId, details: { mode: "single", asyncId: priorRunId, asyncDir: priorAsyncDir, results: [] }, state: deps.state, dm: deps.dm });
+                    const reattachedResult = workflowChildResult(key, imported, childParams, deps.state);
+                    if (reattachedResult.ok) {
+                      workflowChildRunIds.set(key, priorRunId);
+                      return { ...reattachedResult, reused: true };
+                    }
+                  }
+                }
                 if (workflowUsageBudget.budget && childParams.async === true)
                   return workflowChildResult(key, buildRequestedModeError(childParams, "workflow usageBudget does not support async runs.run launches."), childParams, deps.state);
                 const budgetState = usageBudgetState(workflowUsageBudget.budget, sumResultsCost(workflowResults));
@@ -5219,7 +5474,11 @@ export function createSubagentExecutor(deps) {
                   preparedChildParams = childRequest;
                   if (workflowUsageBudget.budget)
                     workflowOwnedUsageBudgets.set(childRequest, workflowUsageBudget.budget);
+                  if (workflowRequiredExtensions)
+                    workflowRetainedRequiredExtensions.set(childRequest, workflowRequiredExtensions);
                   workflowLaunchObservers.set(childRequest, (launch) => {
+                    if (launch.runId)
+                      appendWorkflowChildJournal(asyncDir, { type: "start", key, fingerprint: journalFingerprint, runId: launch.runId });
                     const step = status.steps?.find((candidate) => candidate.workflowKey === key);
                     if (step) {
                       step.agent = launch.agent;
@@ -5309,16 +5568,19 @@ export function createSubagentExecutor(deps) {
             });
             const finalPreflightWarnings = workflowPreflightWarnings(workflowPreflight, workflow.trace, { settled: true });
             const finalPreflightTrace = annotateWorkflowPreflightTrace(workflow.trace, workflowPreflight);
-            const returnPreview = formatWorkflowValue(workflow.value).slice(0, 1000);
-            const emitPreview = workflow.emits.length > 0 ? ` Emitted: ${workflow.emits.map(formatWorkflowValue).join(", ").slice(0, 1000)}` : "";
+            const returnText = formatWorkflowValue(workflow.value);
+            const emitText = workflow.emits.map(formatWorkflowValue).join(", ");
+            const returnPreview = returnText.length > 1000 ? `${returnText.slice(0, 1000)}…` : returnText;
+            const emitPreview = workflow.emits.length > 0 ? ` Emitted: ${emitText.length > 1000 ? `${emitText.slice(0, 1000)}…` : emitText}` : "";
+            const previewNote = returnText.length > 1000 || emitText.length > 1000 ? ` (truncated; full return value and emits: ${statusPath} (workflow.value, workflow.emits))` : "";
             const runningSummary = workflowRunningChildrenSummary(workflow.children);
-            const summary = `${runningSummary ? `Workflow dispatch completed; ${runningSummary}` : `Workflow completed with ${workflow.children.length} child run(s).`} Return: ${returnPreview}${emitPreview} Trace: ${workflow.trace.length} event(s).${workflowOutputPathMappingSummary(workflow.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
+            const summary = `${runningSummary ? `Workflow dispatch completed; ${runningSummary}` : `Workflow completed with ${workflow.children.length} child run(s).`} Return: ${returnPreview}${emitPreview}${previewNote} Trace: ${workflow.trace.length} event(s).${workflowOutputPathMappingSummary(workflow.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
             const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath, summary, producedChildOutputPaths);
             const resultSummary = appendWorkflowOutputWarning(summary, outputWarning);
             const workflowUsage = sumResultsUsage(workflowResults);
             settleWorkflowSteerInbox("complete");
             const workflowChildren = workflowChildSummary({ parentToolCallId: toolCallId, workflowRunId, workflowState: "completed", inventoryComplete: true, trace: workflow.trace, children: workflow.children, steps: status.steps });
-            status = { ...status, state: "complete", endedAt: Date.now(), workflow: { value: workflow.value, trace: finalPreflightTrace, emits: workflow.emits, console: workflow.console, ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {} }, workflowChildren, totalTokens: { input: workflowUsage.input, output: workflowUsage.output, total: workflowUsage.input + workflowUsage.output }, totalCost: sumResultsCost(workflowResults) };
+            status = { ...status, state: "complete", endedAt: Date.now(), workflow: { value: workflow.value, trace: finalPreflightTrace, emits: workflow.emits, console: workflow.console, ...workflowRunEvidence, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {} }, workflowChildren, totalTokens: { input: workflowUsage.input, output: workflowUsage.output, total: workflowUsage.input + workflowUsage.output }, totalCost: sumResultsCost(workflowResults) };
             const receipt = terminalWorkflowReceipt(workflowRunId, "complete", workflow.children, workflowChildren, undefined, validHostStepNodes(status.workflowGraph), workflowResource?.provenance, workflowArgsDigest);
             delete status.workflowReceiptPath;
             let workflowReceipt;
@@ -5339,6 +5601,9 @@ export function createSubagentExecutor(deps) {
           } catch (error) {
             const partial = error instanceof WorkflowScriptError ? error.partial : { trace: [], emits: [], console: [], children: [] };
             const stopped = controller.signal.aborted;
+            const stopCause = stopped ? workflowStopCause(controller.signal.reason) : undefined;
+            if (stopCause)
+              workflowRunEvidence.stopCause = stopCause;
             const detachedChildKeys = new Set(partial.children.filter((child) => child.detached).map((child) => child.key));
             const hasRealFailedChild = partial.children.some((child) => !child.ok && child.state !== "running" && !child.detached);
             const pauseForDetached = !stopped && error instanceof WorkflowScriptError && error.errorKind === "detached-child" && detachedChildKeys.size > 0 && !hasRealFailedChild;
@@ -5360,13 +5625,14 @@ export function createSubagentExecutor(deps) {
             const workflowChildren = workflowChildSummary({ parentToolCallId: toolCallId, workflowRunId, workflowState, inventoryComplete: true, trace: partial.trace, children: partial.children, steps: status.steps });
             const finalPreflightWarnings = workflowPreflightWarnings(workflowPreflight, partial.trace, { settled: true });
             const finalPreflightTrace = annotateWorkflowPreflightTrace(partial.trace, workflowPreflight);
-            status = compactOptional({ ...status, state, stopped: stopped || undefined, activityState: pauseForDetached || status.activityState === "needs_attention" ? "needs_attention" : undefined, error: workflowFailureMessage(error, workflowRunId, partial.children), endedAt: Date.now(), workflow: { trace: finalPreflightTrace, emits: partial.emits, console: partial.console, ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {} }, workflowChildren });
+            status = compactOptional({ ...status, state, stopped: stopped || undefined, activityState: pauseForDetached || status.activityState === "needs_attention" ? "needs_attention" : undefined, error: workflowFailureMessage(error, workflowRunId, partial.children), endedAt: Date.now(), workflow: { trace: finalPreflightTrace, emits: partial.emits, console: partial.console, ...error instanceof WorkflowScriptError && error.errorKind ? { failureKind: error.errorKind } : {}, ...workflowRunEvidence, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {} }, workflowChildren });
             if (pauseForDetached) {
               const promoted = promotePausedWorkflowIfSettled(status);
               if (promoted)
                 status = promoted;
             }
-            const terminalSummary = `${status.state === "complete" ? "Workflow completed after detached child finished." : status.error ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${workflowOutputPathMappingSummary(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
+            const errorPreview = status.error && status.error.length > 1000 ? `${status.error.slice(0, 1000)}… (truncated; full error: ${statusPath} (error))` : status.error;
+            const terminalSummary = `${status.state === "complete" ? "Workflow completed after detached child finished." : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${stopCause ? ` ${WORKFLOW_RUNTIME_REPLACED_RELAUNCH_NOTICE}` : ""}${workflowOutputPathMappingSummary(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
             const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath, terminalSummary, producedChildOutputPaths);
             const resultSummary = appendWorkflowOutputWarning(terminalSummary, outputWarning);
             const receiptState = status.state === "complete" ? "complete" : status.state === "paused" ? "paused" : status.state === "stopped" ? "stopped" : "failed";
@@ -5411,6 +5677,7 @@ export function createSubagentExecutor(deps) {
       const workflowOutput = typeof workflowChildDefaults.output === "string" || typeof workflowChildDefaults.output === "boolean" ? workflowChildDefaults.output : undefined;
       const configuredOutputBaseDir = resolveConfiguredSingleRunOutputBaseDir(deps);
       const workflowAggregateOutputPath = resolveSingleOutputPath(workflowOutput, ctx.cwd, workflowCwd, resolveSingleRunOutputBaseDir(deps, workflowArtifactsDir, foregroundWorkflowRunId));
+      const workflowFullResultPath = path.join(workflowArtifactsDir, `${sanitizeRunPathSegment(foregroundWorkflowRunId)}_workflow-result.md`);
       const claimedOutputPaths = new Map;
       const childOutputOverrides = new Map;
       const childOutputClaimPaths = new Map;
@@ -5470,6 +5737,7 @@ export function createSubagentExecutor(deps) {
             sendWorkflowProgress();
           },
           admit: async (calls, admissionSignal) => {
+            admitEnabledWorkflowChildren(calls);
             await preflightWorkflowWorktrees({ workflowDefaults: workflowChildDefaults, defaultWorktree: deps.config.worktree, calls, ctxCwd: ctx.cwd, signal: admissionSignal, deadlineAt: workflowDeadlineAt });
             const outputClaims = workflowChildOutputClaims({ ctxCwd: ctx.cwd, workflowCwd, artifactsDir: workflowArtifactsDir, workflowRunId: foregroundWorkflowRunId, aggregateOutputPath: workflowAggregateOutputPath, configuredOutputBaseDir, discoverAgents: discoverWorkflowAgents, agents: workflowAgents, workflowAgentScope: workflowChildDefaults.agentScope, state: deps.state, claimedOutputPaths, entries: calls });
             if (outputClaims.error)
@@ -5515,6 +5783,8 @@ export function createSubagentExecutor(deps) {
               preparedChildParams = childRequest;
               if (workflowUsageBudget.budget)
                 workflowOwnedUsageBudgets.set(childRequest, workflowUsageBudget.budget);
+              if (workflowRequiredExtensions)
+                workflowRetainedRequiredExtensions.set(childRequest, workflowRequiredExtensions);
               if (delegatedWorkflowPermit) {
                 if (childRequest.async !== false)
                   throw new Error("Workflow child permit supports one foreground child only.");
@@ -5583,36 +5853,31 @@ export function createSubagentExecutor(deps) {
         const finalPreflightTrace = annotateWorkflowPreflightTrace(workflow.trace, workflowPreflight);
         const workflowChildren = workflowChildSummary({ parentToolCallId: _id, workflowRunId: foregroundWorkflowRunId, workflowState: "completed", inventoryComplete: true, trace: workflow.trace, children: workflow.children });
         const receipt = terminalWorkflowReceipt(foregroundWorkflowRunId, "complete", workflow.children, workflowChildren, undefined, [...workflowHostSteps.values()], workflowResource?.provenance, workflowArgsDigest);
-        const traceLines = finalPreflightTrace.map((entry) => `- ${entry.operation} ${entry.key}: ${entry.state}${entry.runId ? ` (${entry.runId})` : ""}${entry.durationMs !== undefined ? ` in ${entry.durationMs}ms` : ""}${entry.warning ? ` — ${entry.warning}` : ""}${entry.error ? ` — ${entry.error}` : ""}`);
+        const trace = finalPreflightTrace.map((entry) => ({ line: `- ${entry.operation} ${entry.key}: ${entry.state}${entry.runId ? ` (${entry.runId})` : ""}${entry.durationMs !== undefined ? ` in ${entry.durationMs}ms` : ""}${entry.warning ? ` — ${entry.warning}` : ""}`, error: entry.error }));
         const runningSummary = workflowRunningChildrenSummary(workflow.children);
-        const sections = [
-          ...workflowPreflight ? [formatWorkflowPreflight(workflowPreflight)] : [],
-          runningSummary ? `Workflow dispatch completed; ${runningSummary}` : "Workflow completed.",
-          `Return:
-${formatWorkflowValue(workflow.value)}`
-        ];
-        if (workflow.emits.length > 0)
-          sections.push(`Emitted:
+        const outputMappings = workflowOutputPathMappingSummary(workflow.children).trim();
+        const displayText = formatWorkflowResultText({
+          head: [...workflowPreflight ? [formatWorkflowPreflight(workflowPreflight)] : [], runningSummary ? `Workflow dispatch completed; ${runningSummary}` : "Workflow completed."],
+          script: [
+            `Return:
+${formatWorkflowValue(workflow.value)}`,
+            ...workflow.emits.length > 0 ? [`Emitted:
 ${workflow.emits.map(formatWorkflowValue).join(`
-`)}`);
-        if (workflow.console.length > 0)
-          sections.push(`Console:
+`)}`] : [],
+            ...workflow.console.length > 0 ? [`Console:
 ${workflow.console.map((entry) => `[${entry.level}] ${entry.text}`).join(`
-`)}`);
-        if (traceLines.length > 0)
-          sections.push(`Call trace:
-${traceLines.join(`
-`)}`);
-        if (finalPreflightWarnings.length > 0)
-          sections.push(formatWorkflowPreflightWarnings(finalPreflightWarnings));
-        const outputMappings = workflowOutputPathMappingSummary(workflow.children).trim();
-        if (outputMappings)
-          sections.push(outputMappings);
-        const workflowText = sections.join(`
-
-`);
-        const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath, workflowText, producedChildOutputPaths);
-        const displayText = appendWorkflowOutputWarning(workflowText, outputWarning);
+`)}`] : []
+          ],
+          trace,
+          tail: [
+            ...finalPreflightWarnings.length > 0 ? [formatWorkflowPreflightWarnings(finalPreflightWarnings)] : [],
+            ...outputMappings ? [outputMappings] : []
+          ],
+          maxOutput: requestParams.maxOutput,
+          aggregateOutputPath: workflowAggregateOutputPath,
+          fullResultPath: workflowFullResultPath,
+          producedChildOutputPaths
+        });
         return attachWorkflowMission(withRunFanoutBudget({
           content: [{ type: "text", text: displayText }],
           details: compactOptional({ mode: "workflow", runId: foregroundWorkflowRunId, results: workflowDetailsResults(workflow.children), ...workflowPreflight ? { preflight: workflowPreflight } : {}, workflowChildren, totalChildUsage: sumResultsUsage(workflowResults), totalCost: sumResultsCost(workflowResults), usageBudget: usageBudgetState(workflowUsageBudget.budget, sumResultsCost(workflowResults)), workflow: { value: workflow.value, trace: finalPreflightTrace, emits: workflow.emits, console: workflow.console, ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {}, receipt }, chatProgress })
@@ -5622,40 +5887,36 @@ ${traceLines.join(`
         const text = workflowFailureMessage(error, foregroundWorkflowRunId, partial.children);
         const finalPreflightWarnings = workflowPreflightWarnings(workflowPreflight, partial.trace, { settled: true });
         const finalPreflightTrace = annotateWorkflowPreflightTrace(partial.trace, workflowPreflight);
-        const traceLines = finalPreflightTrace.map((entry) => `- ${entry.operation} ${entry.key}: ${entry.state}${entry.runId ? ` (${entry.runId})` : ""}${entry.warning ? ` — ${entry.warning}` : ""}${entry.error ? ` — ${entry.error}` : ""}`);
-        const sections = [
-          ...workflowPreflight ? [formatWorkflowPreflight(workflowPreflight)] : [],
-          `Workflow failed: ${text}`
-        ];
-        if (partial.emits.length > 0)
-          sections.push(`Emitted:
+        const trace = finalPreflightTrace.map((entry) => ({ line: `- ${entry.operation} ${entry.key}: ${entry.state}${entry.runId ? ` (${entry.runId})` : ""}${entry.warning ? ` — ${entry.warning}` : ""}`, error: entry.error }));
+        const outputMappings = workflowOutputPathMappingSummary(partial.children).trim();
+        const displayText = formatWorkflowResultText({
+          head: workflowPreflight ? [formatWorkflowPreflight(workflowPreflight)] : [],
+          script: [
+            `Workflow failed: ${text}`,
+            ...partial.emits.length > 0 ? [`Emitted:
 ${partial.emits.map(formatWorkflowValue).join(`
-`)}`);
-        if (partial.console.length > 0)
-          sections.push(`Console:
+`)}`] : [],
+            ...partial.console.length > 0 ? [`Console:
 ${partial.console.map((entry) => `[${entry.level}] ${entry.text}`).join(`
-`)}`);
-        if (traceLines.length > 0)
-          sections.push(`Call trace:
-${traceLines.join(`
-`)}`);
-        if (finalPreflightWarnings.length > 0)
-          sections.push(formatWorkflowPreflightWarnings(finalPreflightWarnings));
-        const outputMappings = workflowOutputPathMappingSummary(partial.children).trim();
-        if (outputMappings)
-          sections.push(outputMappings);
-        const workflowText = sections.join(`
-
-`);
-        const outputWarning = writeWorkflowAggregateOutput(workflowAggregateOutputPath, workflowText, producedChildOutputPaths);
-        const displayText = appendWorkflowOutputWarning(workflowText, outputWarning);
+`)}`] : []
+          ],
+          trace,
+          tail: [
+            ...finalPreflightWarnings.length > 0 ? [formatWorkflowPreflightWarnings(finalPreflightWarnings)] : [],
+            ...outputMappings ? [outputMappings] : []
+          ],
+          maxOutput: requestParams.maxOutput,
+          aggregateOutputPath: workflowAggregateOutputPath,
+          fullResultPath: workflowFullResultPath,
+          producedChildOutputPaths
+        });
         const workflowChildren = workflowChildSummary({ parentToolCallId: _id, workflowRunId: foregroundWorkflowRunId, workflowState: "failed", inventoryComplete: true, trace: partial.trace, children: partial.children });
         const terminalOutcome = workflowFailureTerminalOutcome(error, partial.children, usageBudgetState(workflowUsageBudget.budget, sumResultsCost(workflowResults)));
         const receipt = terminalWorkflowReceipt(foregroundWorkflowRunId, "failed", partial.children, workflowChildren, terminalOutcome, [...workflowHostSteps.values()], workflowResource?.provenance, workflowArgsDigest);
         return attachWorkflowMission(withRunFanoutBudget({
           content: [{ type: "text", text: displayText }],
           isError: true,
-          details: compactOptional({ mode: "workflow", runId: foregroundWorkflowRunId, results: workflowDetailsResults(partial.children), ...workflowPreflight ? { preflight: workflowPreflight } : {}, workflowChildren, totalChildUsage: sumResultsUsage(workflowResults), totalCost: sumResultsCost(workflowResults), usageBudget: usageBudgetState(workflowUsageBudget.budget, sumResultsCost(workflowResults)), workflow: { trace: finalPreflightTrace, emits: partial.emits, console: partial.console, ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {}, receipt }, chatProgress })
+          details: compactOptional({ mode: "workflow", runId: foregroundWorkflowRunId, results: workflowDetailsResults(partial.children), ...workflowPreflight ? { preflight: workflowPreflight } : {}, workflowChildren, totalChildUsage: sumResultsUsage(workflowResults), totalCost: sumResultsCost(workflowResults), usageBudget: usageBudgetState(workflowUsageBudget.budget, sumResultsCost(workflowResults)), workflow: { trace: finalPreflightTrace, emits: partial.emits, console: partial.console, ...error instanceof WorkflowScriptError && error.errorKind ? { failureKind: error.errorKind } : {}, ...workflowArgsEvidence ?? {}, ...workflowResource ? { resource: workflowResource.provenance } : {}, ...finalPreflightWarnings.length ? { preflightWarnings: finalPreflightWarnings } : {}, receipt }, chatProgress })
         }, workflowFanoutBudget));
       } finally {
         workflowProgressClosed = true;
@@ -5696,11 +5957,40 @@ ${traceLines.join(`
         if (deps.allowMutatingManagementActions === false) {
           return { content: [{ type: "text", text: "Action 'worktree.cleanup' is not available from child-safe subagent fanout mode." }], isError: true, details: { mode: "management", results: [] } };
         }
+        if (paramsWithResolvedCwd.mode === "apply") {
+          try {
+            if (!paramsWithResolvedCwd.repo?.trim() || !paramsWithResolvedCwd.planId?.trim() || paramsWithResolvedCwd.handoffPath !== undefined)
+              throw new Error("worktree.cleanup apply requires explicit repo and planId, without handoffPath.");
+            const repo = path.resolve(requestCwd, paramsWithResolvedCwd.repo);
+            const plan = loadReviewedCleanupPlan(repo, paramsWithResolvedCwd.planId);
+            const decision = resolveAuthorityDecision({ action: "discardWorktree", ...deps.config.authorityPolicy === undefined ? {} : { policy: deps.config.authorityPolicy } });
+            if (decision === "forbid")
+              throw new Error("Authority policy forbids worktree cleanup.");
+            if (decision === "confirm") {
+              if (!ctx.hasUI)
+                throw new Error("Authority policy requires interactive confirmation for worktree cleanup.");
+              if (!await ctx.ui.confirm("Apply reviewed worktree cleanup?", `Repository: ${plan.repoRoot}
+Plan: ${plan.planId}
+Remove up to ${plan.entries.filter((entry) => entry.decision === "remove").length} eligible worktrees. All local branches are retained.`))
+                return { content: [{ type: "text", text: "Worktree cleanup canceled." }], details: { mode: "management", results: [] } };
+            }
+            const applied = await applyReviewedCleanupPlan({
+              repo: plan.repoRoot,
+              planId: plan.planId,
+              authorized: true,
+              signal,
+              foregroundRunOwnership: (runId) => deps.state.foregroundControls.has(runId) ? "active" : deps.state.foregroundRuns?.get(runId)?.children.length && deps.state.foregroundRuns.get(runId).children.every((child) => child.status !== "detached") ? "terminal" : "unknown"
+            });
+            return { content: [{ type: "text", text: formatCleanupReceipt(applied) }], details: { mode: "management", results: [] } };
+          } catch (error) {
+            return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+          }
+        }
         if (paramsWithResolvedCwd.mode !== "plan") {
-          return { content: [{ type: "text", text: "worktree.cleanup currently supports mode='plan' only; apply/removal is not available yet." }], isError: true, details: { mode: "management", results: [] } };
+          return { content: [{ type: "text", text: "worktree.cleanup requires mode='plan' or mode='apply'." }], isError: true, details: { mode: "management", results: [] } };
         }
         if (paramsWithResolvedCwd.planId !== undefined) {
-          return { content: [{ type: "text", text: "worktree.cleanup plan mode does not accept planId; apply is not available yet." }], isError: true, details: { mode: "management", results: [] } };
+          return { content: [{ type: "text", text: "worktree.cleanup plan mode does not accept planId." }], isError: true, details: { mode: "management", results: [] } };
         }
         try {
           const created = createWorktreeCleanupPlan({
@@ -5778,7 +6068,7 @@ ${paramsWithResolvedCwd.handoffPath}`);
           return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
         }
       }
-      const policyAction = action === "stop" ? "stopRun" : action === "steer" ? "steerRun" : action === "schedule.create" ? "scheduleCreate" : action === "inspector.open" ? "inspectorOpen" : action === "project.open" ? "projectOpen" : undefined;
+      const policyAction = action === "stop" || action === "command.cancel" ? "stopRun" : action === "steer" || action === "command.yield" ? "steerRun" : action === "schedule.create" ? "scheduleCreate" : action === "inspector.open" ? "inspectorOpen" : action === "project.open" ? "projectOpen" : undefined;
       if (policyAction) {
         if (deps.allowMutatingManagementActions === false && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
           return { content: [{ type: "text", text: `Action '${action}' is not available from child-safe subagent fanout mode.` }], isError: true, details: { mode: "management", results: [] } };
@@ -5812,7 +6102,7 @@ ${paramsWithResolvedCwd.handoffPath}`);
           cwd: requestCwd,
           ...deps.config.missions ? { missions: deps.config.missions } : {},
           ...deps.config.authorityPolicy ? { authorityPolicy: deps.config.authorityPolicy } : {},
-          plugins: createBuiltinInspectorPlugins(),
+          plugins: getInspectorPlugins(deps.dm),
           signal
         });
       }
@@ -5934,8 +6224,14 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
       }
       if (action === "guide") {
         try {
+          const guide = readSubagentGuide(paramsWithResolvedCwd.topic);
+          const [topic, section] = paramsWithResolvedCwd.topic?.split("/") ?? [];
+          const fullNotice = topic === "tool-reference" ? disabledFeatureNotice(disabledFeatures) : undefined;
+          const notice = fullNotice && section !== undefined ? "Some options and actions documented here are disabled by config in this session; guide topic tool-reference lists them." : fullNotice;
           return {
-            content: [{ type: "text", text: readSubagentGuide(paramsWithResolvedCwd.topic) }],
+            content: [{ type: "text", text: notice ? `${notice}
+
+${guide}` : guide }],
             details: { mode: "management", results: [] }
           };
         } catch (error) {
@@ -5957,10 +6253,12 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
       if (action === "doctor") {
         let currentSessionFile = null;
         let currentSessionId = deps.state.currentSessionId;
+        let budgetSessionId = deps.state.currentSessionId;
         let sessionError;
         try {
           currentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
           currentSessionId = ctx.sessionManager.getSessionId();
+          budgetSessionId = currentSessionFile ?? currentSessionId;
         } catch (error) {
           sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
         }
@@ -5971,8 +6269,8 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
           if (!sessionError)
             sessionError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
         }
-        const spawnBudget = getSpawnBudgetSnapshot(deps.state, deps.config, currentSessionId);
-        const activeAsyncCapacity = currentSessionId ? getActiveAsyncCapacitySnapshot(currentSessionId, resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession), { liveWorkflowRunIds: new Set(deps.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps.config.capacity?.abandonedSlotReleaseAfterMs) }) : { used: 0, limit: resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession) ?? 0 };
+        const spawnBudget = getSpawnBudgetSnapshot(deps.state, deps.config, budgetSessionId);
+        const activeAsyncCapacity = budgetSessionId ? getActiveAsyncCapacitySnapshot(budgetSessionId, resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession), { liveWorkflowRunIds: new Set(deps.state.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps.config.capacity?.abandonedSlotReleaseAfterMs) }) : { used: 0, limit: resolveMaxActiveAsyncRunsPerSession(deps.config.maxActiveAsyncRunsPerSession) ?? 0 };
         deps.state.activeAsyncCapacity = activeAsyncCapacity;
         return {
           content: [{
@@ -5985,6 +6283,8 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
               requestedSessionDir: paramsWithResolvedCwd.sessionDir,
               currentSessionFile,
               currentSessionId,
+              spawnBudget,
+              activeAsyncCapacity,
               orchestratorTarget,
               sessionError,
               expandTilde: deps.expandTilde
@@ -5993,6 +6293,22 @@ Usage is not reset. Compaction keeps the same budget; a new parent session start
           details: { mode: "management", results: [], spawnBudget, activeAsyncCapacity }
         };
       }
+      if (["command.status", "command.yield", "command.cancel"].includes(action)) {
+        try {
+          if (deps.allowMutatingManagementActions === false && action !== "command.status")
+            throw new Error(`Action '${action}' is not available from child-safe subagent fanout mode.`);
+          const targetRunId = paramsWithResolvedCwd.id ?? paramsWithResolvedCwd.runId;
+          if (!targetRunId || paramsWithResolvedCwd.dir)
+            throw new Error(`${action} requires id or runId; directory targets are not supported.`);
+          deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
+          const target = resolveSubagentRunId(targetRunId, { state: deps.state, nested: nestedResolutionScopeForExecutor(deps) });
+          if (!target)
+            throw new Error(`No run found for '${targetRunId}'.`);
+          return await commandAction({ state: deps.state, target, operation: action.slice("command.".length), index: paramsWithResolvedCwd.index, toolCallId: paramsWithResolvedCwd.toolCallId, signal });
+        } catch (error) {
+          return { content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true, details: { mode: "management", results: [] } };
+        }
+      }
       if (action === "status" || action === "debug.run") {
         if (!preserveActiveSession)
           deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
@@ -6151,7 +6467,7 @@ ${item.text}` } : item)
       }
       if (action.startsWith("schedule.")) {
         if (!isScheduledRunAction(action)) {
-          return { content: [{ type: "text", text: unknownSubagentActionMessage(action) }], isError: true, details: { mode: "management", results: [] } };
+          return { content: [{ type: "text", text: unknownSubagentActionMessage(action, disabledFeatures) }], isError: true, details: { mode: "management", results: [] } };
         }
         if (deps.allowMutatingManagementActions === false && MUTATING_MANAGEMENT_ACTIONS.has(action)) {
           return {
@@ -6194,55 +6510,46 @@ ${item.text}` } : item)
       }
       if (action === "stop") {
         const targetRunId = paramsWithResolvedCwd.runId ?? paramsWithResolvedCwd.id;
-        const workflowController = targetRunId ? deps.state.workflowControllers?.get(targetRunId) : undefined;
-        if (workflowController && targetRunId) {
-          const stopChild = deps.state.workflowChildStops?.get(targetRunId);
-          if (paramsWithResolvedCwd.childId !== undefined) {
-            const workflowRunId = targetRunId;
-            const asyncJob = deps.state.asyncJobs.get(workflowRunId);
-            if (!asyncJob?.asyncDir)
-              return { content: [{ type: "text", text: `Status file not found for async workflow '${workflowRunId}'.` }], isError: true, details: { mode: "management", results: [] } };
-            const status = readStatus(asyncJob.asyncDir);
-            if (!status)
-              return { content: [{ type: "text", text: `Status file not found for async workflow '${workflowRunId}'.` }], isError: true, details: { mode: "management", results: [] } };
-            const resolution = resolveAsyncStatusChild(status, paramsWithResolvedCwd.childId);
-            if (!resolution.ok)
-              return { content: [{ type: "text", text: resolution.message }], isError: true, details: { mode: "management", results: [] } };
-            if (!isStoppableAsyncStatusStep(resolution.child.step))
-              return { content: [{ type: "text", text: `Child '${paramsWithResolvedCwd.childId}' in async run '${targetRunId}' is ${resolution.child.step.status}; stop only supports pending or running children.` }], isError: true, details: { mode: "management", results: [] } };
-            if (!stopChild)
-              return { content: [{ type: "text", text: `Workflow ${targetRunId} child stop is unavailable in this extension runtime.` }], isError: true, details: { mode: "management", results: [] } };
-            if (!stopChild(resolution.child.id, `Workflow child '${resolution.child.id}' stopped.`))
-              return { content: [{ type: "text", text: `Child '${paramsWithResolvedCwd.childId}' in workflow ${workflowRunId} is not available to stop.` }], isError: true, details: { mode: "management", results: [] } };
-            try {
-              fs.appendFileSync(path.join(asyncJob.asyncDir, "events.jsonl"), `${JSON.stringify({
-                type: "subagent.child-status",
-                version: 1,
-                runId: workflowRunId,
-                childId: resolution.child.id,
-                status: "stopping",
-                ts: Date.now(),
-                reason: "subagent-action",
-                source: "async",
-                stepIndex: resolution.child.index,
-                agent: resolution.child.step.agent,
-                ...resolution.child.step.runId ? { childRunId: resolution.child.step.runId } : {},
-                ...resolution.child.step.workflowKey ? { workflowKey: resolution.child.step.workflowKey } : {},
-                ...resolution.child.step.phase ? { phase: resolution.child.step.phase } : {},
-                ...resolution.child.step.label ? { label: resolution.child.step.label } : {}
-              })}
+        const workflowRunId = targetRunId && paramsWithResolvedCwd.childId !== undefined ? resolveLiveWorkflowRunId(deps, targetRunId) : undefined;
+        if (workflowRunId && paramsWithResolvedCwd.childId !== undefined) {
+          const stopChild = deps.state.workflowChildStops?.get(workflowRunId);
+          const asyncJob = deps.state.asyncJobs.get(workflowRunId);
+          if (!asyncJob?.asyncDir)
+            return { content: [{ type: "text", text: `Status file not found for async workflow '${workflowRunId}'.` }], isError: true, details: { mode: "management", results: [] } };
+          const status = readStatus(asyncJob.asyncDir);
+          if (!status)
+            return { content: [{ type: "text", text: `Status file not found for async workflow '${workflowRunId}'.` }], isError: true, details: { mode: "management", results: [] } };
+          const resolution = resolveAsyncStatusChild(status, paramsWithResolvedCwd.childId);
+          if (!resolution.ok)
+            return { content: [{ type: "text", text: resolution.message }], isError: true, details: { mode: "management", results: [] } };
+          if (!isStoppableAsyncStatusStep(resolution.child.step))
+            return { content: [{ type: "text", text: `Child '${paramsWithResolvedCwd.childId}' in async run '${workflowRunId}' is ${resolution.child.step.status}; stop only supports pending or running children.` }], isError: true, details: { mode: "management", results: [] } };
+          if (!stopChild)
+            return { content: [{ type: "text", text: `Workflow ${workflowRunId} child stop is unavailable in this extension runtime.` }], isError: true, details: { mode: "management", results: [] } };
+          if (!stopChild(resolution.child.id, `Workflow child '${resolution.child.id}' stopped.`))
+            return { content: [{ type: "text", text: `Child '${paramsWithResolvedCwd.childId}' in workflow ${workflowRunId} is not available to stop.` }], isError: true, details: { mode: "management", results: [] } };
+          try {
+            fs.appendFileSync(path.join(asyncJob.asyncDir, "events.jsonl"), `${JSON.stringify({
+              type: "subagent.child-status",
+              version: 1,
+              runId: workflowRunId,
+              childId: resolution.child.id,
+              status: "stopping",
+              ts: Date.now(),
+              reason: "subagent-action",
+              source: "async",
+              stepIndex: resolution.child.index,
+              agent: resolution.child.step.agent,
+              ...resolution.child.step.runId ? { childRunId: resolution.child.step.runId } : {},
+              ...resolution.child.step.workflowKey ? { workflowKey: resolution.child.step.workflowKey } : {},
+              ...resolution.child.step.phase ? { phase: resolution.child.step.phase } : {},
+              ...resolution.child.step.label ? { label: resolution.child.step.label } : {}
+            })}
 `, "utf-8");
-            } catch (error) {
-              console.error(`Failed to append child status event for workflow ${workflowRunId}:`, error);
-            }
-            return { content: [{ type: "text", text: `Stop requested for child ${resolution.child.id} in async workflow ${workflowRunId}.` }], details: { mode: "management", results: [] } };
+          } catch (error) {
+            console.error(`Failed to append child status event for workflow ${workflowRunId}:`, error);
           }
-          const asyncJob = deps.state.asyncJobs.get(targetRunId);
-          const status = asyncJob?.asyncDir ? readStatus(asyncJob.asyncDir) : undefined;
-          if (status)
-            stopStoppableAsyncStatusChildren(status, stopChild, "Workflow stopped.");
-          workflowController.abort(new Error("Workflow stopped."));
-          return { content: [{ type: "text", text: `Stop requested for async workflow ${targetRunId}.` }], details: { mode: "management", results: [] } };
+          return { content: [{ type: "text", text: `Stop requested for child ${resolution.child.id} in async workflow ${workflowRunId}.` }], details: { mode: "management", results: [] } };
         }
         let resolved;
         if (paramsWithResolvedCwd.dir) {
@@ -6317,7 +6624,7 @@ ${item.text}` } : item)
       }
       if (!SUBAGENT_ACTIONS.includes(action)) {
         return {
-          content: [{ type: "text", text: unknownSubagentActionMessage(action) }],
+          content: [{ type: "text", text: unknownSubagentActionMessage(action, disabledFeatures) }],
           isError: true,
           details: { mode: "management", results: [] }
         };
@@ -6412,7 +6719,17 @@ ${item.text}` } : item)
       return;
     };
     let prepareForkSessionForIndex = async () => {};
+    const launchCapabilityCeiling = () => intersectSubagentCapabilityCeilings(intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)), deps.childRuntime?.capabilityCeiling);
+    const assertLaunchableAgentsAllowedBeforeFork = () => {
+      if (!contextPolicy.usesFork)
+        return;
+      const ceiling = launchCapabilityCeiling();
+      const launchable = hasSingle ? [effectiveParams.agent] : hasTasks ? (effectiveParams.tasks ?? []).map((task) => task.agent) : (effectiveParams.chain ?? []).flatMap((step) => isDynamicParallelStep(step) && (step.expand.maxItems ?? deps.config.chain?.dynamicFanout?.maxItems ?? 0) === 0 ? [] : getStepAgents(step));
+      for (const agent of launchable)
+        assertAgentAllowedByCapabilityCeiling(agent, ceiling);
+    };
     try {
+      assertLaunchableAgentsAllowedBeforeFork();
       const pruneSession = contextPolicy.usesFork && deps.config.forkContext?.mode === "pruned" ? await createPrunedForkSessionWriter(ctx, deps.config.forkContext, signal) : undefined;
       const forkContextResolver = createForkContextResolver(ctx.sessionManager, contextPolicy.usesFork ? "fork" : undefined, pruneSession ? { pruneSession } : {});
       prepareForkSessionForIndex = forkContextResolver.prepareSessionForIndex;
@@ -6421,14 +6738,24 @@ ${item.text}` } : item)
       return toExecutionErrorResult(effectiveParams, error, contextPolicy.contextSummary);
     }
     const selectedAgentNames = hasSingle ? [effectiveParams.agent] : hasTasks ? (effectiveParams.tasks ?? []).map((task) => task.agent) : (effectiveParams.chain ?? []).flatMap((step) => getStepAgents(step));
-    const externalAgent = selectedAgentNames.map((name) => agents.find((agent) => agent.name === name)).find((agent) => agent?.runner?.type === "external-cli" || agent?.runner?.type === "external-job");
-    const externalAsyncRequired = Boolean(externalAgent) && effectiveParams.async === undefined && effectiveParams.clarify !== true && effectiveParams.foregroundOnly !== true;
+    const selectedAgents = selectedAgentNames.map((name) => agents.find((agent) => agent.name === name));
+    const externalAgent = selectedAgents.find((agent) => agent?.runner?.type === "external-cli" || agent?.runner?.type === "external-job");
+    const launcherAgent = selectedAgents.find((agent) => agent?.launcher !== undefined);
+    const externalAsyncRequired = effectiveParams.foregroundOnly !== true && (Boolean(externalAgent) && effectiveParams.async === undefined && effectiveParams.clarify !== true || Boolean(launcherAgent) && normalizedParams.async === undefined && normalizedParams.clarify !== true);
     const requestedAsync = externalAsyncRequired ? true : effectiveParams.async ?? deps.asyncByDefault;
     const backgroundRequestedWhileClarifying = (hasChain || hasTasks) && requestedAsync && effectiveParams.clarify === true;
     const effectiveAsync = requestedAsync && effectiveParams.clarify !== true;
     if (externalAgent && (!effectiveAsync || effectiveParams.foregroundOnly === true)) {
       return buildRequestedModeError(effectiveParams, `Agent '${externalAgent.name}' uses runner.type='${externalAgent.runner?.type}', which currently supports async/background execution only. Omit async or pass async:true; clarify and foregroundOnly are unsupported.`);
     }
+    if (launcherAgent && (!effectiveAsync || normalizedParams.async === false || normalizedParams.clarify === true || effectiveParams.foregroundOnly === true)) {
+      return buildRequestedModeError(effectiveParams, `Agent '${launcherAgent.name}' uses launcher '${launcherAgent.launcher}', which wraps the background runner only. Foreground children run inside the parent process, so a launcher cannot wrap them. Omit async or pass async:true; clarify and foregroundOnly are unsupported.`);
+    }
+    for (const agent of selectedAgents) {
+      const launcherError = agent ? resolveAgentRunnerLauncher(agent, deps.config.runnerLaunchers, effectiveParams.machine ?? agent.machine).error : undefined;
+      if (launcherError)
+        return buildRequestedModeError(effectiveParams, launcherError);
+    }
     if (effectiveAsync && hasSingle && effectiveParams.resume === undefined && effectiveParams.worktree === true) {
       try {
         await preflightWorktreeSource(effectiveCwd, { signal });
@@ -6519,8 +6846,13 @@ ${item.text}` } : item)
     const childSessionFileForTask = (agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) => forkSessionFileForTask(agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) ?? path.join(sessionDirForIndex(idx), "session.jsonl");
     const childSessionFileForIndex = (idx) => path.join(sessionDirForIndex(idx), "session.jsonl");
     try {
+      assertLaunchableAgentsAllowedBeforeFork();
       if (!(effectiveParams.clarify === true && ctx.hasUI) || deps.config.forkContext?.mode === "pruned") {
-        await preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, prepareForkSessionForTask, deps.config.chain?.dynamicFanout?.maxItems);
+        const prepareAllowedForkSession = async (agent, ...rest) => {
+          assertAgentAllowedByCapabilityCeiling(agent, launchCapabilityCeiling());
+          await prepareForkSessionForTask(agent, ...rest);
+        };
+        await preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, prepareAllowedForkSession, deps.config.chain?.dynamicFanout?.maxItems);
       }
     } catch (error) {
       activeAsyncCapacity?.rollback();
@@ -6597,6 +6929,7 @@ ${item.text}` } : item)
       backgroundRequestedWhileClarifying,
       effectiveAsync,
       asyncRunId,
+      toolCallId: _id,
       controlConfig,
       ...delegatedExecution ? { suppressUnchangedDelegationUpdates: true } : {},
       intercomBridge,
@@ -6605,12 +6938,14 @@ ${item.text}` } : item)
       toolBudget: runToolBudget.toolBudget,
       usageBudget: usageBudget.budget,
       inheritedUsageBudget,
+      requiredExtensions: retainedRequiredExtensions,
       allowZeroToolBudget,
       configToolBudget: configToolBudget.toolBudget,
       configToolTimeoutMs: deps.config.toolTimeoutMs,
       contextPolicy,
       modelScope,
       parentModel: requestParentModel,
+      scopedModelIds: scopedModelIdsFromContext(ctx),
       parentSessionId: requestSessionId,
       parentPiSessionId: requestPiSessionId,
       capabilityCeiling: intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)),
@@ -6689,6 +7024,7 @@ ${item.text}` } : item)
           params: effectiveParams,
           agents,
           parentModel: requestParentModel,
+          scopedModelIds: scopedModelIdsFromContext(ctx),
           availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
           currentProvider: requestParentModel?.provider,
           modelScope,
@@ -6822,32 +7158,54 @@ ${item.text}` } : item)
     }
   };
   const executePublic = (id, params, signal, onUpdate, ctx) => {
-    const normalized = normalizePublicSubagentExecution(params);
+    const disabledFeatureError = disabledFeatureResult(params);
+    if (disabledFeatureError)
+      return Promise.resolve(disabledFeatureError);
+    const normalized = normalizePublicSubagentExecution(params, { structuredWorkflows: disabledFeatures.features.has("workflow-scripts") });
     if (!normalized.ok) {
       return Promise.resolve({ content: [{ type: "text", text: normalized.error }], isError: true, details: { mode: normalized.mode, results: [] } });
     }
     let publicParams = normalized.params;
-    if (publicParams.workflow !== undefined) {
-      const resolved = resolveWorkflowResource(publicParams.workflow, publicParams.args, ctx.sessionManager.getSessionId() ?? undefined);
+    const workflow = publicParams.workflow;
+    const errorResult = (text) => Promise.resolve({ content: [{ type: "text", text }], isError: true, details: { mode: publicParams.action ? "management" : "workflow", results: [] } });
+    const scriptTextHint = " A workflow string is a named workflow resource or a script file path. To run script text, write it in one ```js workflow block in the same reply and call subagent({ workflow: true }).";
+    if (publicParams.tasks !== undefined || publicParams.chain !== undefined) {
+      const kind = publicParams.tasks !== undefined ? "tasks" : "chain";
+      const resolved = resolveStructuredWorkflowResource({ kind, steps: publicParams[kind], task: publicParams.task });
+      if (!resolved.ok)
+        return errorResult(resolved.error);
+      const { tasks: _tasks, chain: _chain, task: _task, ...withoutStructuredInput } = publicParams;
+      publicParams = { ...withoutStructuredInput, workflowScript: resolved.resource.script };
+      workflowResourcePermits.set(publicParams, resolved.resource.permit);
+    } else if (typeof workflow === "string" && !isWorkflowScriptPath(workflow)) {
+      const resolved = resolveWorkflowResource(workflow, publicParams.args, ctx.sessionManager.getSessionId() ?? undefined);
       if (!resolved.ok)
-        return Promise.resolve({ content: [{ type: "text", text: resolved.error }], isError: true, details: { mode: "workflow", results: [] } });
+        return Promise.resolve({ content: [{ type: "text", text: resolved.error + scriptTextHint }], isError: true, details: { mode: "workflow", results: [] } });
       const { workflow: _workflow, args: _args, ...withoutResourceInput } = publicParams;
       publicParams = { ...withoutResourceInput, workflowScript: resolved.resource.script };
       workflowResourcePermits.set(publicParams, resolved.resource.permit);
-    } else if (publicParams.workflowScript !== undefined || publicParams.workflowScriptPath !== undefined) {
+    } else if (workflow !== undefined || publicParams.workflowScript !== undefined) {
       const normalizedArgs = normalizeWorkflowArgs(publicParams.args);
-      if ("error" in normalizedArgs)
-        return Promise.resolve({ content: [{ type: "text", text: normalizedArgs.error }], isError: true, details: { mode: publicParams.action ? "management" : "workflow", results: [] } });
-      publicParams = { ...publicParams, args: deepFreezeWorkflowArgs(normalizedArgs.args) };
-    }
-    const loaded = loadWorkflowScriptPath(publicParams, ctx.cwd);
-    if (loaded.error) {
-      return Promise.resolve({ content: [{ type: "text", text: loaded.error }], isError: true, details: { mode: publicParams.action ? "management" : "workflow", results: [] } });
+      const validateOnly = publicParams.action === "validate";
+      if ("error" in normalizedArgs && !validateOnly)
+        return errorResult(normalizedArgs.error);
+      let workflowScript = publicParams.workflowScript;
+      if (workflow !== undefined) {
+        const source = workflow === true ? readReplyWorkflowScript(ctx.sessionManager, id) : readWorkflowScriptFile(workflow, publicParams.cwd, ctx.cwd);
+        if ("error" in source)
+          return errorResult(workflow === true ? source.error : source.error + scriptTextHint);
+        workflowScript = source.script;
+      }
+      const { workflow: _workflow, ...withoutWorkflowSource } = publicParams;
+      publicParams = { ...withoutWorkflowSource, workflowScript, args: "error" in normalizedArgs ? publicParams.args : deepFreezeWorkflowArgs(normalizedArgs.args) };
     }
-    publicExecutions.add(loaded.params);
-    return executeWithSingleDispatchGuard(id, loaded.params, signal, onUpdate, ctx);
+    publicExecutions.add(publicParams);
+    return executeWithSingleDispatchGuard(id, publicParams, signal, onUpdate, ctx);
   };
   const executeDelegated = async (id, params, signal, onUpdate, ctx) => {
+    const disabledFeatureError = disabledFeatureResult(params);
+    if (disabledFeatureError)
+      return disabledFeatureError;
     const delegatedParams = { ...params };
     const privateParams = delegatedParams;
     const thinkingOverride = privateParams.delegatedThinkingOverride;