pi-subagents 0.73.0 → 0.74.0

package/src/runs/foreground/subagent-executor.js

@@ -15,12 +15,14 @@ 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 { 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";
@@ -46,6 +48,7 @@ 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/pi-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 { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
@@ -68,11 +71,12 @@ 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 { awaitExistingAsyncRun, claimWorkflowAwaitedResult } from "../background/await-async-run.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 { 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";
@@ -89,15 +93,17 @@ 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";
 import { resolveWorkflowChatProgress } from "../../workflows/chat-progress.js";
 import { annotateWorkflowPreflightTrace, formatWorkflowPreflight, formatWorkflowPreflightWarnings, normalizeWorkflowPreflight, workflowPreflightWarnings } from "../../workflows/workflow-preflight.js";
 import { authorizeWorkflowResourceHost, claimWorkflowChildPermit, 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, createWorktrees, preflightWorktreeSource, withWorktreeTransaction, diffWorktrees, formatWorktreeDiffSummary, } from "../shared/worktree.js";
 import { createWorktreeCleanupPlan, formatWorktreeCleanupPlan } from "../shared/worktree-cleanup-plan.js";
@@ -132,9 +138,10 @@ function hasSingleAdjacentTransposition(left, right) {
         && 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))
@@ -142,7 +149,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}`;
@@ -185,21 +192,18 @@ 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);
@@ -294,6 +298,10 @@ function trustedSessionRootsForStatus(ctx, deps) {
         roots.push(deps.getSubagentSessionRoot(parentSessionFile));
     return [...new Set(roots)];
 }
+/** Children follow the launching session's trust; hosts older than Pi's trust concept keep Pi's default. */
+function sessionProjectTrust(ctx) {
+    return typeof ctx.isProjectTrusted === "function" ? ctx.isProjectTrusted() : undefined;
+}
 function spawnBudgetErrorResult(message, mode) {
     return {
         content: [{ type: "text", text: message }],
@@ -995,6 +1003,7 @@ function appendStepToAsyncChain(input) {
         parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
         currentModelProvider: parentModel?.provider,
         currentModel: parentModel,
+        scopedModelIds: scopedModelIdsFromContext(input.ctx),
         modelScope: discoveredForAppend.modelScope,
         modelResponseAliases: input.deps.config.modelResponseAliases,
         interactive: input.ctx.hasUI,
@@ -1444,11 +1453,13 @@ async function resumeExternalJobFollowUp(input) {
             parentSessionId: input.ctx.sessionManager.getSessionId() ?? 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,
+            projectTrusted: sessionProjectTrust(input.ctx),
         }),
         cwd: input.effectiveCwd,
         artifactsDir,
@@ -1708,11 +1719,13 @@ async function resumeAsyncRun(input) {
                 parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
                 currentModelProvider: parentModel?.provider,
                 currentModel: parentModel,
+                scopedModelIds: scopedModelIdsFromContext(input.ctx),
                 modelScope,
                 modelResponseAliases: input.deps.config.modelResponseAliases,
                 interactive: input.ctx.hasUI,
                 permissions: input.deps.config.permissions,
                 childRuntime: input.deps.childRuntime,
+                projectTrusted: sessionProjectTrust(input.ctx),
             }),
             availableModels,
             cwd: effectiveCwd,
@@ -1836,12 +1849,14 @@ async function resumeAsyncRun(input) {
             parentSessionId: input.ctx.sessionManager.getSessionId() ?? undefined,
             currentModelProvider: parentModel?.provider,
             currentModel: parentModel,
+            scopedModelIds: scopedModelIdsFromContext(input.ctx),
             modelScope,
             // Absence in the retained contract is meaningful; never acquire current aliases.
             modelResponseAliases: recoveryDescriptor ? recoveryDescriptor.modelResponseAliases : foregroundContract?.modelResponseAliases,
             interactive: input.ctx.hasUI,
             permissions: input.deps.config.permissions,
             childRuntime: input.deps.childRuntime,
+            projectTrusted: sessionProjectTrust(input.ctx),
         }),
         cwd: effectiveCwd,
         maxOutput: input.params.maxOutput ?? recoveryDescriptor?.maxOutput,
@@ -1937,67 +1952,34 @@ 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.pi, 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, pi: input.deps.pi });
     }
     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));
@@ -2733,7 +2715,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 });
@@ -2752,6 +2734,7 @@ function collectStaticLaunchSummaries(input) {
         explicitModel,
         agents: input.agents,
         parentModel: input.parentModel,
+        scopedModelIds: input.scopedModelIds,
         availableModels: input.availableModels,
         currentProvider: input.currentProvider,
         modelScope: input.modelScope,
@@ -2925,29 +2908,11 @@ function emitWorkflowAwaitedChildComplete(pi, 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);
-    }
+/** Consumes an awaited workflow child's published result: clears the payload, announces completion, and builds the tool result. */
+function importWorkflowAwaitedChildResult(completed, options) {
     if (completed.importedPublication)
-        removeWorkflowAwaitedResult(asyncDir, resultPath, options.runId, completed.importedPublication);
-    emitWorkflowAwaitedChildComplete(options.pi, options.state, options.runId, asyncDir, params.workflowParentRunId, completed);
+        removeWorkflowAwaitedResult(options.asyncDir, options.resultPath, options.runId, completed.importedPublication);
+    emitWorkflowAwaitedChildComplete(options.pi, options.state, options.runId, options.asyncDir, options.parentWorkflowRunId, completed);
     const usage = importedAsyncRootUsage(completed);
     const childResult = omitUndefinedProperties({
         index: 0,
@@ -2976,15 +2941,54 @@ 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],
         },
     };
 }
+// A replaced runtime leaves the child running so a relaunch of the workflow can re-attach to it.
+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) };
+}
+// Live workflow controls are keyed by the full run id; a stop id may be a prefix or the launch tool-call id.
+function resolveLiveWorkflowRunId(deps, id) {
+    const controllers = deps.state.workflowControllers;
+    if (!controllers?.size)
+        return undefined;
+    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 {
+        // The generic stop path resolves the id again and reports the error.
+        return undefined;
+    }
+}
+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, pi: options.pi });
+}
 async function runAsyncPath(data, deps) {
     const { params, effectiveCwd, agents, ctx, shareEnabled, sessionRoot, sessionFileForTask, thinkingOverrideForTask, artifactConfig, artifactsDir, effectiveAsync, controlConfig, intercomBridge, nestedRoute, contextPolicy, unknownAgentDiagnosticContext, } = data;
     const hasChain = (params.chain?.length ?? 0) > 0;
@@ -3008,11 +3012,13 @@ async function runAsyncPath(data, deps) {
         parentSessionId: data.parentPiSessionId,
         currentModelProvider: parentModel?.provider,
         currentModel: parentModel,
+        scopedModelIds: data.scopedModelIds,
         modelScope: data.modelScope,
         modelResponseAliases: deps.config.modelResponseAliases,
         interactive: ctx.hasUI,
         permissions: deps.config.permissions,
         childRuntime: deps.childRuntime,
+        projectTrusted: sessionProjectTrust(ctx),
     });
     const availableModels = ctx.modelRegistry.getAvailable().map(toModelInfo);
     const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth, deps.childRuntime);
@@ -3040,7 +3046,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,
@@ -3463,7 +3469,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,
@@ -3569,6 +3575,24 @@ async function runSinglePath(data, deps) {
     let detachForeground;
     let childSessionControls;
     const foregroundControl = deps.state.foregroundControls.get(runId);
+    const syncHerdrForegroundChild = () => {
+        if (!foregroundControl?.parentWorkflowRunId)
+            return;
+        try {
+            deps.pi.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({
@@ -3608,6 +3632,7 @@ async function runSinglePath(data, deps) {
         // Capture the owned mailbox before a child can start and finish between polling ticks.
         if (deps.childRuntime?.fanoutChild)
             deps.activateSupervisorTransport?.();
+        syncHerdrForegroundChild();
     }
     const modelResponseAliases = deps.config.modelResponseAliases === undefined ? undefined : structuredClone(deps.config.modelResponseAliases);
     const forwardSingleUpdate = onUpdate
@@ -3628,6 +3653,7 @@ async function runSinglePath(data, deps) {
         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.pi,
@@ -3641,6 +3667,7 @@ 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.pi.events,
@@ -3720,8 +3747,7 @@ async function runSinglePath(data, deps) {
                     }
                     finally {
                         try {
-                            if (foregroundControl)
-                                finishForegroundChild(foregroundControl, 0);
+                            finishTrackedForegroundChild();
                         }
                         finally {
                             removeForegroundControlIfIdle(deps.state, runId, deps.trackRetainedNestedRoute);
@@ -3752,8 +3778,7 @@ async function runSinglePath(data, deps) {
         if (!r?.detached) {
             if (!artifactConfig.enabled)
                 cleanupStructuredOutputRuntime(structuredRuntime);
-            if (foregroundControl)
-                finishForegroundChild(foregroundControl, 0);
+            finishTrackedForegroundChild();
         }
     }
     if (!r.detached) {
@@ -3855,7 +3880,7 @@ async function runSinglePath(data, deps) {
     };
 }
 function inferExecutionMode(params) {
-    if (params.workflowScript !== undefined)
+    if (params.workflowScript !== undefined || params.workflow !== undefined)
         return "workflow";
     if ((params.chain?.length ?? 0) > 0)
         return "chain";
@@ -3936,16 +3961,19 @@ function workflowChildResult(key, result, childParams = {}, resumeState, forcedT
         ? 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}\n\n${receiptOutput}`
-        : childError || receiptOutput || output || "Child run failed.";
+    const stopped = result.details.results.some((child) => child.stopped);
+    // A stopped child's receipt text carries the run fan-out annotation; report the structured stop reason instead.
+    const failureErrorBase = stopped && childError
+        ? childError
+        : childError && receiptOutput
+            ? receiptOutput.includes(childError) ? receiptOutput : `${childError}\n\n${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}`);
     const failureError = [failureErrorBase, ...savedOutputEvidence].join("\n");
     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" }
@@ -4047,9 +4075,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.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) {
@@ -4200,7 +4228,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)
@@ -4580,6 +4608,20 @@ 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 undefined;
+        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 workflowLaunchObserver = workflowLaunchObservers.get(params);
         const inheritedUsageBudget = workflowOwnedUsageBudgets.get(params);
@@ -4614,8 +4656,8 @@ export function createSubagentExecutor(deps) {
                     : rememberParentModel(deps.state, resolveCurrentSessionId(ctx.sessionManager), currentParentModel)) ?? null;
             })();
         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)
@@ -4662,8 +4704,12 @@ export function createSubagentExecutor(deps) {
             if (launchBlockingErrors.length > 0) {
                 return buildRequestedModeError(requestParams, `Workflow '${_id}' validation failed before child launch; no children launched. ${launchBlockingErrors.map((error) => error.message).join(" ")}`);
             }
-            for (const warning of workflowValidation.warnings ?? [])
-                console.warn(`[pi-subagents] ${warning.message}`);
+            // A package chain's per-step stop check defeats static launch counting; runtime fan-out enforcement still applies.
+            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(`[pi-subagents] ${warning.message}`);
+            }
             const acceptanceErrors = validateAcceptanceInput(requestParams.acceptance);
             if (acceptanceErrors.length > 0)
                 return buildRequestedModeError(requestParams, acceptanceErrors.join(" "));
@@ -4804,6 +4850,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);
@@ -4837,7 +4889,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),
                 };
@@ -5381,6 +5433,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",
@@ -5414,7 +5468,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);
@@ -5429,6 +5483,9 @@ 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 });
                                 appendWorkflowEvent({
                                     type: "subagent.workflow.child_settled",
                                     childKey: notification.childKey,
@@ -5461,6 +5518,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)
@@ -5483,6 +5541,33 @@ 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") {
+                                    // The previous run's awaited async child may still be running: wait for that exact run
+                                    // instead of launching again. Journal it first so another reload can re-attach too.
+                                    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) : 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, pi: deps.pi });
+                                        const reattachedResult = workflowChildResult(key, imported, childParams, deps.state);
+                                        // Like a settled journal match: only a successful child is reused; a failed or stopped one launches fresh.
+                                        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));
@@ -5504,6 +5589,8 @@ export function createSubagentExecutor(deps) {
                                     if (workflowUsageBudget.budget)
                                         workflowOwnedUsageBudgets.set(childRequest, workflowUsageBudget.budget);
                                     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;
@@ -5605,7 +5692,7 @@ export function createSubagentExecutor(deps) {
                         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;
@@ -5628,6 +5715,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;
@@ -5650,7 +5740,7 @@ 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, ...(error instanceof WorkflowScriptError && error.errorKind ? { failureKind: error.errorKind } : {}), ...(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)
@@ -5660,7 +5750,7 @@ export function createSubagentExecutor(deps) {
                         const errorPreview = status.error && status.error.length > 1_000 ? `${status.error.slice(0, 1_000)}… (truncated; full error: ${statusPath} (error))` : status.error;
                         const terminalSummary = `${status.state === "complete"
                             ? "Workflow completed after detached child finished."
-                            : errorPreview ?? (pauseForDetached ? "Workflow paused." : "Workflow failed.")}${workflowOutputPathMappingSummary(partial.children)}${finalPreflightWarnings.length ? ` ${finalPreflightWarnings.join(" ")}` : ""}`;
+                            : 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";
@@ -5774,6 +5864,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)
@@ -6245,8 +6336,10 @@ export function createSubagentExecutor(deps) {
             }
             if (action === "guide") {
                 try {
+                    const guide = readSubagentGuide(paramsWithResolvedCwd.topic);
+                    const notice = paramsWithResolvedCwd.topic === "tool-reference" ? disabledFeatureNotice(disabledFeatures) : undefined;
                     return {
-                        content: [{ type: "text", text: readSubagentGuide(paramsWithResolvedCwd.topic) }],
+                        content: [{ type: "text", text: notice ? `${notice}\n\n${guide}` : guide }],
                         details: { mode: "management", results: [] },
                     };
                 }
@@ -6476,7 +6569,7 @@ export function createSubagentExecutor(deps) {
             }
             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 {
@@ -6520,55 +6613,47 @@ export function createSubagentExecutor(deps) {
             }
             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 } : {}),
-                            })}\n`, "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: [] } };
+                // Whole-workflow stops reach stopAsyncRun below, which stops a live workflow in-process.
+                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 } : {}),
+                        })}\n`, "utf-8");
+                    }
+                    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) {
@@ -6646,7 +6731,7 @@ export function createSubagentExecutor(deps) {
             }
             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: [] },
                 };
@@ -7009,6 +7094,7 @@ export function createSubagentExecutor(deps) {
             contextPolicy,
             modelScope,
             parentModel: requestParentModel,
+            scopedModelIds: scopedModelIdsFromContext(ctx),
             parentSessionId: requestSessionId,
             parentPiSessionId: requestPiSessionId,
             capabilityCeiling: intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)),
@@ -7102,6 +7188,7 @@ export function createSubagentExecutor(deps) {
                     params: effectiveParams,
                     agents,
                     parentModel: requestParentModel,
+                    scopedModelIds: scopedModelIdsFromContext(ctx),
                     availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
                     currentProvider: requestParentModel?.provider,
                     modelScope,
@@ -7254,33 +7341,57 @@ export function createSubagentExecutor(deps) {
         }
     };
     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: [] } });
+        // Models tend to put script text in the workflow string; say how to pass it instead.
+        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) {
+            // Normalization admits chain/tasks only with workflow scripts disabled; the original input was checked above.
+            const kind = publicParams.tasks !== undefined ? "tasks" : "chain";
+            const resolved = resolveStructuredWorkflowResource({ kind, steps: publicParams[kind], task: publicParams.task });
             if (!resolved.ok)
-                return Promise.resolve({ content: [{ type: "text", text: resolved.error }], isError: true, details: { mode: "workflow", results: [] } });
+                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 + 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: [] } });
+                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: 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;