@fitchmultz/pi-subagents 0.0.0-stage → 0.44.4

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

@@ -0,0 +1,1872 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { spawnSync } from "node:child_process";
+import { readChildProcessIdentity } from "../../shared/post-exit-stdio-guard.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { writeAtomicJson } from "../../shared/atomic-json.js";
+import { readAsyncControlRequests } from "./async-control.js";
+import { appendJsonl, getArtifactPaths } from "../../shared/artifacts.js";
+import { PI_CODING_AGENT_PACKAGE, resolveInstalledPiPackageRoot } from "../shared/pi-spawn.js";
+import { captureSingleOutputSnapshot, cleanupSingleOutputFile, finalizeSingleOutput, findDuplicateOutputPath, formatConsumedOutputReference, formatSavedOutputReference, injectSingleOutputInstruction, resolveSingleOutput } from "../shared/single-output.js";
+import { DEFAULT_MAX_OUTPUT, truncateOutput, } from "../../shared/types.js";
+import { DEFAULT_CONTROL_CONFIG, buildControlEvent, deriveActivityState, claimControlNotification, formatControlIntercomMessage, formatControlNoticeMessage, } from "../shared/subagent-control.js";
+import { isDynamicRunnerGroup, isParallelGroup, flattenSteps, MAX_PARALLEL_CONCURRENCY, } from "../shared/parallel-utils.js";
+import { cleanupTempDir, SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../shared/pi-args.js";
+import { isClaudeCodeModel, } from "../shared/claude-code.js";
+import { renderChainTask } from "../shared/chain-outputs.js";
+import { createStructuredOutputRuntime, readStructuredOutput } from "../shared/structured-output.js";
+import { DynamicFanoutError, materializeDynamicParallelStep } from "../shared/dynamic-fanout.js";
+import { completeWorkflowStep, runParallelTasks, workflowChildSucceeded } from "../shared/workflow-policy.js";
+import { nestedSummaryFromAsyncStatus, writeNestedEvent } from "../shared/nested-events.js";
+import { runModelAttempts, sumAttemptUsage } from "../shared/model-fallback.js";
+import { buildChildInvocation, runChildAttempt } from "../shared/child-attempt.js";
+import { createNativeFinalization, FINALIZATION_EVENT } from "../shared/native-finalization.js";
+import { updateStreamingText } from "../shared/streaming-text.js";
+import { pendingSupervisorQuestion, saveAsyncRunResult, saveRunStatus, saveQuestionContract } from "../shared/supervisor-questions.js";
+import { compactForegroundResult, detectSubagentError, extractTextFromContent, extractToolArgsPreview, findLatestSessionFile } from "../../shared/utils.js";
+import { hasCompletedMutationToolCall, resolveCompletionPolicy } from "../shared/completion-guard.js";
+import { createMutatingFailureState, recordMutatingFailure, resetMutatingFailureState, resolveCurrentPath, shouldEscalateMutatingFailures, summarizeRecentMutatingFailures, } from "../shared/mutating-tool-guard.js";
+import { appendWorktreeSummary, cleanupWorktrees, createWorktrees, findWorktreeTaskCwdConflict, formatParallelWorktreeSummary, formatWorktreeTaskCwdConflict, WorktreeCleanupError, } from "../shared/worktree.js";
+import { recordRun } from "../shared/run-history.js";
+import { resolveEffectiveThinking } from "../../shared/model-info.js";
+import { namespaceParallelOutput, writeInitialProgressFile } from "../../shared/settings.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { evaluateRunAcceptance, acceptanceHumanAction, createFinalizationReportRuntime, readFinalizationReport, formatUnconfirmedFinalizationOutput, resolveExecutionOutcome, resolveFinalizationOutput, formatAcceptancePrompt, stripAcceptanceReport, } from "../shared/acceptance.js";
+const ASYNC_INTERRUPT_SIGNAL = "SIGUSR2";
+function formatProcessExitFailure(input) {
+    const duration = input.durationMs !== undefined ? ` after ${input.durationMs}ms` : "";
+    if (input.exitCode === 143) {
+        return `${input.agent} exited with code 143${duration}. The child process received SIGTERM or exited as if terminated by SIGTERM; if this was close to 300000ms, Pi's default HTTP idle timeout is a likely provider-side cause.`;
+    }
+    return `${input.agent} exited with code ${input.exitCode ?? 1}${duration} without producing a final assistant response.`;
+}
+function emptyUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+}
+function tokenUsageFromAttempts(attempts) {
+    if (!attempts || attempts.length === 0)
+        return null;
+    let input = 0;
+    let output = 0;
+    for (const attempt of attempts) {
+        input += attempt.usage?.input ?? 0;
+        output += attempt.usage?.output ?? 0;
+    }
+    const total = input + output;
+    return total > 0 ? { input, output, total } : null;
+}
+function appendRecentStepOutput(step, lines) {
+    const nonEmpty = lines.filter((line) => line.trim());
+    if (nonEmpty.length === 0)
+        return;
+    step.recentOutput ??= [];
+    step.recentOutput.push(...nonEmpty);
+    if (step.recentOutput.length > 50) {
+        step.recentOutput.splice(0, step.recentOutput.length - 50);
+    }
+}
+function clearStepCurrentActivity(step) {
+    step.currentTool = undefined;
+    step.currentToolArgs = undefined;
+    step.currentToolStartedAt = undefined;
+    step.currentPath = undefined;
+}
+function resetStepLiveDetail(step) {
+    clearStepCurrentActivity(step);
+    step.recentTools = [];
+    step.recentOutput = [];
+}
+function markStepPaused(step, now) {
+    step.status = "paused";
+    step.activityState = undefined;
+    clearStepCurrentActivity(step);
+    step.startedAt ??= now;
+    step.endedAt = now;
+    step.durationMs = step.startedAt !== undefined ? now - step.startedAt : undefined;
+    step.lastActivityAt = now;
+    step.exitCode = 0;
+}
+// Durable run records have no age cleanup. Streaming deltas and cumulative tool
+// progress repeat what message_end and tool_execution_end already record.
+const TRANSIENT_CHILD_EVENT_TYPES = new Set(["message_update", "tool_execution_update"]);
+async function runPiStreaming(options, outputFile, context) {
+    const outputFd = fs.openSync(outputFile, "w", 0o600);
+    const auditPath = `${outputFile}.audit.log`;
+    const appendEvent = (event) => appendJsonl(context.eventsPath, JSON.stringify({
+        ...event, recordVersion: 3, subagentSource: "child", subagentRunId: context.runId,
+        subagentStepIndex: context.stepIndex, subagentAgent: context.agent, observedAt: Date.now(),
+    }));
+    const output = (text) => { fs.writeFileSync(outputFd, text); };
+    try {
+        const result = await runChildAttempt({
+            ...options, auditPath,
+            onStart: (control, result) => {
+                if (control.pid)
+                    saveQuestionContract(context.runId, context.stepIndex, { pid: control.pid, processIdentity: readChildProcessIdentity(control.pid), sessionFile: options.sessionFile, attemptBaseline: result.attemptBaseline, updatedAt: Date.now() });
+                options.onStart?.(control, result);
+            },
+            onOutput: output,
+            onStderr: (text) => {
+                appendEvent({ type: "subagent.child.stderr", auditPath, length: Buffer.byteLength(text) });
+            },
+            onEvent: (event, result, mutation) => {
+                // Preserve live callback ordering; only the disk representation is reduced.
+                options.onEvent?.(event, result, mutation);
+                if (TRANSIENT_CHILD_EVENT_TYPES.has(event.type ?? ""))
+                    return;
+                if (event.type === "subagent.native_baseline") {
+                    appendEvent(event);
+                    saveQuestionContract(context.runId, context.stepIndex, { attemptBaseline: result.attemptBaseline, baselineSource: "native-migration" });
+                }
+                else if (event.type === "subagent.native") {
+                    appendEvent(event);
+                    saveQuestionContract(context.runId, context.stepIndex, { nativeSessionId: result.nativeSessionId, terminalLeafId: result.terminalLeafId, effectiveConfiguration: result.effectiveConfiguration, updatedAt: Date.now() });
+                }
+                else if (event.type === FINALIZATION_EVENT) {
+                    const marker = event;
+                    const file = `${outputFile}.boundaries.jsonl`;
+                    fs.appendFileSync(file, `${JSON.stringify(marker)}\n`, { mode: 0o600 });
+                    appendEvent({ type: marker.type, nonce: marker.nonce, turn: marker.turn, lastEntryId: marker.lastEntryId, messageCount: marker.messageCount, at: marker.at, boundaryFile: file });
+                }
+                else {
+                    appendEvent({ type: event.type, messageNumber: result.messageCount,
+                        ...(event.message ? { role: event.message.role, timestamp: event.message.timestamp } : {}),
+                        toolCallId: event.toolCallId, toolName: event.toolName, isError: event.isError,
+                        ...(event.type === "tool_execution_start" ? { argsPreview: extractToolArgsPreview(event.args ?? {}) } : {}),
+                        ...(event.type === "tool_execution_end" ? { auditPath } : {}) });
+                }
+            },
+        });
+        appendEvent({ type: "subagent.child.finalized", agentProcessExit: result.agentProcessExit, exitCode: result.exitCode,
+            accounting: result.accounting, nativeSessionId: result.nativeSessionId, terminalLeafId: result.terminalLeafId,
+            terminalEntryId: result.terminalEntryId, nativeReferences: result.nativeReferences, auditPath: result.auditPath, auditRecords: result.auditRecords, auditSaveError: result.auditSaveError, outputFile });
+        saveQuestionContract(context.runId, context.stepIndex, { nativeSessionId: result.nativeSessionId, terminalLeafId: result.terminalLeafId, terminalEntryId: result.terminalEntryId,
+            effectiveConfiguration: result.effectiveConfiguration, accounting: result.accounting, auditPath: result.auditPath, updatedAt: Date.now() });
+        return result;
+    }
+    finally {
+        fs.closeSync(outputFd);
+    }
+}
+function resolvePiPackageRootFallback() {
+    const root = resolveInstalledPiPackageRoot();
+    if (root)
+        return root;
+    throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
+}
+async function exportSessionHtml(sessionFile, outputDir, piPackageRoot) {
+    const pkgRoot = piPackageRoot ?? resolvePiPackageRootFallback();
+    const exportModulePath = path.join(pkgRoot, "dist", "core", "export-html", "index.js");
+    const moduleUrl = pathToFileURL(exportModulePath).href;
+    const mod = await import(__rewriteRelativeImportExtension(moduleUrl));
+    const exportFromFile = mod
+        .exportFromFile;
+    if (typeof exportFromFile !== "function") {
+        throw new Error("exportFromFile not available");
+    }
+    const outputPath = path.join(outputDir, `${path.basename(sessionFile, ".jsonl")}.html`);
+    return exportFromFile(sessionFile, { outputPath });
+}
+function createShareLink(htmlPath) {
+    try {
+        const auth = spawnSync("gh", ["auth", "status"], { encoding: "utf-8" });
+        if (auth.status !== 0) {
+            return { error: "GitHub CLI is not logged in. Run 'gh auth login' first." };
+        }
+    }
+    catch {
+        return { error: "GitHub CLI (gh) is not installed." };
+    }
+    try {
+        const result = spawnSync("gh", ["gist", "create", htmlPath], { encoding: "utf-8" });
+        if (result.status !== 0) {
+            const err = (result.stderr || "").trim() || "Failed to create gist.";
+            return { error: err };
+        }
+        const gistUrl = (result.stdout || "").trim();
+        const gistId = gistUrl.split("/").pop();
+        if (!gistId)
+            return { error: "Failed to parse gist ID." };
+        const shareUrl = `https://shittycodingagent.ai/session/?${gistId}`;
+        return { shareUrl, gistUrl };
+    }
+    catch (err) {
+        return { error: String(err) };
+    }
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor((ms % 60000) / 1000);
+    return `${minutes}m${seconds}s`;
+}
+function writeRunLog(logPath, input) {
+    const lines = [];
+    lines.push(`# Subagent run ${input.id}`);
+    lines.push("");
+    lines.push(`- **Mode:** ${input.mode}`);
+    lines.push(`- **Launch cwd:** ${input.cwd}`);
+    lines.push(`- **Started:** ${new Date(input.startedAt).toISOString()}`);
+    lines.push(`- **Ended:** ${new Date(input.endedAt).toISOString()}`);
+    lines.push(`- **Duration:** ${formatDuration(input.endedAt - input.startedAt)}`);
+    if (input.sessionFile)
+        lines.push(`- **Session:** ${input.sessionFile}`);
+    if (input.shareUrl)
+        lines.push(`- **Share:** ${input.shareUrl}`);
+    if (input.shareError)
+        lines.push(`- **Share error:** ${input.shareError}`);
+    if (input.artifactsDir)
+        lines.push(`- **Artifacts:** ${input.artifactsDir}`);
+    lines.push("");
+    lines.push("## Steps");
+    lines.push("| Step | Agent | Status | Duration |");
+    lines.push("| --- | --- | --- | --- |");
+    input.steps.forEach((step, i) => {
+        const duration = step.durationMs !== undefined ? formatDuration(step.durationMs) : "-";
+        lines.push(`| ${i + 1} | ${step.agent} | ${step.status} | ${duration} |`);
+    });
+    lines.push("");
+    lines.push("## Summary");
+    if (input.truncated) {
+        lines.push("_Output truncated_");
+        lines.push("");
+    }
+    lines.push(input.summary.trim() || "(no output)");
+    lines.push("");
+    fs.writeFileSync(logPath, lines.join("\n"), "utf-8");
+}
+/** Run a single pi agent step, returning output and metadata */
+async function runSingleStep(step, ctx) {
+    const startedAt = Date.now();
+    let toolCount = 0;
+    const toolCalls = [];
+    if (ctx.signal?.aborted)
+        return { agent: step.agent, output: "", exitCode: 1, error: "Subagent cancelled." };
+    if (ctx.nativeFinalization && step.effectiveAcceptance?.explicit && !step.sessionFile) {
+        step = { ...step, sessionFile: path.join(path.dirname(ctx.outputFile), `session-${ctx.flatIndex}.jsonl`) };
+    }
+    saveQuestionContract(ctx.id, ctx.flatIndex, { task: step.task, label: step.label, effectiveAcceptance: step.effectiveAcceptance, output: step.outputPath ?? false, outputMode: step.outputMode, outputSchema: step.structuredOutputSchema ?? step.structuredOutput?.schema, launch: step.launch ? { ...step.launch, cwd: step.cwd ?? ctx.cwd, output: step.outputPath ?? false, outputMode: step.outputMode ?? "inline", outputSchema: step.structuredOutputSchema ?? step.structuredOutput?.schema, model: step.model, thinking: step.thinking } : undefined, sessionFile: step.sessionFile });
+    const interruptController = new AbortController();
+    ctx.registerInterrupt?.(() => interruptController.abort());
+    const interruptSignal = AbortSignal.any([ctx.interruptSignal, interruptController.signal].filter((signal) => signal !== undefined));
+    const verificationSignal = AbortSignal.any([ctx.signal, interruptSignal].filter((signal) => signal !== undefined));
+    const effectiveStructuredOutput = step.structuredOutput ?? (step.structuredOutputSchema
+        ? createStructuredOutputRuntime(step.structuredOutputSchema, path.join(path.dirname(ctx.outputFile), "structured-output"))
+        : undefined);
+    let task = step.task;
+    if (step.effectiveAcceptance) {
+        const acceptancePrompt = formatAcceptancePrompt(step.effectiveAcceptance);
+        if (acceptancePrompt)
+            task = `${task}\n${acceptancePrompt}`;
+    }
+    const sessionEnabled = Boolean(step.sessionFile) || ctx.sessionEnabled;
+    const sessionDir = step.sessionFile ? undefined : ctx.sessionDir;
+    let artifactPaths;
+    if (ctx.artifactsDir) {
+        const index = ctx.flatStepCount > 1 ? ctx.flatIndex : undefined;
+        artifactPaths = getArtifactPaths(ctx.artifactsDir, ctx.id, step.agent, index);
+        fs.mkdirSync(ctx.artifactsDir, { recursive: true });
+        fs.writeFileSync(artifactPaths.inputPath, `# Task for ${step.agent}\n\n${task}`, "utf-8");
+    }
+    const eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
+    let nativeExecution;
+    let nativeSegments = [];
+    const nativeAttempt = (segment) => {
+        const state = segment.execution;
+        const error = state?.error ?? segment.event.submission.error
+            ?? (state?.exitCode && !state.interrupted ? formatProcessExitFailure({ agent: step.agent, exitCode: state.exitCode, durationMs: segment.durationMs }) : undefined);
+        return {
+            ...nativeExecution, exitCode: error && !state?.exitCode ? 1 : state?.exitCode ?? 0, error,
+            interrupted: state?.interrupted, timedOut: state?.timedOut, resourceLimitExceeded: state?.resourceLimitExceeded,
+            terminalFailure: Boolean(segment.event.submission.error) || state?.terminalFailure,
+            messages: segment.messages, usage: segment.usage, durationMs: segment.durationMs,
+            finalOutput: segment.event.submission.output, reportSubmission: segment.event.turn > 0 ? segment.event.submission : undefined,
+            resolvedOutput: segment.event.resolvedOutput, finalization: undefined,
+        };
+    };
+    async function runAttempt(prompt, model, review) {
+        if (verificationSignal.aborted) {
+            const outcome = resolveExecutionOutcome({ result: { exitCode: 1 }, signal: ctx.signal, interruptSignal });
+            return { stderr: "", messages: [], usage: emptyUsage(), durationMs: 0, observedCompletedMutation: false, finalOutput: outcome.error ?? "Interrupted. Waiting for explicit next action.",
+                ...outcome, exitCode: outcome.exitCode ?? 1, model, terminalFailure: true, resolvedOutput: { fullOutput: "" } };
+        }
+        ctx.onAttemptStart?.({ model, thinking: resolveEffectiveThinking(model, step.thinking) });
+        const structuredRuntime = review ? review.reportRuntime : effectiveStructuredOutput;
+        const outputSnapshot = review ? review.outputSnapshot : captureSingleOutputSnapshot(step.outputPath);
+        if (structuredRuntime) {
+            try {
+                fs.rmSync(structuredRuntime.outputPath, { force: true });
+            }
+            catch {
+                // readStructuredOutput reports unreadable or stale output after the attempt.
+            }
+        }
+        let args;
+        let env;
+        let tempDir;
+        let claudeCodeInvocation;
+        const sessionFile = review?.sessionFile ?? step.sessionFile;
+        const nativeFinalization = ctx.nativeFinalization && !review && !isClaudeCodeModel(model) && step.effectiveAcceptance?.explicit
+            ? createNativeFinalization(step.effectiveAcceptance, structuredRuntime, step.outputPath) : undefined;
+        try {
+            const built = buildChildInvocation({
+                task: prompt, model, thinking: step.thinking,
+                sessionEnabled: review ? true : sessionEnabled, sessionDir: review ? undefined : sessionDir, sessionFile,
+                inheritProjectContext: step.inheritProjectContext, inheritSkills: step.inheritSkills,
+                tools: step.tools, allowSubagents: step.allowSubagents, extensions: step.extensions,
+                systemPrompt: step.systemPrompt, systemPromptMode: step.systemPromptMode, mcpDirectTools: step.mcpDirectTools,
+                cwd: step.cwd ?? ctx.cwd, intercomSessionName: ctx.childIntercomTarget, orchestratorIntercomTarget: ctx.orchestratorIntercomTarget,
+                runId: ctx.id, childAgentName: step.agent, childIndex: ctx.flatIndex, rootSessionId: ctx.rootSessionId,
+                parentEventSink: ctx.nestedRoute?.eventSink, parentControlInbox: ctx.nestedRoute?.controlInbox,
+                parentRootRunId: ctx.nestedRoute?.rootRunId, parentCapabilityToken: ctx.nestedRoute?.capabilityToken,
+                structuredOutput: structuredRuntime, projectTrust: ctx.projectTrust, nativeFinalization,
+            });
+            args = built.args;
+            env = built.env;
+            tempDir = built.tempDir;
+            claudeCodeInvocation = built.claudeCodeInvocation;
+        }
+        catch (error) {
+            if (nativeFinalization)
+                cleanupTempDir(path.dirname(nativeFinalization.reportRuntime.schemaPath));
+            const message = error instanceof Error ? error.message : String(error);
+            return { stderr: message, exitCode: 1, messages: [], usage: emptyUsage(), durationMs: 0, observedCompletedMutation: false, model, error: message,
+                finalOutput: message, terminalFailure: true, resolvedOutput: { fullOutput: message } };
+        }
+        let run;
+        try {
+            run = await runPiStreaming({ args, cwd: step.cwd ?? ctx.cwd, env, agent: step.agent, model,
+                maxSubagentDepth: step.maxSubagentDepth, maxExecutionTimeMs: step.maxExecutionTimeMs, maxTokens: step.maxTokens,
+                interruptSignal, signal: ctx.signal, claudeCodeInvocation, sessionFile,
+                structuredOutput: structuredRuntime, reportRuntime: review?.reportRuntime, nativeFinalization,
+                onEvent: (event, result, mutation) => {
+                    if (event.type === "tool_execution_start")
+                        toolCount++;
+                    if (event.type === "message_end" && event.message?.role === "assistant") {
+                        toolCalls.push(...(compactForegroundResult({ agent: step.agent, task: step.task, exitCode: 0, usage: result.usage, messages: [event.message] }).toolCalls ?? []));
+                    }
+                    ctx.onChildEvent?.(event, mutation);
+                },
+            }, review ? `${ctx.outputFile}.finalization-${review.turn}.log` : ctx.outputFile, { eventsPath, runId: ctx.id, stepIndex: ctx.flatIndex, agent: step.agent });
+        }
+        finally {
+            cleanupTempDir(tempDir);
+            if (nativeFinalization)
+                cleanupTempDir(path.dirname(nativeFinalization.reportRuntime.schemaPath));
+        }
+        const initialSegment = nativeFinalization ? run.finalization?.[0] : undefined;
+        if (initialSegment) {
+            nativeExecution = run;
+            nativeSegments = run.finalization.slice(1);
+            run = nativeAttempt(initialSegment);
+        }
+        const reportSubmission = review?.reportRuntime ? readFinalizationReport(run.messages, review.reportRuntime, { structuredResult: Boolean(claudeCodeInvocation) }) : undefined;
+        const hiddenError = run.exitCode === 0 && !run.error && !reportSubmission?.output ? detectSubagentError(run.messages) : undefined;
+        let structuredOutput;
+        let structuredError;
+        if (!review && structuredRuntime && run.exitCode === 0 && !run.error && !hiddenError?.hasError && !run.interrupted) {
+            const structured = readStructuredOutput(structuredRuntime);
+            structuredError = structured.error;
+            structuredOutput = structured.value;
+        }
+        const completionGuardTriggered = !review && run.exitCode === 0 && !run.error && !hiddenError?.hasError && !run.interrupted
+            && resolveCompletionPolicy({ completionGuardEnabled: step.completionGuard === true, usesAcceptanceContract: step.effectiveAcceptance?.explicit === true }) === "mutation-guard"
+            && !run.observedCompletedMutation && !hasCompletedMutationToolCall(run.messages);
+        let error = completionGuardTriggered
+            ? "Subagent completed without making edits required by completionGuard: true.\nUse an acceptance contract when a valid no-op is allowed."
+            : structuredError ?? (hiddenError?.hasError
+                ? hiddenError.details ? `${hiddenError.errorType} failed (exit ${hiddenError.exitCode ?? 1}): ${hiddenError.details}` : `${hiddenError.errorType} failed with exit code ${hiddenError.exitCode ?? 1}`
+                : run.error || (run.exitCode !== 0 ? run.stderr.trim() || formatProcessExitFailure({ agent: step.agent, exitCode: run.exitCode, durationMs: run.durationMs }) : undefined));
+        let exitCode = completionGuardTriggered || structuredError ? 1 : hiddenError?.hasError ? hiddenError.exitCode ?? 1 : error && run.exitCode === 0 ? 1 : run.exitCode;
+        const finalOutput = reportSubmission?.output ?? run.finalOutput;
+        const fullOutput = review ? resolveFinalizationOutput(finalOutput, review.previousOutput) : stripAcceptanceReport(finalOutput);
+        const resolvedOutput = initialSegment ? initialSegment.event.resolvedOutput : step.outputPath && exitCode === 0 && !run.interrupted && !reportSubmission?.reportSubmissionError
+            ? resolveSingleOutput(step.outputPath, fullOutput, outputSnapshot)
+            : { fullOutput };
+        if (resolvedOutput.saveError) {
+            exitCode = 1;
+            error = `Failed to save output file '${step.outputPath}': ${resolvedOutput.saveError}`;
+        }
+        return { ...run, exitCode, error, model: model ?? run.model, structuredOutput, reportSubmission, finalOutput, resolvedOutput, completionGuardTriggered,
+            terminalFailure: Boolean(completionGuardTriggered || structuredError || hiddenError?.hasError || resolvedOutput.saveError) };
+    }
+    const { result: initial, modelAttempts, attemptedModels, notes: attemptNotes } = await runModelAttempts({
+        candidates: step.modelCandidates?.length ? step.modelCandidates : [step.model], signal: verificationSignal,
+        runAttempt: (model) => runAttempt(task, model),
+    });
+    for (const segment of nativeSegments) {
+        const attempt = nativeAttempt(segment);
+        modelAttempts.push({ model: attempt.model ?? "default", success: attempt.exitCode === 0 && !attempt.error && !attempt.interrupted,
+            exitCode: attempt.exitCode, error: attempt.error, accounting: attempt.accounting, usage: { ...attempt.usage } });
+    }
+    let execution = initial;
+    let structuredOutput = initial.structuredOutput;
+    let resolvedOutput = initial.resolvedOutput;
+    let output = stripAcceptanceReport(resolvedOutput.fullOutput);
+    const initialOutput = output;
+    const sessionFile = step.sessionFile ?? (sessionDir ? findLatestSessionFile(sessionDir) ?? undefined : undefined);
+    const nativeReport = !initial.model || !isClaudeCodeModel(initial.model);
+    const acceptance = step.effectiveAcceptance ? await evaluateRunAcceptance({
+        acceptance: step.effectiveAcceptance, initial, initialOutput: initial.finalOutput, sessionFile, cwd: step.cwd ?? ctx.cwd, signal: verificationSignal, nativeReport, outputSchema: effectiveStructuredOutput?.schema, recordedTurns: nativeSegments.length,
+        initialAcceptance: nativeExecution?.finalization?.[0]?.event.acceptance,
+        runTurn: async (prompt, turn, sessionFile) => {
+            const cached = nativeSegments[turn - 1];
+            const reportRuntime = !cached && (nativeReport || effectiveStructuredOutput) ? createFinalizationReportRuntime(effectiveStructuredOutput?.schema) : undefined;
+            let reviewed;
+            try {
+                reviewed = cached ? nativeAttempt(cached) : await runAttempt(prompt, initial.model ?? step.model, { turn, sessionFile, previousOutput: output, reportRuntime,
+                    outputSnapshot: nativeReport ? resolvedOutput.writtenSnapshot : undefined });
+            }
+            finally {
+                if (reportRuntime)
+                    cleanupTempDir(path.dirname(reportRuntime.schemaPath));
+            }
+            execution = reviewed;
+            if (!cached)
+                modelAttempts.push({ model: reviewed.model ?? "default", success: reviewed.exitCode === 0 && !reviewed.error && !reviewed.interrupted,
+                    exitCode: reviewed.exitCode, error: reviewed.error, accounting: reviewed.accounting, usage: { ...reviewed.usage } });
+            if (reviewed.exitCode !== 0 || reviewed.error || reviewed.interrupted)
+                return { ...reviewed.reportSubmission, output: reviewed.finalOutput,
+                    error: reviewed.error ?? reviewed.resourceLimitExceeded?.message ?? "Acceptance finalization turn did not complete successfully." };
+            if (reviewed.reportSubmission?.reportSubmissionError)
+                return reviewed.reportSubmission;
+            if (effectiveStructuredOutput && reviewed.reportSubmission?.structuredOutput !== undefined) {
+                structuredOutput = reviewed.reportSubmission.structuredOutput;
+                fs.writeFileSync(effectiveStructuredOutput.outputPath, JSON.stringify(structuredOutput), { mode: 0o600 });
+            }
+            resolvedOutput = reviewed.resolvedOutput;
+            output = stripAcceptanceReport(resolvedOutput.fullOutput);
+            return { ...reviewed.reportSubmission, output: reviewed.finalOutput, acceptance: cached?.event.acceptance };
+        },
+    }) : undefined;
+    const outcome = resolveExecutionOutcome({ result: execution, acceptance, signal: ctx.signal, interruptSignal });
+    const previousError = modelAttempts.slice(0, -1).reverse().find((attempt) => attempt.error)?.error;
+    if (outcome.exitCode !== 0 && outcome.error && previousError && execution.usage.turns === 0) {
+        const context = `Previous attempt before the empty retry failed with: ${previousError}`;
+        outcome.error += `\n${context}`;
+        output = output ? `${output}\n${context}` : outcome.error;
+    }
+    if (acceptance?.unconfirmedOutput !== undefined) {
+        const auditOutput = resolvedOutput.savedPath && !resolvedOutput.writtenSnapshot ? output : acceptance.unconfirmedOutput;
+        output = formatUnconfirmedFinalizationOutput(auditOutput);
+    }
+    if (outcome.timedOut) {
+        const reason = outcome.error ?? "Timed out.";
+        const partial = output.trim();
+        output = partial && partial !== reason ? `${reason}\n\nPartial output before timeout:\n${partial}` : reason;
+    }
+    const effectiveFinalExitCode = outcome.exitCode ?? 1;
+    const cleanup = effectiveFinalExitCode === 0 && !outcome.interrupted && resolvedOutput.savedPath && step.outputMode !== "file-only" && step.outputPathFromAgentDefault === true
+        ? cleanupSingleOutputFile(resolvedOutput.savedPath, output, undefined)
+        : undefined;
+    if (ctx.worktreePath && resolvedOutput.savedPath && (!cleanup || cleanup.action === "skipped")) {
+        const relative = path.relative(ctx.worktreePath, resolvedOutput.savedPath);
+        if (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) {
+            const savedPath = path.join(path.dirname(ctx.outputFile), "outputs", String(ctx.flatIndex), path.basename(resolvedOutput.savedPath));
+            fs.mkdirSync(path.dirname(savedPath), { recursive: true });
+            fs.copyFileSync(resolvedOutput.savedPath, savedPath);
+            resolvedOutput.savedPath = savedPath;
+        }
+    }
+    const outputReference = resolvedOutput.savedPath
+        ? cleanup ? formatConsumedOutputReference(resolvedOutput.savedPath, output, cleanup) : formatSavedOutputReference(resolvedOutput.savedPath, output)
+        : undefined;
+    const outputForSummary = finalizeSingleOutput({
+        fullOutput: attemptNotes.length ? `${attemptNotes.join("\n")}\n\n${output}`.trim() : output,
+        outputPath: step.outputPath, outputMode: step.outputMode, exitCode: effectiveFinalExitCode,
+        savedPath: resolvedOutput.savedPath, outputReference, saveError: resolvedOutput.saveError, cleanup,
+    }).displayOutput;
+    const usage = sumAttemptUsage(modelAttempts);
+    const progressSummary = { toolCount, tokens: usage.input + usage.output, durationMs: Date.now() - startedAt };
+    recordRun(step.agent, step.task, effectiveFinalExitCode, progressSummary.durationMs);
+    if (artifactPaths) {
+        fs.writeFileSync(artifactPaths.outputPath, output, "utf-8");
+        fs.writeFileSync(artifactPaths.metadataPath, JSON.stringify({
+            runId: ctx.id, agent: step.agent, task, exitCode: effectiveFinalExitCode, interrupted: outcome.interrupted, agentProcessExit: execution.agentProcessExit,
+            error: outcome.error, acceptance, initialOutput: acceptance?.finalization ? initialOutput : undefined, usage,
+            model: initial.model, attemptedModels: attemptedModels.length ? attemptedModels : undefined, modelAttempts,
+            resourceLimitExceeded: outcome.resourceLimitExceeded, skills: step.skills, timestamp: Date.now(),
+        }, null, 2), "utf-8");
+    }
+    const result = {
+        accounting: modelAttempts.find((attempt) => attempt.accounting?.state === "incomplete")?.accounting ?? execution.accounting,
+        nativeSessionId: execution.nativeSessionId, terminalLeafId: execution.terminalLeafId, terminalEntryId: execution.terminalEntryId,
+        auditPath: execution.auditPath, auditSaveError: execution.auditSaveError,
+        agent: step.agent, output: outputForSummary, exitCode: effectiveFinalExitCode, error: outcome.error, agentProcessExit: execution.agentProcessExit,
+        usage, timedOut: outcome.timedOut, task: step.task, skills: step.skills,
+        finalOutput: step.outputMode === "file-only" ? outputForSummary : output,
+        initialOutput: acceptance?.finalization ? initialOutput : undefined,
+        outputMode: step.outputMode ?? "inline", outputReference, outputCleanup: cleanup, outputSaveError: resolvedOutput.saveError,
+        savedOutputPath: cleanup && cleanup.action !== "skipped" ? undefined : resolvedOutput.savedPath,
+        toolCalls: toolCalls.length ? toolCalls : undefined, progressSummary,
+        sessionFile, intercomTarget: ctx.childIntercomTarget, model: initial.model,
+        attemptedModels: attemptedModels.length ? attemptedModels : undefined, modelAttempts, artifactPaths,
+        interrupted: outcome.interrupted, completionGuardTriggered: initial.completionGuardTriggered,
+        structuredOutput, structuredOutputPath: effectiveStructuredOutput?.outputPath,
+        structuredOutputSchemaPath: effectiveStructuredOutput?.schemaPath, acceptance, resourceLimitExceeded: outcome.resourceLimitExceeded,
+    };
+    saveQuestionContract(ctx.id, ctx.flatIndex, { result: { ...result, task: step.task, usage, finalOutput: result.finalOutput }, updatedAt: Date.now() });
+    return result;
+}
+function markParallelGroupSetupFailure(input) {
+    for (let taskIndex = 0; taskIndex < input.group.parallel.length; taskIndex++) {
+        const flatTaskIndex = input.groupStartFlatIndex + taskIndex;
+        input.statusPayload.steps[flatTaskIndex].status = "failed";
+        input.statusPayload.steps[flatTaskIndex].startedAt = input.failedAt;
+        input.statusPayload.steps[flatTaskIndex].endedAt = input.failedAt;
+        input.statusPayload.steps[flatTaskIndex].durationMs = 0;
+        input.statusPayload.steps[flatTaskIndex].exitCode = 1;
+        input.results.push({ agent: input.group.parallel[taskIndex].agent, output: input.setupError, success: false, exitCode: 1, sessionFile: input.group.parallel[taskIndex].sessionFile });
+    }
+    input.statusPayload.currentStep = input.groupStartFlatIndex;
+    input.statusPayload.lastUpdate = input.failedAt;
+    input.statusPayload.outputFile = path.join(input.asyncDir, `output-${input.groupStartFlatIndex}.log`);
+    writeAtomicJson(input.statusPath, input.statusPayload);
+    appendJsonl(input.eventsPath, JSON.stringify({
+        type: "subagent.parallel.completed",
+        ts: input.failedAt,
+        runId: input.runId,
+        stepIndex: input.stepIndex,
+        success: false,
+    }));
+}
+function markParallelGroupRunning(input) {
+    for (let taskIndex = 0; taskIndex < input.group.parallel.length; taskIndex++) {
+        const flatTaskIndex = input.groupStartFlatIndex + taskIndex;
+        input.statusPayload.steps[flatTaskIndex].status = "pending";
+        input.statusPayload.steps[flatTaskIndex].startedAt = undefined;
+        input.statusPayload.steps[flatTaskIndex].endedAt = undefined;
+        input.statusPayload.steps[flatTaskIndex].durationMs = undefined;
+        input.statusPayload.steps[flatTaskIndex].lastActivityAt = undefined;
+        input.statusPayload.steps[flatTaskIndex].activityState = undefined;
+        input.statusPayload.steps[flatTaskIndex].error = undefined;
+    }
+    input.statusPayload.currentStep = input.groupStartFlatIndex;
+    input.statusPayload.activityState = undefined;
+    input.statusPayload.lastActivityAt = input.groupStartTime;
+    input.statusPayload.lastUpdate = input.groupStartTime;
+    input.statusPayload.outputFile = path.join(input.asyncDir, `output-${input.groupStartFlatIndex}.log`);
+    writeAtomicJson(input.statusPath, input.statusPayload);
+    appendJsonl(input.eventsPath, JSON.stringify({
+        type: "subagent.parallel.started",
+        ts: input.groupStartTime,
+        runId: input.runId,
+        stepIndex: input.stepIndex,
+        agents: input.group.parallel.map((task) => task.agent),
+        count: input.group.parallel.length,
+    }));
+}
+function prepareParallelTaskRun(task, cwd, worktreeSetup, taskIndex) {
+    if (!worktreeSetup)
+        return { taskForRun: task, taskCwd: cwd };
+    return {
+        taskForRun: { ...task, cwd: undefined },
+        taskCwd: worktreeSetup.worktrees[taskIndex].agentCwd,
+    };
+}
+function formatRunnerWorktreeSummary(worktreeSetup, asyncDir, stepIndex, group) {
+    return formatParallelWorktreeSummary(worktreeSetup, path.join(asyncDir, "worktree-diffs", `step-${stepIndex}`), group.parallel.map((task) => task.agent));
+}
+function ensureParallelProgressFile(cwd, group) {
+    const progressPath = path.join(cwd, "progress.md");
+    if (!group.parallel.some((task) => task.task.includes(`Update progress at: ${progressPath}`)))
+        return;
+    writeInitialProgressFile(cwd);
+}
+function materializeDynamicOutputPath(input) {
+    if (!input.step.output || !input.step.outputPath)
+        return input.step;
+    const output = namespaceParallelOutput(input.step.output, input.step.agent, input.stepIndex, input.taskIndex);
+    if (!output)
+        return input.step;
+    const outputPath = path.resolve(input.chainDir, output);
+    const task = input.step.task.includes(input.step.outputPath)
+        ? input.step.task.split(input.step.outputPath).join(outputPath)
+        : injectSingleOutputInstruction(input.step.task, outputPath);
+    return { ...input.step, task, outputPath };
+}
+async function runSubagent(config) {
+    const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir } = config;
+    let previousOutput = "";
+    const outputs = {};
+    const renderTask = (template, item) => config.resultMode === "single" || config.resultMode === "parallel" ? template
+        : renderChainTask(template, { originalTask: config.originalTask, previousOutput, chainDir: config.chainDir, outputs, item }, placeholder);
+    const results = [];
+    const worktreeSummaries = [];
+    let setupCleanupWarning = "";
+    const overallStartTime = Date.now();
+    const shareEnabled = config.share === true;
+    const asyncDir = config.asyncDir;
+    const statusPath = path.join(asyncDir, "status.json");
+    const eventsPath = path.join(asyncDir, "events.jsonl");
+    const logPath = path.join(asyncDir, `subagent-log-${id}.md`);
+    const controlConfig = config.controlConfig ?? DEFAULT_CONTROL_CONFIG;
+    const cancellation = new AbortController();
+    const cancelRunner = () => cancellation.abort();
+    for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
+        process.on(signal, cancelRunner);
+    const activeChildInterrupts = new Map();
+    const interruption = new AbortController();
+    let interrupted = false;
+    let currentActivityState;
+    let activityTimer;
+    let controlRequestTimer;
+    let latestSessionFile;
+    const parallelGroups = [];
+    const initialStatusSteps = [];
+    let flatStepCount = 0;
+    for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+        const step = steps[stepIndex];
+        if (isParallelGroup(step)) {
+            parallelGroups.push({ start: flatStepCount, count: step.parallel.length, stepIndex });
+            for (const task of step.parallel) {
+                initialStatusSteps.push({
+                    agent: task.agent,
+                    phase: task.phase,
+                    label: task.label,
+                    outputName: task.outputName,
+                    structured: task.structured,
+                    status: "pending",
+                    ...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
+                    skills: task.skills,
+                    model: task.model,
+                    thinking: task.thinking,
+                    attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+                    recentTools: [],
+                    recentOutput: [],
+                });
+            }
+            flatStepCount += step.parallel.length;
+        }
+        else if (isDynamicRunnerGroup(step)) {
+            parallelGroups.push({ start: flatStepCount, count: 1, stepIndex });
+            initialStatusSteps.push({
+                agent: `expand:${step.parallel.agent}`,
+                phase: step.phase ?? step.parallel.phase,
+                label: step.label ?? step.parallel.label ?? `Dynamic fanout (${step.collect.as})`,
+                outputName: step.collect.as,
+                structured: Boolean(step.collect.outputSchema),
+                status: "pending",
+                recentTools: [],
+                recentOutput: [],
+            });
+            flatStepCount++;
+        }
+        else {
+            initialStatusSteps.push({
+                agent: step.agent,
+                phase: step.phase,
+                label: step.label,
+                outputName: step.outputName,
+                structured: step.structured,
+                status: "pending",
+                ...(step.sessionFile ? { sessionFile: step.sessionFile } : {}),
+                skills: step.skills,
+                model: step.model,
+                thinking: step.thinking,
+                attemptedModels: step.modelCandidates && step.modelCandidates.length > 0 ? step.modelCandidates : step.model ? [step.model] : undefined,
+                recentTools: [],
+                recentOutput: [],
+            });
+            flatStepCount++;
+        }
+    }
+    const flatSteps = flattenSteps(steps);
+    const sessionEnabled = Boolean(config.sessionDir)
+        || shareEnabled
+        || flatSteps.some((step) => Boolean(step.sessionFile));
+    const statusPayload = {
+        runId: id,
+        runtimeVersion: config.runtimeVersion,
+        indexedControl: true,
+        controlRequestFiles: true,
+        ...(config.sessionId ? { sessionId: config.sessionId } : {}),
+        mode: config.resultMode ?? (flatSteps.length > 1 ? "chain" : "single"),
+        state: "running",
+        lastActivityAt: overallStartTime,
+        startedAt: overallStartTime,
+        lastUpdate: overallStartTime,
+        pid: process.pid,
+        cwd,
+        currentStep: 0,
+        chainStepCount: steps.length,
+        parallelGroups,
+        workflowGraph: config.workflowGraph,
+        steps: initialStatusSteps,
+        artifactsDir,
+        sessionDir: config.sessionDir,
+        outputFile: path.join(asyncDir, "output-0.log"),
+    };
+    fs.mkdirSync(asyncDir, { recursive: true });
+    writeAtomicJson(statusPath, statusPayload);
+    if (config.runtimeVersion !== 2)
+        saveRunStatus(id, statusPayload);
+    const emitNestedSelfEvent = (type) => {
+        if (!config.nestedRoute || !config.nestedSelf)
+            return;
+        try {
+            writeNestedEvent(config.nestedRoute, {
+                type,
+                ts: Date.now(),
+                parentRunId: config.nestedSelf.parentRunId,
+                parentStepIndex: config.nestedSelf.parentStepIndex,
+                child: nestedSummaryFromAsyncStatus(statusPayload, asyncDir, {
+                    id,
+                    parentRunId: config.nestedSelf.parentRunId,
+                    parentStepIndex: config.nestedSelf.parentStepIndex,
+                    depth: config.nestedSelf.depth,
+                    path: config.nestedSelf.path,
+                    mode: statusPayload.mode,
+                    ts: Date.now(),
+                }),
+            });
+        }
+        catch (error) {
+            console.error("Failed to emit nested async status event:", error);
+        }
+    };
+    const refreshWorkflowGraph = () => {
+        if (!config.workflowGraph)
+            return;
+        const graph = structuredClone(statusPayload.workflowGraph ?? config.workflowGraph);
+        const normalize = (status) => {
+            if (status === "complete" || status === "completed")
+                return "completed";
+            if (status === "running" || status === "failed" || status === "blocked" || status === "paused" || status === "pending")
+                return status;
+            return "pending";
+        };
+        const updateNode = (node) => {
+            if (node.flatIndex !== undefined) {
+                const step = statusPayload.steps[node.flatIndex];
+                if (step) {
+                    node.status = normalize(step.status);
+                    node.error = step.error;
+                    node.acceptanceStatus = step.acceptance?.status;
+                }
+                if (statusPayload.currentStep === node.flatIndex)
+                    graph.currentNodeId = node.id;
+            }
+            for (const child of node.children ?? [])
+                updateNode(child);
+            if (node.children?.length) {
+                if (node.children.every((child) => child.status === "completed"))
+                    node.status = "completed";
+                else if (node.children.some((child) => child.status === "running"))
+                    node.status = "running";
+                else if (node.children.some((child) => child.status === "failed"))
+                    node.status = "failed";
+                else if (node.children.some((child) => child.status === "blocked"))
+                    node.status = "blocked";
+                else if (node.children.some((child) => child.status === "paused"))
+                    node.status = "paused";
+            }
+            if (node.error)
+                node.status = "failed";
+        };
+        for (const node of graph.nodes)
+            updateNode(node);
+        statusPayload.workflowGraph = graph;
+    };
+    let statusWriteTimer;
+    const writeStatusPayload = () => {
+        if (statusWriteTimer) {
+            clearTimeout(statusWriteTimer);
+            statusWriteTimer = undefined;
+        }
+        refreshWorkflowGraph();
+        writeAtomicJson(statusPath, statusPayload);
+        if (config.runtimeVersion !== 2)
+            saveRunStatus(id, statusPayload);
+        emitNestedSelfEvent(statusPayload.state === "running" || statusPayload.state === "queued" ? "subagent.nested.updated" : "subagent.nested.completed");
+    };
+    const scheduleStatusWrite = () => {
+        if (statusWriteTimer)
+            return;
+        statusWriteTimer = setTimeout(writeStatusPayload, 200);
+        statusWriteTimer.unref?.();
+    };
+    let deadlineTimer;
+    statusPayload.timeoutAt = config.timeoutMs !== undefined ? overallStartTime + config.timeoutMs : undefined;
+    const scheduleDeadline = () => {
+        clearTimeout(deadlineTimer);
+        if (statusPayload.timeoutAt === undefined || cancellation.signal.aborted)
+            return;
+        const expire = () => {
+            statusPayload.timedOut = true;
+            statusPayload.error = `Timed out after ${statusPayload.timeoutAt - overallStartTime}ms.`;
+            cancellation.abort(new DOMException(statusPayload.error, "TimeoutError"));
+            writeStatusPayload();
+        };
+        const remaining = statusPayload.timeoutAt - Date.now();
+        if (remaining <= 0)
+            expire();
+        else {
+            deadlineTimer = setTimeout(expire, remaining);
+            deadlineTimer.unref();
+        }
+    };
+    scheduleDeadline();
+    writeStatusPayload();
+    const markDynamicGraphGroup = (stepIndex, status, error, acceptance) => {
+        const groupNode = statusPayload.workflowGraph?.nodes.find((node) => node.id === `step-${stepIndex}`);
+        if (!groupNode)
+            return;
+        groupNode.status = status;
+        groupNode.error = error;
+        groupNode.acceptanceStatus = acceptance?.status ?? groupNode.acceptanceStatus;
+    };
+    const refreshUsageTotals = () => {
+        statusPayload.totalTokens = statusPayload.steps.reduce((total, step) => ({
+            input: total.input + (step.tokens?.input ?? 0), output: total.output + (step.tokens?.output ?? 0), total: total.total + (step.tokens?.total ?? 0),
+        }), { input: 0, output: 0, total: 0 });
+    };
+    const stepOutputActivityAt = (index) => {
+        const step = statusPayload.steps[index];
+        let lastActivityAt = step?.lastActivityAt ?? step?.startedAt ?? overallStartTime;
+        const outputPath = path.join(asyncDir, `output-${index}.log`);
+        try {
+            lastActivityAt = Math.max(lastActivityAt, fs.statSync(outputPath).mtimeMs);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                console.error(`Failed to inspect async output file '${outputPath}':`, error);
+            }
+        }
+        return lastActivityAt;
+    };
+    const childSafeControls = Boolean(config.nestedSelf) || (process.env[SUBAGENT_CHILD_ENV] === "1" && process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1");
+    const emittedControlEventKeys = new Set();
+    const mutatingFailureStates = initialStatusSteps.map(() => createMutatingFailureState());
+    const mutatingFailureWindowMs = 5 * 60_000;
+    const appendControlEvent = (event) => {
+        if (!controlConfig.enabled)
+            return;
+        const childIntercomTarget = config.childIntercomTargets?.[event.index ?? statusPayload.currentStep];
+        const channels = controlConfig.notifyChannels;
+        if (channels.length === 0 || !claimControlNotification(controlConfig, event, emittedControlEventKeys, childIntercomTarget))
+            return;
+        appendJsonl(eventsPath, JSON.stringify({
+            type: "subagent.control",
+            event,
+            channels,
+            childIntercomTarget,
+            noticeText: formatControlNoticeMessage(event, childIntercomTarget, childSafeControls),
+            ...(config.controlIntercomTarget && channels.includes("intercom") ? {
+                intercom: {
+                    to: config.controlIntercomTarget,
+                    message: formatControlIntercomMessage(event, childIntercomTarget, childSafeControls),
+                },
+            } : {}),
+        }));
+    };
+    const syncTopLevelCurrentTool = () => {
+        const activeStep = statusPayload.steps
+            .filter((step) => step.status === "running" && typeof step.currentTool === "string" && step.currentTool.length > 0)
+            .sort((left, right) => (right.currentToolStartedAt ?? 0) - (left.currentToolStartedAt ?? 0))[0];
+        statusPayload.currentTool = activeStep?.currentTool;
+        statusPayload.currentToolStartedAt = activeStep?.currentToolStartedAt;
+        statusPayload.currentPath = activeStep?.currentPath;
+    };
+    const updateStepModel = (flatIndex, model, thinking, now = Date.now()) => {
+        const step = statusPayload.steps[flatIndex];
+        if (!step)
+            return;
+        step.model = model;
+        step.thinking = thinking;
+        step.modelStartedAt = now;
+        statusPayload.lastUpdate = now;
+        writeStatusPayload();
+    };
+    const clearControlNotificationKeys = (flatIndex) => {
+        const childKey = config.childIntercomTargets?.[flatIndex] ?? `${config.id}:${flatIndex}`;
+        for (const key of emittedControlEventKeys)
+            if (key.startsWith(`${childKey}:`))
+                emittedControlEventKeys.delete(key);
+    };
+    const updateStepFromChildEvent = (flatIndex, event, toolSnapshot) => {
+        const step = statusPayload.steps[flatIndex];
+        if (!step)
+            return;
+        const now = Date.now();
+        statusPayload.currentStep = flatIndex;
+        if (step.activityState === "needs_attention") {
+            step.activityState = undefined;
+            clearControlNotificationKeys(flatIndex);
+            statusPayload.activityState = statusPayload.steps.some((candidate) => candidate.activityState === "needs_attention")
+                ? "needs_attention"
+                : undefined;
+        }
+        step.streamingText = updateStreamingText(step.streamingText, event);
+        if (event.type === "tool_execution_start" && event.toolName) {
+            const currentPath = resolveCurrentPath(event.toolName, event.args);
+            step.toolCount = (step.toolCount ?? 0) + 1;
+            step.currentTool = event.toolName;
+            step.currentToolArgs = extractToolArgsPreview(event.args ?? {});
+            step.currentToolStartedAt = now;
+            step.currentPath = currentPath;
+            statusPayload.toolCount = (statusPayload.toolCount ?? 0) + 1;
+            syncTopLevelCurrentTool();
+        }
+        else if (event.type === "tool_execution_end") {
+            if (step.currentTool) {
+                step.recentTools ??= [];
+                step.recentTools.push({ tool: step.currentTool, args: step.currentToolArgs || "", endMs: now });
+            }
+            step.currentTool = undefined;
+            step.currentToolArgs = undefined;
+            step.currentToolStartedAt = undefined;
+            step.currentPath = undefined;
+            syncTopLevelCurrentTool();
+        }
+        else if (event.type === "message_end" && event.message?.role === "toolResult") {
+            const resultText = extractTextFromContent(event.message.content);
+            appendRecentStepOutput(step, resultText.split("\n").slice(-10));
+            if (toolSnapshot?.mutates && toolSnapshot.errored) {
+                const state = mutatingFailureStates[flatIndex];
+                recordMutatingFailure(state, {
+                    tool: toolSnapshot.tool,
+                    path: toolSnapshot.path,
+                    error: resultText.split("\n").find((line) => line.trim())?.trim().slice(0, 180) ?? "mutating tool failed",
+                    ts: now,
+                }, mutatingFailureWindowMs);
+                if (controlConfig.enabled && shouldEscalateMutatingFailures(state, controlConfig.failedToolAttemptsBeforeAttention) && step.activityState !== "needs_attention") {
+                    const previous = step.activityState;
+                    step.activityState = "needs_attention";
+                    statusPayload.activityState = "needs_attention";
+                    appendControlEvent(buildControlEvent({
+                        type: "needs_attention",
+                        from: previous,
+                        to: "needs_attention",
+                        runId: id,
+                        agent: step.agent,
+                        index: flatIndex,
+                        ts: now,
+                        message: `${step.agent} needs attention after repeated mutating tool failures`,
+                        reason: "tool_failures",
+                        turns: step.turnCount,
+                        tokens: step.tokens?.total,
+                        toolCount: step.toolCount,
+                        currentTool: toolSnapshot.tool,
+                        currentToolDurationMs: toolSnapshot.startedAt ? Math.max(0, now - toolSnapshot.startedAt) : undefined,
+                        currentPath: toolSnapshot.path,
+                        recentFailureSummary: summarizeRecentMutatingFailures(state),
+                    }));
+                }
+            }
+            else if (toolSnapshot?.mutates) {
+                resetMutatingFailureState(mutatingFailureStates[flatIndex]);
+            }
+        }
+        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;
+            const usage = event.message.usage;
+            if (usage) {
+                const input = usage.input ?? 0;
+                const output = usage.output ?? 0;
+                const previousInput = step.tokens?.input ?? 0;
+                const previousOutput = step.tokens?.output ?? 0;
+                step.tokens = { input: previousInput + input, output: previousOutput + output, total: previousInput + previousOutput + input + output };
+                const totalInput = statusPayload.totalTokens?.input ?? 0;
+                const totalOutput = statusPayload.totalTokens?.output ?? 0;
+                statusPayload.totalTokens = { input: totalInput + input, output: totalOutput + output, total: totalInput + totalOutput + input + output };
+            }
+            statusPayload.turnCount = Math.max(statusPayload.turnCount ?? 0, step.turnCount);
+        }
+        syncTopLevelCurrentTool();
+        step.lastActivityAt = now;
+        statusPayload.lastActivityAt = now;
+        statusPayload.lastUpdate = now;
+        scheduleStatusWrite();
+    };
+    const updateRunnerActivityState = (now) => {
+        if (!controlConfig.enabled)
+            return false;
+        let changed = false;
+        let runLastActivityAt = statusPayload.lastActivityAt ?? overallStartTime;
+        for (let index = 0; index < statusPayload.steps.length; index++) {
+            const step = statusPayload.steps[index];
+            if (step.status !== "running")
+                continue;
+            const lastActivityAt = stepOutputActivityAt(index);
+            runLastActivityAt = Math.max(runLastActivityAt, lastActivityAt);
+            if (step.lastActivityAt !== lastActivityAt) {
+                step.lastActivityAt = lastActivityAt;
+                changed = true;
+            }
+            const idleState = deriveActivityState({
+                config: controlConfig,
+                startedAt: step.startedAt ?? overallStartTime,
+                lastActivityAt,
+                now,
+            });
+            if (idleState === "needs_attention") {
+                const previous = step.activityState;
+                step.activityState = "needs_attention";
+                if (previous !== "needs_attention") {
+                    appendControlEvent(buildControlEvent({
+                        from: previous,
+                        to: "needs_attention",
+                        runId: id,
+                        agent: step.agent,
+                        index,
+                        ts: now,
+                        lastActivityAt,
+                        currentTool: step.currentTool,
+                        currentToolDurationMs: step.currentToolStartedAt !== undefined ? Math.max(0, now - step.currentToolStartedAt) : undefined,
+                        supervisorQuestion: pendingSupervisorQuestion({ runId: id, agent: step.agent, index, sessionFile: step.sessionFile }),
+                    }));
+                    changed = true;
+                }
+            }
+            else if (step.activityState === "needs_attention") {
+                step.activityState = undefined;
+                clearControlNotificationKeys(index);
+                changed = true;
+            }
+        }
+        if (statusPayload.lastActivityAt !== runLastActivityAt) {
+            statusPayload.lastActivityAt = runLastActivityAt;
+            changed = true;
+        }
+        const nextRunState = statusPayload.steps.some((step) => step.activityState === "needs_attention")
+            ? "needs_attention"
+            : undefined;
+        if (nextRunState !== currentActivityState) {
+            currentActivityState = nextRunState;
+            statusPayload.activityState = nextRunState;
+            changed = true;
+        }
+        statusPayload.lastUpdate = now;
+        if (changed)
+            writeStatusPayload();
+        return changed;
+    };
+    if (controlConfig.enabled) {
+        activityTimer = setInterval(() => {
+            if (statusPayload.state !== "running")
+                return;
+            const now = Date.now();
+            updateRunnerActivityState(now);
+        }, 1000);
+        activityTimer.unref?.();
+    }
+    const interruptRunner = () => {
+        if (interrupted || statusPayload.state !== "running")
+            return;
+        interrupted = true;
+        interruption.abort();
+        const now = Date.now();
+        currentActivityState = undefined;
+        statusPayload.activityState = undefined;
+        statusPayload.lastUpdate = now;
+        writeStatusPayload();
+        appendJsonl(eventsPath, JSON.stringify({
+            type: "subagent.run.stop-requested",
+            ts: now,
+            runId: id,
+        }));
+        for (const interrupt of activeChildInterrupts.values())
+            interrupt();
+    };
+    process.on(ASYNC_INTERRUPT_SIGNAL, interruptRunner);
+    controlRequestTimer = setInterval(() => {
+        for (const request of readAsyncControlRequests(asyncDir, id)) {
+            if (request.action === "extend") {
+                if (statusPayload.timeoutAt === undefined || cancellation.signal.aborted || interrupted)
+                    continue;
+                statusPayload.timeoutAt = Math.max(statusPayload.timeoutAt, Date.now()) + request.extendMs;
+                scheduleDeadline();
+                writeStatusPayload();
+                appendJsonl(eventsPath, JSON.stringify({ type: "subagent.run.extended", requestId: request.requestId, runId: id, ts: Date.now(), timeoutAt: statusPayload.timeoutAt }));
+            }
+            else if (request.action === "cancel")
+                cancellation.abort();
+            else if (request.index === undefined)
+                interruptRunner();
+            else
+                activeChildInterrupts.get(request.index)?.();
+        }
+    }, 100);
+    controlRequestTimer.unref?.();
+    appendJsonl(eventsPath, JSON.stringify({
+        type: "subagent.run.started",
+        ts: overallStartTime,
+        runId: id,
+        mode: statusPayload.mode,
+        cwd,
+        pid: process.pid,
+    }));
+    const stoppedParallelChild = (task, index, reason) => {
+        const now = Date.now();
+        const step = statusPayload.steps[index];
+        const paused = reason === "interrupted";
+        const error = `Skipped due to ${reason}`;
+        const exitCode = paused ? 0 : -1;
+        if (paused)
+            markStepPaused(step, now);
+        else
+            Object.assign(step, { status: "failed", error, startedAt: now, endedAt: now, durationMs: 0, exitCode });
+        statusPayload.lastUpdate = now;
+        writeStatusPayload();
+        appendJsonl(eventsPath, JSON.stringify({ type: paused ? "subagent.step.paused" : "subagent.step.failed", ts: now, runId: id, stepIndex: index, agent: task.agent, exitCode, interrupted: paused, durationMs: 0 }));
+        return { agent: task.agent, output: error, error, exitCode, interrupted: paused, skipped: true };
+    };
+    const runParallelChild = async (input) => {
+        const { task, flatIndex: fi } = input;
+        const taskStartTime = Date.now();
+        const statusStep = statusPayload.steps[fi];
+        statusPayload.currentStep = fi;
+        statusStep.status = "running";
+        statusStep.error = undefined;
+        statusStep.activityState = undefined;
+        resetStepLiveDetail(statusStep);
+        statusStep.startedAt = taskStartTime;
+        if (input.resetTiming) {
+            statusStep.endedAt = undefined;
+            statusStep.durationMs = undefined;
+        }
+        statusStep.lastActivityAt = taskStartTime;
+        statusPayload.outputFile = path.join(asyncDir, `output-${fi}.log`);
+        statusPayload.lastActivityAt = taskStartTime;
+        statusPayload.lastUpdate = taskStartTime;
+        writeStatusPayload();
+        appendJsonl(eventsPath, JSON.stringify({ type: "subagent.step.started", ts: taskStartTime, runId: id, stepIndex: fi, agent: task.agent }));
+        const singleResult = await runSingleStep({ ...task, task: renderTask(task.task, input.item) }, {
+            nativeFinalization: config.runtimeVersion === 2,
+            worktreePath: input.worktreePath,
+            cwd: input.taskCwd, sessionEnabled,
+            sessionDir: input.sessionDir,
+            artifactsDir, id,
+            flatIndex: fi, flatStepCount: input.flatStepCount,
+            outputFile: path.join(asyncDir, `output-${fi}.log`),
+            childIntercomTarget: config.childIntercomTargets?.[fi],
+            orchestratorIntercomTarget: config.childIntercomTargets?.[fi] ? config.controlIntercomTarget : undefined,
+            nestedRoute: config.nestedRoute,
+            projectTrust: config.projectTrust,
+            rootSessionId: config.rootSessionId,
+            signal: cancellation.signal,
+            interruptSignal: input.interruptSignal,
+            registerInterrupt: (interrupt) => {
+                if (interrupt)
+                    activeChildInterrupts.set(fi, interrupt);
+                else
+                    activeChildInterrupts.delete(fi);
+            },
+            onAttemptStart: (attempt) => updateStepModel(fi, attempt.model, attempt.thinking),
+            onChildEvent: (event, mutation) => updateStepFromChildEvent(fi, event, mutation),
+        });
+        activeChildInterrupts.delete(fi);
+        if (input.trackSession && task.sessionFile)
+            latestSessionFile = task.sessionFile;
+        const taskEndTime = Date.now();
+        statusStep.status = singleResult.interrupted ? "paused" : singleResult.exitCode === 0 ? singleResult.acceptance?.status === "blocked" ? "blocked" : "complete" : "failed";
+        clearStepCurrentActivity(statusStep);
+        statusStep.endedAt = taskEndTime;
+        statusStep.durationMs = taskEndTime - taskStartTime;
+        statusStep.exitCode = singleResult.exitCode;
+        statusStep.agentProcessExit = singleResult.agentProcessExit;
+        statusStep.model = singleResult.model;
+        statusStep.thinking = resolveEffectiveThinking(singleResult.model, statusStep.thinking);
+        statusStep.attemptedModels = singleResult.attemptedModels;
+        statusStep.modelAttempts = singleResult.modelAttempts;
+        statusStep.tokens = tokenUsageFromAttempts(singleResult.modelAttempts) ?? undefined;
+        refreshUsageTotals();
+        statusStep.error = singleResult.error;
+        statusStep.structuredOutput = singleResult.structuredOutput;
+        statusStep.structuredOutputPath = singleResult.structuredOutputPath;
+        statusStep.structuredOutputSchemaPath = singleResult.structuredOutputSchemaPath;
+        statusStep.acceptance = singleResult.acceptance;
+        statusStep.resourceLimitExceeded = singleResult.resourceLimitExceeded;
+        statusPayload.lastUpdate = taskEndTime;
+        writeStatusPayload();
+        appendJsonl(eventsPath, JSON.stringify({
+            type: singleResult.interrupted ? "subagent.step.paused" : singleResult.exitCode !== 0 ? "subagent.step.failed" : singleResult.acceptance?.status === "blocked" ? "subagent.step.blocked" : "subagent.step.completed",
+            ts: taskEndTime, runId: id, stepIndex: fi, agent: task.agent,
+            exitCode: singleResult.exitCode, durationMs: taskEndTime - taskStartTime,
+            interrupted: singleResult.interrupted, agentProcessExit: singleResult.agentProcessExit,
+            resourceLimitExceeded: singleResult.resourceLimitExceeded,
+        }));
+        if (input.notifyCompletionGuard && singleResult.completionGuardTriggered) {
+            appendControlEvent(buildControlEvent({
+                from: statusStep.activityState,
+                to: "needs_attention",
+                runId: id,
+                agent: task.agent,
+                index: fi,
+                ts: taskEndTime,
+                message: `${task.agent} completed without making edits for an implementation task`,
+                reason: "completion_guard",
+            }));
+        }
+        return { ...singleResult, skipped: false };
+    };
+    let flatIndex = 0;
+    let workflowComplete = false;
+    for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
+        if (interrupted || cancellation.signal.aborted)
+            break;
+        const step = steps[stepIndex];
+        if (isDynamicRunnerGroup(step)) {
+            const groupStartFlatIndex = flatIndex;
+            let materialized;
+            try {
+                materialized = materializeDynamicParallelStep(step, outputs, stepIndex, { maxItems: config.dynamicFanoutMaxItems, allowRunnerFields: true });
+            }
+            catch (error) {
+                const now = Date.now();
+                const message = error instanceof DynamicFanoutError ? error.message : error instanceof Error ? error.message : String(error);
+                statusPayload.state = "failed";
+                statusPayload.error = message;
+                statusPayload.currentStep = flatIndex;
+                const placeholder = statusPayload.steps[groupStartFlatIndex];
+                if (placeholder) {
+                    placeholder.status = "failed";
+                    placeholder.error = message;
+                    placeholder.startedAt = now;
+                    placeholder.endedAt = now;
+                    placeholder.durationMs = 0;
+                    placeholder.exitCode = 1;
+                }
+                statusPayload.lastUpdate = now;
+                markDynamicGraphGroup(stepIndex, "failed", message);
+                writeStatusPayload();
+                break;
+            }
+            const dynamicSteps = materialized.parallel.map((task, itemIndex) => materializeDynamicOutputPath({
+                step: {
+                    ...step.parallel,
+                    label: task.label ?? step.parallel.label,
+                    sessionFile: step.sessionFiles?.[itemIndex],
+                    structuredOutput: undefined,
+                    structuredOutputSchema: step.parallel.structuredOutputSchema ?? step.parallel.structuredOutput?.schema,
+                },
+                chainDir: config.chainDir ?? cwd,
+                stepIndex,
+                taskIndex: itemIndex,
+            }));
+            const duplicateOutputError = findDuplicateOutputPath(dynamicSteps);
+            if (duplicateOutputError) {
+                const now = Date.now();
+                statusPayload.state = "failed";
+                statusPayload.error = duplicateOutputError;
+                statusPayload.currentStep = flatIndex;
+                const placeholderStep = statusPayload.steps[groupStartFlatIndex];
+                if (placeholderStep) {
+                    placeholderStep.status = "failed";
+                    placeholderStep.error = duplicateOutputError;
+                    placeholderStep.startedAt = now;
+                    placeholderStep.endedAt = now;
+                    placeholderStep.durationMs = 0;
+                    placeholderStep.exitCode = 1;
+                }
+                statusPayload.lastUpdate = now;
+                markDynamicGraphGroup(stepIndex, "failed", duplicateOutputError);
+                writeStatusPayload();
+                break;
+            }
+            const dynamicStatusSteps = dynamicSteps.map((task) => ({
+                agent: task.agent,
+                phase: task.phase ?? step.phase,
+                label: task.label,
+                outputName: undefined,
+                structured: Boolean(task.structuredOutputSchema),
+                status: "pending",
+                ...(task.sessionFile ? { sessionFile: task.sessionFile } : {}),
+                skills: task.skills,
+                model: task.model,
+                thinking: task.thinking,
+                attemptedModels: task.modelCandidates && task.modelCandidates.length > 0 ? task.modelCandidates : task.model ? [task.model] : undefined,
+                recentTools: [],
+                recentOutput: [],
+            }));
+            const previousChildIntercomTargets = config.childIntercomTargets;
+            statusPayload.steps.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps);
+            if (previousChildIntercomTargets) {
+                const dynamicGroupUsesIntercom = previousChildIntercomTargets[groupStartFlatIndex] !== undefined;
+                config.childIntercomTargets = statusPayload.steps.map((statusStep, index) => {
+                    if (index >= groupStartFlatIndex && index < groupStartFlatIndex + dynamicStatusSteps.length) {
+                        return dynamicGroupUsesIntercom ? resolveSubagentIntercomTarget(id, statusStep.agent, index) : undefined;
+                    }
+                    const previousIndex = index < groupStartFlatIndex ? index : index - (dynamicStatusSteps.length - 1);
+                    return previousChildIntercomTargets[previousIndex] !== undefined
+                        ? resolveSubagentIntercomTarget(id, statusStep.agent, index)
+                        : undefined;
+                });
+            }
+            mutatingFailureStates.splice(groupStartFlatIndex, 1, ...dynamicStatusSteps.map(() => createMutatingFailureState()));
+            const materializedDelta = dynamicStatusSteps.length - 1;
+            for (const group of statusPayload.parallelGroups) {
+                if (group.stepIndex === stepIndex) {
+                    group.start = groupStartFlatIndex;
+                    group.count = dynamicStatusSteps.length;
+                }
+                else if (group.stepIndex > stepIndex) {
+                    group.start += materializedDelta;
+                }
+            }
+            if (statusPayload.workflowGraph) {
+                const shiftFlatIndexes = (nodes) => {
+                    for (const node of nodes) {
+                        if (node.stepIndex !== undefined && node.stepIndex > stepIndex && node.flatIndex !== undefined && node.flatIndex >= groupStartFlatIndex) {
+                            node.flatIndex += dynamicStatusSteps.length;
+                        }
+                        if (node.children)
+                            shiftFlatIndexes(node.children);
+                    }
+                };
+                shiftFlatIndexes(statusPayload.workflowGraph.nodes);
+                const groupNode = statusPayload.workflowGraph.nodes.find((node) => node.id === `step-${stepIndex}`);
+                if (groupNode) {
+                    groupNode.children = materialized.items.map((item, itemIndex) => ({
+                        id: `step-${stepIndex}-item-${item.idKey}`,
+                        kind: "agent",
+                        agent: step.parallel.agent,
+                        phase: dynamicSteps[itemIndex]?.phase ?? step.phase,
+                        label: dynamicSteps[itemIndex]?.label?.trim() || `${step.parallel.agent} ${item.key}`,
+                        status: "pending",
+                        flatIndex: groupStartFlatIndex + itemIndex,
+                        stepIndex,
+                        itemKey: item.key,
+                        structured: Boolean(dynamicSteps[itemIndex]?.structuredOutputSchema),
+                    }));
+                }
+            }
+            writeStatusPayload();
+            const parallelResults = await runParallelTasks({
+                tasks: dynamicSteps,
+                concurrency: step.concurrency ?? MAX_PARALLEL_CONCURRENCY,
+                failFast: step.failFast,
+                signal: cancellation.signal,
+                interruptSignal: interruption.signal,
+                stoppedTask: (task, index, reason) => stoppedParallelChild(task, groupStartFlatIndex + index, reason),
+                runTask: (task, taskIdx, failFastSignal) => runParallelChild({
+                    task,
+                    flatIndex: groupStartFlatIndex + taskIdx,
+                    interruptSignal: failFastSignal,
+                    item: { name: step.expand.item ?? "item", value: materialized.items[taskIdx].item },
+                    taskCwd: cwd,
+                    sessionDir: config.sessionDir ? path.join(config.sessionDir, `dynamic-${stepIndex}-${taskIdx}`) : undefined,
+                    flatStepCount: Math.max(statusPayload.steps.length, 1),
+                }),
+            });
+            flatIndex += dynamicSteps.length;
+            for (const pr of parallelResults)
+                results.push({ ...pr, success: workflowChildSucceeded(pr) });
+            const completion = completeWorkflowStep({ stepIndex, stepCount: steps.length, results: parallelResults, previousOutput, dynamic: { step, items: materialized.items } });
+            Object.assign(outputs, completion.outputs);
+            statusPayload.outputs = outputs;
+            if (completion.error) {
+                statusPayload.error = completion.error;
+            }
+            previousOutput = completion.previousOutput;
+            workflowComplete = completion.complete;
+            const error = completion.error ?? parallelResults[completion.failedIndices[0]]?.error;
+            markDynamicGraphGroup(stepIndex, completion.status === "completed" ? "completed" : completion.status === "blocked" ? "blocked" : completion.status === "paused" ? "paused" : "failed", error);
+            appendJsonl(eventsPath, JSON.stringify({
+                type: "subagent.dynamic.completed",
+                ts: Date.now(),
+                runId: id,
+                stepIndex,
+                success: completion.advance,
+                state: completion.status === "completed" ? "complete" : completion.status,
+            }));
+            statusPayload.lastUpdate = Date.now();
+            writeStatusPayload();
+            if (!completion.advance)
+                break;
+            continue;
+        }
+        if (isParallelGroup(step)) {
+            const group = step;
+            const groupCwd = group.cwd ?? cwd;
+            const groupStartFlatIndex = flatIndex;
+            let worktreeSetup;
+            if (group.worktree) {
+                const worktreeTaskCwdConflict = findWorktreeTaskCwdConflict(group.parallel, groupCwd);
+                if (worktreeTaskCwdConflict) {
+                    const failedAt = Date.now();
+                    markParallelGroupSetupFailure({
+                        statusPayload,
+                        results,
+                        group,
+                        groupStartFlatIndex,
+                        setupError: formatWorktreeTaskCwdConflict(worktreeTaskCwdConflict, groupCwd),
+                        failedAt,
+                        statusPath,
+                        eventsPath,
+                        asyncDir,
+                        runId: id,
+                        stepIndex,
+                    });
+                    flatIndex += group.parallel.length;
+                    break;
+                }
+                try {
+                    worktreeSetup = await createWorktrees(groupCwd, `${id}-s${stepIndex}`, group.parallel.length, {
+                        agents: group.parallel.map((task) => task.agent),
+                        signal: AbortSignal.any([cancellation.signal, interruption.signal]),
+                        setupHook: config.worktreeSetupHook
+                            ? { hookPath: config.worktreeSetupHook, timeoutMs: config.worktreeSetupHookTimeoutMs }
+                            : undefined,
+                    });
+                }
+                catch (error) {
+                    const setupError = error instanceof Error ? error.message : String(error);
+                    if (interrupted && !cancellation.signal.aborted) {
+                        if (error instanceof WorktreeCleanupError)
+                            setupCleanupWarning = setupError;
+                        for (const [index, task] of group.parallel.entries()) {
+                            const stopped = stoppedParallelChild(task, groupStartFlatIndex + index, "interrupted");
+                            if (error instanceof WorktreeCleanupError)
+                                stopped.output += `\n\n${setupError}`;
+                            results.push({ ...stopped, success: false });
+                        }
+                        flatIndex += group.parallel.length;
+                        break;
+                    }
+                    const failedAt = Date.now();
+                    markParallelGroupSetupFailure({
+                        statusPayload,
+                        results,
+                        group,
+                        groupStartFlatIndex,
+                        setupError,
+                        failedAt,
+                        statusPath,
+                        eventsPath,
+                        asyncDir,
+                        runId: id,
+                        stepIndex,
+                    });
+                    flatIndex += group.parallel.length;
+                    break;
+                }
+            }
+            try {
+                if (group.worktree)
+                    ensureParallelProgressFile(groupCwd, group);
+                const groupStartTime = Date.now();
+                markParallelGroupRunning({
+                    statusPayload,
+                    group,
+                    groupStartFlatIndex,
+                    groupStartTime,
+                    statusPath,
+                    eventsPath,
+                    asyncDir,
+                    runId: id,
+                    stepIndex,
+                });
+                const parallelResults = await runParallelTasks({
+                    tasks: group.parallel,
+                    concurrency: group.concurrency ?? MAX_PARALLEL_CONCURRENCY,
+                    failFast: group.failFast,
+                    signal: cancellation.signal,
+                    interruptSignal: interruption.signal,
+                    stoppedTask: (task, index, reason) => stoppedParallelChild(task, groupStartFlatIndex + index, reason),
+                    runTask: (task, taskIdx, failFastSignal) => {
+                        const { taskForRun, taskCwd } = prepareParallelTaskRun(task, groupCwd, worktreeSetup, taskIdx);
+                        return runParallelChild({
+                            task: taskForRun,
+                            worktreePath: worktreeSetup?.worktrees[taskIdx]?.path,
+                            flatIndex: groupStartFlatIndex + taskIdx,
+                            interruptSignal: failFastSignal,
+                            taskCwd,
+                            sessionDir: config.sessionDir ? path.join(config.sessionDir, `parallel-${taskIdx}`) : undefined,
+                            flatStepCount: flatSteps.length,
+                            resetTiming: true,
+                            trackSession: true,
+                            notifyCompletionGuard: true,
+                        });
+                    },
+                });
+                flatIndex += group.parallel.length;
+                refreshUsageTotals();
+                statusPayload.lastUpdate = Date.now();
+                writeStatusPayload();
+                for (const pr of parallelResults)
+                    results.push({ ...pr, success: workflowChildSucceeded(pr) });
+                const completion = completeWorkflowStep({
+                    stepIndex, stepCount: steps.length, results: parallelResults, previousOutput, parallel: true,
+                    outputNames: group.parallel.map((task) => task.outputName),
+                });
+                Object.assign(outputs, completion.outputs);
+                statusPayload.outputs = outputs;
+                const worktreeSummary = formatRunnerWorktreeSummary(worktreeSetup, asyncDir, stepIndex, group);
+                previousOutput = completion.advance ? appendWorktreeSummary(completion.previousOutput, worktreeSummary) : completion.previousOutput;
+                workflowComplete = completion.complete;
+                if (worktreeSummary)
+                    worktreeSummaries.push(worktreeSummary);
+                appendJsonl(eventsPath, JSON.stringify({
+                    type: "subagent.parallel.completed",
+                    ts: Date.now(),
+                    runId: id,
+                    stepIndex,
+                    success: completion.advance,
+                    state: completion.status === "completed" ? "complete" : completion.status,
+                }));
+                writeStatusPayload();
+                if (!completion.advance)
+                    break;
+            }
+            catch (error) {
+                if (worktreeSetup)
+                    worktreeSetup.preserveOnCleanup = true;
+                throw error;
+            }
+            finally {
+                if (worktreeSetup)
+                    cleanupWorktrees(worktreeSetup);
+            }
+        }
+        else {
+            const seqStep = step;
+            const stepStartTime = Date.now();
+            statusPayload.currentStep = flatIndex;
+            statusPayload.steps[flatIndex].status = "running";
+            statusPayload.steps[flatIndex].activityState = undefined;
+            statusPayload.activityState = undefined;
+            resetStepLiveDetail(statusPayload.steps[flatIndex]);
+            statusPayload.steps[flatIndex].skills = seqStep.skills;
+            statusPayload.steps[flatIndex].startedAt = stepStartTime;
+            statusPayload.steps[flatIndex].lastActivityAt = stepStartTime;
+            statusPayload.lastActivityAt = stepStartTime;
+            statusPayload.lastUpdate = stepStartTime;
+            statusPayload.outputFile = path.join(asyncDir, `output-${flatIndex}.log`);
+            writeStatusPayload();
+            appendJsonl(eventsPath, JSON.stringify({
+                type: "subagent.step.started",
+                ts: stepStartTime,
+                runId: id,
+                stepIndex: flatIndex,
+                agent: seqStep.agent,
+            }));
+            const singleResult = await runSingleStep({ ...seqStep, task: renderTask(seqStep.task) }, {
+                nativeFinalization: config.runtimeVersion === 2,
+                cwd, sessionEnabled,
+                sessionDir: config.sessionDir,
+                artifactsDir, id,
+                flatIndex, flatStepCount: flatSteps.length,
+                outputFile: path.join(asyncDir, `output-${flatIndex}.log`),
+                childIntercomTarget: config.childIntercomTargets?.[flatIndex],
+                orchestratorIntercomTarget: config.childIntercomTargets?.[flatIndex] ? config.controlIntercomTarget : undefined,
+                nestedRoute: config.nestedRoute,
+                projectTrust: config.projectTrust,
+                rootSessionId: config.rootSessionId,
+                signal: cancellation.signal,
+                registerInterrupt: (interrupt) => {
+                    if (interrupt)
+                        activeChildInterrupts.set(flatIndex, interrupt);
+                    else
+                        activeChildInterrupts.delete(flatIndex);
+                },
+                onAttemptStart: (attempt) => updateStepModel(flatIndex, attempt.model, attempt.thinking),
+                onChildEvent: (event, mutation) => updateStepFromChildEvent(flatIndex, event, mutation),
+            });
+            activeChildInterrupts.delete(flatIndex);
+            if (seqStep.sessionFile) {
+                latestSessionFile = seqStep.sessionFile;
+            }
+            const completion = completeWorkflowStep({ stepIndex, stepCount: steps.length, results: [singleResult], previousOutput, outputNames: [seqStep.outputName] });
+            previousOutput = completion.previousOutput;
+            workflowComplete = completion.complete;
+            results.push({ ...singleResult, success: workflowChildSucceeded(singleResult) });
+            Object.assign(outputs, completion.outputs);
+            statusPayload.outputs = outputs;
+            const stepTokens = tokenUsageFromAttempts(singleResult.modelAttempts);
+            const stepEndTime = Date.now();
+            statusPayload.steps[flatIndex].status = singleResult.interrupted ? "paused" : singleResult.exitCode === 0 ? singleResult.acceptance?.status === "blocked" ? "blocked" : "complete" : "failed";
+            clearStepCurrentActivity(statusPayload.steps[flatIndex]);
+            statusPayload.steps[flatIndex].endedAt = stepEndTime;
+            statusPayload.steps[flatIndex].durationMs = stepEndTime - stepStartTime;
+            statusPayload.steps[flatIndex].exitCode = singleResult.exitCode;
+            statusPayload.steps[flatIndex].agentProcessExit = singleResult.agentProcessExit;
+            statusPayload.steps[flatIndex].model = singleResult.model;
+            statusPayload.steps[flatIndex].thinking = resolveEffectiveThinking(singleResult.model, statusPayload.steps[flatIndex].thinking);
+            statusPayload.steps[flatIndex].attemptedModels = singleResult.attemptedModels;
+            statusPayload.steps[flatIndex].modelAttempts = singleResult.modelAttempts;
+            statusPayload.steps[flatIndex].error = singleResult.error;
+            statusPayload.steps[flatIndex].structuredOutput = singleResult.structuredOutput;
+            statusPayload.steps[flatIndex].structuredOutputPath = singleResult.structuredOutputPath;
+            statusPayload.steps[flatIndex].structuredOutputSchemaPath = singleResult.structuredOutputSchemaPath;
+            statusPayload.steps[flatIndex].acceptance = singleResult.acceptance;
+            statusPayload.steps[flatIndex].resourceLimitExceeded = singleResult.resourceLimitExceeded;
+            if (stepTokens) {
+                statusPayload.steps[flatIndex].tokens = stepTokens;
+                refreshUsageTotals();
+            }
+            statusPayload.lastUpdate = stepEndTime;
+            writeStatusPayload();
+            appendJsonl(eventsPath, JSON.stringify({
+                type: singleResult.interrupted ? "subagent.step.paused" : singleResult.exitCode !== 0 ? "subagent.step.failed" : singleResult.acceptance?.status === "blocked" ? "subagent.step.blocked" : "subagent.step.completed",
+                ts: stepEndTime,
+                runId: id,
+                stepIndex: flatIndex,
+                agent: seqStep.agent,
+                exitCode: singleResult.exitCode,
+                durationMs: stepEndTime - stepStartTime,
+                interrupted: singleResult.interrupted, agentProcessExit: singleResult.agentProcessExit,
+                tokens: stepTokens,
+                resourceLimitExceeded: singleResult.resourceLimitExceeded,
+            }));
+            if (singleResult.completionGuardTriggered) {
+                const event = buildControlEvent({
+                    from: statusPayload.steps[flatIndex].activityState,
+                    to: "needs_attention",
+                    runId: id,
+                    agent: seqStep.agent,
+                    index: flatIndex,
+                    ts: stepEndTime,
+                    message: `${seqStep.agent} completed without making edits for an implementation task`,
+                    reason: "completion_guard",
+                });
+                appendControlEvent(event);
+            }
+            flatIndex++;
+            if (!completion.advance)
+                break;
+        }
+    }
+    const resultMode = config.resultMode ?? statusPayload.mode;
+    const childText = (result) => result.error && !result.output.includes(result.error) ? `${result.error}\n${result.output}`.trim() : result.output;
+    let summary = resultMode === "single" && results.length === 1 ? childText(results[0]) : results.map((result) => `${result.agent}:\n${childText(result)}`).join("\n\n");
+    if (statusPayload.error && !summary.includes(statusPayload.error))
+        summary = `${statusPayload.error}\n\n${summary}`.trim();
+    if (statusPayload.timedOut)
+        summary = [
+            `${resultMode === "parallel" ? "Parallel run" : resultMode === "chain" ? "Chain" : "Run"} timed out.`,
+            summary,
+        ].filter(Boolean).join("\n\n");
+    if (worktreeSummaries.length > 0)
+        summary = appendWorktreeSummary(summary, worktreeSummaries.join("\n\n"));
+    const fullSummary = summary;
+    let truncated = false;
+    const outputLimits = { ...DEFAULT_MAX_OUTPUT, ...maxOutput };
+    const lastArtifactPath = results[results.length - 1]?.artifactPaths?.outputPath;
+    const referenceOnly = resultMode === "single" && results.length === 1 && results[0]?.outputMode === "file-only" && results[0].exitCode === 0 && results[0].outputReference;
+    const truncResult = referenceOnly ? { text: summary, truncated: false } : truncateOutput(summary, outputLimits, lastArtifactPath);
+    if (truncResult.truncated) {
+        summary = truncResult.text;
+        truncated = true;
+    }
+    const agentName = flatSteps.length === 1
+        ? flatSteps[0].agent
+        : resultMode === "parallel"
+            ? `parallel:${flatSteps.map((s) => s.agent).join("+")}`
+            : `chain:${flatSteps.map((s) => s.agent).join("->")}`;
+    let sessionFile;
+    let shareUrl;
+    let gistUrl;
+    let shareError;
+    if (shareEnabled) {
+        sessionFile = config.sessionDir
+            ? (findLatestSessionFile(config.sessionDir) ?? undefined)
+            : undefined;
+        if (!sessionFile && latestSessionFile) {
+            sessionFile = latestSessionFile;
+        }
+        if (sessionFile) {
+            try {
+                const exportDir = config.sessionDir ?? path.dirname(sessionFile);
+                fs.mkdirSync(exportDir, { recursive: true });
+                const htmlPath = await exportSessionHtml(sessionFile, exportDir, config.piPackageRoot);
+                const share = createShareLink(htmlPath);
+                if ("error" in share)
+                    shareError = share.error;
+                else {
+                    shareUrl = share.shareUrl;
+                    gistUrl = share.gistUrl;
+                }
+            }
+            catch (err) {
+                shareError = String(err);
+            }
+        }
+        else {
+            shareError = "Session file not found.";
+        }
+    }
+    clearTimeout(deadlineTimer);
+    if (activityTimer) {
+        clearInterval(activityTimer);
+        activityTimer = undefined;
+    }
+    if (controlRequestTimer) {
+        clearInterval(controlRequestTimer);
+        controlRequestTimer = undefined;
+    }
+    process.off(ASYNC_INTERRUPT_SIGNAL, interruptRunner);
+    for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
+        process.off(signal, cancelRunner);
+    const effectiveSessionFile = sessionFile ?? latestSessionFile ?? undefined;
+    const runEndedAt = Date.now();
+    if (interrupted) {
+        for (let index = 0; index < statusPayload.steps.length; index++) {
+            const step = statusPayload.steps[index];
+            if (step.status !== "pending")
+                continue;
+            markStepPaused(step, runEndedAt);
+            appendJsonl(eventsPath, JSON.stringify({
+                type: "subagent.step.paused",
+                ts: runEndedAt,
+                runId: id,
+                stepIndex: index,
+                agent: step.agent,
+                interrupted: true,
+                durationMs: 0,
+            }));
+        }
+    }
+    const hasFailedSteps = statusPayload.steps.some((step) => step.status === "failed");
+    const hasPausedSteps = statusPayload.steps.some((step) => step.status === "paused");
+    const finalRunState = hasFailedSteps || statusPayload.error || cancellation.signal.aborted ? "failed"
+        : statusPayload.steps.some((step) => step.status === "blocked") ? "blocked"
+            : interrupted || hasPausedSteps ? "paused" : workflowComplete ? "complete" : "failed";
+    statusPayload.state = finalRunState;
+    statusPayload.activityState = undefined;
+    statusPayload.currentTool = undefined;
+    statusPayload.currentToolStartedAt = undefined;
+    statusPayload.currentPath = undefined;
+    statusPayload.endedAt = runEndedAt;
+    statusPayload.lastUpdate = runEndedAt;
+    statusPayload.sessionFile = effectiveSessionFile;
+    statusPayload.shareUrl = shareUrl;
+    statusPayload.gistUrl = gistUrl;
+    statusPayload.shareError = shareError;
+    if (statusPayload.state === "failed" && !statusPayload.error) {
+        const failedStep = statusPayload.steps.find((s) => s.status === "failed");
+        if (failedStep?.agent) {
+            statusPayload.error = `Step failed: ${failedStep.agent}`;
+        }
+        else if (cancellation.signal.aborted) {
+            statusPayload.error = "Subagent cancelled.";
+        }
+    }
+    writeStatusPayload();
+    appendJsonl(eventsPath, JSON.stringify({
+        type: "subagent.run.completed",
+        ts: runEndedAt,
+        runId: id,
+        status: statusPayload.state,
+        durationMs: runEndedAt - overallStartTime,
+    }));
+    writeRunLog(logPath, {
+        id,
+        mode: statusPayload.mode,
+        cwd,
+        startedAt: overallStartTime,
+        endedAt: runEndedAt,
+        steps: statusPayload.steps.map((step) => ({
+            agent: step.agent,
+            status: step.status,
+            durationMs: step.durationMs,
+        })),
+        summary: fullSummary,
+        truncated: false,
+        artifactsDir,
+        sessionFile: effectiveSessionFile,
+        shareUrl,
+        shareError,
+    });
+    try {
+        const resultData = {
+            id,
+            runtimeVersion: config.runtimeVersion,
+            maxOutput: outputLimits, error: statusPayload.error,
+            timedOut: statusPayload.timedOut,
+            agent: agentName,
+            mode: resultMode,
+            success: finalRunState === "complete",
+            state: finalRunState,
+            summary: finalRunState === "blocked" ? `Needs your action — acceptance incomplete.\n${results.map((result) => acceptanceHumanAction(result.acceptance)).filter(Boolean).join("\n")}` : finalRunState === "paused" ? `Paused after interrupt. Waiting for explicit next action.${setupCleanupWarning ? `\n\n${setupCleanupWarning}` : ""}` : summary,
+            results: results.map((r) => {
+                const referenceOnly = r.outputMode === "file-only" && r.exitCode === 0 && r.outputReference;
+                const childOutput = referenceOnly ? { text: referenceOnly.message, truncated: false } : truncateOutput(r.output, outputLimits, r.artifactPaths?.outputPath);
+                return { ...r, output: childOutput.text,
+                    finalOutput: referenceOnly ? referenceOnly.message : r.finalOutput === undefined ? undefined : truncateOutput(r.finalOutput, outputLimits, r.artifactPaths?.outputPath).text,
+                    initialOutput: r.initialOutput === undefined ? undefined : truncateOutput(r.initialOutput, outputLimits, r.artifactPaths?.outputPath).text,
+                    truncated: r.truncated || childOutput.truncated || undefined };
+            }),
+            outputs,
+            workflowGraph: statusPayload.workflowGraph,
+            exitCode: statusPayload.timedOut ? 124 : finalRunState === "failed" ? 1 : 0,
+            timestamp: runEndedAt,
+            durationMs: runEndedAt - overallStartTime,
+            truncated,
+            artifactsDir,
+            cwd,
+            asyncDir,
+            sessionId: config.sessionId ?? undefined,
+            sessionFile: effectiveSessionFile,
+            intercomTarget: config.controlIntercomTarget,
+            shareUrl,
+            gistUrl,
+            shareError,
+            ...(taskIndex !== undefined && { taskIndex }),
+            ...(totalTasks !== undefined && { totalTasks }),
+        };
+        const saved = saveAsyncRunResult(id, resultData);
+        resultData.completionId = saved.completionId;
+        resultData.recordVersion = 3;
+        if (config.runtimeVersion !== 2 || path.resolve(resultPath) !== path.resolve(asyncDir, "result.json"))
+            writeAtomicJson(resultPath, resultData);
+    }
+    catch (err) {
+        console.error(`Failed to write result file ${resultPath}:`, err);
+    }
+}
+const configArg = process.argv[2];
+if (configArg) {
+    try {
+        const configJson = fs.readFileSync(configArg, "utf-8");
+        const config = JSON.parse(configJson);
+        try {
+            if (config.runtimeVersion !== 2)
+                fs.unlinkSync(configArg);
+        }
+        catch {
+            // Temp config cleanup is best effort.
+        }
+        runSubagent(config).catch((runErr) => {
+            console.error("Subagent runner error:", runErr);
+            process.exit(1);
+        });
+    }
+    catch (err) {
+        console.error("Subagent runner error:", err);
+        process.exit(1);
+    }
+}
+else {
+    let input = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+        input += chunk;
+    });
+    process.stdin.on("end", () => {
+        try {
+            const config = JSON.parse(input);
+            runSubagent(config).catch((runErr) => {
+                console.error("Subagent runner error:", runErr);
+                process.exit(1);
+            });
+        }
+        catch (err) {
+            console.error("Subagent runner error:", err);
+            process.exit(1);
+        }
+    });
+}