@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/runs/background/async-job-tracker.js

@@ -1,353 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { renderWidget, widgetRenderKey } from "../../tui/render.js";
-import { POLL_INTERVAL_MS, RESULTS_DIR, } from "../../shared/types.js";
-import { readStatus } from "../../shared/utils.js";
-import { startedJob } from "./async-job-admission.js";
-import { reconcileAsyncRun } from "./stale-run-reconciler.js";
-import { findNestedRouteForRootId, hasLiveNestedDescendants } from "../shared/nested-events.js";
-import { asyncStatusToSummary, createAsyncRunDiscovery, listAsyncRuns } from "./async-status.js";
-import { isTuiContext } from "../../shared/ui-mode.js";
-import { exactAsyncRunLocation } from "./async-run-location.js";
-import { AsyncJobProjection } from "./async-job-projection.js";
-import { errorCode, hasText, isRecord } from "./async-value.js";
-import { parseAsyncStartedEvent } from "./run-schemas.js";
-function terminal(status) {
-    return (status === "complete" || status === "failed" || status === "blocked" || status === "paused");
-}
-function completionState(data) {
-    if (data.state === "blocked" || data.state === "paused") {
-        return data.state;
-    }
-    return data.success === true ? "complete" : "failed";
-}
-/** Owns job admission, restoration discovery, polling, and cleanup timers. */
-class AsyncJobTracker {
-    pi;
-    state;
-    asyncDirRoot;
-    options;
-    restoreDiscovery;
-    restoreBoundary = 0;
-    restoreDiscoveryDeadline = 0;
-    constructor(pi, state, asyncDirRoot, options) {
-        this.pi = pi;
-        this.state = state;
-        this.asyncDirRoot = asyncDirRoot;
-        this.options = options;
-    }
-    rerender(ctx, jobs = Array.from(this.state.asyncJobs.values())) {
-        (this.options.render ?? renderWidget)(ctx, jobs);
-        const ui = ctx.ui;
-        ui.requestRender?.();
-    }
-    rerenderCurrent() {
-        const ctx = this.state.lastUiContext;
-        if (ctx && isTuiContext(ctx)) {
-            this.rerender(ctx);
-        }
-    }
-    summarizeJob(job, status) {
-        return asyncStatusToSummary(job.asyncDir, status, [], job.nestedRoute ? (job.nestedChildren ?? []) : undefined);
-    }
-    cancelCleanup(id) {
-        const timer = this.state.cleanupTimers.get(id);
-        if (timer) {
-            clearTimeout(timer);
-            this.state.cleanupTimers.delete(id);
-        }
-    }
-    scheduleCleanup(id) {
-        this.cancelCleanup(id);
-        const timer = setTimeout(() => {
-            this.state.cleanupTimers.delete(id);
-            this.state.asyncJobs.delete(id);
-            if (this.state.lastUiContext) {
-                this.rerender(this.state.lastUiContext);
-            }
-        }, 10000);
-        this.state.cleanupTimers.set(id, timer);
-    }
-    refreshNested(id) {
-        const job = this.state.asyncJobs.get(id);
-        if (!job) {
-            return false;
-        }
-        try {
-            new AsyncJobProjection(job, this.pi.events).refreshNested();
-            return true;
-        }
-        catch (error) {
-            console.error(`Failed to refresh nested async descendants for '${job.asyncDir}':`, error);
-            return false;
-        }
-    }
-    refreshJob(id, restored) {
-        const job = this.state.asyncJobs.get(id);
-        if (!job) {
-            return false;
-        }
-        const before = widgetRenderKey(job);
-        const projection = new AsyncJobProjection(job, this.pi.events);
-        try {
-            projection.emitNewControlEvents();
-            const nestedReady = this.refreshNested(id);
-            const reconciliation = restored.get(job.asyncDir) ??
-                reconcileAsyncRun(job.asyncDir, {
-                    resultsDir: RESULTS_DIR,
-                    startedRun: {
-                        runId: job.asyncId,
-                        pid: job.pid,
-                        sessionId: job.sessionId,
-                        mode: job.mode,
-                        agents: job.agents,
-                        chainStepCount: job.chainStepCount,
-                        parallelGroups: job.parallelGroups,
-                        startedAt: job.startedAt,
-                        sessionFile: job.sessionFile,
-                    },
-                });
-            const status = reconciliation.status ?? readStatus(job.asyncDir);
-            if (status) {
-                const previous = job.status;
-                projection.applySummary(this.summarizeJob(job, status));
-                this.reconcileCleanup(id, previous, nestedReady);
-            }
-            else {
-                projection.markRunning();
-            }
-        }
-        catch (error) {
-            if (job.status !== "failed") {
-                console.error(`Failed to read async status for '${job.asyncDir}':`, error);
-                projection.markFailed();
-            }
-            if (!hasLiveNestedDescendants(job.nestedChildren) && !this.state.cleanupTimers.has(id)) {
-                this.scheduleCleanup(id);
-            }
-        }
-        return widgetRenderKey(job) !== before;
-    }
-    reconcileCleanup(id, previous, nestedReady) {
-        const job = this.state.asyncJobs.get(id);
-        if (!job) {
-            return;
-        }
-        if (!terminal(job.status)) {
-            this.cancelCleanup(id);
-            return;
-        }
-        if (nestedReady &&
-            !hasLiveNestedDescendants(job.nestedChildren) &&
-            (previous !== job.status || !this.state.cleanupTimers.has(id))) {
-            this.scheduleCleanup(id);
-        }
-    }
-    discoverDuringPoll() {
-        let records = [];
-        let changed = false;
-        if (this.restoreDiscovery) {
-            try {
-                records = this.restoreDiscovery();
-                changed = this.discoverRestoredJobs(records, true);
-            }
-            catch (error) {
-                console.error("Failed to discover active async jobs:", error);
-            }
-            if (Date.now() >= this.restoreDiscoveryDeadline) {
-                this.restoreDiscovery = undefined;
-                this.restoreDiscoveryDeadline = 0;
-            }
-        }
-        return { records, changed };
-    }
-    poll() {
-        const discovery = this.discoverDuringPoll();
-        if (this.state.asyncJobs.size === 0) {
-            if (this.restoreDiscovery) {
-                return;
-            }
-            if (this.state.lastUiContext && isTuiContext(this.state.lastUiContext)) {
-                this.rerender(this.state.lastUiContext, []);
-            }
-            if (this.state.poller) {
-                clearInterval(this.state.poller);
-                this.state.poller = null;
-            }
-            return;
-        }
-        const restored = new Map(discovery.records.map((record) => [record.location.asyncDir, record]));
-        let changed = discovery.changed;
-        for (const id of this.state.asyncJobs.keys()) {
-            changed = this.refreshJob(id, restored) || changed;
-        }
-        if (changed) {
-            this.rerenderCurrent();
-        }
-    }
-    ensurePoller = () => {
-        if (this.state.poller) {
-            return;
-        }
-        this.state.poller = setInterval(() => {
-            this.poll();
-        }, POLL_INTERVAL_MS);
-        this.state.poller.unref();
-    };
-    handleStarted = (data) => {
-        const info = parseAsyncStartedEvent(data);
-        if (!hasText(info.id)) {
-            return;
-        }
-        const now = Date.now();
-        const asyncDir = info.asyncDir ??
-            exactAsyncRunLocation(info.id, this.asyncDirRoot, RESULTS_DIR).asyncDir ??
-            path.join(this.asyncDirRoot, info.id);
-        this.state.asyncJobs.set(info.id, startedJob(info.id, info, asyncDir, now));
-        this.ensurePoller();
-        this.rerenderCurrent();
-    };
-    handleComplete = (data) => {
-        if (!isRecord(data) || typeof data.id !== "string" || data.id.length === 0) {
-            return;
-        }
-        const job = this.state.asyncJobs.get(data.id);
-        let nestedReady = true;
-        if (job) {
-            new AsyncJobProjection(job, this.pi.events).complete(completionState(data), typeof data.asyncDir === "string" ? data.asyncDir : undefined);
-            nestedReady = this.refreshNested(data.id);
-        }
-        this.rerenderCurrent();
-        if (nestedReady && !hasLiveNestedDescendants(job?.nestedChildren)) {
-            this.scheduleCleanup(data.id);
-        }
-    };
-    controlCursor(run, sinceBoundary) {
-        let cursor = 0;
-        let since = sinceBoundary ? this.restoreBoundary : undefined;
-        // Late publications use the original restoration cut, not an EOF observed after discovery.
-        if (!sinceBoundary) {
-            try {
-                cursor = fs.statSync(path.join(run.asyncDir, "events.jsonl")).size;
-            }
-            catch (error) {
-                if (errorCode(error) !== "ENOENT") {
-                    since = this.restoreBoundary;
-                    console.error(`Failed to inspect async control events for '${run.asyncDir}':`, error);
-                }
-            }
-        }
-        return { controlEventCursor: cursor, controlEventSince: since };
-    }
-    restoredJob(run, sinceBoundary) {
-        const groups = run.parallelGroups ?? [];
-        const current = run.currentStep;
-        const active = current === undefined
-            ? undefined
-            : groups.find((group) => current >= group.start && current < group.start + group.count);
-        const steps = active ? run.steps.slice(active.start, active.start + active.count) : run.steps;
-        let nestedRoute;
-        try {
-            nestedRoute = findNestedRouteForRootId(run.id);
-        }
-        catch (error) {
-            console.error(`Failed to restore nested async descendants for '${run.asyncDir}':`, error);
-        }
-        return {
-            asyncId: run.id,
-            asyncDir: run.asyncDir,
-            status: run.state,
-            pid: run.pid,
-            sessionId: run.sessionId,
-            activityState: run.activityState,
-            lastActivityAt: run.lastActivityAt,
-            currentTool: run.currentTool,
-            currentToolStartedAt: run.currentToolStartedAt,
-            currentPath: run.currentPath,
-            turnCount: run.turnCount,
-            toolCount: run.toolCount,
-            mode: run.mode,
-            agents: steps.map((step) => step.agent),
-            currentStep: run.currentStep,
-            chainStepCount: run.chainStepCount,
-            parallelGroups: groups,
-            steps: steps.map((step) => ({ ...step })),
-            stepsTotal: steps.length,
-            runningSteps: steps.filter((step) => step.status === "running").length,
-            completedSteps: steps.filter((step) => step.status === "complete" || step.status === "completed").length,
-            activeParallelGroup: active !== undefined,
-            startedAt: run.startedAt,
-            updatedAt: run.lastUpdate ?? run.startedAt,
-            totalTokens: run.totalTokens,
-            sessionFile: run.sessionFile,
-            ...this.controlCursor(run, sinceBoundary),
-            nestedRoute,
-            nestedChildren: run.nestedChildren,
-        };
-    }
-    discoverRestoredJobs(records, sinceBoundary) {
-        let changed = false;
-        for (const run of listAsyncRuns(this.asyncDirRoot, {
-            states: ["queued", "running"],
-            records,
-            resultsDir: RESULTS_DIR,
-            skipInvalid: true,
-        })) {
-            if (this.state.asyncJobs.has(run.id)) {
-                continue;
-            }
-            this.state.asyncJobs.set(run.id, this.restoredJob(run, sinceBoundary));
-            changed = true;
-        }
-        return changed;
-    }
-    restoreJobs = (sessionId, ctx, restoration) => {
-        this.restoreBoundary = restoration?.startedAt ?? Date.now();
-        this.restoreDiscovery =
-            restoration?.discover ??
-                createAsyncRunDiscovery(this.asyncDirRoot, {
-                    sessionId: ctx.sessionManager.getSessionFile() ?? sessionId,
-                    ownerSessionId: ctx.sessionManager.getSessionId(),
-                    resultsDir: RESULTS_DIR,
-                    skipInvalid: true,
-                });
-        this.restoreDiscoveryDeadline = this.restoreBoundary + 2_000;
-        try {
-            this.discoverRestoredJobs(restoration?.records ?? this.restoreDiscovery(), restoration !== undefined);
-        }
-        catch (error) {
-            console.error("Failed to discover active async jobs:", error);
-        }
-        if (isTuiContext(ctx)) {
-            this.state.lastUiContext = ctx;
-            this.rerender(ctx);
-        }
-        this.ensurePoller();
-    };
-    resetJobs = (ctx) => {
-        this.restoreDiscovery = undefined;
-        this.restoreBoundary = 0;
-        this.restoreDiscoveryDeadline = 0;
-        for (const timer of this.state.cleanupTimers.values()) {
-            clearTimeout(timer);
-        }
-        this.state.cleanupTimers.clear();
-        this.state.asyncJobs.clear();
-        this.state.foregroundRuns?.clear();
-        this.state.resultFileCoalescer.clear();
-        if (ctx && isTuiContext(ctx)) {
-            this.state.lastUiContext = ctx;
-            this.rerender(ctx, []);
-        }
-    };
-}
-export function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
-    const tracker = new AsyncJobTracker(pi, state, asyncDirRoot, options);
-    return {
-        ensurePoller: tracker.ensurePoller,
-        handleStarted: tracker.handleStarted,
-        handleComplete: tracker.handleComplete,
-        restoreJobs: tracker.restoreJobs,
-        resetJobs: tracker.resetJobs,
-    };
-}

package/dist/runs/background/async-launch.js

@@ -1,216 +0,0 @@
-import { spawn } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { inspect } from "node:util";
-import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../shared/pi-args.js";
-import { RUNNER_ERROR_LOG_FILE, RESULTS_DIR, SUBAGENT_ASYNC_STARTED_EVENT, } from "../../shared/types.js";
-import { formatRunAction } from "../../shared/status-format.js";
-import { ensureTempRoot } from "../../shared/temp-root.js";
-import { getRunMetadataDir } from "../shared/supervisor-questions.js";
-import { nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent, } from "../shared/nested-events.js";
-import { resolvePiPackageRoot } from "../shared/pi-spawn.js";
-export function formatAsyncStartedMessage(headline, childSafe = process.env[SUBAGENT_CHILD_ENV] === "1" &&
-    process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1") {
-    return [
-        headline,
-        "",
-        "The async run is detached. Do not run sleep timers or polling loops just to wait for it.",
-        "If you have independent work, continue that work. If you have nothing else to do until the async result arrives, end your turn now; Pi will deliver the completion when the run finishes.",
-        `Use ${formatRunAction("status", "...", {}, childSafe)} when you need the current status/result, or to inspect a blocked/stale run. Do not poll just to wait.`,
-    ].join("\n");
-}
-export function formatAsyncStartError(mode, message) {
-    return {
-        content: [{ type: "text", text: message }],
-        isError: true,
-        details: { mode, results: [] },
-    };
-}
-export function launchErrorMessage(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    return typeof error === "string" ? error : inspect(error);
-}
-export function prepareAsyncOwner(id) {
-    const inheritedRoute = resolveInheritedNestedRouteFromEnv();
-    const nestedAddress = inheritedRoute ? resolveNestedParentAddressFromEnv() : undefined;
-    const asyncDir = getRunMetadataDir(id);
-    fs.mkdirSync(asyncDir, { recursive: true });
-    return { id, asyncDir, inheritedRoute, nestedAddress };
-}
-export function createRunnerLaunch(params, owner, plan) {
-    const { inheritedRoute, nestedAddress, id } = owner;
-    return {
-        ...plan,
-        id,
-        timeoutMs: params.timeoutMs,
-        resultPath: inheritedRoute
-            ? nestedResultsPath(inheritedRoute.rootRunId, id)
-            : path.join(RESULTS_DIR, `${id}.json`),
-        placeholder: "{previous}",
-        maxOutput: params.maxOutput,
-        artifactsDir: params.artifactsDir,
-        share: params.shareEnabled,
-        sessionDir: params.sessionRoot === undefined || params.sessionRoot.length === 0
-            ? undefined
-            : path.join(params.sessionRoot, `async-${id}`),
-        asyncDir: owner.asyncDir,
-        sessionId: params.ctx.currentSessionId,
-        rootSessionId: params.ctx.rootSessionId,
-        piPackageRoot: resolvePiPackageRoot(),
-        worktreeSetupHook: params.worktreeSetupHook,
-        worktreeSetupHookTimeoutMs: params.worktreeSetupHookTimeoutMs,
-        controlConfig: params.controlConfig,
-        controlIntercomTarget: params.controlIntercomTarget,
-        nestedRoute: params.nestedRoute ?? inheritedRoute,
-        nestedSelf: inheritedRoute && nestedAddress
-            ? {
-                parentRunId: nestedAddress.parentRunId,
-                parentStepIndex: nestedAddress.parentStepIndex,
-                depth: nestedAddress.depth,
-                path: nestedAddress.path,
-            }
-            : undefined,
-        projectTrust: params.projectTrust,
-    };
-}
-/** Handoff is irreversible once a pid exists; descriptor cleanup cannot turn it into a failed launch. */
-export function spawnRunner(cfg) {
-    const { cwd, asyncDir } = cfg;
-    try {
-        if (!fs.statSync(cwd).isDirectory()) {
-            return { error: `cwd is not a directory: ${cwd}` };
-        }
-    }
-    catch {
-        return { error: `cwd does not exist: ${cwd}` };
-    }
-    ensureTempRoot();
-    const cfgPath = path.join(asyncDir, "launch.json");
-    fs.writeFileSync(cfgPath, JSON.stringify({ ...cfg, runtimeVersion: 2 }), {
-        mode: 0o600,
-        flag: "wx",
-    });
-    const directory = path.dirname(fileURLToPath(import.meta.url));
-    const extension = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
-    const fd = fs.openSync(path.join(asyncDir, RUNNER_ERROR_LOG_FILE), "a");
-    try {
-        const child = spawn(process.execPath, [
-            path.join(directory, `subagent-runner-launcher${extension}`),
-            path.join(directory, `subagent-runner${extension}`),
-            cfgPath,
-        ], { cwd, detached: true, stdio: ["ignore", "ignore", fd] });
-        child.on("error", (error) => {
-            console.error(`[pi-subagents] async spawn failed: ${error.message}`);
-        });
-        if (typeof child.pid !== "number") {
-            return { error: `async runner did not produce a pid for cwd: ${cwd}` };
-        }
-        try {
-            child.unref();
-        }
-        catch (error) {
-            console.error("[pi-subagents] async runner detach cleanup failed:", error);
-        }
-        return { pid: child.pid };
-    }
-    finally {
-        try {
-            fs.closeSync(fd);
-        }
-        catch (error) {
-            console.error("[pi-subagents] async runner stderr descriptor cleanup failed:", error);
-        }
-    }
-}
-function announceNestedStart(owner, cfg, pid, overview) {
-    const { inheritedRoute, nestedAddress } = owner;
-    if (!inheritedRoute || !nestedAddress) {
-        return;
-    }
-    const now = Date.now();
-    const target = cfg.childIntercomTargets?.at(0) ?? undefined;
-    const agents = overview.agents ?? (overview.agent === undefined ? [] : [overview.agent]);
-    const mode = cfg.resultMode ?? "single";
-    const chainStepCount = overview.chainStepCount ?? 1;
-    try {
-        writeNestedEvent(inheritedRoute, {
-            type: "subagent.nested.started",
-            ts: now,
-            parentRunId: nestedAddress.parentRunId,
-            parentStepIndex: nestedAddress.parentStepIndex,
-            child: {
-                id: cfg.id,
-                parentRunId: nestedAddress.parentRunId,
-                parentStepIndex: nestedAddress.parentStepIndex,
-                depth: nestedAddress.depth,
-                path: nestedAddress.path,
-                asyncDir: cfg.asyncDir,
-                pid,
-                ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
-                leafIntercomTarget: target,
-                intercomTarget: target,
-                ownerState: "live",
-                mode,
-                state: "running",
-                agent: overview.agent,
-                agents,
-                chainStepCount,
-                parallelGroups: overview.parallelGroups,
-                startedAt: now,
-                lastUpdate: now,
-            },
-        });
-    }
-    catch (error) {
-        console.error("Failed to emit nested async start event:", error);
-    }
-}
-export function launchAsyncRun(pi, owner, cfg, overview) {
-    const mode = cfg.resultMode ?? "single";
-    const label = mode === "single" ? "run" : mode;
-    let launched;
-    try {
-        launched = spawnRunner(cfg);
-    }
-    catch (error) {
-        return formatAsyncStartError(mode, `Failed to start async ${label} '${cfg.id}': ${launchErrorMessage(error)}`);
-    }
-    if (launched.error !== undefined) {
-        return formatAsyncStartError(mode, `Failed to start async ${label} '${cfg.id}': ${launched.error}`);
-    }
-    announceNestedStart(owner, cfg, launched.pid, overview);
-    let notice = "";
-    const { headline, ...eventOverview } = overview;
-    try {
-        pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
-            ...eventOverview,
-            id: cfg.id,
-            pid: launched.pid,
-            sessionId: cfg.sessionId,
-            mode,
-            workflowGraph: cfg.workflowGraph,
-            cwd: cfg.cwd,
-            asyncDir: cfg.asyncDir,
-            nestedRoute: overview.nestedRoute,
-        });
-    }
-    catch (error) {
-        // A detached process already owns this run. Returning isError would invite duplicate revival.
-        notice = `\n\nRun started, but its tracking notice could not be published: ${launchErrorMessage(error)}`;
-    }
-    return {
-        content: [{ type: "text", text: `${formatAsyncStartedMessage(headline)}${notice}` }],
-        details: {
-            mode,
-            runId: cfg.id,
-            results: [],
-            asyncId: cfg.id,
-            asyncDir: cfg.asyncDir,
-            asyncPid: launched.pid,
-            ...(cfg.workflowGraph ? { workflowGraph: cfg.workflowGraph } : {}),
-        },
-    };
-}

package/dist/runs/background/async-plan.js

@@ -1,116 +0,0 @@
-/**
- * Async execution logic for subagent tool
- */
-import * as path from "node:path";
-import { applyThinkingSuffix } from "../shared/pi-args.js";
-import { materializeAgentDefaultOutputPath, normalizeSingleOutputOverride, } from "../shared/single-output.js";
-import { buildModelCandidates, resolveModelCandidate, } from "../shared/model-fallback.js";
-import { resolveEffectiveThinking } from "../../shared/model-info.js";
-import { DEFAULT_MAX_OUTPUT, } from "../../shared/types.js";
-export function usesAgentDefaultOutput(output) {
-    return output === undefined || output === true || output === "true";
-}
-export function materializeAsyncDefaultOutput(params) {
-    return materializeAgentDefaultOutputPath({
-        output: params.output,
-        artifactsDir: params.artifactsDir ?? params.asyncDir,
-        runId: params.runId,
-        agent: params.agent,
-        index: params.index,
-    });
-}
-export function resolveAsyncOutput(params) {
-    const effectiveOutput = usesAgentDefaultOutput(params.requestedOutput)
-        ? normalizeSingleOutputOverride(true, params.agentDefaultOutput)
-        : normalizeSingleOutputOverride(params.requestedOutput, params.agentDefaultOutput);
-    return usesAgentDefaultOutput(params.requestedOutput)
-        ? materializeAsyncDefaultOutput({
-            output: effectiveOutput,
-            artifactsDir: params.artifactsDir,
-            asyncDir: params.asyncDir,
-            runId: params.runId,
-            agent: params.agent,
-            index: params.index,
-        })
-        : effectiveOutput;
-}
-function outputFilename(step, agent, explicit) {
-    if (explicit !== undefined && explicit.length > 0) {
-        return explicit;
-    }
-    if (step.outputPathFromAgentDefault !== true ||
-        step.outputPath === undefined ||
-        step.outputPath.length === 0) {
-        return;
-    }
-    if (typeof agent.output !== "string" || path.isAbsolute(agent.output)) {
-        return;
-    }
-    return path.basename(agent.output);
-}
-export function withSavedLaunch(step, agent, params, generatedOutputFilename) {
-    return {
-        ...step,
-        launch: {
-            agent,
-            model: step.model,
-            thinking: step.thinking,
-            modelCandidates: step.modelCandidates ?? [],
-            artifacts: params.artifactsDir !== undefined,
-            artifactsDir: params.artifactsDir,
-            share: params.shareEnabled,
-            systemPrompt: step.systemPrompt ?? "",
-            skills: step.skills ?? [],
-            cwd: step.cwd ?? params.ctx.cwd,
-            context: agent.defaultContext ?? "fresh",
-            output: step.outputPath ?? false,
-            outputMode: step.outputMode ?? "inline",
-            generatedOutputFilename: outputFilename(step, agent, generatedOutputFilename),
-            outputSchema: step.structuredOutputSchema,
-            effectiveAcceptance: step.effectiveAcceptance,
-            maxOutput: { ...DEFAULT_MAX_OUTPUT, ...params.maxOutput },
-            maxSubagentDepth: step.maxSubagentDepth,
-            maxExecutionTimeMs: step.maxExecutionTimeMs,
-            maxTokens: step.maxTokens,
-            controlConfig: params.controlConfig,
-            projectTrust: params.projectTrust,
-            projectTrusted: params.ctx.projectTrusted,
-        },
-    };
-}
-export function resolveLaunchModel(agent, modelOverride, options) {
-    const { availableModels, preferredProvider, savedLaunch } = options;
-    const primary = modelOverride ?? savedLaunch?.model ?? agent.model;
-    const thinking = savedLaunch?.thinking ?? agent.thinking;
-    const model = applyThinkingSuffix(resolveModelCandidate(primary, availableModels, preferredProvider), thinking);
-    // Only caller selections pin the route; persisted candidates already encode the saved policy.
-    const fallbacks = modelOverride !== undefined && modelOverride.length > 0
-        ? []
-        : (savedLaunch?.modelCandidates ?? agent.fallbackModels);
-    return {
-        model,
-        thinking: resolveEffectiveThinking(model, thinking),
-        modelCandidates: buildModelCandidates(primary, fallbacks, availableModels, preferredProvider)
-            .map((candidate) => applyThinkingSuffix(candidate, thinking))
-            .filter((candidate) => typeof candidate === "string"),
-    };
-}
-export const UNAVAILABLE_SUBAGENT_SKILL_ERROR = "Skills not found: pi-subagents";
-export function agentRuntimeFields(agent) {
-    return {
-        tools: agent.tools,
-        allowSubagents: agent.allowSubagents,
-        extensions: agent.extensions,
-        mcpDirectTools: agent.mcpDirectTools,
-        completionGuard: agent.completionGuard,
-        systemPromptMode: agent.systemPromptMode,
-        inheritProjectContext: agent.inheritProjectContext,
-        inheritSkills: agent.inheritSkills,
-        maxExecutionTimeMs: agent.maxExecutionTimeMs,
-        maxTokens: agent.maxTokens,
-    };
-}
-export class UnavailableSubagentSkillError extends Error {
-}
-export class AsyncStartValidationError extends Error {
-}