pi-subagents 0.77.0 → 0.79.0

package/src/runs/background/subagent-runner.js

@@ -23,17 +23,19 @@ import { closeSteerInbox, closeStopInbox, consumeInterruptRequest, consumeSteerR
 import { appendJsonl as appendRawJsonl, formatOutputArtifactContent, getArtifactPaths, writeArtifact, writeMetadata } from "../../shared/artifacts.js";
 import { PI_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.js";
 import { preflightLaunchCwd } from "../shared/launch-cwd.js";
-import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, injectOutputPathSystemPrompt, injectSingleOutputInstruction, resolveSingleOutput } from "../shared/single-output.js";
+import { captureSingleOutputSnapshot, extractChildWrittenOutput, finalizeSingleOutput, formatSavedOutputReference, injectSingleOutputInstruction, isSettlementFatalOutputError, resolveSingleOutput } from "../shared/single-output.js";
+import { timedOutRunSummary } from "../shared/partial-output.js";
 import { runSetupCommand } from "../shared/worktree-setup-command.js";
 import { DEFAULT_MAX_OUTPUT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, truncateOutput, } from "../../shared/types.js";
 import { DEFAULT_CONTROL_CONFIG, buildControlEvent, deriveActivityState, claimControlNotification, formatControlIntercomMessage, formatControlNoticeMessage, shouldEmitOpenToolAttention, } from "../shared/subagent-control.js";
 import { isDynamicRunnerGroup, isParallelGroup, flattenSteps, mapConcurrent, aggregateParallelOutputs, MAX_PARALLEL_CONCURRENCY, DEFAULT_GLOBAL_CONCURRENCY_LIMIT, Semaphore, } from "../shared/parallel-utils.js";
-import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan } from "../shared/child-tool-plan.js";
+import { applyThinkingSuffix, projectLaunchResolvedChildExtensions, resolvePiLaunchToolPlan, supervisorChannelDir } from "../shared/child-tool-plan.js";
+import { retainsChildCommand } from "../shared/child-commands.js";
 import { buildRunnerChildLaunch } from "./runner-child-launch.js";
 import { normalizeExtensionBindings } from "../shared/extension-bindings.js";
 import { runChildSession } from "./run-child-session.js";
 import { loadRunnerChildSessionFactory } from "./runner-child-sessions.js";
-import { SUBAGENT_CHILD_ENV } from "../shared/child-runtime-config.js";
+import { SUBAGENT_CHILD_ENV, SUBAGENT_RUNNER_PID_ENV } from "../shared/child-runtime-config.js";
 import { deriveChildSessionName } from "../../shared/child-session-name.js";
 import { alignForkedSessionCwd } from "../../shared/fork-session-cwd.js";
 import { outputEntryFromAsyncResult, resolveOutputReferences } from "../shared/chain-outputs.js";
@@ -49,13 +51,12 @@ import { processTerminalPath, writeProcessTerminalCandidate } from "./process-te
 import { persistRunnerStartupFailure } from "./runner-startup-failure.js";
 import { currentPidNamespaceScope } from "./pid-namespace.js";
 import { createSteeringStatus, recordSteeringRequest, steeringStatus, terminalSteeringNoticeState, unconsumedSteerReason, updateSteeringTarget } from "./steering.js";
-import { PROMPT_REDACTED, detectSubagentError, extractTextFromContent, extractToolArgsPreview, formatEmptyTerminalAssistantResponseError, getAgentDir, hasEmptyTerminalAssistantResponse, readStatus } from "../../shared/utils.js";
-import { planBackgroundRunHistory, recordRun } from "../shared/run-history.js";
+import { PROMPT_REDACTED, SUBAGENT_STOPPED_MESSAGE, SUBAGENT_TIMED_OUT_MESSAGE, detectSubagentError, extractTextFromContent, extractToolArgsPreview, formatEmptyTerminalAssistantResponseError, getAgentDir, hasEmptyTerminalAssistantResponse, readStatus } from "../../shared/utils.js";
 import { planAbortRecovery } from "../shared/abort-recovery.js";
 import { createMutatingFailureState, didMutatingToolFail, isMutatingTool, nextLongRunningTrigger, recordMutatingFailure, resetMutatingFailureState, resolveCurrentPath, shouldEscalateMutatingFailures, summarizeRecentMutatingFailures, } from "../shared/long-running-guard.js";
 import { parseSessionTokens } from "../../shared/session-tokens.js";
 import { cleanupWorktrees, createWorktrees, withWorktreeTransaction, WorktreeSetupError, diffWorktrees, findWorktreeTaskCwdConflict, formatWorktreeDiffSummary, formatWorktreeTaskCwdConflict, WORKTREE_AGENT_CWD_PLACEHOLDER, } from "../shared/worktree.js";
-import { findModelInfo, resolveEffectiveThinking } from "../../shared/model-info.js";
+import { findModelInfo, qualifyModelWithProvider, resolveEffectiveThinking } from "../../shared/model-info.js";
 import { assertThinkingWithinCeiling } from "../../shared/thinking-ceiling.js";
 import { resolveLaunchBinding } from "../../shared/launch-contract.js";
 import { writeInitialProgressFile } from "../../shared/settings.js";
@@ -65,7 +66,7 @@ import { attachContractProjections, isAgentContract } from "../shared/agent-cont
 import { waitForImportedAsyncRoot } from "./chain-root-attachment.js";
 import { appendRunnerStepsToStatus, consumeChainAppendRequests, countPendingChainAppendRequests, statusStepDescription } from "./chain-append.js";
 import { asyncStatusChildIdentity } from "../shared/child-identity.js";
-import { initialToolBudgetState, toolBudgetState } from "../shared/tool-budget.js";
+import { initialToolBudgetState, isToolBudgetBlockedMessage, toolBudgetState } from "../shared/tool-budget.js";
 import { toolTimeoutCallKey } from "../shared/tool-timeout.js";
 import { usageBudgetExceededMessage, usageBudgetState } from "../shared/usage-budget.js";
 import { formatParallelHandoffError, formatParallelHandoffReference, parallelHandoffPath, writeParallelHandoffGroup, writeWorktreeSetupHandoff } from "../shared/parallel-handoff.js";
@@ -85,6 +86,7 @@ const INTERCOM_DETACH_RECEIPT = "Detached for intercom coordination before task
 // into one of them must register nothing; the variable marks the process as a
 // child host.
 process.env[SUBAGENT_CHILD_ENV] = "1";
+process.env[SUBAGENT_RUNNER_PID_ENV] = String(process.pid);
 function persistStepArtifacts(input) {
     const errors = {};
     if (input.artifactConfig?.includeOutput !== false) {
@@ -467,7 +469,7 @@ export async function runSingleStepInner(step, ctx) {
             }
             const stopped = importStopped || imported.stopped === true || ctx.stopSignal?.aborted === true;
             const timedOut = !stopped && (importTimedOut || imported.timedOut === true || ctx.timeoutSignal?.aborted === true || ctx.skipAcceptance?.() === true);
-            const message = stopped ? ctx.stopMessage ?? "Subagent stopped by user." : ctx.timeoutMessage ?? "Subagent timed out.";
+            const message = stopped ? ctx.stopMessage ?? SUBAGENT_STOPPED_MESSAGE : ctx.timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE;
             return omitUndefinedProperties({
                 agent: imported.agent,
                 output: timedOut || stopped ? message : imported.output,
@@ -554,6 +556,47 @@ export async function runSingleStepInner(step, ctx) {
         }
     }
     transcriptWriter?.writeInitialUserMessage(`${PROMPT_REDACTED}; live Prompt Audit only.`);
+    // External CLI and external job runs settle their output the same way; only their runner metadata differs.
+    const settleExternalOutput = (external, outputSnapshot, runnerMetadata) => {
+        try {
+            fs.writeFileSync(ctx.outputFile, external.output, "utf-8");
+        }
+        catch { /* Observability output is best-effort. */ }
+        const resolvedOutput = step.outputPath && external.exitCode === 0
+            ? resolveSingleOutput(step.outputPath, external.output, outputSnapshot, step.outputClaimPath)
+            : { fullOutput: external.output };
+        const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, resolvedOutput.fullOutput) : undefined;
+        const settlementFatalOutputError = isSettlementFatalOutputError(resolvedOutput, step.outputMode);
+        const exitCode = settlementFatalOutputError ? 1 : external.exitCode;
+        const error = settlementFatalOutputError && resolvedOutput.saveError
+            ? external.error ? `${external.error}\n${resolvedOutput.saveError}` : resolvedOutput.saveError
+            : external.error;
+        const finalizedOutput = finalizeSingleOutput(omitUndefinedProperties({
+            fullOutput: resolvedOutput.fullOutput,
+            outputPath: step.outputPath,
+            outputMode: step.outputMode,
+            exitCode: exitCode ?? 1,
+            savedPath: resolvedOutput.savedPath,
+            outputReference,
+            saveError: resolvedOutput.saveError,
+        }));
+        const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false
+            ? persistStepArtifacts({
+                artifactPaths,
+                artifactConfig: ctx.artifactConfig,
+                output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, error: error, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })),
+                metadata: { runId: ctx.id, parentSessionId: step.parentSessionId, agent: step.agent, task: PROMPT_REDACTED, ...runnerMetadata, exitCode: exitCode, error: error, timestamp: Date.now() },
+            })
+            : {};
+        return {
+            output: finalizedOutput.displayOutput,
+            exitCode,
+            error,
+            outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join("\n") || undefined,
+            artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
+            metadataSaveError: artifactErrors.metadataSaveError,
+        };
+    };
     if (step.runner?.type === "external-cli") {
         const externalCwd = step.machine?.cwd ?? step.cwd ?? ctx.cwd;
         const externalAbortSignal = combinedAbortSignal([ctx.timeoutSignal, ctx.stopSignal]);
@@ -561,7 +604,7 @@ export async function runSingleStepInner(step, ctx) {
             await ctx.prepareExternalActivity?.(externalCwd, externalAbortSignal);
         if (externalAbortSignal?.aborted) {
             const stopped = ctx.stopSignal?.aborted === true;
-            const message = stopped ? ctx.stopMessage ?? "Subagent stopped by user." : ctx.timeoutMessage ?? "Subagent timed out.";
+            const message = stopped ? ctx.stopMessage ?? SUBAGENT_STOPPED_MESSAGE : ctx.timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE;
             return omitUndefinedProperties({ agent: step.agent, context: step.context, output: message, error: message, exitCode: 1, stopped: stopped || undefined, timedOut: stopped ? undefined : true });
         }
         if (step.machine) {
@@ -584,7 +627,7 @@ export async function runSingleStepInner(step, ctx) {
                     else if (raced.kind === "timeout")
                         settled = createHerdrExternalAdapter(step.runner.adapter).normalize(evidenceInput, "Placed external run timed out; truthful pane retained for inspection.");
                     else
-                        return { agent: step.agent, context: step.context, output: "Placed external run stopped by user.", outputState: "present", exitCode: 1, stopped: true, runner, execution: { status: "stopped", success: false, exitCode: 1, stopped: true } };
+                        return { agent: step.agent, context: step.context, output: "Placed external run stopped.", outputState: "present", exitCode: 1, stopped: true, runner, execution: { status: "stopped", success: false, exitCode: 1, stopped: true } };
                 }
                 catch (error) {
                     retain = true;
@@ -599,7 +642,7 @@ export async function runSingleStepInner(step, ctx) {
                 const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, resolvedOutput.fullOutput) : undefined;
                 const finalizedOutput = finalizeSingleOutput(omitUndefinedProperties({ fullOutput: resolvedOutput.fullOutput, outputPath: step.outputPath, outputMode: step.outputMode, exitCode: 1, preserveSavedOutput: true, savedPath: resolvedOutput.savedPath, outputReference, saveError: resolvedOutput.saveError }));
                 const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false ? persistStepArtifacts({ artifactPaths, artifactConfig: ctx.artifactConfig, output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })), metadata: { runId: ctx.id, parentSessionId: step.parentSessionId, agent: step.agent, task: PROMPT_REDACTED, runner, placement: session.owner.identity, settlement: settled.settlement, outcome: settled.outcome, timestamp: Date.now() } }) : {};
-                return omitUndefinedProperties({ agent: step.agent, ...(childSessionName ? { sessionName: childSessionName } : {}), context: step.context, output: finalizedOutput.displayOutput, outputState: output.trim() ? "present" : "absent", exitCode: 1, error: resolvedOutput.fatalError ? resolvedOutput.saveError : undefined, timedOut, stopped, artifactPaths, outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join("\n") || undefined, metadataSaveError: artifactErrors.metadataSaveError, runner, execution: { status: "partial", success: false, exitCode: 1 } });
+                return omitUndefinedProperties({ agent: step.agent, ...(childSessionName ? { sessionName: childSessionName } : {}), context: step.context, output: finalizedOutput.displayOutput, outputState: output.trim() ? "present" : "absent", exitCode: 1, error: isSettlementFatalOutputError(resolvedOutput, step.outputMode) ? resolvedOutput.saveError : undefined, timedOut, stopped, artifactPaths, outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join("\n") || undefined, metadataSaveError: artifactErrors.metadataSaveError, runner, execution: { status: "partial", success: false, exitCode: 1 } });
             }
             catch (error) {
                 // Any post-allocation uncertainty retains the pane; only explicit stop
@@ -655,50 +698,22 @@ export async function runSingleStepInner(step, ctx) {
         const ran = await runExternalCli(preparedExternal.input);
         const externalProcess = preparedExternal.decorateProcess(ran.externalProcess);
         const external = step.machine ? decorateHerdrMachineResult(ran, step.machine, step.runner.adapter) : ran;
-        try {
-            fs.writeFileSync(ctx.outputFile, external.output, "utf-8");
-        }
-        catch { /* Observability output is best-effort. */ }
-        const resolvedOutput = step.outputPath && external.exitCode === 0
-            ? resolveSingleOutput(step.outputPath, external.output, outputSnapshot, step.outputClaimPath)
-            : { fullOutput: external.output };
-        const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, resolvedOutput.fullOutput) : undefined;
-        const exitCode = resolvedOutput.fatalError ? 1 : external.exitCode;
-        const error = resolvedOutput.fatalError && resolvedOutput.saveError
-            ? external.error ? `${external.error}\n${resolvedOutput.saveError}` : resolvedOutput.saveError
-            : external.error;
-        const finalizedOutput = finalizeSingleOutput(omitUndefinedProperties({
-            fullOutput: resolvedOutput.fullOutput,
-            outputPath: step.outputPath,
-            outputMode: step.outputMode,
-            exitCode: exitCode ?? 1,
-            savedPath: resolvedOutput.savedPath,
-            outputReference,
-            saveError: resolvedOutput.saveError,
-        }));
-        const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false
-            ? persistStepArtifacts({
-                artifactPaths,
-                artifactConfig: ctx.artifactConfig,
-                output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, error: external.error, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })),
-                metadata: { runId: ctx.id, parentSessionId: step.parentSessionId, agent: step.agent, task: PROMPT_REDACTED, runner, externalProcess: externalProcess, exitCode: external.exitCode, error: external.error, timestamp: Date.now() },
-            })
-            : {};
+        const settled = settleExternalOutput(external, outputSnapshot, { runner, externalProcess });
         return omitUndefinedProperties({
             agent: step.agent,
             ...(childSessionName ? { sessionName: childSessionName } : {}),
             context: step.context,
-            output: finalizedOutput.displayOutput,
+            output: settled.output,
             outputState: external.output.trim() ? "present" : "absent",
-            exitCode,
-            error,
+            exitCode: settled.exitCode,
+            error: settled.error,
             timedOut: external.timedOut,
             stopped: external.stopped,
             processSignal: external.processSignal,
             artifactPaths,
-            outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join("\n") || undefined,
-            artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
-            metadataSaveError: artifactErrors.metadataSaveError,
+            outputSaveError: settled.outputSaveError,
+            artifactOutputSaveFailed: settled.artifactOutputSaveFailed,
+            metadataSaveError: settled.metadataSaveError,
             runner,
             externalProcess: externalProcess,
         });
@@ -728,49 +743,21 @@ export async function runSingleStepInner(step, ctx) {
             onExternalJob: ctx.onExternalJob,
             followUp: step.externalJobFollowUp,
         }));
-        try {
-            fs.writeFileSync(ctx.outputFile, external.output, "utf-8");
-        }
-        catch { /* Observability output is best-effort. */ }
-        const resolvedOutput = step.outputPath && external.exitCode === 0
-            ? resolveSingleOutput(step.outputPath, external.output, outputSnapshot, step.outputClaimPath)
-            : { fullOutput: external.output };
-        const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, resolvedOutput.fullOutput) : undefined;
-        const exitCode = resolvedOutput.fatalError ? 1 : external.exitCode;
-        const error = resolvedOutput.fatalError && resolvedOutput.saveError
-            ? external.error ? `${external.error}\n${resolvedOutput.saveError}` : resolvedOutput.saveError
-            : external.error;
-        const finalizedOutput = finalizeSingleOutput(omitUndefinedProperties({
-            fullOutput: resolvedOutput.fullOutput,
-            outputPath: step.outputPath,
-            outputMode: step.outputMode,
-            exitCode: exitCode ?? 1,
-            savedPath: resolvedOutput.savedPath,
-            outputReference,
-            saveError: resolvedOutput.saveError,
-        }));
-        const artifactErrors = artifactPaths && ctx.artifactConfig?.enabled !== false
-            ? persistStepArtifacts({
-                artifactPaths,
-                artifactConfig: ctx.artifactConfig,
-                output: formatOutputArtifactContent(omitUndefinedProperties({ output: resolvedOutput.fullOutput, error: external.error, metadataPath: ctx.artifactConfig?.includeMetadata === false ? undefined : artifactPaths.metadataPath })),
-                metadata: { runId: ctx.id, parentSessionId: step.parentSessionId, agent: step.agent, task: PROMPT_REDACTED, runner, externalJob: external.externalJob, exitCode: external.exitCode, error: external.error, timestamp: Date.now() },
-            })
-            : {};
+        const settled = settleExternalOutput(external, outputSnapshot, { runner, externalJob: external.externalJob });
         return omitUndefinedProperties({
             agent: step.agent,
             ...(childSessionName ? { sessionName: childSessionName } : {}),
             context: step.context,
-            output: finalizedOutput.displayOutput,
+            output: settled.output,
             outputState: external.output.trim() ? "present" : "absent",
-            exitCode,
-            error,
+            exitCode: settled.exitCode,
+            error: settled.error,
             timedOut: external.timedOut,
             stopped: external.stopped,
             artifactPaths,
-            outputSaveError: [resolvedOutput.saveError, artifactErrors.outputSaveError].filter(Boolean).join("\n") || undefined,
-            artifactOutputSaveFailed: artifactErrors.outputSaveError ? true : undefined,
-            metadataSaveError: artifactErrors.metadataSaveError,
+            outputSaveError: settled.outputSaveError,
+            artifactOutputSaveFailed: settled.artifactOutputSaveFailed,
+            metadataSaveError: settled.metadataSaveError,
             runner,
             externalJob: external.externalJob,
         });
@@ -1020,7 +1007,11 @@ export async function runSingleStepInner(step, ctx) {
         const mutationEvidence = run.nativeMachine ? { source: "tracked-files", trackedOnly: true, changedFiles: [], attemptedMutation: remoteGitChanged === true, ...(remoteGitChanged === undefined ? { unavailable: "Remote Git before/after evidence was incomplete." } : {}) } : collectTrackedMutationEvidence(mutationSnapshot, step.cwd ?? ctx.cwd);
         finalMutationEvidence = mutationEvidence;
         const mutationAttemptObserved = run.observedMutationAttempt === true || mutationEvidence.attemptedMutation === true;
-        const finalOutputHasPersistableFileContent = run.exitCode === 0 && !run.error && !emptyOutputError && Boolean(stripAcceptanceReport(run.finalOutput).trim());
+        // Validated structured output is persistable file content even when the final text is only
+        // an acceptance-report fence; otherwise the required-output precheck forces exitCode 1 before
+        // resolveSingleOutput can publish the canonical JSON into the bound file-only path.
+        const finalOutputHasPersistableFileContent = run.exitCode === 0 && !run.error && !emptyOutputError
+            && (Boolean(stripAcceptanceReport(run.finalOutput).trim()) || validatedStructuredOutput);
         const requiredOutput = step.outputMode === "file-only" && step.outputPath
             ? { kind: "file-only", path: step.outputPath, missing: !fs.existsSync(step.outputPath) && !finalOutputHasPersistableFileContent }
             : effectiveStructuredOutput
@@ -1104,7 +1095,7 @@ export async function runSingleStepInner(step, ctx) {
     const resolvedOutput = step.outputPath && finalResult?.exitCode === 0
         ? resolveSingleOutput(step.outputPath, structuredText ?? replyOutput, finalOutputSnapshot, step.outputClaimPath)
         : { fullOutput: replyOutput };
-    if (resolvedOutput.fatalError) {
+    if (isSettlementFatalOutputError(resolvedOutput, step.outputMode)) {
         if (finalResult) {
             finalResult.exitCode = 1;
             finalResult.error = finalResult.error ? `${finalResult.error}\n${resolvedOutput.saveError}` : resolvedOutput.saveError;
@@ -1114,7 +1105,7 @@ export async function runSingleStepInner(step, ctx) {
     const outputReference = resolvedOutput.savedPath ? formatSavedOutputReference(resolvedOutput.savedPath, output) : undefined;
     let outputForSummary = output;
     if (finalResult?.stopped && !outputForSummary.trim()) {
-        outputForSummary = ctx.stopMessage ?? "Subagent stopped by user.";
+        outputForSummary = ctx.stopMessage ?? SUBAGENT_STOPPED_MESSAGE;
     }
     // Unfinished streamed text never stands in for the child's completed reply.
     const outputForAcceptance = finalResult?.outputPartial ? "" : rawOutput;
@@ -1167,7 +1158,7 @@ export async function runSingleStepInner(step, ctx) {
             cwd: step.cwd ?? ctx.cwd,
             stagedIndexBaseline,
             signal: combinedAbortSignal([ctx.timeoutSignal, ctx.stopSignal]),
-            abortMessage: ctx.stopSignal?.aborted ? ctx.stopMessage ?? "Subagent stopped by user." : ctx.timeoutMessage ?? "Subagent timed out.",
+            abortMessage: ctx.stopSignal?.aborted ? ctx.stopMessage ?? SUBAGENT_STOPPED_MESSAGE : ctx.timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE,
             reportOptional: isAgentContract(step.agentContract),
             artifactsDir: ctx.artifactsDir,
             runId: ctx.id,
@@ -1194,9 +1185,9 @@ export async function runSingleStepInner(step, ctx) {
     }
     const intercomDetachReceipt = finalResult?.finalOutput === INTERCOM_DETACH_RECEIPT;
     const baseFinalError = stoppedAfterAcceptance
-        ? ctx.stopMessage ?? "Subagent stopped by user."
+        ? ctx.stopMessage ?? SUBAGENT_STOPPED_MESSAGE
         : timedOutAfterAcceptance
-            ? finalResult?.error ?? ctx.timeoutMessage ?? "Subagent timed out."
+            ? finalResult?.error ?? ctx.timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE
             : acceptanceCanFailRun
                 ? (finalResult?.error ? `${finalResult.error}\n${acceptanceFailure}` : acceptanceFailure)
                 : finalResult?.error ?? (intercomDetachReceipt ? INTERCOM_DETACH_RECEIPT : undefined);
@@ -1343,8 +1334,8 @@ function markParallelGroupSetupFailure(input) {
         const paused = !stopped && input.statusPayload.state === "paused";
         const timedOut = !stopped && !paused && input.statusPayload.timedOut === true;
         statusStep.status = stopped ? "stopped" : paused ? "paused" : "failed";
-        // Mirror the run-level timeout onto the step so consumers (status readers,
-        // run-history recording) see timed_out rather than a bare failure — the
+        // Mirror the run-level timeout onto the step so status readers see
+        // timed_out rather than a bare failure — the
         // StepResult below already carries it, the status step must too.
         if (timedOut)
             statusStep.timedOut = true;
@@ -1518,11 +1509,6 @@ export async function runSubagent(config, childSessions) {
     let previousOutput = "";
     const outputs = {};
     const results = [];
-    // Flat indices of steps a child session was actually dispatched for — the
-    // ground truth for run-history: stopRunner/timeoutRunner/fail-fast/budget
-    // skips relabel never-launched steps to terminal statuses, so status alone
-    // cannot distinguish them from steps that really ran.
-    const launchedFlatIndices = new Set();
     const overallStartTime = Date.now();
     const shareEnabled = config.share === true;
     const asyncDir = config.asyncDir;
@@ -1549,7 +1535,7 @@ export async function runSubagent(config, childSessions) {
     let stopped = false;
     let usageBudgetExceeded = false;
     const timeoutMessage = config.timeoutMs !== undefined ? `Subagent timed out after ${config.timeoutMs}ms.` : undefined;
-    const stopMessage = "Subagent stopped by user.";
+    const stopMessage = SUBAGENT_STOPPED_MESSAGE;
     const timeoutAbortController = new AbortController();
     const stopAbortController = new AbortController();
     const setupInterruptController = new AbortController();
@@ -1705,6 +1691,7 @@ export async function runSubagent(config, childSessions) {
         ...(config.launchResolvedExtensions ? { launchResolvedExtensions: config.launchResolvedExtensions } : {}),
         ...(config.capabilityCeiling ? { capabilityCeiling: config.capabilityCeiling } : {}),
         ...(config.runFanoutBudget ? { runFanoutBudget: getRunFanoutBudgetSnapshot(config.runFanoutBudget) } : {}),
+        ...(config.revivalLease ? { revivedFrom: config.revivalLease.sourceRunId } : {}),
         ...(config.parentWorkflowRunId ? { parentWorkflowRunId: config.parentWorkflowRunId } : {}),
         ...(config.workflowKey ? { workflowKey: config.workflowKey } : {}),
         ...(config.lane ? { lane: config.lane } : {}),
@@ -2211,8 +2198,8 @@ export async function runSubagent(config, childSessions) {
         agent,
         sessionName,
         context,
-        output: timeoutMessage ?? "Subagent timed out.",
-        error: timeoutMessage ?? "Subagent timed out.",
+        output: timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE,
+        error: timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE,
         exitCode: 1,
         timedOut: true,
     });
@@ -2251,6 +2238,7 @@ export async function runSubagent(config, childSessions) {
         });
         mutatingFailureStates.push(...Array.from({ length: added.addedFlatSteps }, () => createMutatingFailureState()));
         pendingToolResults.push(...Array.from({ length: added.addedFlatSteps }, () => undefined));
+        pendingToolResultsByCallId.push(...Array.from({ length: added.addedFlatSteps }, () => new Map()));
         if (config.childIntercomTargets) {
             config.childIntercomTargets = statusPayload.steps.map((statusStep, index) => resolveSubagentIntercomTarget(id, statusStep.agent, index));
         }
@@ -2347,6 +2335,9 @@ export async function runSubagent(config, childSessions) {
     const activeLongRunningSteps = new Set();
     const mutatingFailureStates = initialStatusSteps.map(() => createMutatingFailureState());
     const pendingToolResults = initialStatusSteps.map(() => undefined);
+    // Pi's parallel tool execution emits every tool_execution_start before the first result message, so each
+    // step matches results to calls by toolCallId; pendingToolResults keeps the last-started call for events without one.
+    const pendingToolResultsByCallId = initialStatusSteps.map(() => new Map());
     const activeToolCalls = initialStatusSteps.map(() => new Map());
     const activeToolKeysByName = initialStatusSteps.map(() => new Map());
     const activeToolSequences = initialStatusSteps.map(() => 0);
@@ -2481,6 +2472,7 @@ export async function runSubagent(config, childSessions) {
         step.activityState = "needs_attention";
         statusPayload.activityState = "needs_attention";
         const toolDurationMs = Math.max(0, now - target.startedAt);
+        const toolCallId = target.key.startsWith("id:") ? target.key.slice(3) : undefined;
         appendControlEvent(buildControlEvent(omitUndefinedProperties({
             type: "needs_attention",
             from: previous,
@@ -2495,7 +2487,8 @@ export async function runSubagent(config, childSessions) {
             tokens: step.tokens?.total,
             toolCount: step.toolCount,
             currentTool: target.tool,
-            toolCallId: target.key.startsWith("id:") ? target.key.slice(3) : undefined,
+            toolCallId,
+            hasCommandController: Boolean(toolCallId && retainsChildCommand(supervisorChannelDir(id, step.agent, flatIndex), toolCallId)),
             currentToolDurationMs: toolDurationMs,
             currentPath: target.path,
         })));
@@ -2698,11 +2691,72 @@ export async function runSubagent(config, childSessions) {
         if (!step)
             return;
         setOptionalProperty(step, "model", model);
+        setOptionalProperty(step, "launchModel", undefined);
         setOptionalProperty(step, "thinking", thinking);
         setOptionalProperty(step, "contextLimit", contextLimit);
         statusPayload.lastUpdate = now;
         writeStatusPayload();
     };
+    // Records a finished child's result on its status step; the sequential and both parallel paths share it.
+    const recordStepResult = (fi, singleResult, startedAt, endedAt, recordLaunchContractDigest = false) => {
+        const step = requiredStatusStep(statusPayload, fi);
+        const childStopped = singleResult.stopped === true;
+        const childInterrupted = singleResult.interrupted === true;
+        step.status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
+        step.endedAt = endedAt;
+        step.durationMs = endedAt - startedAt;
+        step.exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
+        setOptionalProperty(step, "timedOut", timedOut || singleResult.timedOut ? true : undefined);
+        setOptionalProperty(step, "stopped", stopped || childStopped ? true : undefined);
+        setOptionalProperty(step, "toolBudget", singleResult.toolBudget);
+        setOptionalProperty(step, "toolBudgetBlocked", singleResult.toolBudgetBlocked);
+        if (singleResult.toolBudget)
+            statusPayload.toolBudget = singleResult.toolBudget;
+        if (singleResult.toolBudgetBlocked)
+            statusPayload.toolBudgetBlocked = true;
+        setOptionalProperty(step, "sessionName", singleResult.sessionName);
+        // Keep the model the child was observed running on; a host extension can switch it
+        // after launch, and singleResult.model only names the launch candidate.
+        setOptionalProperty(step, "model", step.model ?? singleResult.model);
+        setOptionalProperty(step, "thinking", resolveEffectiveThinking(singleResult.model, step.thinking));
+        setOptionalProperty(step, "requestedModel", singleResult.requestedModel);
+        setOptionalProperty(step, "contextOverflow", singleResult.contextOverflow);
+        setOptionalProperty(step, "totalCost", singleResult.totalCost);
+        setOptionalProperty(step, "error", stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE) : singleResult.error);
+        setOptionalProperty(step, "transcriptPath", singleResult.transcriptPath ?? step.transcriptPath);
+        setOptionalProperty(step, "transcriptError", singleResult.transcriptError);
+        setOptionalProperty(step, "agentContract", singleResult.agentContract);
+        if (recordLaunchContractDigest)
+            setOptionalProperty(step, "launchContractDigest", singleResult.launchContractDigest);
+        setOptionalProperty(step, "launchResolvedExtensions", singleResult.launchResolvedExtensions);
+        setOptionalProperty(step, "runtimeAcknowledgedExtensions", singleResult.runtimeAcknowledgedExtensions);
+        setOptionalProperty(step, "effects", singleResult.effects);
+        setOptionalProperty(step, "execution", singleResult.execution);
+        setOptionalProperty(step, "review", singleResult.review);
+        setOptionalProperty(step, "structuredOutput", singleResult.structuredOutput);
+        setOptionalProperty(step, "structuredOutputPath", singleResult.structuredOutputPath);
+        setOptionalProperty(step, "structuredOutputSchemaPath", singleResult.structuredOutputSchemaPath);
+        setOptionalProperty(step, "acceptance", singleResult.acceptance);
+        setOptionalProperty(step, "timeoutRecovery", singleResult.timeoutRecovery);
+        setOptionalProperty(step, "watchdog", singleResult.watchdog);
+        setOptionalProperty(step, "capabilityCeiling", singleResult.capabilityCeiling);
+        setOptionalProperty(step, "capabilityAudit", singleResult.capabilityAudit);
+        if (singleResult.capabilityCeiling)
+            statusPayload.capabilityCeiling = singleResult.capabilityCeiling;
+        if (singleResult.capabilityAudit)
+            statusPayload.capabilityAudit = singleResult.capabilityAudit;
+    };
+    // Adds a parallel child's cost to the in-flight usage ledger.
+    const addParallelUsageCost = (totalCost) => {
+        if (!totalCost)
+            return;
+        pendingParallelUsageCost = {
+            inputTokens: pendingParallelUsageCost.inputTokens + totalCost.inputTokens,
+            outputTokens: pendingParallelUsageCost.outputTokens + totalCost.outputTokens,
+            costUsd: pendingParallelUsageCost.costUsd + totalCost.costUsd,
+        };
+        refreshUsageBudget();
+    };
     const updateStepFromChildEvent = (flatIndex, event) => {
         const step = statusPayload.steps[flatIndex];
         if (!step)
@@ -2745,11 +2799,15 @@ export async function runSubagent(config, childSessions) {
             step.toolCount = (step.toolCount ?? 0) + 1;
             const configuredToolBudget = flatSteps[flatIndex]?.toolBudget;
             if (configuredToolBudget) {
-                step.toolBudget = toolBudgetState(configuredToolBudget, step.toolCount);
+                step.toolBudget = toolBudgetState(configuredToolBudget, step.toolCount, step.toolBudget?.blockedTool);
                 statusPayload.toolBudget = step.toolBudget;
             }
             recordActiveToolCall(flatIndex, { toolCallId: event.toolCallId, toolName: event.toolName }, { argsPreview, currentPath, blocksSupervisor, now });
-            pendingToolResults[flatIndex] = omitUndefinedProperties({ tool: event.toolName, path: currentPath, mutates, startedAt: now });
+            const pending = omitUndefinedProperties({ tool: event.toolName, path: currentPath, mutates, startedAt: now });
+            pendingToolResults[flatIndex] = pending;
+            const startedCallId = event.toolCallId;
+            if (typeof startedCallId === "string" && startedCallId)
+                pendingToolResultsByCallId[flatIndex].set(startedCallId, pending);
             statusPayload.toolCount = (statusPayload.toolCount ?? 0) + 1;
             syncTopLevelCurrentTool();
             if (controlConfig.enabled && blocksSupervisor && step.activityState !== "needs_attention") {
@@ -2794,21 +2852,30 @@ export async function runSubagent(config, childSessions) {
             }
             syncTopLevelCurrentTool();
         }
-        else if (event.type === "tool_result_end" && event.message) {
-            const toolSnapshot = pendingToolResults[flatIndex];
-            pendingToolResults[flatIndex] = undefined;
+        else if (event.type === "message_end" && event.message?.role === "toolResult") {
+            // Pi delivers every tool result, including a blocked call, as a toolResult message after tool_execution_end.
+            const resultCallId = event.message.toolCallId;
+            const byCallId = pendingToolResultsByCallId[flatIndex];
+            const keyedSnapshot = typeof resultCallId === "string" ? byCallId.get(resultCallId) : undefined;
+            if (keyedSnapshot)
+                byCallId.delete(resultCallId);
+            const toolSnapshot = keyedSnapshot ?? pendingToolResults[flatIndex];
+            if (!keyedSnapshot || pendingToolResults[flatIndex] === keyedSnapshot)
+                pendingToolResults[flatIndex] = undefined;
             const resultText = extractTextFromContent(event.message.content);
-            if (toolSnapshot && resultText.includes("Tool budget hard limit reached")) {
-                const configuredToolBudget = flatSteps[flatIndex]?.toolBudget;
-                if (configuredToolBudget) {
-                    step.toolBudget = toolBudgetState(configuredToolBudget, step.toolCount ?? 0, toolSnapshot.tool);
-                    step.toolBudgetBlocked = true;
-                    statusPayload.toolBudget = step.toolBudget;
-                    statusPayload.toolBudgetBlocked = true;
-                }
+            const resultToolName = event.message.toolName;
+            const blockedTool = (typeof resultToolName === "string" && resultToolName.length > 0 ? resultToolName : undefined) ?? toolSnapshot?.tool;
+            const configuredToolBudget = flatSteps[flatIndex]?.toolBudget;
+            const budgetBlocked = configuredToolBudget !== undefined && isToolBudgetBlockedMessage(configuredToolBudget, resultText, blockedTool);
+            if (budgetBlocked) {
+                step.toolBudget = toolBudgetState(configuredToolBudget, step.toolCount ?? 0, blockedTool);
+                step.toolBudgetBlocked = true;
+                statusPayload.toolBudget = step.toolBudget;
+                statusPayload.toolBudgetBlocked = true;
             }
             appendRecentStepOutput(step, resultText.split("\n").slice(-10));
-            if (toolSnapshot?.mutates && didMutatingToolFail(resultText)) {
+            // A budget block has its own signal; it is not a failing mutation.
+            if (toolSnapshot?.mutates && !budgetBlocked && didMutatingToolFail(event.message)) {
                 const state = mutatingFailureStates[flatIndex];
                 recordMutatingFailure(state, omitUndefinedProperties({
                     tool: toolSnapshot.tool,
@@ -2847,6 +2914,20 @@ export async function runSubagent(config, childSessions) {
         else if (event.type === "message_end" && event.message?.role === "assistant") {
             appendRecentStepOutput(step, stripAcceptanceReport(extractTextFromContent(event.message.content)).split("\n").slice(-10));
             step.turnCount = (step.turnCount ?? 0) + 1;
+            // The launch model is only a candidate: a host extension (e.g. a model
+            // router) can switch the child's model on its first input, so report the
+            // model each assistant message actually ran on. Mirrors the foreground
+            // path's `progress.model = observedModel`.
+            if (event.message.model) {
+                const observedModel = qualifyModelWithProvider(event.message.model, event.message.provider, flatSteps[flatIndex]?.modelVerificationRegistry) ?? event.message.model;
+                if (observedModel !== step.model) {
+                    step.launchModel ??= step.model;
+                    step.model = observedModel;
+                }
+            }
+            const { provider, model } = event.message;
+            if (typeof provider === "string" && provider && typeof model === "string" && model)
+                step.resolvedModel = { provider, model };
             const usage = event.message.usage;
             if (config.usageBudget) {
                 const known = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -3099,7 +3180,7 @@ export async function runSubagent(config, childSessions) {
             return;
         timedOut = true;
         const now = Date.now();
-        const message = timeoutMessage ?? "Subagent timed out.";
+        const message = timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE;
         statusPayload.timedOut = true;
         statusPayload.error = message;
         currentActivityState = undefined;
@@ -3293,7 +3374,7 @@ export async function runSubagent(config, childSessions) {
                         }),
                         cwd,
                         signal: combinedAbortSignal([timeoutAbortController.signal, stopAbortController.signal]),
-                        abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? "Subagent timed out.",
+                        abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE,
                         reportOptional: isAgentContract(step.agentContract),
                     }))
                     : undefined;
@@ -3304,7 +3385,7 @@ export async function runSubagent(config, childSessions) {
                     placeholder.acceptance = effectiveGroupAcceptance;
                 const groupAcceptanceFailure = effectiveGroupAcceptance && (!isAgentContract(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
                 if (groupTimedOut || groupStopped || groupAcceptanceFailure) {
-                    const errorMessage = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? "Subagent timed out." : groupAcceptanceFailure;
+                    const errorMessage = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE : groupAcceptanceFailure;
                     statusPayload.state = groupStopped ? "stopped" : "failed";
                     statusPayload.error = errorMessage;
                     setOptionalProperty(statusPayload, "stopped", groupStopped ? true : statusPayload.stopped);
@@ -3352,7 +3433,6 @@ export async function runSubagent(config, childSessions) {
                         dynamic: step.parallel.acceptanceInput === undefined,
                         agentContract: step.parallel.agentContract ?? step.agentContract,
                     })),
-                    systemPrompt: step.parallel.namespaceOutputPath ? injectOutputPathSystemPrompt(step.parallel.systemPrompt ?? "", outputPath, step.parallel) : step.parallel.systemPrompt,
                     outputPath,
                     label: task.label ?? step.parallel.label,
                     ...(step.sessionFiles?.[itemIndex] ? { sessionFile: step.sessionFiles[itemIndex] } : {}),
@@ -3397,6 +3477,7 @@ export async function runSubagent(config, childSessions) {
             }
             mutatingFailureStates.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => createMutatingFailureState()));
             pendingToolResults.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => undefined));
+            pendingToolResultsByCallId.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => new Map()));
             const materializedDelta = dynamicStatusSteps.length - 1;
             for (const group of statusPayload.parallelGroups) {
                 if (group.stepIndex === stepIndex) {
@@ -3477,7 +3558,6 @@ export async function runSubagent(config, childSessions) {
                     return omitUndefinedProperties({ agent: task.agent, ...(task.sessionName ? { sessionName: task.sessionName } : {}), context: task.context, output: "(skipped — fail-fast)", exitCode: -1, skipped: true });
                 }
                 const taskStartTime = Date.now();
-                launchedFlatIndices.add(fi);
                 statusPayload.currentStep = fi;
                 requiredStatusStep(statusPayload, fi).status = "running";
                 delete requiredStatusStep(statusPayload, fi).error;
@@ -3531,54 +3611,8 @@ export async function runSubagent(config, childSessions) {
                 const taskEndTime = Date.now();
                 const childInterrupted = singleResult.interrupted === true;
                 const childStopped = singleResult.stopped === true;
-                requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
-                requiredStatusStep(statusPayload, fi).endedAt = taskEndTime;
-                requiredStatusStep(statusPayload, fi).durationMs = taskEndTime - taskStartTime;
-                requiredStatusStep(statusPayload, fi).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "timedOut", timedOut || singleResult.timedOut ? true : undefined);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "stopped", stopped || childStopped ? true : undefined);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "toolBudget", singleResult.toolBudget);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "toolBudgetBlocked", singleResult.toolBudgetBlocked);
-                if (singleResult.toolBudget)
-                    statusPayload.toolBudget = singleResult.toolBudget;
-                if (singleResult.toolBudgetBlocked)
-                    statusPayload.toolBudgetBlocked = true;
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "sessionName", singleResult.sessionName);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "model", singleResult.model);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, fi).thinking));
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "requestedModel", singleResult.requestedModel);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "contextOverflow", singleResult.contextOverflow);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "totalCost", singleResult.totalCost);
-                if (singleResult.totalCost) {
-                    pendingParallelUsageCost = {
-                        inputTokens: pendingParallelUsageCost.inputTokens + singleResult.totalCost.inputTokens,
-                        outputTokens: pendingParallelUsageCost.outputTokens + singleResult.totalCost.outputTokens,
-                        costUsd: pendingParallelUsageCost.costUsd + singleResult.totalCost.costUsd,
-                    };
-                    refreshUsageBudget();
-                }
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "error", stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? "Subagent timed out.") : singleResult.error);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "transcriptPath", singleResult.transcriptPath ?? requiredStatusStep(statusPayload, fi).transcriptPath);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "transcriptError", singleResult.transcriptError);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "agentContract", singleResult.agentContract);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "launchContractDigest", singleResult.launchContractDigest);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "launchResolvedExtensions", singleResult.launchResolvedExtensions);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "runtimeAcknowledgedExtensions", singleResult.runtimeAcknowledgedExtensions);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "effects", singleResult.effects);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "execution", singleResult.execution);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "review", singleResult.review);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutput", singleResult.structuredOutput);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutputPath", singleResult.structuredOutputPath);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutputSchemaPath", singleResult.structuredOutputSchemaPath);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "acceptance", singleResult.acceptance);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "timeoutRecovery", singleResult.timeoutRecovery);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "watchdog", singleResult.watchdog);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "capabilityCeiling", singleResult.capabilityCeiling);
-                setOptionalProperty(requiredStatusStep(statusPayload, fi), "capabilityAudit", singleResult.capabilityAudit);
-                if (singleResult.capabilityCeiling)
-                    statusPayload.capabilityCeiling = singleResult.capabilityCeiling;
-                if (singleResult.capabilityAudit)
-                    statusPayload.capabilityAudit = singleResult.capabilityAudit;
+                recordStepResult(fi, singleResult, taskStartTime, taskEndTime, true);
+                addParallelUsageCost(singleResult.totalCost);
                 statusPayload.lastUpdate = taskEndTime;
                 writeStatusPayload();
                 appendCapabilityCeilingAppliedEvent(eventsPath, id, fi, task.agent, singleResult);
@@ -3591,7 +3625,7 @@ export async function runSubagent(config, childSessions) {
                     appendTerminalChildStatusEvent(fi, taskEndTime);
                 if (singleResult.exitCode !== 0 && failFast && !childStopped)
                     aborted = true;
-                return stopped || childStopped ? { ...singleResult, output: stopMessage, error: stopMessage, exitCode: 1, interrupted: false, timedOut: false, stopped: true, skipped: false } : timedOut ? { ...singleResult, output: singleResult.output || (timeoutMessage ?? "Subagent timed out."), error: singleResult.error ?? timeoutMessage ?? "Subagent timed out.", exitCode: 1, interrupted: false, timedOut: true, skipped: false } : { ...singleResult, skipped: false };
+                return stopped || childStopped ? { ...singleResult, output: stopMessage, error: stopMessage, exitCode: 1, interrupted: false, timedOut: false, stopped: true, skipped: false } : timedOut ? { ...singleResult, output: singleResult.output || (timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE), error: singleResult.error ?? timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE, exitCode: 1, interrupted: false, timedOut: true, skipped: false } : { ...singleResult, skipped: false };
             }, globalSemaphore);
             flatIndex += dynamicSteps.length;
             for (const pr of parallelResults) {
@@ -3678,7 +3712,7 @@ export async function runSubagent(config, childSessions) {
                             }),
                             cwd,
                             signal: combinedAbortSignal([timeoutAbortController.signal, stopAbortController.signal]),
-                            abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? "Subagent timed out.",
+                            abortMessage: stopAbortController.signal.aborted ? stopMessage : timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE,
                             reportOptional: isAgentContract(step.agentContract),
                         }))
                         : undefined;
@@ -3686,7 +3720,7 @@ export async function runSubagent(config, childSessions) {
                     const groupTimedOut = !groupStopped && (timedOut || timeoutAbortController.signal.aborted);
                     const effectiveGroupAcceptance = groupTimedOut || groupStopped ? undefined : groupAcceptance;
                     const groupAcceptanceFailure = effectiveDynamicGroupAcceptance.explicit && effectiveGroupAcceptance && (!isAgentContract(step.agentContract) || step.gateOn === "acceptance") ? acceptanceFailureMessage(effectiveGroupAcceptance) : undefined;
-                    const groupError = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? "Subagent timed out." : groupAcceptanceFailure;
+                    const groupError = groupStopped ? stopMessage : groupTimedOut ? timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE : groupAcceptanceFailure;
                     markDynamicGraphGroup(stepIndex, groupError ? groupStopped ? "stopped" : "failed" : "completed", groupError, effectiveGroupAcceptance);
                     if (groupError) {
                         results.push(omitUndefinedProperties({
@@ -3801,7 +3835,7 @@ export async function runSubagent(config, childSessions) {
                     if (config.deadlineAt !== undefined && Date.now() >= config.deadlineAt)
                         timeoutRunner();
                     if (setupSignal.aborted)
-                        throw new Error(stopped ? stopMessage : timedOut ? timeoutMessage ?? "Subagent timed out." : "Subagent paused during worktree setup.");
+                        throw new Error(stopped ? stopMessage : timedOut ? timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE : "Subagent paused during worktree setup.");
                 }
                 catch (error) {
                     if (worktreeSetup)
@@ -3896,7 +3930,6 @@ export async function runSubagent(config, childSessions) {
                         return omitUndefinedProperties({ agent: task.agent, ...(task.sessionName ? { sessionName: task.sessionName } : {}), context: task.context, output: "(skipped — fail-fast)", exitCode: -1, skipped: true });
                     }
                     const taskStartTime = Date.now();
-                    launchedFlatIndices.add(fi);
                     statusPayload.currentStep = fi;
                     requiredStatusStep(statusPayload, fi).status = "running";
                     delete requiredStatusStep(statusPayload, fi).error;
@@ -3962,53 +3995,8 @@ export async function runSubagent(config, childSessions) {
                     const taskDuration = taskEndTime - taskStartTime;
                     const childInterrupted = singleResult.interrupted === true;
                     const childStopped = singleResult.stopped === true;
-                    requiredStatusStep(statusPayload, fi).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
-                    requiredStatusStep(statusPayload, fi).endedAt = taskEndTime;
-                    requiredStatusStep(statusPayload, fi).durationMs = taskDuration;
-                    requiredStatusStep(statusPayload, fi).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "timedOut", timedOut || singleResult.timedOut ? true : undefined);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "stopped", stopped || childStopped ? true : undefined);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "toolBudget", singleResult.toolBudget);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "toolBudgetBlocked", singleResult.toolBudgetBlocked);
-                    if (singleResult.toolBudget)
-                        statusPayload.toolBudget = singleResult.toolBudget;
-                    if (singleResult.toolBudgetBlocked)
-                        statusPayload.toolBudgetBlocked = true;
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "sessionName", singleResult.sessionName);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "model", singleResult.model);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, fi).thinking));
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "requestedModel", singleResult.requestedModel);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "contextOverflow", singleResult.contextOverflow);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "totalCost", singleResult.totalCost);
-                    if (singleResult.totalCost) {
-                        pendingParallelUsageCost = {
-                            inputTokens: pendingParallelUsageCost.inputTokens + singleResult.totalCost.inputTokens,
-                            outputTokens: pendingParallelUsageCost.outputTokens + singleResult.totalCost.outputTokens,
-                            costUsd: pendingParallelUsageCost.costUsd + singleResult.totalCost.costUsd,
-                        };
-                        refreshUsageBudget();
-                    }
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "error", stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? "Subagent timed out.") : singleResult.error);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "transcriptPath", singleResult.transcriptPath ?? requiredStatusStep(statusPayload, fi).transcriptPath);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "transcriptError", singleResult.transcriptError);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "agentContract", singleResult.agentContract);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "launchResolvedExtensions", singleResult.launchResolvedExtensions);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "runtimeAcknowledgedExtensions", singleResult.runtimeAcknowledgedExtensions);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "effects", singleResult.effects);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "execution", singleResult.execution);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "review", singleResult.review);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutput", singleResult.structuredOutput);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutputPath", singleResult.structuredOutputPath);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "structuredOutputSchemaPath", singleResult.structuredOutputSchemaPath);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "acceptance", singleResult.acceptance);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "timeoutRecovery", singleResult.timeoutRecovery);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "watchdog", singleResult.watchdog);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "capabilityCeiling", singleResult.capabilityCeiling);
-                    setOptionalProperty(requiredStatusStep(statusPayload, fi), "capabilityAudit", singleResult.capabilityAudit);
-                    if (singleResult.capabilityCeiling)
-                        statusPayload.capabilityCeiling = singleResult.capabilityCeiling;
-                    if (singleResult.capabilityAudit)
-                        statusPayload.capabilityAudit = singleResult.capabilityAudit;
+                    recordStepResult(fi, singleResult, taskStartTime, taskEndTime);
+                    addParallelUsageCost(singleResult.totalCost);
                     statusPayload.lastUpdate = taskEndTime;
                     writeStatusPayload();
                     appendCapabilityCeilingAppliedEvent(eventsPath, id, fi, task.agent, singleResult);
@@ -4021,7 +4009,7 @@ export async function runSubagent(config, childSessions) {
                         appendTerminalChildStatusEvent(fi, taskEndTime);
                     if (singleResult.exitCode !== 0 && failFast && !childStopped)
                         aborted = true;
-                    return stopped || childStopped ? { ...singleResult, output: stopMessage, error: stopMessage, exitCode: 1, interrupted: false, timedOut: false, stopped: true, skipped: false } : timedOut ? { ...singleResult, output: singleResult.output || (timeoutMessage ?? "Subagent timed out."), error: singleResult.error ?? timeoutMessage ?? "Subagent timed out.", exitCode: 1, interrupted: false, timedOut: true, skipped: false } : { ...singleResult, skipped: false };
+                    return stopped || childStopped ? { ...singleResult, output: stopMessage, error: stopMessage, exitCode: 1, interrupted: false, timedOut: false, stopped: true, skipped: false } : timedOut ? { ...singleResult, output: singleResult.output || (timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE), error: singleResult.error ?? timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE, exitCode: 1, interrupted: false, timedOut: true, skipped: false } : { ...singleResult, skipped: false };
                 }, globalSemaphore);
                 flatIndex += group.parallel.length;
                 for (let t = 0; t < group.parallel.length; t++) {
@@ -4290,7 +4278,6 @@ export async function runSubagent(config, childSessions) {
             }
             const singleCwd = singleWorktreeSetup?.worktrees[0]?.agentCwd ?? cwd;
             const stepStartTime = Date.now();
-            launchedFlatIndices.add(flatIndex);
             statusPayload.currentStep = flatIndex;
             requiredStatusStep(statusPayload, flatIndex).status = "running";
             delete requiredStatusStep(statusPayload, flatIndex).activityState;
@@ -4372,10 +4359,10 @@ export async function runSubagent(config, childSessions) {
                 launchContractDigest: singleResult.launchContractDigest,
                 launchResolvedExtensions: singleResult.launchResolvedExtensions,
                 runtimeAcknowledgedExtensions: singleResult.runtimeAcknowledgedExtensions,
-                output: stopped || childStopped ? stopMessage : timedOut ? singleResult.output || (timeoutMessage ?? "Subagent timed out.") : singleResult.output,
+                output: stopped || childStopped ? stopMessage : timedOut ? singleResult.output || (timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE) : singleResult.output,
                 outputState: singleResult.outputState,
                 outputPartial: singleResult.outputPartial,
-                error: stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? "Subagent timed out.") : singleResult.error,
+                error: stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE) : singleResult.error,
                 success: !stopped && !childStopped && !timedOut && singleResult.interrupted !== true && singleResult.exitCode === 0 && singleResult.execution?.status !== "partial",
                 exitCode: stopped || childStopped ? 1 : timedOut ? 1 : singleResult.interrupted === true ? 0 : singleResult.exitCode,
                 sessionFile: singleResult.sessionFile,
@@ -4454,45 +4441,7 @@ export async function runSubagent(config, childSessions) {
             }
             const stepEndTime = Date.now();
             const childInterrupted = singleResult.interrupted === true;
-            requiredStatusStep(statusPayload, flatIndex).status = stopped || childStopped ? "stopped" : timedOut ? "failed" : childInterrupted ? "paused" : singleResult.execution?.status === "partial" ? "partial" : singleResult.exitCode === 0 ? "complete" : "failed";
-            requiredStatusStep(statusPayload, flatIndex).endedAt = stepEndTime;
-            requiredStatusStep(statusPayload, flatIndex).durationMs = stepEndTime - stepStartTime;
-            requiredStatusStep(statusPayload, flatIndex).exitCode = stopped || childStopped ? 1 : timedOut ? 1 : childInterrupted ? 0 : singleResult.exitCode;
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "timedOut", timedOut || singleResult.timedOut ? true : undefined);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "stopped", stopped || childStopped ? true : undefined);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "toolBudget", singleResult.toolBudget);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "toolBudgetBlocked", singleResult.toolBudgetBlocked);
-            if (singleResult.toolBudget)
-                statusPayload.toolBudget = singleResult.toolBudget;
-            if (singleResult.toolBudgetBlocked)
-                statusPayload.toolBudgetBlocked = true;
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "sessionName", singleResult.sessionName);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "model", singleResult.model);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "thinking", resolveEffectiveThinking(singleResult.model, requiredStatusStep(statusPayload, flatIndex).thinking));
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "requestedModel", singleResult.requestedModel);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "contextOverflow", singleResult.contextOverflow);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "totalCost", singleResult.totalCost);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "error", stopped || childStopped ? stopMessage : timedOut ? (timeoutMessage ?? "Subagent timed out.") : singleResult.error);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "transcriptPath", singleResult.transcriptPath ?? requiredStatusStep(statusPayload, flatIndex).transcriptPath);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "transcriptError", singleResult.transcriptError);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "agentContract", singleResult.agentContract);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "launchResolvedExtensions", singleResult.launchResolvedExtensions);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "runtimeAcknowledgedExtensions", singleResult.runtimeAcknowledgedExtensions);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "effects", singleResult.effects);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "execution", singleResult.execution);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "review", singleResult.review);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "structuredOutput", singleResult.structuredOutput);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "structuredOutputPath", singleResult.structuredOutputPath);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "structuredOutputSchemaPath", singleResult.structuredOutputSchemaPath);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "acceptance", singleResult.acceptance);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "timeoutRecovery", singleResult.timeoutRecovery);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "watchdog", singleResult.watchdog);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "capabilityCeiling", singleResult.capabilityCeiling);
-            setOptionalProperty(requiredStatusStep(statusPayload, flatIndex), "capabilityAudit", singleResult.capabilityAudit);
-            if (singleResult.capabilityCeiling)
-                statusPayload.capabilityCeiling = singleResult.capabilityCeiling;
-            if (singleResult.capabilityAudit)
-                statusPayload.capabilityAudit = singleResult.capabilityAudit;
+            recordStepResult(flatIndex, singleResult, stepStartTime, stepEndTime);
             if (stepTokens) {
                 requiredStatusStep(statusPayload, flatIndex).tokens = stepTokens;
                 statusPayload.totalTokens = { ...previousCumulativeTokens };
@@ -4722,7 +4671,7 @@ export async function runSubagent(config, childSessions) {
     }
     if (timedOut) {
         statusPayload.timedOut = true;
-        statusPayload.error = timeoutMessage ?? "Subagent timed out.";
+        statusPayload.error = timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE;
     }
     if (usageBudgetExceeded && statusPayload.usageBudget && !statusPayload.error) {
         statusPayload.error = usageBudgetExceededMessage(statusPayload.usageBudget);
@@ -4767,13 +4716,13 @@ export async function runSubagent(config, childSessions) {
             mode: resultMode,
             success: statusPayload.state === "complete",
             state: statusPayload.state,
-            summary: stopped ? stopMessage : signalTerminated ? (statusPayload.error ?? "Subagent process terminated by signal.") : timedOut ? (timeoutMessage ?? "Subagent timed out.") : usageBudgetExceeded ? (statusPayload.error ?? "Usage budget exhausted.") : interrupted ? "Paused after interrupt. Waiting for explicit next action." : statusPayload.state === "partial" ? (statusPayload.error ?? summary) : summary,
+            summary: stopped ? stopMessage : signalTerminated ? (statusPayload.error ?? "Subagent process terminated by signal.") : timedOut ? timedOutRunSummary(timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE, summary, results) : usageBudgetExceeded ? (statusPayload.error ?? "Usage budget exhausted.") : interrupted ? "Paused after interrupt. Waiting for explicit next action." : statusPayload.state === "partial" ? (statusPayload.error ?? summary) : summary,
             ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {}),
             ...(config.deadlineAt !== undefined ? { deadlineAt: config.deadlineAt } : {}),
             ...(statusPayload.toolBudget ? { toolBudget: statusPayload.toolBudget } : {}),
             ...(statusPayload.toolBudgetBlocked ? { toolBudgetBlocked: true } : {}),
             ...(statusPayload.usageBudget ? { usageBudget: statusPayload.usageBudget } : {}),
-            ...(stopped ? { stopped: true, error: stopMessage } : timedOut ? { timedOut: true, error: timeoutMessage ?? "Subagent timed out." } : usageBudgetExceeded ? { error: statusPayload.error ?? "Usage budget exhausted." } : {}),
+            ...(stopped ? { stopped: true, error: stopMessage } : timedOut ? { timedOut: true, error: timeoutMessage ?? SUBAGENT_TIMED_OUT_MESSAGE } : usageBudgetExceeded ? { error: statusPayload.error ?? "Usage budget exhausted." } : {}),
             results: results.map((r) => omitUndefinedProperties({
                 agent: r.agent,
                 ...(r.sessionName ? { sessionName: r.sessionName } : {}),
@@ -4883,26 +4832,6 @@ export async function runSubagent(config, childSessions) {
         totalCost: finalTotalCost,
         usageBudget: statusPayload.usageBudget,
     }));
-    // Paused runs record an interrupted attempt; a later resume records another.
-    for (const historyEntry of planBackgroundRunHistory({
-        steps,
-        resultMode,
-        statusSteps: statusPayload.steps.map((step, index) => ({
-            agent: step.agent,
-            status: step.status,
-            durationMs: step.durationMs,
-            timedOut: step.timedOut,
-            stopped: step.stopped,
-            launched: launchedFlatIndices.has(index),
-        })),
-        stepResults: results,
-        runDurationMs: runEndedAt - overallStartTime,
-        stopped,
-        interrupted,
-        timedOut,
-    })) {
-        recordRun(historyEntry.agent, historyEntry.task, historyEntry.exitCode, historyEntry.durationMs, historyEntry.terminal);
-    }
     writeRunLog(logPath, omitUndefinedProperties({
         id,
         mode: statusPayload.mode,