@fitchmultz/pi-subagents 0.44.7 → 0.45.0

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

@@ -1,1872 +1,81 @@
-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(),
+import { appendJsonl } from "../../shared/artifacts.js";
+import { saveRunStatus } from "../shared/supervisor-questions.js";
+import { parseSubagentRunConfig } from "./run-schemas.js";
+import { createRunnerStatus } from "./runner-initial-status.js";
+import { RunnerMonitor } from "./runner-monitor.js";
+import { RunnerLifecycle } from "./runner-lifecycle.js";
+import { RunnerWorkflow } from "./runner-workflow.js";
+import { completeRunner } from "./runner-completion.js";
+async function runSubagent(config) {
+    const startedAt = Date.now();
+    const status = createRunnerStatus(config, startedAt);
+    fs.mkdirSync(config.asyncDir, { recursive: true });
+    writeAtomicJson(path.join(config.asyncDir, "status.json"), status);
+    if (config.runtimeVersion !== 2) {
+        saveRunStatus(config.id, status);
+    }
+    const monitor = new RunnerMonitor(config, status, startedAt);
+    const lifecycle = new RunnerLifecycle(config, status, monitor);
+    lifecycle.start(startedAt);
+    appendJsonl(path.join(config.asyncDir, "events.jsonl"), JSON.stringify({
+        type: "subagent.run.started",
+        ts: startedAt,
+        runId: config.id,
+        mode: status.mode,
+        cwd: config.cwd,
+        pid: process.pid,
     }));
-    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;
+        const evidence = await new RunnerWorkflow(config, monitor, lifecycle).run(startedAt);
+        await completeRunner(config, evidence, monitor, lifecycle);
     }
     finally {
-        fs.closeSync(outputFd);
+        lifecycle.dispose();
     }
 }
-function resolvePiPackageRootFallback() {
-    const root = resolveInstalledPiPackageRoot();
-    if (root)
-        return root;
-    throw new Error(`Could not resolve ${PI_CODING_AGENT_PACKAGE} package root`);
+function runnerError(error) {
+    console.error("Subagent runner error:", error);
+    process.exit(1);
 }
-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;
+function launchConfig(text, file) {
+    const value = JSON.parse(text);
+    const config = parseSubagentRunConfig(value);
+    if (file !== undefined && config.runtimeVersion !== 2) {
         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;
+            fs.unlinkSync(file);
         }
-    }
-    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.";
+        catch {
+            /* Legacy temporary configuration cleanup is best effort. */
         }
     }
-    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);
-    }
+    runSubagent(config).catch(runnerError);
 }
-const configArg = process.argv[2];
-if (configArg) {
+const configArg = process.argv.at(2);
+if (configArg !== undefined && configArg.length > 0) {
     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);
-        });
+        launchConfig(fs.readFileSync(configArg, "utf-8"), configArg);
     }
-    catch (err) {
-        console.error("Subagent runner error:", err);
-        process.exit(1);
+    catch (error) {
+        runnerError(error);
     }
 }
 else {
     let input = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
-        input += chunk;
+        if (typeof chunk === "string") {
+            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);
-            });
+            launchConfig(input);
         }
-        catch (err) {
-            console.error("Subagent runner error:", err);
-            process.exit(1);
+        catch (error) {
+            runnerError(error);
         }
     });
 }