@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/runs/background/run-status.js

@@ -1,274 +0,0 @@
-import { formatAsyncRunList, listAsyncRuns } from "./async-status.js";
-import { buildManagementControl, formatRunAction } from "../../shared/status-format.js";
-import { ASYNC_DIR, RESULTS_DIR, } from "../../shared/types.js";
-import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { exactAsyncRunLocation, resolveAsyncRunLocation } from "./async-run-location.js";
-import { resolveSubagentRunId } from "./run-id-resolver.js";
-import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, findNestedRun, } from "../shared/nested-events.js";
-import { readAsyncResultFile } from "./async-result-file.js";
-import { readStatus } from "../../shared/utils.js";
-import { ASYNC_COMPLETION_REMINDER, hasExistingSessionFile, normalizedState, } from "./run-status-contracts.js";
-import { canExtend, formatNestedExactStatus, formatResumeGuidance, runtimeHeader, runtimeSteps, runtimeFooter, } from "./run-status-render.js";
-import { errorMessage, hasText } from "./async-value.js";
-function errorResult(message) {
-    return {
-        content: [{ type: "text", text: message }],
-        isError: true,
-        details: { mode: "single", results: [] },
-    };
-}
-function completionTargetsSession(run, state) {
-    return (state === undefined || (hasText(run.sessionId) && run.sessionId === state.currentSessionId));
-}
-function nestedCompletionTargetsSession(rootRunId, asyncDirRoot, state) {
-    if (!state || state.ownedRuns?.has(rootRunId) === true) {
-        return true;
-    }
-    const tracked = state.asyncJobs.get(rootRunId);
-    if (tracked) {
-        return completionTargetsSession(tracked, state);
-    }
-    try {
-        const location = exactAsyncRunLocation(rootRunId, asyncDirRoot, RESULTS_DIR);
-        const status = location.asyncDir === null ? null : readStatus(location.asyncDir);
-        return status === null ? false : completionTargetsSession(status, state);
-    }
-    catch {
-        return false;
-    }
-}
-function listControl(run) {
-    const running = run.steps.find((step) => step.status === "running");
-    const target = running
-        ? resolveSubagentIntercomTarget(run.id, running.agent, running.index)
-        : undefined;
-    const resumable = run.steps.find((step) => hasExistingSessionFile(step.sessionFile));
-    return buildManagementControl({
-        state: normalizedState(run.state),
-        runId: run.id,
-        index: running?.index ?? resumable?.index,
-        intercomTarget: target,
-        canNudge: running !== undefined,
-        canResume: running !== undefined ||
-            resumable !== undefined ||
-            (run.steps.length <= 1 && hasExistingSessionFile(run.sessionFile)),
-        canInterrupt: run.state === "running",
-    });
-}
-function inspectList(deps) {
-    if (deps.nested) {
-        return errorResult("Child-safe subagent status requires a run id.");
-    }
-    const runs = listAsyncRuns(deps.asyncDirRoot ?? ASYNC_DIR, {
-        resultsDir: deps.resultsDir ?? RESULTS_DIR,
-        kill: deps.kill,
-        now: deps.now,
-    }).filter((run) => completionTargetsSession(run, deps.state));
-    const text = formatAsyncRunList(runs, "Async runs");
-    const reminder = runs.some((run) => run.state === "running" || run.state === "queued");
-    return {
-        content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
-        details: { mode: "single", results: [], managementControls: runs.map(listControl) },
-    };
-}
-function inspectNested(nested, deps) {
-    const children = reconcileNestedAsyncDescendants(nested.match.route, {
-        resultsDir: deps.resultsDir ?? RESULTS_DIR,
-        kill: deps.kill,
-        now: deps.now,
-    });
-    const run = findNestedRun(children, nested.id) ?? nested.match.run;
-    const state = normalizedState(run.state);
-    const text = formatNestedExactStatus(nested.match.rootRunId, run, deps.nested !== undefined);
-    const reminder = state === "live" &&
-        nestedCompletionTargetsSession(nested.match.rootRunId, deps.asyncDirRoot ?? ASYNC_DIR, deps.state);
-    return {
-        content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
-        details: {
-            mode: "single",
-            results: [],
-            managementControl: buildManagementControl({
-                state,
-                runId: run.id,
-                intercomTarget: run.intercomTarget ?? run.leafIntercomTarget,
-                canNudge: false,
-                canResume: state === "live" || hasText(run.sessionFile),
-                canInterrupt: state === "live",
-            }),
-        },
-    };
-}
-function resolveInspection(params, deps) {
-    const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-    const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-    const requestedId = params.id ?? params.runId;
-    if (!hasText(params.dir) && hasText(requestedId)) {
-        const resolved = resolveSubagentRunId(requestedId, {
-            asyncDirRoot,
-            resultsDir,
-            state: deps.state,
-            nested: deps.nested,
-        });
-        if (resolved?.kind === "nested") {
-            return inspectNested(resolved, deps);
-        }
-        return resolved?.kind === "async"
-            ? resolved.location
-            : { asyncDir: null, resultPath: null, resolvedId: requestedId };
-    }
-    return resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
-}
-function nestedProjection(status, deps) {
-    let children = [];
-    try {
-        const route = findNestedRouteForRootId(status.runId);
-        if (route) {
-            children = reconcileNestedAsyncDescendants(route, {
-                resultsDir: deps.resultsDir ?? RESULTS_DIR,
-                kill: deps.kill,
-                now: deps.now,
-            });
-        }
-        // Step attachment happens on a fresh display projection, never persisted status.
-        return { children };
-    }
-    catch (error) {
-        return { children, warning: `Nested status unavailable: ${errorMessage(error)}` };
-    }
-}
-function runtimeControl(status) {
-    const state = normalizedState(status.state);
-    const steps = (status.steps ?? []).map((step, index) => ({ step, index }));
-    const running = steps.find(({ step }) => step.status === "running");
-    const target = running
-        ? resolveSubagentIntercomTarget(status.runId, running.step.agent, running.index)
-        : undefined;
-    const resumable = steps.find(({ step }) => hasExistingSessionFile(step.sessionFile));
-    const persisted = resumable !== undefined || (steps.length <= 1 && hasExistingSessionFile(status.sessionFile));
-    return buildManagementControl({
-        state,
-        runId: status.runId,
-        index: running?.index ?? resumable?.index,
-        intercomTarget: target,
-        canNudge: running !== undefined,
-        canResume: state === "live" ? running !== undefined : persisted,
-        canInterrupt: status.state === "running",
-        canExtend: canExtend(status),
-    });
-}
-function inspectRuntime(asyncDir, deps) {
-    const reconciliation = reconcileAsyncRun(asyncDir, {
-        resultsDir: deps.resultsDir ?? RESULTS_DIR,
-        kill: deps.kill,
-        now: deps.now,
-    });
-    const status = reconciliation.status;
-    if (!status) {
-        return undefined;
-    }
-    const nested = nestedProjection(status, deps);
-    const projected = { ...status, steps: status.steps?.map((step) => ({ ...step })) };
-    attachRootChildrenToSteps(status.runId, projected.steps, nested.children);
-    const steps = runtimeSteps(projected, asyncDir, deps);
-    const lines = [
-        ...runtimeHeader(projected, asyncDir, deps, reconciliation),
-        ...steps.lines,
-        ...runtimeFooter(projected, asyncDir, deps, nested),
-    ];
-    if ((status.state === "running" || status.state === "queued") &&
-        completionTargetsSession(status, deps.state)) {
-        lines.push(ASYNC_COMPLETION_REMINDER);
-    }
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: {
-            mode: "single",
-            results: [],
-            intercomTargets: steps.intercomTargets,
-            managementControl: runtimeControl(status),
-        },
-    };
-}
-function savedResultLines(data, resultPath, runId, options) {
-    const lines = [
-        ...(options.includeRunHeader !== false
-            ? [`Run: ${runId ?? "unknown"}`, `State: ${data.terminalState}`]
-            : []),
-        `${options.includeRunHeader === false ? "Runtime result" : "Result"}: ${resultPath}`,
-        `Status: ${formatRunAction("status", runId ?? "unknown", {}, options.childSafe)}`,
-    ];
-    const children = data.results ??
-        (hasText(data.agent) ? [{ agent: data.agent, sessionFile: data.sessionFile }] : []);
-    lines.push(formatResumeGuidance(runId, children, data.sessionFile, options.childSafe));
-    if (hasText(data.summary)) {
-        const summary = options.full === true || data.summary.length <= 600
-            ? data.summary
-            : `${data.summary.slice(0, 599)}…`;
-        lines.push("", summary);
-    }
-    return lines;
-}
-function inspectResult(resultPath, resolvedId, params, deps) {
-    const data = readAsyncResultFile(resultPath);
-    const runId = data.runId ?? data.id ?? resolvedId;
-    const lines = savedResultLines(data, resultPath, runId, {
-        includeRunHeader: deps.includeRunHeader,
-        childSafe: deps.nested !== undefined,
-        full: params.full,
-    });
-    const children = data.results ??
-        (hasText(data.agent) ? [{ agent: data.agent, sessionFile: data.sessionFile }] : []);
-    const state = normalizedState(data.terminalState);
-    const resumable = children
-        .map((child, index) => ({ child, index }))
-        .find(({ child }) => hasExistingSessionFile(child.sessionFile));
-    return {
-        content: [{ type: "text", text: lines.join("\n") }],
-        details: {
-            mode: "single",
-            results: [],
-            managementControl: buildManagementControl({
-                state,
-                runId: runId ?? "unknown",
-                index: resumable?.index,
-                canResume: state !== "live" && resumable !== undefined,
-            }),
-        },
-    };
-}
-function inspectLocation(location, params, deps) {
-    if (location.asyncDir === null && location.resultPath === null) {
-        return errorResult("Async run not found. Provide id or dir.");
-    }
-    if (location.asyncDir !== null) {
-        const runtime = inspectRuntime(location.asyncDir, deps);
-        if (runtime) {
-            return runtime;
-        }
-    }
-    if (location.resultPath !== null) {
-        try {
-            return inspectResult(location.resultPath, location.resolvedId, params, deps);
-        }
-        catch (error) {
-            return errorResult(`Failed to read async result file: ${errorMessage(error)}`);
-        }
-    }
-    return errorResult("Status file not found.");
-}
-export function inspectSubagentStatus(params, deps = {}) {
-    try {
-        if (!hasText(params.id) && !hasText(params.runId) && !hasText(params.dir)) {
-            return inspectList(deps);
-        }
-        const location = resolveInspection(params, deps);
-        if ("content" in location) {
-            return location;
-        }
-        return inspectLocation(location, params, deps);
-    }
-    catch (error) {
-        return errorResult(errorMessage(error));
-    }
-}

package/dist/runs/background/runner-attempt-output.js

@@ -1,155 +0,0 @@
-import { detectSubagentError } from "../../shared/utils.js";
-import { hasCompletedMutationToolCall, resolveCompletionPolicy, } from "../shared/completion-guard.js";
-import { readStructuredOutput } from "../shared/structured-output.js";
-import { resolveSingleOutput } from "../shared/single-output.js";
-import { readFinalizationReport, resolveFinalizationOutput, stripAcceptanceReport, } from "../shared/acceptance.js";
-export 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 processFailure(step, run) {
-    if (run.error !== undefined && run.error.length > 0) {
-        return run.error;
-    }
-    if (run.exitCode === 0) {
-        return;
-    }
-    const reason = formatProcessExitFailure({
-        agent: step.agent,
-        exitCode: run.exitCode,
-        durationMs: run.durationMs,
-    });
-    const stderr = run.stderr.trim();
-    return stderr.length === 0 ? reason : `${reason}\n${stderr}`;
-}
-function hiddenFailure(error) {
-    if (error?.hasError !== true) {
-        return;
-    }
-    return error.details !== undefined && error.details.length > 0
-        ? `${error.errorType ?? "Subagent"} failed (exit ${error.exitCode ?? 1}): ${error.details}`
-        : `${error.errorType ?? "Subagent"} failed with exit code ${error.exitCode ?? 1}`;
-}
-function completionGuard(step, run, review) {
-    return (review === undefined &&
-        resolveCompletionPolicy({
-            completionGuardEnabled: step.completionGuard === true,
-            usesAcceptanceContract: step.effectiveAcceptance?.explicit === true,
-        }) === "mutation-guard" &&
-        !run.observedCompletedMutation &&
-        !hasCompletedMutationToolCall(run.messages));
-}
-function resolveAttemptOutput(step, fullOutput, input) {
-    if (input.context.initialSegment) {
-        return input.context.initialSegment.event.resolvedOutput;
-    }
-    if (step.outputPath === undefined ||
-        step.outputPath.length === 0 ||
-        input.exitCode !== 0 ||
-        input.run.interrupted === true ||
-        (input.reportSubmission?.reportSubmissionError !== undefined &&
-            input.reportSubmission.reportSubmissionError.length > 0)) {
-        return { fullOutput };
-    }
-    return resolveSingleOutput(step.outputPath, fullOutput, input.context.outputSnapshot);
-}
-/** Classifies a completed attempt, validates structured output and publishes its single output. */
-export function interpretAttemptOutput(step, run, context) {
-    const { reportSubmission, hiddenError, structured, successful } = analyzeAttempt(run, context);
-    const guardTriggered = successful && completionGuard(step, run, context.review);
-    const error = attemptError(step, run, {
-        guardTriggered,
-        structuredError: structured?.error,
-        hiddenError,
-    });
-    const exitCode = failureExitCode(run.exitCode, {
-        guardTriggered,
-        structuredError: structured?.error,
-        hiddenError,
-        error,
-    });
-    const { finalOutput, fullOutput } = attemptText(run, reportSubmission, context.review);
-    const resolvedOutput = resolveAttemptOutput(step, fullOutput, {
-        context,
-        run,
-        exitCode,
-        reportSubmission,
-    });
-    const state = outputState(step, resolvedOutput, error, exitCode);
-    return {
-        ...run,
-        ...state,
-        model: context.model ?? run.model,
-        structuredOutput: structured?.value,
-        reportSubmission,
-        finalOutput,
-        resolvedOutput,
-        completionGuardTriggered: guardTriggered,
-        terminalFailure: terminalFailure(guardTriggered, structured?.error, hiddenError, resolvedOutput.saveError),
-    };
-}
-function attemptError(step, run, input) {
-    if (input.guardTriggered) {
-        return "Subagent completed without making edits required by completionGuard: true.\nUse an acceptance contract when a valid no-op is allowed.";
-    }
-    return input.structuredError ?? hiddenFailure(input.hiddenError) ?? processFailure(step, run);
-}
-function attemptText(run, report, review) {
-    const finalOutput = report?.output ?? run.finalOutput;
-    const fullOutput = review === undefined
-        ? stripAcceptanceReport(finalOutput)
-        : resolveFinalizationOutput(finalOutput, review.previousOutput);
-    return { finalOutput, fullOutput };
-}
-function hiddenAttemptFailure(run, report) {
-    return successfulProcess(run) && (report === undefined || report.output.length === 0)
-        ? detectSubagentError(run.messages)
-        : undefined;
-}
-function analyzeAttempt(run, context) {
-    const reportSubmission = context.review?.reportRuntime
-        ? readFinalizationReport(run.messages, context.review.reportRuntime, {
-            structuredResult: context.structuredResult,
-        })
-        : undefined;
-    const hiddenError = hiddenAttemptFailure(run, reportSubmission);
-    const successful = successfulProcess(run) && hiddenError?.hasError !== true && run.interrupted !== true;
-    const structured = successful && context.review === undefined && context.structuredRuntime
-        ? readStructuredOutput(context.structuredRuntime)
-        : undefined;
-    return { reportSubmission, hiddenError, structured, successful };
-}
-function successfulProcess(run) {
-    return run.exitCode === 0 && (run.error === undefined || run.error.length === 0);
-}
-function terminalFailure(guard, structuredError, hiddenError, saveError) {
-    return (guard ||
-        (structuredError !== undefined && structuredError.length > 0) ||
-        hiddenError?.hasError === true ||
-        (saveError !== undefined && saveError.length > 0));
-}
-function outputState(step, resolvedOutput, error, exitCode) {
-    if (resolvedOutput.saveError !== undefined && resolvedOutput.saveError.length > 0) {
-        return {
-            exitCode: 1,
-            error: `Failed to save output file '${step.outputPath ?? ""}': ${resolvedOutput.saveError}`,
-        };
-    }
-    return { error, exitCode };
-}
-function failureExitCode(exitCode, input) {
-    if (input.guardTriggered ||
-        (input.structuredError !== undefined && input.structuredError.length > 0)) {
-        return 1;
-    }
-    if (input.hiddenError?.hasError === true) {
-        return input.hiddenError.exitCode ?? 1;
-    }
-    if (input.error !== undefined && input.error.length > 0 && exitCode === 0) {
-        return 1;
-    }
-    return exitCode;
-}

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

@@ -1,263 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { interpretAttemptOutput, formatProcessExitFailure, } from "./runner-attempt-output.js";
-import { runPiStreaming } from "./runner-streaming.js";
-import { captureSingleOutputSnapshot } from "../shared/single-output.js";
-import { cleanupTempDir } from "../shared/pi-args.js";
-import { isClaudeCodeModel } from "../shared/claude-code.js";
-import { buildChildInvocation, } from "../shared/child-attempt.js";
-import { createNativeFinalization } from "../shared/native-finalization.js";
-import { compactForegroundResult } from "../../shared/utils.js";
-import { resolveEffectiveThinking } from "../../shared/model-info.js";
-import { resolveExecutionOutcome } from "../shared/acceptance.js";
-function emptyUsage() {
-    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-function nativeSegmentError(segment, agent) {
-    const state = segment.execution;
-    if (state?.error !== undefined) {
-        return state.error;
-    }
-    if (segment.event.submission.error !== undefined) {
-        return segment.event.submission.error;
-    }
-    const exitCode = state?.exitCode ?? 0;
-    if (exitCode === 0 || state?.interrupted === true) {
-        return;
-    }
-    return formatProcessExitFailure({ agent, exitCode, durationMs: segment.durationMs });
-}
-function nativeSegmentState(segment, error) {
-    const { exitCode = 0, interrupted, timedOut, resourceLimitExceeded, terminalFailure, } = segment.execution ?? {};
-    const submissionError = segment.event.submission.error;
-    return {
-        exitCode: error !== undefined && error.length > 0 && exitCode === 0 ? 1 : exitCode,
-        interrupted,
-        timedOut,
-        resourceLimitExceeded,
-        terminalFailure: (submissionError !== undefined && submissionError.length > 0) || terminalFailure,
-    };
-}
-export class RunnerAttempt {
-    nativeExecution;
-    nativeSegments = [];
-    toolCount = 0;
-    toolCalls = [];
-    eventsPath;
-    step;
-    ctx;
-    environment;
-    constructor(step, ctx, environment) {
-        this.step = step;
-        this.ctx = ctx;
-        this.environment = environment;
-        this.eventsPath = path.join(path.dirname(ctx.outputFile), "events.jsonl");
-    }
-    nativeAttempt(segment) {
-        const nativeExecution = this.nativeExecution;
-        if (nativeExecution === undefined) {
-            throw new Error("Native segment requires a finalized execution.");
-        }
-        const error = nativeSegmentError(segment, this.step.agent);
-        return {
-            ...nativeExecution,
-            ...nativeSegmentState(segment, error),
-            error,
-            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 run(prompt, model, review) {
-        const { step, ctx } = this;
-        const { verificationSignal, effectiveStructuredOutput } = this.environment;
-        if (verificationSignal.aborted) {
-            return this.abortedAttempt(model);
-        }
-        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.
-            }
-        }
-        const nativeFinalization = this.nativeFinalization(model, review, structuredRuntime);
-        let built;
-        try {
-            built = this.buildInvocation(prompt, model, {
-                review,
-                structuredRuntime,
-                nativeFinalization,
-            });
-        }
-        catch (error) {
-            if (nativeFinalization) {
-                cleanupTempDir(path.dirname(nativeFinalization.reportRuntime.schemaPath));
-            }
-            const message = error instanceof Error ? error.message : "Failed to prepare child invocation.";
-            return this.failedPreparation(model, message);
-        }
-        const runResult = await this.executeInvocation(built, {
-            model,
-            review,
-            structuredRuntime,
-            nativeFinalization,
-        });
-        const adopted = this.adoptNativeRun(runResult, nativeFinalization !== undefined);
-        return interpretAttemptOutput(step, adopted.run, {
-            model,
-            review,
-            structuredRuntime,
-            outputSnapshot,
-            initialSegment: adopted.initialSegment,
-            structuredResult: built.claudeCodeInvocation !== undefined,
-        });
-    }
-    abortedAttempt(model) {
-        const outcome = resolveExecutionOutcome({
-            result: { exitCode: 1 },
-            signal: this.ctx.signal,
-            interruptSignal: this.environment.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: "" },
-        };
-    }
-    nativeFinalization(model, review, runtime) {
-        const acceptance = this.step.effectiveAcceptance;
-        if (this.ctx.nativeFinalization !== true ||
-            review !== undefined ||
-            isClaudeCodeModel(model) ||
-            acceptance?.explicit !== true) {
-            return;
-        }
-        return createNativeFinalization(acceptance, runtime, this.step.outputPath);
-    }
-    adoptNativeRun(run, enabled) {
-        const initialSegment = enabled ? run.finalization?.at(0) : undefined;
-        if (initialSegment === undefined) {
-            return { run };
-        }
-        this.nativeExecution = run;
-        this.nativeSegments = run.finalization?.slice(1) ?? [];
-        return { run: this.nativeAttempt(initialSegment), initialSegment };
-    }
-    failedPreparation(model, message) {
-        return {
-            stderr: message,
-            exitCode: 1,
-            messages: [],
-            usage: emptyUsage(),
-            durationMs: 0,
-            observedCompletedMutation: false,
-            model,
-            error: message,
-            finalOutput: message,
-            terminalFailure: true,
-            resolvedOutput: { fullOutput: message },
-        };
-    }
-    buildInvocation(prompt, model, input) {
-        const { step, ctx } = this;
-        const { review, structuredRuntime, nativeFinalization } = input;
-        const { sessionEnabled, sessionDir } = this.environment;
-        const sessionFile = review?.sessionFile ?? step.sessionFile;
-        return 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,
-        });
-    }
-    async executeInvocation(built, input) {
-        const { step, ctx, eventsPath } = this;
-        const { interruptSignal } = this.environment;
-        const { args, env, tempDir, claudeCodeInvocation } = built;
-        const { model, review, structuredRuntime, nativeFinalization } = input;
-        const sessionFile = review?.sessionFile ?? step.sessionFile;
-        try {
-            return 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") {
-                        this.toolCount++;
-                    }
-                    if (event.type === "message_end" && event.message?.role === "assistant") {
-                        this.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));
-            }
-        }
-    }
-}