@fitchmultz/pi-subagents 0.49.0 → 0.50.0

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

@@ -1,173 +0,0 @@
-import * as fs from "node:fs";
-import { appendJsonl } from "../../shared/artifacts.js";
-import { readChildProcessIdentity } from "../../shared/post-exit-stdio-guard.js";
-import { extractToolArgsPreview } from "../../shared/utils.js";
-import { runChildAttempt, } from "../shared/child-attempt.js";
-import { FINALIZATION_EVENT } from "../shared/native-finalization.js";
-import { saveQuestionContract } from "../shared/supervisor-questions.js";
-// Durable records omit repetitive progress deltas, but the live consumer sees every event.
-const TRANSIENT_CHILD_EVENT_TYPES = new Set(["message_update", "tool_execution_update"]);
-function hasBoundaryIdentity(value) {
-    return ("type" in value &&
-        value.type === FINALIZATION_EVENT &&
-        "nonce" in value &&
-        typeof value.nonce === "string" &&
-        (!("lastEntryId" in value) || typeof value.lastEntryId === "string"));
-}
-function hasBoundaryCounters(value) {
-    return ("turn" in value &&
-        typeof value.turn === "number" &&
-        "messageCount" in value &&
-        typeof value.messageCount === "number" &&
-        "at" in value &&
-        typeof value.at === "number");
-}
-function isBoundaryMarker(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        hasBoundaryIdentity(value) &&
-        hasBoundaryCounters(value));
-}
-class ChildAudit {
-    context;
-    outputFile;
-    constructor(context, outputFile) {
-        this.context = context;
-        this.outputFile = outputFile;
-    }
-    append(event) {
-        appendJsonl(this.context.eventsPath, JSON.stringify({
-            ...event,
-            recordVersion: 3,
-            subagentSource: "child",
-            subagentRunId: this.context.runId,
-            subagentStepIndex: this.context.stepIndex,
-            subagentAgent: this.context.agent,
-            observedAt: Date.now(),
-        }));
-    }
-    record(event, result) {
-        if (TRANSIENT_CHILD_EVENT_TYPES.has(event.type ?? "")) {
-            return;
-        }
-        if (event.type === "subagent.native_baseline") {
-            this.append(event);
-            saveQuestionContract(this.context.runId, this.context.stepIndex, {
-                attemptBaseline: result.attemptBaseline,
-                baselineSource: "native-migration",
-            });
-            return;
-        }
-        if (event.type === "subagent.native") {
-            this.append(event);
-            saveQuestionContract(this.context.runId, this.context.stepIndex, {
-                nativeSessionId: result.nativeSessionId,
-                terminalLeafId: result.terminalLeafId,
-                effectiveConfiguration: result.effectiveConfiguration,
-                updatedAt: Date.now(),
-            });
-            return;
-        }
-        if (isBoundaryMarker(event)) {
-            const file = `${this.outputFile}.boundaries.jsonl`;
-            fs.appendFileSync(file, `${JSON.stringify(event)}\n`, { mode: 0o600 });
-            this.append({
-                type: event.type,
-                nonce: event.nonce,
-                turn: event.turn,
-                lastEntryId: event.lastEntryId,
-                messageCount: event.messageCount,
-                at: event.at,
-                boundaryFile: file,
-            });
-            return;
-        }
-        this.append({
-            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: `${this.outputFile}.audit.log` } : {}),
-        });
-    }
-    finalized(result) {
-        this.append({
-            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: this.outputFile,
-        });
-        saveQuestionContract(this.context.runId, this.context.stepIndex, {
-            nativeSessionId: result.nativeSessionId,
-            terminalLeafId: result.terminalLeafId,
-            terminalEntryId: result.terminalEntryId,
-            effectiveConfiguration: result.effectiveConfiguration,
-            accounting: result.accounting,
-            auditPath: result.auditPath,
-            updatedAt: Date.now(),
-        });
-    }
-}
-export async function runPiStreaming(options, outputFile, context) {
-    const outputFd = fs.openSync(outputFile, "w", 0o600);
-    const audit = new ChildAudit(context, outputFile);
-    let outputWritten = false;
-    try {
-        const result = await runChildAttempt({
-            ...options,
-            auditPath: `${outputFile}.audit.log`,
-            onStart: (control, started) => {
-                if (control.pid !== undefined && control.pid !== 0) {
-                    saveQuestionContract(context.runId, context.stepIndex, {
-                        pid: control.pid,
-                        processIdentity: readChildProcessIdentity(control.pid),
-                        sessionFile: options.sessionFile,
-                        attemptBaseline: started.attemptBaseline,
-                        updatedAt: Date.now(),
-                    });
-                }
-                options.onStart?.(control, started);
-            },
-            onOutput: (text) => {
-                fs.writeFileSync(outputFd, text);
-                outputWritten ||= text.length > 0;
-            },
-            onStderr: (text) => {
-                audit.append({
-                    type: "subagent.child.stderr",
-                    auditPath: `${outputFile}.audit.log`,
-                    length: Buffer.byteLength(text),
-                });
-            },
-            onEvent: (event, observed, mutation) => {
-                // Preserve callback ordering: disk publication follows the live owner update.
-                options.onEvent?.(event, observed, mutation);
-                audit.record(event, observed);
-            },
-        });
-        // Native recovery and non-streaming providers can finalize text without publishing deltas.
-        // onOutput can change outputWritten while the child attempt is awaiting stream completion.
-        // oxlint-disable-next-line typescript/no-unnecessary-condition
-        if (!outputWritten && result.finalOutput.length > 0) {
-            fs.writeFileSync(outputFd, `${result.finalOutput}\n`);
-        }
-        audit.finalized(result);
-        return result;
-    }
-    finally {
-        fs.closeSync(outputFd);
-    }
-}

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

@@ -1,213 +0,0 @@
-import * as path from "node:path";
-import { inspect } from "node:util";
-import { appendJsonl } from "../../shared/artifacts.js";
-import { renderChainTask } from "../shared/chain-outputs.js";
-import { flattenSteps, isParallelGroup, isDynamicRunnerGroup, MAX_PARALLEL_CONCURRENCY, } from "../shared/parallel-utils.js";
-import { completeWorkflowStep, runParallelTasks, workflowChildSucceeded, } from "../shared/workflow-policy.js";
-import { appendWorktreeSummary } from "../shared/worktree.js";
-import { RunnerChildExecutor } from "./runner-child-executor.js";
-import { RunnerParallelGroup } from "./runner-parallel.js";
-import { prepareDynamicGroup } from "./runner-dynamic.js";
-/** Owns chain output admission, flattened scheduling position and completed child records. */
-export class RunnerWorkflow {
-    config;
-    monitor;
-    lifecycle;
-    executor;
-    outputs = {};
-    results = [];
-    worktreeSummaries = [];
-    previousOutput = "";
-    flatIndex = 0;
-    workflowComplete = false;
-    setupCleanupWarning = "";
-    flatStepCount;
-    constructor(config, monitor, lifecycle) {
-        this.config = config;
-        this.monitor = monitor;
-        this.lifecycle = lifecycle;
-        this.flatStepCount = flattenSteps(config.steps).length;
-        this.executor = new RunnerChildExecutor(config, monitor, lifecycle, (template, item) => this.renderTask(template, item));
-    }
-    async run(overallStartTime) {
-        for (const [stepIndex, step] of this.config.steps.entries()) {
-            if (this.lifecycle.interrupted || this.lifecycle.cancellation.signal.aborted) {
-                break;
-            }
-            let advance;
-            if (isDynamicRunnerGroup(step)) {
-                // Each group depends on outputs admitted by the previous group.
-                // oxlint-disable-next-line no-await-in-loop
-                advance = await this.runDynamic(step, stepIndex);
-            }
-            else if (isParallelGroup(step)) {
-                // Complete worktree cleanup before admitting the next workflow step.
-                // oxlint-disable-next-line no-await-in-loop
-                advance = await this.runParallel(step, stepIndex);
-            }
-            else {
-                // Sequential chain tasks consume the preceding child's completed output.
-                // oxlint-disable-next-line no-await-in-loop
-                advance = await this.runSequential(step, stepIndex);
-            }
-            if (!advance) {
-                break;
-            }
-        }
-        return {
-            results: this.results,
-            outputs: this.outputs,
-            worktreeSummaries: this.worktreeSummaries,
-            setupCleanupWarning: this.setupCleanupWarning,
-            overallStartTime,
-            latestSessionFile: this.executor.latestSessionFile,
-            workflowComplete: this.workflowComplete,
-        };
-    }
-    renderTask(template, item) {
-        const { config } = this;
-        if (config.resultMode === "single" || config.resultMode === "parallel") {
-            return template;
-        }
-        return renderChainTask(template, {
-            originalTask: config.originalTask,
-            previousOutput: this.previousOutput,
-            chainDir: config.chainDir,
-            outputs: this.outputs,
-            item,
-        }, config.placeholder);
-    }
-    recordCompletion(completion, results) {
-        this.results.push(...results.map((result) => ({ ...result, success: workflowChildSucceeded(result) })));
-        Object.assign(this.outputs, completion.outputs);
-        this.monitor.statusPayload.outputs = this.outputs;
-        this.previousOutput = completion.previousOutput;
-        this.workflowComplete = completion.complete;
-    }
-    async runSequential(step, stepIndex) {
-        let advance = false;
-        await this.executor.run({
-            task: step,
-            flatIndex: this.flatIndex,
-            taskCwd: this.config.cwd,
-            sessionDir: this.config.sessionDir,
-            flatStepCount: this.flatStepCount,
-            sequential: true,
-            trackSession: true,
-            notifyCompletionGuard: true,
-            beforeFinish: (result) => {
-                const completion = completeWorkflowStep({
-                    stepIndex,
-                    stepCount: this.config.steps.length,
-                    results: [result],
-                    previousOutput: this.previousOutput,
-                    outputNames: [step.outputName],
-                });
-                this.recordCompletion(completion, [result]);
-                advance = completion.advance;
-            },
-        });
-        this.flatIndex++;
-        return advance;
-    }
-    async runDynamic(step, stepIndex) {
-        let plan;
-        try {
-            plan = prepareDynamicGroup(step, this.outputs, {
-                stepIndex,
-                chainDir: this.config.chainDir ?? this.config.cwd,
-                maxItems: this.config.dynamicFanoutMaxItems,
-            });
-        }
-        catch (error) {
-            this.monitor.failDynamicStep(stepIndex, this.flatIndex, error instanceof Error ? error.message : inspect(error));
-            return false;
-        }
-        this.monitor.expandChildren(plan, step, { stepIndex, flatIndex: this.flatIndex });
-        const results = await this.executeDynamic(step, stepIndex, plan);
-        this.flatIndex += plan.tasks.length;
-        const completion = completeWorkflowStep({
-            stepIndex,
-            stepCount: this.config.steps.length,
-            results,
-            previousOutput: this.previousOutput,
-            dynamic: { step, items: plan.materialized.items },
-        });
-        this.recordCompletion(completion, results);
-        if (completion.error !== undefined && completion.error.length > 0) {
-            this.monitor.statusPayload.error = completion.error;
-        }
-        const error = completion.error ?? results[completion.failedIndices[0]]?.error;
-        this.monitor.markDynamicGraphGroup(stepIndex, dynamicGraphStatus(completion.status), error);
-        this.appendGroupCompletion("dynamic", stepIndex, completion);
-        this.monitor.statusPayload.lastUpdate = Date.now();
-        this.monitor.writeStatusPayload();
-        return completion.advance;
-    }
-    executeDynamic(step, stepIndex, plan) {
-        const start = this.flatIndex;
-        const sessionDir = this.config.sessionDir;
-        return runParallelTasks({
-            tasks: plan.tasks,
-            concurrency: step.concurrency ?? MAX_PARALLEL_CONCURRENCY,
-            failFast: step.failFast,
-            signal: this.lifecycle.cancellation.signal,
-            interruptSignal: this.lifecycle.interruption.signal,
-            stoppedTask: (task, index, reason) => this.executor.stop(task, start + index, reason),
-            runTask: (task, index, interruptSignal) => this.executor.run({
-                task,
-                flatIndex: start + index,
-                interruptSignal,
-                item: { name: step.expand.item ?? "item", value: plan.materialized.items[index].item },
-                taskCwd: this.config.cwd,
-                sessionDir: sessionDir === undefined || sessionDir.length === 0
-                    ? undefined
-                    : path.join(sessionDir, `dynamic-${stepIndex}-${index}`),
-                flatStepCount: Math.max(this.monitor.statusPayload.steps.length, 1),
-            }),
-        });
-    }
-    async runParallel(group, stepIndex) {
-        const operation = new RunnerParallelGroup(this.config, this.monitor, this.lifecycle, this.executor);
-        return await operation.run(group, {
-            flatIndex: this.flatIndex,
-            stepIndex,
-            flatStepCount: this.flatStepCount,
-            previousOutput: this.previousOutput,
-        }, {
-            failed: (results, warning) => {
-                this.results.push(...results);
-                this.setupCleanupWarning = warning ?? this.setupCleanupWarning;
-                this.flatIndex += group.parallel.length;
-            },
-            completed: ({ results, completion, summary }) => {
-                this.flatIndex += group.parallel.length;
-                this.recordCompletion(completion, results);
-                this.previousOutput = completion.advance
-                    ? appendWorktreeSummary(completion.previousOutput, summary)
-                    : completion.previousOutput;
-                if (summary.length > 0) {
-                    this.worktreeSummaries.push(summary);
-                }
-                this.appendGroupCompletion("parallel", stepIndex, completion);
-                this.monitor.writeStatusPayload();
-            },
-        });
-    }
-    appendGroupCompletion(kind, stepIndex, completion) {
-        appendJsonl(path.join(this.config.asyncDir, "events.jsonl"), JSON.stringify({
-            type: `subagent.${kind}.completed`,
-            ts: Date.now(),
-            runId: this.config.id,
-            stepIndex,
-            success: completion.advance,
-            state: completion.status === "completed" ? "complete" : completion.status,
-        }));
-    }
-}
-function dynamicGraphStatus(status) {
-    if (status === "completed" || status === "blocked" || status === "paused") {
-        return status;
-    }
-    return "failed";
-}

package/dist/runs/background/stale-run-reconciler.js

@@ -1,198 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeAtomicJson } from "../../shared/atomic-json.js";
-import { RESULTS_DIR, } from "../../shared/types.js";
-import { normalizeParallelGroups } from "./parallel-groups.js";
-import { nestedSummaryFromAsyncStatus, projectNestedEvents, resolveNestedAsyncDir, writeNestedEvent, } from "../shared/nested-events.js";
-import { isDurableRun } from "./async-result-file.js";
-import { readRunJson } from "../shared/supervisor-questions.js";
-import { readStatus } from "../../shared/utils.js";
-import { buildFailedRepair, terminalStatusFromResult, writeFailedRepair, } from "./async-run-repair.js";
-import { errorCode, hasText } from "./async-value.js";
-function buildStartedStatus(asyncDir, startedRun, now) {
-    const startedAt = startedRun.startedAt ?? now;
-    const agents = (startedRun.agents?.length ?? 0) > 0 ? (startedRun.agents ?? []) : ["subagent"];
-    const count = startedRun.chainStepCount;
-    const groups = count === undefined
-        ? []
-        : normalizeParallelGroups(startedRun.parallelGroups, agents.length, count);
-    return {
-        runId: startedRun.runId.length > 0 ? startedRun.runId : path.basename(asyncDir),
-        sessionId: startedRun.sessionId,
-        mode: startedRun.mode ?? "single",
-        state: "running",
-        pid: startedRun.pid,
-        startedAt,
-        lastUpdate: now,
-        currentStep: 0,
-        chainStepCount: count,
-        ...(groups.length > 0 ? { parallelGroups: groups } : {}),
-        steps: agents.map((agent) => ({ agent, status: "running", startedAt })),
-        sessionFile: startedRun.sessionFile,
-    };
-}
-function terminal(state) {
-    return state === "complete" || state === "failed" || state === "blocked" || state === "paused";
-}
-function publishNestedRepair(result, route, child, ts) {
-    if (!result.status ||
-        isDurableRun(result.status) ||
-        (!result.repaired && !terminal(result.status.state))) {
-        return;
-    }
-    writeNestedEvent(route, {
-        type: terminal(result.status.state) ? "subagent.nested.completed" : "subagent.nested.updated",
-        ts,
-        parentRunId: child.parentRunId,
-        parentStepIndex: child.parentStepIndex,
-        child,
-    });
-}
-function projectedNestedChild(run, status, asyncDir, ts) {
-    const child = nestedSummaryFromAsyncStatus(status, asyncDir, {
-        id: run.id,
-        parentRunId: run.parentRunId,
-        parentStepIndex: run.parentStepIndex,
-        depth: run.depth,
-        path: run.path,
-        mode: run.mode,
-        ts,
-    });
-    const steps = child.steps?.map((step, index) => {
-        return { ...step, children: run.steps?.at(index)?.children };
-    });
-    return { ...child, steps };
-}
-function reconcileNestedRun(run, route, options) {
-    if (run.state !== "running" && run.state !== "queued") {
-        return run;
-    }
-    const asyncDir = resolveNestedAsyncDir(route.rootRunId, run);
-    if (!hasText(asyncDir)) {
-        return run;
-    }
-    const result = reconcileAsyncRun(asyncDir, {
-        ...options,
-        resultsDir: path.join(options.resultsDir ?? RESULTS_DIR, "nested", route.rootRunId),
-    });
-    if (!result.status) {
-        return run;
-    }
-    const ts = options.now?.() ?? Date.now();
-    const child = projectedNestedChild(run, result.status, asyncDir, ts);
-    publishNestedRepair(result, route, child, ts);
-    return { ...run, ...child, ...(hasText(result.message) ? { error: result.message } : {}) };
-}
-function reconcileNestedTree(run, route, options) {
-    const projected = reconcileNestedRun(run, route, options);
-    const children = projected.children?.map((child) => reconcileNestedTree(child, route, options));
-    const steps = projected.steps?.map((step) => {
-        return {
-            ...step,
-            children: step.children?.map((child) => reconcileNestedTree(child, route, options)),
-        };
-    });
-    return { ...projected, children, steps };
-}
-export function reconcileNestedAsyncDescendants(route, options = {}) {
-    return projectNestedEvents(route).children.map((run) => reconcileNestedTree(run, route, options));
-}
-export function checkPidLiveness(pid, kill = (target, signal) => process.kill(target, signal)) {
-    try {
-        kill(pid, 0);
-        return "alive";
-    }
-    catch (error) {
-        return errorCode(error) === "ESRCH" ? "dead" : "unknown";
-    }
-}
-function durableProjection(status, recovery) {
-    const { asyncDir, resultPath, options, now } = recovery;
-    const final = terminalStatusFromResult(status, resultPath, status.endedAt ?? now);
-    if (final) {
-        return { status: final, repaired: false, resultPath };
-    }
-    if (typeof status.pid === "number" && checkPidLiveness(status.pid, options.kill) === "dead") {
-        const failure = buildFailedRepair(status, asyncDir, status.lastUpdate ?? status.startedAt);
-        return { status: failure.status, repaired: false, message: failure.message };
-    }
-    if (terminal(status.state)) {
-        return {
-            status: { ...status, state: "running" },
-            repaired: false,
-            message: "Waiting for the owner's final result. Completion is unconfirmed.",
-        };
-    }
-    return { status, repaired: false };
-}
-function legacyProjection(status, effective, recovery) {
-    const { asyncDir, resultPath, now } = recovery;
-    if (fs.existsSync(resultPath)) {
-        const final = effective.state === "running" || effective.state === "queued"
-            ? terminalStatusFromResult(effective, resultPath, now)
-            : undefined;
-        if (final) {
-            writeAtomicJson(path.join(asyncDir, "status.json"), final);
-            return {
-                status: final,
-                repaired: true,
-                resultPath,
-                message: "Existing async result file was used to repair stale running status.",
-            };
-        }
-        return { status: effective, repaired: false, resultPath };
-    }
-    return legacyMissingResult(status, effective, recovery);
-}
-function awaitingInitialStatus(status, effective, recovery) {
-    const start = recovery.options.startedRun?.startedAt ?? effective.startedAt;
-    return status === null && recovery.now - start < (recovery.options.missingStatusGraceMs ?? 1000);
-}
-function legacyMissingResult(status, effective, recovery) {
-    const { options, now, asyncDir, resultPath } = recovery;
-    const unchanged = { status, repaired: false, resultPath };
-    if ((effective.state !== "running" && effective.state !== "queued") ||
-        typeof effective.pid !== "number" ||
-        awaitingInitialStatus(status, effective, recovery)) {
-        return unchanged;
-    }
-    if (checkPidLiveness(effective.pid, options.kill) === "dead") {
-        return writeFailedRepair(asyncDir, effective, resultPath, { now });
-    }
-    const lastUpdate = effective.lastUpdate ?? effective.startedAt;
-    if (now - lastUpdate <= (options.staleAlivePidMs ?? 24 * 60 * 60 * 1000)) {
-        return unchanged;
-    }
-    const reason = `Async runner process ${effective.pid} still has a live PID, but status has not updated for ${now - lastUpdate}ms. Marked run failed by stale-run reconciliation because PID ownership cannot be verified.`;
-    return writeFailedRepair(asyncDir, effective, resultPath, { now, reason });
-}
-function resultLocation(asyncDir, status, options, record) {
-    const runId = status.runId.length > 0 ? status.runId : path.basename(asyncDir);
-    const durable = isDurableRun(status) ||
-        (record === undefined
-            ? isDurableRun(readRunJson(path.join(asyncDir, "launch.json")))
-            : record.durable);
-    return {
-        durable,
-        resultPath: durable
-            ? path.join(asyncDir, "result.json")
-            : path.join(options.resultsDir ?? RESULTS_DIR, `${runId}.json`),
-    };
-}
-export function reconcileAsyncRun(asyncDir, options = {}, record) {
-    const now = options.now?.() ?? Date.now();
-    const status = record === undefined ? readStatus(asyncDir) : record.status;
-    const effective = status ??
-        (options.startedRun === undefined
-            ? undefined
-            : buildStartedStatus(asyncDir, options.startedRun, now));
-    if (!effective) {
-        return { status: null, repaired: false };
-    }
-    const location = resultLocation(asyncDir, effective, options, record);
-    const recovery = { asyncDir, resultPath: location.resultPath, options, now };
-    // The detached durable owner is the only execution writer. Inspection projects its evidence.
-    return location.durable
-        ? durableProjection(effective, recovery)
-        : legacyProjection(status, effective, recovery);
-}

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

@@ -1,75 +0,0 @@
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
-const RETRY_WINDOW_MS = 30_000;
-const RETRY_DELAY_MS = 500;
-const MAX_STDERR_LENGTH = 64 * 1024;
-function run(runnerPath, configPath, piPackageRoot) {
-    return new Promise((resolve) => {
-        const child = spawn(process.execPath, [runnerPath, configPath], {
-            stdio: ["ignore", "inherit", "pipe"],
-            env: piPackageRoot !== undefined && piPackageRoot.length > 0
-                ? { ...process.env, PI_PACKAGE_DIR: process.env.PI_PACKAGE_DIR ?? piPackageRoot }
-                : process.env,
-        });
-        let stderr = "";
-        child.stderr.on("data", (chunk) => {
-            if (!Buffer.isBuffer(chunk)) {
-                return;
-            }
-            process.stderr.write(chunk);
-            stderr = `${stderr}${chunk.toString()}`.slice(-MAX_STDERR_LENGTH);
-        });
-        child.once("error", (error) => {
-            const failure = error.stack ?? error.message;
-            process.stderr.write(`${failure}\n`);
-            resolve({ code: 1, stderr: failure });
-        });
-        child.once("close", (code) => resolve({ code: code ?? 1, stderr }));
-    });
-}
-const runnerPath = process.argv.at(2);
-const configPath = process.argv.at(3);
-if (runnerPath === undefined || configPath === undefined) {
-    throw new Error("Usage: subagent-runner-launcher <runner> <config>");
-}
-let statusPath;
-let piPackageRoot;
-try {
-    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-    if (typeof config === "object" && config !== null) {
-        if ("piPackageRoot" in config && typeof config.piPackageRoot === "string") {
-            piPackageRoot = config.piPackageRoot;
-        }
-        if ("asyncDir" in config && typeof config.asyncDir === "string") {
-            statusPath = path.join(config.asyncDir, "status.json");
-        }
-    }
-}
-catch {
-    // The runner owns reporting malformed launch files; launcher discovery is best effort.
-}
-// ponytail: bridge short in-place extension updates; use shared update locking if longer gaps appear.
-const deadline = Date.now() + RETRY_WINDOW_MS;
-let announcedRetry = false;
-while (true) {
-    // Retrying before startup must finish before inspecting the next process outcome.
-    // oxlint-disable-next-line no-await-in-loop
-    const result = await run(runnerPath, configPath, piPackageRoot);
-    const failedBeforeStartup = statusPath === undefined || !fs.existsSync(statusPath);
-    if (result.code === 0 ||
-        !failedBeforeStartup ||
-        !result.stderr.includes("ERR_MODULE_NOT_FOUND") ||
-        Date.now() >= deadline) {
-        process.exitCode = result.code;
-        break;
-    }
-    if (!announcedRetry) {
-        process.stderr.write("[pi-subagents] Runner dependencies are being updated; retrying startup.\n");
-        announcedRetry = true;
-    }
-    // Back off between dependency-update retries instead of launching concurrent runners.
-    // oxlint-disable-next-line no-await-in-loop
-    await delay(RETRY_DELAY_MS);
-}