pi-subagents 0.70.1 → 0.72.0

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

@@ -40,6 +40,7 @@ import { canPreferFork, createForkContextResolver, resolveSubagentLaunchContext
 import { createPrunedForkSessionWriter } from "../../shared/pruned-fork.js";
 import { resolveCurrentSessionId } from "../../shared/session-identity.js";
 import { currentCompletionOwnerId } from "../../shared/completion-owner.js";
+import { SUBAGENT_ASYNC_COMPLETE_EVENT } from "../../shared/types.js";
 import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
 import { formatControlIntercomMessage, formatControlNoticeMessage, resolveControlConfig, shouldNotifyControlEvent } from "../shared/subagent-control.js";
 import { formatSpawnBudget, getSpawnBudgetSnapshot, grantSpawnBudget, preflightSpawnBudget, preflightSpawnBudgetGrant, reserveSpawnBudget } from "../shared/spawn-budget.js";
@@ -47,13 +48,13 @@ import { claimRunFanoutBatch, claimRunFanoutBatchWithCommit, createRunFanoutBudg
 import { retainLiveForegroundNestedRoute } from "../../integrations/pi-web-session-liveness.js";
 import { validateToolBudgetConfig } from "../shared/tool-budget.js";
 import { usageBudgetExceededMessage, usageBudgetState, validateUsageBudgetConfig } from "../shared/usage-budget.js";
-import { intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
+import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.js";
 import { isAgentContract } from "../shared/agent-contract.js";
 import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
 import { resolveRequiredChildExtensions } from "../../shared/required-child-extensions.js";
 import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, outputPathMappingFromTask, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
 import { assertJsonSchemaObject, cleanupStructuredOutputRuntime, createStructuredOutputRuntime } from "../shared/structured-output.js";
-import { compactForegroundDetails, getSingleResultOutput, readStatus, resolveChildCwd, sumResultsCost, sumResultsUsage, toAgentToolUsage } from "../../shared/utils.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 { summarizeContextModes } from "../shared/context-mode.js";
 import { attachNestedChildrenToResultChildren, buildSubagentResultIntercomPayload, deliverSubagentResultIntercomEvent, formatSubagentResultReceipt, resolveSubagentResultStatus, stripDetailsOutputsForIntercomReceipt, } from "../../intercom/result-intercom.js";
@@ -84,7 +85,7 @@ import { MissionNotFoundError, updateMission } from "../../missions/store.js";
 import { createMissionWorkflowState } from "../../missions/workflow-state.js";
 import { resolveAuthorityDecision } from "../../policy/authority.js";
 import { handleInspectorAction, INSPECTOR_ACTIONS } from "../../inspectors/actions.js";
-import { createBuiltinInspectorPlugins } from "../../inspectors/plugins.js";
+import { getInspectorPlugins } from "../../inspectors/plugins.js";
 import { handleHerdrProjectPaneAction, HERDR_PROJECT_PANE_ACTIONS } from "../../inspectors/herdr/project-panes.js";
 import { previewSimpleWorkflowRun, runWorkflowScript, validateWorkflowScript, WorkflowScriptError } from "../../workflows/scripted-workflow.js";
 import { formatIncrementalChildCompletion, incrementalChildCompletionTriggersTurn } from "../background/notify.js";
@@ -100,7 +101,7 @@ import { deepFreezeWorkflowArgs, normalizeWorkflowArgs, resolveWorkflowResource
 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";
-import { DIRS, DEFAULT_ARTIFACT_CONFIG, DEFAULT_FORK_PREAMBLE, SUBAGENT_ACTIONS, SUBAGENT_CONTROL_EVENT, SUBAGENT_CONTROL_INTERCOM_EVENT, SUBAGENT_FOREGROUND_COMPLETE_EVENT, checkSubagentDepth, resolveChildMaxSubagentDepth, resolveCurrentMaxSubagentDepth, resolveMaxSubagentSpawnsPerRun, wrapForkTask, } from "../../shared/types.js";
+import { DIRS, DEFAULT_ARTIFACT_CONFIG, 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, 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"]);
@@ -1159,6 +1160,57 @@ function resolveNestedResumeTarget(match, trustedSessionRoots) {
         ...(recoveryDescriptor ? { recoveryDescriptor } : {}),
     });
 }
+function resolveNestedExternalJobResumeTarget(match, params, deps) {
+    const run = match.match.run;
+    if (run.state === "stopped")
+        return undefined;
+    const asyncDir = resolveNestedAsyncDir(match.match.rootRunId, run);
+    if (!asyncDir)
+        return undefined;
+    const status = readNestedRunStatus(asyncDir, run);
+    const steps = status?.steps ?? [];
+    const step = steps[params.index ?? 0];
+    if (!step) {
+        // An index outside an external-job run gets the async resolver's index error instead of a Pi revive.
+        if (params.index === undefined || !steps.some((candidate) => candidate.runner?.type === "external-job"))
+            return undefined;
+    }
+    else if (!step.runner) {
+        // Pi steps record no runner, and neither does a launch status before the runner starts.
+        // A session file means a Pi run; otherwise the agent definition says what the step runs.
+        if (nestedRunSessionFile(run))
+            return undefined;
+        const agent = deps.discoverAgents(status?.cwd ?? deps.state.baseCwd, resolveExecutionAgentScope(params.agentScope)).agents.find((candidate) => candidate.name === step.agent);
+        if (agent?.runner?.type === "external-job")
+            throw new Error(externalJobWithoutMetadataMessage(run.id));
+        return undefined;
+    }
+    else if (step.runner.type !== "external-job") {
+        return undefined;
+    }
+    // External-job runs have no Pi session, so resume them as a provider follow-up from their own run directory.
+    const target = resolveAsyncResumeTarget(compactOptional({ dir: asyncDir, index: params.index }), nestedRunScope(match.match.rootRunId), { requireSessionFile: false });
+    if (target.kind === "live")
+        throw new Error(externalJobStillRunningMessage(target.runId));
+    return { source: "async", ...target };
+}
+function readNestedRunStatus(asyncDir, run) {
+    try {
+        return readStatus(asyncDir);
+    }
+    catch (error) {
+        // A nested Pi run revives from its session file, so its unreadable status file must not block it.
+        if (nestedRunSessionFile(run))
+            return null;
+        throw error;
+    }
+}
+function externalJobStillRunningMessage(runId) {
+    return `External-job run '${runId}' is still running. Wait for completion, then use subagent({ action: "resume", id: "${runId}", message: "..." }).`;
+}
+function externalJobWithoutMetadataMessage(runId) {
+    return `External-job run '${runId}' has no persisted provider metadata. Cannot follow up without the parent provider job id.`;
+}
 async function waitForNestedControlResult(target, requestId, ignoredFiles, timeoutMs = 1_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -1319,14 +1371,14 @@ function externalRunnerControlError(asyncDir, action) {
 }
 async function resumeExternalJobFollowUp(input) {
     if (input.target.kind === "live" || input.target.state === "running" || input.target.state === "queued") {
-        return { content: [{ type: "text", text: `External-job run '${input.target.runId}' is still running. Wait for completion, then use subagent({ action: "resume", id: "${input.target.runId}", message: "..." }).` }], isError: true, details: { mode: "management", results: [] } };
+        return { content: [{ type: "text", text: externalJobStillRunningMessage(input.target.runId) }], isError: true, details: { mode: "management", results: [] } };
     }
     const runner = input.target.runner;
     const externalJob = input.target.externalJob;
     if (runner?.type !== "external-job")
         return { content: [{ type: "text", text: "Internal error: external-job follow-up was requested for a non-external-job runner." }], isError: true, details: { mode: "management", results: [] } };
     if (!externalJob)
-        return { content: [{ type: "text", text: `External-job run '${input.target.runId}' has no persisted provider metadata. Cannot follow up without the parent provider job id.` }], isError: true, details: { mode: "management", results: [] } };
+        return { content: [{ type: "text", text: externalJobWithoutMetadataMessage(input.target.runId) }], isError: true, details: { mode: "management", results: [] } };
     if (externalJob.provider !== runner.provider)
         return { content: [{ type: "text", text: `External-job run '${input.target.runId}' has mismatched provider metadata. Refusing to follow up.` }], isError: true, details: { mode: "management", results: [] } };
     if (!externalJobOptionsEqual(externalJob.options, runner.options))
@@ -1342,11 +1394,14 @@ async function resumeExternalJobFollowUp(input) {
     const requestDigest = externalJobFollowUpRequestDigest({ provider: runner.provider, parentProviderJobId: externalJob.providerJobId, promptDigest, options: runner.options });
     const requestId = externalJobFollowUpRequestId(requestDigest);
     const runId = externalJobFollowUpRunId(requestDigest);
-    const asyncDir = path.join(DIRS.async, runId);
+    // A child launches the follow-up under its nested route, so look for an earlier one where it would be.
+    const nestedRoute = inheritedNestedRoute(input.deps);
+    const runRoots = nestedRoute ? nestedRunScope(nestedRoute.rootRunId) : { asyncDirRoot: DIRS.async, resultsDir: DIRS.results };
+    const asyncDir = path.join(runRoots.asyncDirRoot, runId);
     const currentSessionId = input.deps.state.currentSessionId;
     if (!currentSessionId)
         return { content: [{ type: "text", text: "External-job follow-up requires an active parent session." }], isError: true, details: { mode: "management", results: [] } };
-    if (fs.existsSync(asyncDir) || fs.existsSync(resultFilePath(DIRS.results, runId))) {
+    if (fs.existsSync(asyncDir) || fs.existsSync(resultFilePath(runRoots.resultsDir, runId))) {
         return externalJobFollowUpStarted({ sourceRunId: input.target.runId, runId, asyncDir, duplicate: true, interactive: input.ctx.hasUI });
     }
     const depthState = checkSubagentDepth(input.deps.config.maxSubagentDepth, input.deps.childRuntime);
@@ -1442,6 +1497,9 @@ function resolveRequestedResumeTarget(params, deps, parentSessionFile) {
             throw new Error("Attaching a running subagent as a chain root is currently available for top-level async runs only.");
         if (resolved.match.run.state === "running" || resolved.match.run.state === "queued")
             return { kind: "live-nested", target: resolved };
+        const externalJobTarget = resolveNestedExternalJobResumeTarget(resolved, params, deps);
+        if (externalJobTarget)
+            return externalJobTarget;
         const trustedSessionRoots = [
             ...(deps.config.defaultSessionDir ? [path.resolve(deps.expandTilde(deps.config.defaultSessionDir))] : []),
             ...(parentSessionFile ? [deps.getSubagentSessionRoot(parentSessionFile)] : []),
@@ -1516,7 +1574,7 @@ async function resumeAsyncRun(input) {
     const discoveredAgents = discovered.agents;
     const unknownAgentDiagnosticContext = diagnosticContextFromDiscovery(discovered, effectiveCwd, scope);
     const modelScope = discovered.modelScope;
-    const sessionName = resolveIntercomSessionTarget(input.deps.pi.getSessionName(), input.ctx.sessionManager.getSessionId());
+    const sessionName = resolveIntercomSessionTarget(input.deps.childRuntime?.intercomSessionName ?? input.deps.pi.getSessionName(), input.ctx.sessionManager.getSessionId());
     const recoveryDescriptor = "recoveryDescriptor" in target ? target.recoveryDescriptor : undefined;
     const recoveryContext = recoveryDescriptor?.context ?? (input.params.context === "profile" ? undefined : input.params.context);
     const intercomBridge = resolveIntercomBridge({
@@ -1558,7 +1616,7 @@ async function resumeAsyncRun(input) {
     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: [] } };
-        return resumeExternalJobFollowUp({
+        const resumed = await resumeExternalJobFollowUp({
             target,
             followUp,
             baseAgentConfig,
@@ -1572,6 +1630,10 @@ async function resumeAsyncRun(input) {
             parentSessionFile,
             absoluteDeadlineAt: input.absoluteDeadlineAt,
         });
+        const resumedRunId = resumed.details.runId ?? resumed.details.asyncId;
+        if (!resumed.isError && resumedRunId)
+            input.onLaunch?.({ agent: target.agent, async: true, runId: resumedRunId });
+        return resumed;
     }
     if (attachChain) {
         if (target.source !== "async") {
@@ -1679,6 +1741,7 @@ async function resumeAsyncRun(input) {
             return result;
         }
         const attachedId = result.details.asyncId ?? runId;
+        input.onLaunch?.({ agent: target.agent, ...(target.sessionFile ? { sessionFile: target.sessionFile } : {}), async: true, runId: attachedId });
         const lines = [
             `Attached async subagent ${target.runId} as the first step of a new chain.`,
             `Chain run: ${attachedId}`,
@@ -1695,11 +1758,14 @@ async function resumeAsyncRun(input) {
     if (!revivalSessionFile) {
         return { content: [{ type: "text", text: `Async run '${target.runId}' child ${target.index} does not have a persisted session file to resume from.` }], isError: true, details: { mode: "management", results: [] } };
     }
+    if (input.params.baseRef !== undefined && "managedWorktree" in target && target.managedWorktree === true) {
+        return { content: [{ type: "text", text: "Cannot resume with baseRef: retained managed-worktree children continue in their existing worktree. Start a new worktree run from that base ref instead." }], isError: true, details: { mode: "management", results: [] } };
+    }
     if (target.source === "async" && asyncReviveRequiresRecoveryDescriptor(target)) {
         return { content: [{ type: "text", text: `Async child '${target.runId}' is missing its required run fan-out recovery identity. Start a new run instead.` }], isError: true, details: { mode: "management", results: [] } };
     }
-    if (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 === "nested" && !target.recoveryDescriptor) {
+        return { content: [{ type: "text", text: `Nested child '${target.runId}' is missing its required recovery identity. Start a new run instead.` }], isError: true, details: { mode: "management", results: [] } };
     }
     const recoveryAgentConfig = recoveryDescriptor ? applySteeringRecoveryAgentConfig(baseAgentConfig, recoveryDescriptor) : baseAgentConfig;
     const agentConfig = intercomBridge.active ? applyIntercomBridgeToAgent(recoveryAgentConfig, intercomBridge) : recoveryAgentConfig;
@@ -1821,15 +1887,19 @@ async function resumeAsyncRun(input) {
         ...(input.params.timeoutMs !== undefined ? { timeoutMs: input.params.timeoutMs } : {}),
         ...(input.absoluteDeadlineAt !== undefined ? { absoluteDeadlineAt: input.absoluteDeadlineAt } : {}),
         ...(input.params.toolBudget !== undefined ? { toolBudget: input.params.toolBudget } : {}),
-        capabilityCeiling: intersectSubagentCapabilityCeilings("capabilityCeiling" in target ? target.capabilityCeiling : undefined, recoveryDescriptor?.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(input.deps.state.currentSessionId)),
+        // Recovery descriptors, remembered foreground runs, and current workflow roots
+        // preserve parent authority before the selected agent's descendant ceiling.
+        capabilityCeiling: intersectSubagentCapabilityCeilings(recoveryDescriptor?.capabilityCeiling ?? (target.source === "foreground" || (target.source === "async" && target.mode === "workflow") ? target.capabilityCeiling : undefined), resolveCurrentSubagentCapabilityCeiling(input.deps.state.currentSessionId)),
         runFanoutBudget: input.params.runFanoutBudget ?? recoveryDescriptor?.runFanoutBudget ?? createRunFanoutBudget(runId, resolveMaxSubagentSpawnsPerRun(input.deps.config.maxSubagentSpawnsPerRun)),
         parentWorkflowRunId: input.params.workflowParentRunId,
         workflowKey: input.params.workflowKey,
         activeAsyncCapacity,
     }));
+    const notifyLaunch = () => input.onLaunch?.({ agent: target.agent, sessionFile: revivalSessionFile, async: true, runId });
     if (result.isError) {
         const startedStatus = readStatus(revivalAsyncDir);
         if (input.params.workflowParentRunId !== undefined && startedStatus?.runId === runId && startedStatus.processTerminal?.runnerProcessInstanceId) {
+            notifyLaunch();
             return {
                 ...result,
                 details: {
@@ -1844,6 +1914,7 @@ async function resumeAsyncRun(input) {
         activeAsyncCapacity?.rollback();
         return result;
     }
+    notifyLaunch();
     for (const brief of queuedBriefs)
         fs.rmSync(brief.path, { force: true });
     if (queuedBriefs.length > 0 && sourceAsyncDir) {
@@ -1872,6 +1943,7 @@ async function resumeAsyncRun(input) {
         }
         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,
@@ -2147,11 +2219,15 @@ function projectEffectiveAcceptanceSchemas(params, agents) {
 }
 function validateExecutionInput(params, agents, hasChain, hasTasks, hasSingle, allowClarifyTaskPrompt, context) {
     if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
+        const agentList = agents.map((a) => a.name).join(", ") || "none";
+        const noMode = !hasChain && !hasTasks && !hasSingle;
         return {
             content: [
                 {
                     type: "text",
-                    text: `Provide exactly one mode. Agents: ${agents.map((a) => a.name).join(", ") || "none"}`,
+                    text: noMode && typeof params.workflowKey === "string"
+                        ? `Workflow child '${params.workflowKey}' has no agent. Pass { key, agent, task }. Agents: ${agentList}`
+                        : `Provide exactly one mode. Agents: ${agentList}`,
                 },
             ],
             isError: true,
@@ -2787,6 +2863,30 @@ function removeWorkflowAwaitedResult(asyncDir, resultPath, runId, publication) {
     }
     removeResultIndex(asyncDir, publication.sessionId, runId, publication.toolCallId);
 }
+function emitWorkflowAwaitedChildComplete(pi, state, runId, asyncDir, parentWorkflowRunId, completed) {
+    let status;
+    try {
+        status = readStatus(asyncDir);
+    }
+    catch (error) {
+        console.error(`Failed to read awaited workflow child status for ${runId}; emitting completion with fallback metadata:`, error);
+    }
+    pi.events.emit(SUBAGENT_ASYNC_COMPLETE_EVENT, {
+        id: runId,
+        runId,
+        sessionId: status?.sessionId ?? completed.importedPublication?.sessionId ?? state.currentSessionId,
+        completionOwnerId: status?.completionOwnerId ?? state.completionOwnerId ?? currentCompletionOwnerId(),
+        asyncDir,
+        agent: completed.agent,
+        mode: "single",
+        state: completed.stopped ? "stopped" : completed.success ? "complete" : "failed",
+        success: completed.success,
+        timestamp: Date.now(),
+        triggerTurn: false,
+        awaitedByWorkflow: true,
+        parentWorkflowRunId,
+    });
+}
 async function waitForWorkflowAsyncSingleResult(params, launchResult, options) {
     if (params.workflowAwaitAsync !== true || !launchResult.details.asyncDir)
         return launchResult;
@@ -2809,6 +2909,7 @@ async function waitForWorkflowAsyncSingleResult(params, launchResult, options) {
     }
     if (completed.importedPublication)
         removeWorkflowAwaitedResult(asyncDir, resultPath, options.runId, completed.importedPublication);
+    emitWorkflowAwaitedChildComplete(options.pi, options.state, options.runId, asyncDir, params.workflowParentRunId, completed);
     const usage = importedAsyncRootUsage(completed);
     const childResult = omitUndefinedProperties({
         index: 0,
@@ -2983,7 +3084,7 @@ async function runAsyncPath(data, deps) {
             lane: params.lane,
             workflowAwaitAsync: params.workflowAwaitAsync,
         }));
-        return waitForWorkflowAsyncSingleResult(params, asyncResult, { runId: id, task: params.task ?? "", signal: data.signal, state: deps.state, kill: deps.kill });
+        return waitForWorkflowAsyncSingleResult(params, asyncResult, { runId: id, task: params.task ?? "", signal: data.signal, state: deps.state, pi: deps.pi, kill: deps.kill });
     }
     return null;
 }
@@ -4662,6 +4763,7 @@ export function createSubagentExecutor(deps) {
                     ...(workflowSessionRoot ? { sessionRoot: workflowSessionRoot } : {}),
                     ...(requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {}),
                     pid: process.pid,
+                    ...(workflowCapabilityCeiling ? { admissionCapabilityCeiling: workflowCapabilityCeiling } : {}),
                     steps: [],
                     ...(workflowPreflight ? { preflight: workflowPreflight } : {}),
                     workflow: { trace: [], emits: [], console: [], ...(workflowArgsEvidence ?? {}), ...(workflowResource ? { resource: workflowResource.provenance } : {}) },
@@ -4730,11 +4832,15 @@ export function createSubagentExecutor(deps) {
                     deps.refreshResultDelivery?.();
                     return false;
                 };
+                const pendingWorkflowChildAnnouncements = new Map();
+                let announcePersistedWorkflowChildren = () => { };
                 const runPersistence = createCapacityResilientJsonWriter({
                     keepAlive: true,
                     onSuccess: (filePath, payload) => {
-                        if (filePath === statusPath)
+                        if (filePath === statusPath) {
+                            announcePersistedWorkflowChildren();
                             queueActiveRunIndex(payload);
+                        }
                         if (filePath === resultPath)
                             settleResultPublication?.(true);
                     },
@@ -4775,7 +4881,8 @@ export function createSubagentExecutor(deps) {
                     else if (options.tolerateStatusWriteFailure) {
                         try {
                             runPersistence.write(statusPath, { ...status });
-                            statusPersistenceDegraded = false;
+                            if (runPersistence.pendingCount() === 0)
+                                statusPersistenceDegraded = false;
                         }
                         catch (error) {
                             const message = `Failed to persist async workflow state ${statusPath}: ${error instanceof Error ? error.message : String(error)}`;
@@ -4871,6 +4978,25 @@ export function createSubagentExecutor(deps) {
                     return { content: [{ type: "text", text: `Failed to create async workflow storage: ${error instanceof Error ? error.message : String(error)}` }], isError: true, details: { mode: "workflow", results: [] } };
                 }
                 appendWorkflowEvent({ type: "subagent.workflow.started", ...(workflowArgsDigest ? { argsDigest: workflowArgsDigest } : {}) });
+                try {
+                    deps.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+                        lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+                        id: workflowRunId,
+                        asyncDir,
+                        cwd: workflowCwd,
+                        ...(workflowSessionRoot ? { sessionRoot: workflowSessionRoot } : {}),
+                        pid: process.pid,
+                        sessionId: currentSessionId ?? undefined,
+                        completionOwnerId,
+                        mode: "workflow",
+                        agent: "workflow",
+                        goal: derivedObjective.trim() ? PROMPT_REDACTED : undefined,
+                        ...(timeout !== undefined ? { timeoutMs: timeout, deadlineAt: startedAt + timeout } : {}),
+                    });
+                }
+                catch (error) {
+                    console.error("Failed to emit async workflow start event:", error);
+                }
                 // The runner does not execute workflow scripts: this active owner must consume its own
                 // durable steer inbox, deliver through in-process child controls, and persist receipts.
                 const emitWorkflowSteerEvent = (type, requestId, index, extra = {}) => {
@@ -5039,6 +5165,44 @@ export function createSubagentExecutor(deps) {
                     const childOutputClaimPaths = new Map();
                     const producedChildOutputPaths = new Set();
                     const workflowSteps = new Map();
+                    const announcedWorkflowChildren = new Set();
+                    const announceWorkflowChild = (key, step) => {
+                        if (announcedWorkflowChildren.has(key))
+                            return;
+                        announcedWorkflowChildren.add(key);
+                        const stepIndex = status.steps?.indexOf(step);
+                        const childEvent = {
+                            type: "subagent.child-status",
+                            version: 1,
+                            runId: workflowRunId,
+                            childId: key,
+                            status: "started",
+                            ts: Date.now(),
+                            source: "async",
+                            asyncDir,
+                            ...(stepIndex !== undefined ? { stepIndex } : {}),
+                            agent: step.agent,
+                            ...(step.runId ? { childRunId: step.runId } : {}),
+                            workflowKey: key,
+                            ...(step.phase ? { phase: step.phase } : {}),
+                            ...(step.label ? { label: step.label } : {}),
+                        };
+                        appendWorkflowEvent({ ...childEvent });
+                        try {
+                            deps.pi.events.emit(SUBAGENT_CHILD_STATUS_EVENT, childEvent);
+                        }
+                        catch (error) {
+                            console.error("Failed to emit workflow child status event:", error);
+                        }
+                    };
+                    announcePersistedWorkflowChildren = () => {
+                        for (const [key, step] of pendingWorkflowChildAnnouncements) {
+                            if (!step.runId)
+                                continue;
+                            announceWorkflowChild(key, step);
+                            pendingWorkflowChildAnnouncements.delete(key);
+                        }
+                    };
                     const runHostCommand = workflowHostCommandRunner({
                         workflowCwd,
                         artifactsDir: workflowArtifactsDir,
@@ -5280,6 +5444,8 @@ export function createSubagentExecutor(deps) {
                                                 step.runId = launch.runId;
                                             if (childRequest.lane)
                                                 step.lane = childRequest.lane;
+                                            if (step.runId)
+                                                pendingWorkflowChildAnnouncements.set(key, step);
                                             persist({ tolerateStatusWriteFailure: true });
                                         }
                                         recordMissionWorkflowChild(missionBinding, workflowRunId, key, { status: "running", agent: launch.agent, ...(launch.sessionFile ? { sessionPath: launch.sessionFile } : {}) });
@@ -5376,7 +5542,7 @@ export function createSubagentExecutor(deps) {
                         catch (receiptError) {
                             appendWorkflowEvent({ type: "subagent.workflow.receipt_write_failed", error: `Failed to persist async workflow receipt: ${receiptError instanceof Error ? receiptError.message : String(receiptError)}` });
                         }
-                        if (!writeWorkflowResult({ id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: true, state: "complete", summary: resultSummary, output: resultSummary, workflowChildren, results: workflowResultChildren(workflow.children, status, false), workflow: status.workflow, ...(workflowReceipt ? { workflowReceipt } : {}), asyncDir, cwd: workflowCwd, sessionId: currentSessionId, completionOwnerId, ...(requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {}), timestamp: Date.now(), durationMs: Date.now() - startedAt }))
+                        if (!writeWorkflowResult({ id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: true, state: "complete", summary: resultSummary, output: resultSummary, workflowChildren, results: workflowResultChildren(workflow.children, status, false), workflow: status.workflow, ...(workflowCapabilityCeiling ? { admissionCapabilityCeiling: workflowCapabilityCeiling } : {}), ...(workflowReceipt ? { workflowReceipt } : {}), asyncDir, cwd: workflowCwd, sessionId: currentSessionId, completionOwnerId, ...(requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {}), timestamp: Date.now(), durationMs: Date.now() - startedAt }))
                             return;
                         if (pendingResultPublication && !await pendingResultPublication)
                             return;
@@ -5433,7 +5599,7 @@ export function createSubagentExecutor(deps) {
                         catch (receiptError) {
                             appendWorkflowEvent({ type: "subagent.workflow.receipt_write_failed", error: `Failed to persist async workflow receipt: ${receiptError instanceof Error ? receiptError.message : String(receiptError)}` });
                         }
-                        if (!writeWorkflowResult({ id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: status.state === "complete", state: status.state, summary: resultSummary, error: status.state === "complete" ? undefined : status.error, stopped: status.stopped, activityState: status.activityState, workflowChildren, ...(terminalOutcome ? { terminalOutcome } : {}), results: workflowResultChildren(partial.children, status, true), workflow: status.workflow, ...(workflowReceipt ? { workflowReceipt } : {}), asyncDir, cwd: workflowCwd, sessionId: currentSessionId, completionOwnerId, ...(requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {}), timestamp: Date.now(), durationMs: Date.now() - startedAt }))
+                        if (!writeWorkflowResult({ id: workflowRunId, runId: workflowRunId, toolCallId, agent: "workflow", mode: "workflow", success: status.state === "complete", state: status.state, summary: resultSummary, error: status.state === "complete" ? undefined : status.error, stopped: status.stopped, activityState: status.activityState, workflowChildren, ...(terminalOutcome ? { terminalOutcome } : {}), results: workflowResultChildren(partial.children, status, true), workflow: status.workflow, ...(workflowCapabilityCeiling ? { admissionCapabilityCeiling: workflowCapabilityCeiling } : {}), ...(workflowReceipt ? { workflowReceipt } : {}), asyncDir, cwd: workflowCwd, sessionId: currentSessionId, completionOwnerId, ...(requestParams.scheduleOrigin ? { scheduleOrigin: requestParams.scheduleOrigin } : {}), timestamp: Date.now(), durationMs: Date.now() - startedAt }))
                             return;
                         if (pendingResultPublication && !await pendingResultPublication)
                             return;
@@ -5880,7 +6046,7 @@ export function createSubagentExecutor(deps) {
                     cwd: requestCwd,
                     ...(deps.config.missions ? { missions: deps.config.missions } : {}),
                     ...(deps.config.authorityPolicy ? { authorityPolicy: deps.config.authorityPolicy } : {}),
-                    plugins: createBuiltinInspectorPlugins(),
+                    plugins: getInspectorPlugins(deps.pi),
                     signal,
                 });
             }
@@ -6035,7 +6201,7 @@ export function createSubagentExecutor(deps) {
                 }
                 let orchestratorTarget;
                 try {
-                    orchestratorTarget = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
+                    orchestratorTarget = resolveIntercomSessionTarget(deps.childRuntime?.intercomSessionName ?? deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
                 }
                 catch (error) {
                     if (!sessionError)
@@ -6117,7 +6283,18 @@ export function createSubagentExecutor(deps) {
                 return withBudget(inspectSubagentStatus(paramsWithResolvedCwd, omitUndefinedProperties({ state: deps.state, nested: nestedScope, sessionRoots, abandonedSlotReleaseAfterMs: resolveAbandonedSlotReleaseAfterMs(deps.config.capacity?.abandonedSlotReleaseAfterMs) })));
             }
             if (action === "resume") {
-                return resumeAsyncRun(omitUndefinedProperties({ params: paramsWithResolvedCwd, requestCwd, ctx, deps, parentModel: requestParentModel, signal }));
+                return resumeAsyncRun(omitUndefinedProperties({
+                    params: paramsWithResolvedCwd,
+                    requestCwd,
+                    ctx,
+                    deps,
+                    parentModel: requestParentModel,
+                    signal,
+                    ...(workflowLaunchObserver ? { onLaunch: (launch) => {
+                            workflowLaunchObservers.delete(params);
+                            workflowLaunchObserver(launch);
+                        } } : {}),
+                }));
             }
             if (action === "steer") {
                 if (paramsWithResolvedCwd.mode !== undefined && resolveSteerDeliveryMode(paramsWithResolvedCwd.mode) === undefined) {
@@ -6401,6 +6578,7 @@ export function createSubagentExecutor(deps) {
                 cwd: requestCwd,
                 config: deps.config,
                 currentSessionId: deps.state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined,
+                discoverAgentsAll: deps.discoverAgentsAll,
                 runtimeAgentOwner: deps.pi,
                 onAgentsChanged: deps.onAgentsChanged,
             });
@@ -6468,7 +6646,7 @@ export function createSubagentExecutor(deps) {
             return buildRequestedModeError(effectiveParams, contextPolicyResult.error);
         const contextPolicy = contextPolicyResult;
         effectiveParams = contextPolicy.params;
-        const sessionName = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
+        const sessionName = resolveIntercomSessionTarget(deps.childRuntime?.intercomSessionName ?? deps.pi.getSessionName(), ctx.sessionManager.getSessionId());
         const intercomBridge = resolveIntercomBridge({
             config: deps.config.intercomBridge,
             override: effectiveParams.intercomBridge,
@@ -6498,10 +6676,29 @@ export function createSubagentExecutor(deps) {
             return spawnBudgetErrorResult(spawnPreflight.error, foregroundMode);
         let forkSessionFileForIndex = () => undefined;
         let prepareForkSessionForIndex = async () => { };
+        // Check before pruner/session preparation, then recheck immediately before each fork
+        // because the session capability ceiling can tighten while preparation awaits.
+        const launchCapabilityCeiling = () => intersectSubagentCapabilityCeilings(intersectSubagentCapabilityCeilings(effectiveParams.capabilityCeiling, resolveCurrentSubagentCapabilityCeiling(requestSessionId)), deps.childRuntime?.capabilityCeiling);
+        const assertLaunchableAgentsAllowedBeforeFork = () => {
+            if (!contextPolicy.usesFork)
+                return;
+            const ceiling = launchCapabilityCeiling();
+            const launchable = hasSingle
+                ? [effectiveParams.agent]
+                : hasTasks
+                    ? (effectiveParams.tasks ?? []).map((task) => task.agent)
+                    : (effectiveParams.chain ?? []).flatMap((step) => isDynamicParallelStep(step)
+                        && (step.expand.maxItems ?? deps.config.chain?.dynamicFanout?.maxItems ?? 0) === 0
+                        ? []
+                        : getStepAgents(step));
+            for (const agent of launchable)
+                assertAgentAllowedByCapabilityCeiling(agent, ceiling);
+        };
         // Forked children keep their requested thinking level. Signed Anthropic thinking
         // blocks are stripped from the inherited transcript by the resolver (they are bound
         // to the parent session), which is not a reason to disable the child's own reasoning.
         try {
+            assertLaunchableAgentsAllowedBeforeFork();
             const pruneSession = contextPolicy.usesFork && deps.config.forkContext?.mode === "pruned"
                 ? await createPrunedForkSessionWriter(ctx, deps.config.forkContext, signal)
                 : undefined;
@@ -6630,8 +6827,15 @@ export function createSubagentExecutor(deps) {
         const childSessionFileForTask = (agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) => forkSessionFileForTask(agentName, idx, modelOverride, modelOverrideFromParent, modelOrigin) ?? path.join(sessionDirForIndex(idx), "session.jsonl");
         const childSessionFileForIndex = (idx) => path.join(sessionDirForIndex(idx), "session.jsonl");
         try {
+            // The ceiling can change while the pruned writer is built; clarify skips preflight but
+            // still branches the parent session at launch.
+            assertLaunchableAgentsAllowedBeforeFork();
             if (!(effectiveParams.clarify === true && ctx.hasUI) || deps.config.forkContext?.mode === "pruned") {
-                await preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, prepareForkSessionForTask, deps.config.chain?.dynamicFanout?.maxItems);
+                const prepareAllowedForkSession = async (agent, ...rest) => {
+                    assertAgentAllowedByCapabilityCeiling(agent, launchCapabilityCeiling());
+                    await prepareForkSessionForTask(agent, ...rest);
+                };
+                await preflightForkSessionsForStaticTasks(effectiveParams, contextPolicy, prepareAllowedForkSession, deps.config.chain?.dynamicFanout?.maxItems);
             }
         }
         catch (error) {