pi-subagents 0.74.0 → 0.76.0

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

@@ -19,6 +19,7 @@ import { isWorkflowScriptPath, normalizePublicSubagentExecution, validateWorkflo
 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";
@@ -54,11 +55,11 @@ import { usageBudgetExceededMessage, usageBudgetState, validateUsageBudgetConfig
 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 { assertRequiredChildExtensionsAdmitted, hasMandatoryRequiredChildExtensions, readRetainedRequiredChildExtensions, resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 import { 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, toAgentToolUsage } from "../../shared/utils.js";
-import { discardPreservedWorktrees, formatParallelHandoffError, formatParallelHandoffReference, formatStoredParallelHandoffCleanup, parallelHandoffPath, readParallelHandoffManifest, recordParallelHandoffMerge, recordParallelHandoffSupersession, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.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, buildSubagentResultIntercomPayload, deliverSubagentResultIntercomEvent, formatSubagentResultReceipt, resolveSubagentResultStatus, stripDetailsOutputsForIntercomReceipt, } from "../../intercom/result-intercom.js";
 import { applySteeringRecoveryAgentConfig, asyncReviveRequiresRecoveryDescriptor, buildRevivedAsyncTask, readAsyncRecoveryDescriptor, resolveAsyncResumeTarget, resolveAsyncRunLocation } from "../background/async-resume.js";
@@ -106,11 +107,12 @@ import { authorizeWorkflowResourceHost, claimWorkflowChildPermit, consumeWorkflo
 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 { 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, SUBAGENT_CHILD_STATUS_EVENT, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, checkSubagentDepth, 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"]);
+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;
 }
@@ -464,6 +466,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 } : {}),
@@ -548,6 +551,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,
@@ -960,6 +964,17 @@ 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 ?? {}),
@@ -1031,6 +1046,7 @@ function appendStepToAsyncChain(input) {
         asyncDir: resolved.location.asyncDir,
         validateOutputBindings: false,
         capabilityCeiling: intersectSubagentCapabilityCeilings(status.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(asyncCtx.currentSessionId)),
+        requiredExtensions: retainedRequiredExtensions,
     }));
     if ("error" in built) {
         return {
@@ -1632,6 +1648,19 @@ async function resumeAsyncRun(input) {
             : "External runners do not persist Pi 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: [] } };
@@ -1779,9 +1808,6 @@ 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: [] } };
     }
@@ -2067,6 +2093,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,
@@ -3069,6 +3096,7 @@ async function runAsyncPath(data, deps) {
             goal: params.task ?? "",
             agentConfig: a,
             recoveryAgentConfig: data.recoveryAgents.find((agent) => agent.name === params.agent),
+            requiredExtensions: data.requiredExtensions,
             ctx: asyncCtx,
             availableModels,
             cwd: effectiveCwd,
@@ -3455,8 +3483,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) {
@@ -3643,7 +3673,6 @@ async function runSinglePath(data, deps) {
         }
         : 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
@@ -3900,6 +3929,7 @@ function duplicateSubagentCallResult(params) {
 }
 const workflowLaunchObservers = new WeakMap();
 const workflowOwnedUsageBudgets = new WeakMap();
+const workflowRetainedRequiredExtensions = new WeakMap();
 /**
  * Terminal-mission retention can remove a mission while its children still
  * report. Remember it to prevent later heartbeats from warning repeatedly.
@@ -4087,7 +4117,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;
@@ -4625,6 +4659,7 @@ export function createSubagentExecutor(deps) {
     const execute = async (_id, params, signal, onUpdate, ctx, preserveActiveSession = false, parentModelOverride) => {
         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);
@@ -4655,6 +4690,12 @@ export function createSubagentExecutor(deps) {
                     ? currentParentModel
                     : rememberParentModel(deps.state, resolveCurrentSessionId(ctx.sessionManager), currentParentModel)) ?? null;
             })();
+        // validate checks args with the same normalization launch uses, reported beside script errors.
+        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) {
                 throw new Error("preflight requires workflow: true or a workflow script path.");
@@ -4666,7 +4707,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 ?? "", workflowValidationOptions(deps, requestParams, ctx.cwd, () => resolveWorkflowParentModel()?.provider));
+                const validation = validateWorkflowRequest();
                 const invalidValidation = { ...validation, ok: false, errors: [...validation.errors, { message }] };
                 return {
                     content: [{ type: "text", text: JSON.stringify(invalidValidation) }],
@@ -4677,8 +4718,7 @@ export function createSubagentExecutor(deps) {
             return buildRequestedModeError(requestParams, message);
         }
         if (requestParams.action?.trim() === "validate") {
-            const validation = validateWorkflowScript(requestParams.workflowScript ?? "", workflowValidationOptions(deps, requestParams, ctx.cwd, () => resolveWorkflowParentModel()?.provider));
-            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)
@@ -4713,6 +4753,9 @@ export function createSubagentExecutor(deps) {
             const acceptanceErrors = validateAcceptanceInput(requestParams.acceptance);
             if (acceptanceErrors.length > 0)
                 return buildRequestedModeError(requestParams, acceptanceErrors.join(" "));
+            // Capture mandatory host extensions at admission: script children may launch after the host disposes its registration.
+            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);
@@ -5588,6 +5631,8 @@ 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 });
@@ -5910,6 +5955,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.");
@@ -6089,11 +6136,35 @@ export function createSubagentExecutor(deps) {
                 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}\nPlan: ${plan.planId}\nRemove 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({
@@ -6178,7 +6249,7 @@ export function createSubagentExecutor(deps) {
                     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) {
                 // Child-safe mode is a hard capability boundary; the policy is an operator
                 // preference. Refuse first, so the gate never prompts for an action that is
@@ -6402,6 +6473,23 @@ export function createSubagentExecutor(deps) {
                     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);
@@ -7088,6 +7176,7 @@ export function createSubagentExecutor(deps) {
             toolBudget: runToolBudget.toolBudget,
             usageBudget: usageBudget.budget,
             inheritedUsageBudget,
+            requiredExtensions: retainedRequiredExtensions,
             allowZeroToolBudget,
             configToolBudget: configToolBudget.toolBudget,
             configToolTimeoutMs: deps.config.toolTimeoutMs,
@@ -7373,7 +7462,9 @@ export function createSubagentExecutor(deps) {
         }
         else if (workflow !== undefined || publicParams.workflowScript !== undefined) {
             const normalizedArgs = normalizeWorkflowArgs(publicParams.args);
-            if ("error" in normalizedArgs)
+            // validate reports args errors with its script errors; launch rejects them here.
+            const validateOnly = publicParams.action === "validate";
+            if ("error" in normalizedArgs && !validateOnly)
                 return errorResult(normalizedArgs.error);
             let workflowScript = publicParams.workflowScript;
             if (workflow !== undefined) {
@@ -7383,7 +7474,7 @@ export function createSubagentExecutor(deps) {
                 workflowScript = source.script;
             }
             const { workflow: _workflow, ...withoutWorkflowSource } = publicParams;
-            publicParams = { ...withoutWorkflowSource, workflowScript, args: deepFreezeWorkflowArgs(normalizedArgs.args) };
+            publicParams = { ...withoutWorkflowSource, workflowScript, args: "error" in normalizedArgs ? publicParams.args : deepFreezeWorkflowArgs(normalizedArgs.args) };
         }
         publicExecutions.add(publicParams);
         return executeWithSingleDispatchGuard(id, publicParams, signal, onUpdate, ctx);