pi-subagents 0.70.0 → 0.71.0

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

@@ -53,8 +53,7 @@ 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 { createTaskMutationArbiter } from "../shared/llm-intent-arbiter.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";
@@ -101,7 +100,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"]);
@@ -1517,7 +1516,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({
@@ -1559,7 +1558,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,
@@ -1573,6 +1572,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") {
@@ -1680,6 +1683,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}`,
@@ -1696,11 +1700,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;
@@ -1822,15 +1829,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: {
@@ -1845,6 +1856,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) {
@@ -2148,11 +2160,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,
@@ -3465,7 +3481,6 @@ async function runSinglePath(data, deps) {
             runtimeSnapshotHost: deps.pi,
             parentSessionId: ctx.sessionManager.getSessionId() ?? undefined,
             requiredExtensions,
-            llmIntentArbiter: createTaskMutationArbiter({ model: ctx.model, modelRegistry: ctx.modelRegistry, sessionId: ctx.sessionManager.getSessionId() }),
             childRuntime: deps.childRuntime,
             onChildSession: (controls) => { childSessionControls = controls; },
             context: data.contextPolicy.contextForAgent(params.agent),
@@ -4664,6 +4679,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 } : {}) },
@@ -4732,11 +4748,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);
                     },
@@ -4777,7 +4797,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)}`;
@@ -4873,6 +4894,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 = {}) => {
@@ -5041,6 +5081,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,
@@ -5282,6 +5360,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 } : {}) });
@@ -5378,7 +5458,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;
@@ -5435,7 +5515,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;
@@ -6037,7 +6117,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)
@@ -6119,7 +6199,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) {
@@ -6470,7 +6561,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,