@ashx-j/lunr 0.1.0

package/dist/builtin-extensions/pi-subagents/src/runs/background/async-execution.js

@@ -0,0 +1,1065 @@
+// @ts-nocheck
+/**
+ * Async execution logic for subagent tool
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
+import { writePrivateAtomicJson } from "../../shared/atomic-json.js";
+import { applyThinkingSuffix } from "../shared/pi-args.js";
+import { injectOutputPathSystemPrompt, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.js";
+import { buildChainInstructions, isDynamicParallelStep, isParallelStep, resolveStepBehavior, suppressProgressForReadOnlyTask, writeInitialProgressFile } from "../../shared/settings.js";
+import { resolvePiPackageRoot } from "../shared/pi-spawn.js";
+import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "../../agents/skills.js";
+import { buildAgentMemoryInjection } from "../../agents/agent-memory.js";
+import { PI_CODING_AGENT_PACKAGE_ROOT_ENV, resolveChildCwd } from "../../shared/utils.js";
+import { buildModelCandidates, resolveEffectiveSubagentModel, resolveSubagentModelOverride } from "../shared/model-fallback.js";
+import { resolveEffectiveThinking } from "../../shared/model-info.js";
+import { resolveExpectedWorktreeAgentCwd } from "../shared/worktree.js";
+import { buildWorkflowGraphSnapshot } from "../shared/workflow-graph.js";
+import { ChainOutputValidationError, validateChainOutputBindings } from "../shared/chain-outputs.js";
+import { createStructuredOutputRuntime } from "../shared/structured-output.js";
+import { resolveEffectiveAcceptance } from "../shared/acceptance.js";
+import { ASYNC_DIR, RESULTS_DIR, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_LIFECYCLE_ARTIFACT_VERSION, TEMP_ROOT_DIR, getAsyncConfigPath, resolveChildMaxSubagentDepth, } from "../../shared/types.js";
+import { nestedResultsPath, resolveInheritedNestedRouteFromEnv, resolveNestedParentAddressFromEnv, writeNestedEvent } from "../shared/nested-events.js";
+import { initialTurnBudgetState } from "../shared/turn-budget.js";
+import { validateToolBudgetConfig } from "../shared/tool-budget.js";
+const require = createRequire(import.meta.url);
+const piPackageRoot = resolvePiPackageRoot();
+function resolveJitiCliFromPackageJson(packageJsonPath) {
+    if (!fs.existsSync(packageJsonPath))
+        return undefined;
+    const packageRoot = path.dirname(packageJsonPath);
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const binField = pkg.bin;
+    const binPath = typeof binField === "string"
+        ? binField
+        : binField?.jiti ?? Object.values(binField ?? {})[0];
+    const candidates = [binPath, "lib/jiti-cli.mjs"].filter((candidate) => Boolean(candidate));
+    for (const candidate of candidates) {
+        const cliPath = path.resolve(packageRoot, candidate);
+        if (fs.existsSync(cliPath))
+            return cliPath;
+    }
+    return undefined;
+}
+function resolveJitiCliPath() {
+    const candidates = [
+        () => require.resolve("jiti/package.json"),
+        () => piPackageRoot
+            ? createRequire(path.join(piPackageRoot, "package.json")).resolve("jiti/package.json")
+            : undefined,
+        () => {
+            if (!process.argv[1])
+                return undefined;
+            const piEntry = fs.realpathSync(process.argv[1]);
+            return createRequire(piEntry).resolve("jiti/package.json");
+        },
+        () => piPackageRoot ? path.join(piPackageRoot, "node_modules", "jiti", "package.json") : undefined,
+    ];
+    for (const candidate of candidates) {
+        try {
+            const packageJsonPath = candidate();
+            if (!packageJsonPath)
+                continue;
+            const cliPath = resolveJitiCliFromPackageJson(packageJsonPath);
+            if (cliPath)
+                return cliPath;
+        }
+        catch {
+            // Candidate not available in this install, continue probing.
+        }
+    }
+    return undefined;
+}
+const jitiCliPath = resolveJitiCliPath();
+export function formatAsyncStartedMessage(headline) {
+    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. When you have nothing left to do until the async result arrives, call subagent_wait() — it blocks until the run finishes and delivers the completion here. Only if you are certain you will get another turn (an interactive session where the user will prompt you again) can you instead stop and let Pi wake you; inside a skill that must run to completion, or in a non-interactive run, there is no next turn, so use subagent_wait().",
+        "Use subagent({ action: \"status\", id: \"...\" }) when you need a one-shot status/result or to inspect a blocked/stale run. To block until completion, prefer subagent_wait(). Do not poll in a loop just to wait.",
+    ].join("\n");
+}
+/**
+ * Check if jiti is available for async execution
+ */
+export function isAsyncAvailable() {
+    return jitiCliPath !== undefined;
+}
+function isNodeExecutableName(execPath) {
+    const basename = path.basename(execPath).toLowerCase();
+    return basename === "node" || basename === "node.exe" || basename === "nodejs" || basename === "nodejs.exe";
+}
+function canUseCurrentNodeExecutable(execPath) {
+    try {
+        fs.accessSync(execPath, process.platform === "win32" ? fs.constants.F_OK : fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveAsyncRunnerNodeCommand() {
+    if (isNodeExecutableName(process.execPath) && canUseCurrentNodeExecutable(process.execPath)) {
+        return process.execPath;
+    }
+    return process.platform === "win32" ? "node.exe" : "node";
+}
+export function resolveAsyncRunnerLogPaths(cfg) {
+    const asyncDir = typeof cfg.asyncDir === "string"
+        ? cfg.asyncDir
+        : undefined;
+    if (!asyncDir)
+        return undefined;
+    return {
+        stdoutPath: path.join(asyncDir, "runner.stdout.log"),
+        stderrPath: path.join(asyncDir, "runner.stderr.log"),
+    };
+}
+function closeFd(fd) {
+    if (fd === undefined)
+        return;
+    try {
+        fs.closeSync(fd);
+    }
+    catch {
+        // Best-effort cleanup; child process already owns its duplicated stdio fd.
+    }
+}
+/**
+ * Spawn the async runner process
+ */
+const RUNNER_STARTUP_TIMEOUT_MS = 10_000;
+const RUNNER_STARTUP_WAIT_BUFFER = typeof SharedArrayBuffer !== "undefined" ? new SharedArrayBuffer(4) : undefined;
+const RUNNER_STARTUP_WAIT_VIEW = RUNNER_STARTUP_WAIT_BUFFER ? new Int32Array(RUNNER_STARTUP_WAIT_BUFFER) : undefined;
+function waitForStartupInterval(delayMs = 20) {
+    if (RUNNER_STARTUP_WAIT_VIEW) {
+        Atomics.wait(RUNNER_STARTUP_WAIT_VIEW, 0, 0, delayMs);
+        return;
+    }
+    const waitUntil = Date.now() + delayMs;
+    while (Date.now() < waitUntil) {
+        // Startup handshakes are synchronous so resume rejects before reporting a run as started.
+    }
+}
+function readRunnerStartup(startupPath, expectedState, expectedToken) {
+    if (!fs.existsSync(startupPath))
+        return undefined;
+    try {
+        const payload = JSON.parse(fs.readFileSync(startupPath, "utf-8"));
+        if (payload.state === "error" && typeof payload.error === "string")
+            return { ok: false, error: payload.error };
+        if (payload.state !== expectedState)
+            return undefined;
+        if (typeof payload.token !== "string" || (expectedToken !== undefined && payload.token !== expectedToken)) {
+            return { ok: false, error: `Async runner wrote an invalid ${expectedState} startup handshake: ${startupPath}` };
+        }
+        return { ok: true, token: payload.token };
+    }
+    catch (error) {
+        return { ok: false, error: `Failed to read async runner startup handshake '${startupPath}': ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
+function waitForRunnerStartup(startupPath, expectedState, timeoutMs, expectedToken) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const result = readRunnerStartup(startupPath, expectedState, expectedToken);
+        if (result)
+            return result;
+        if (Date.now() >= deadline)
+            break;
+        waitForStartupInterval(Math.min(20, Math.max(1, deadline - Date.now())));
+    }
+    const finalResult = readRunnerStartup(startupPath, expectedState, expectedToken);
+    if (finalResult)
+        return finalResult;
+    return { ok: false, error: `Timed out after ${timeoutMs}ms waiting for the async runner startup state '${expectedState}'.` };
+}
+function writeRunnerStartupControl(filePath, payload) {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+    try {
+        fs.writeFileSync(tempPath, JSON.stringify(payload), { encoding: "utf-8", mode: 0o600 });
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(tempPath, { force: true });
+        }
+        catch {
+            // Preserve the startup-control write error.
+        }
+        throw error;
+    }
+}
+function runnerIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+function terminateRunnerBeforeProceed(pid) {
+    for (const signal of ["SIGTERM", "SIGKILL"]) {
+        if (!runnerIsAlive(pid))
+            return;
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            if (!runnerIsAlive(pid))
+                return;
+        }
+        const deadline = Date.now() + 1000;
+        while (runnerIsAlive(pid) && Date.now() < deadline)
+            waitForStartupInterval();
+    }
+}
+function spawnRunner(cfg, suffix, cwd) {
+    if (!jitiCliPath) {
+        return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
+    }
+    try {
+        const cwdStats = fs.statSync(cwd);
+        if (!cwdStats.isDirectory()) {
+            return { error: `cwd is not a directory: ${cwd}` };
+        }
+    }
+    catch {
+        return { error: `cwd does not exist: ${cwd}` };
+    }
+    fs.mkdirSync(TEMP_ROOT_DIR, { recursive: true });
+    const cfgPath = getAsyncConfigPath(suffix);
+    fs.writeFileSync(cfgPath, JSON.stringify(cfg));
+    // lunr: bake-in ships compiled .js only; use the .ts when present (upstream dev), else the .js sibling.
+    const runnerTsPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
+    const runner = fs.existsSync(runnerTsPath) ? runnerTsPath : runnerTsPath.replace(/\.ts$/, ".js");
+    const nodeCommand = resolveAsyncRunnerNodeCommand();
+    const startupPath = typeof cfg.revivalLease === "object"
+        && typeof cfg.asyncDir === "string"
+        ? path.join(cfg.asyncDir, "runner-startup.json")
+        : undefined;
+    const startupAckPath = startupPath ? path.join(path.dirname(startupPath), "runner-startup-ack.json") : undefined;
+    const startupProceedPath = startupPath ? path.join(path.dirname(startupPath), "runner-startup-proceed.json") : undefined;
+    if (startupPath)
+        fs.rmSync(startupPath, { force: true });
+    if (startupAckPath)
+        fs.rmSync(startupAckPath, { force: true });
+    if (startupProceedPath)
+        fs.rmSync(startupProceedPath, { force: true });
+    const logPaths = resolveAsyncRunnerLogPaths(cfg);
+    let stdoutFd;
+    let stderrFd;
+    try {
+        if (logPaths) {
+            fs.mkdirSync(path.dirname(logPaths.stdoutPath), { recursive: true });
+            stdoutFd = fs.openSync(logPaths.stdoutPath, "a");
+            stderrFd = fs.openSync(logPaths.stderrPath, "a");
+        }
+        const proc = spawn(nodeCommand, [jitiCliPath, runner, cfgPath], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", stdoutFd ?? "ignore", stderrFd ?? "ignore"],
+            windowsHide: true,
+            env: {
+                ...process.env,
+                ...(piPackageRoot ? { [PI_CODING_AGENT_PACKAGE_ROOT_ENV]: piPackageRoot } : {}),
+            },
+        });
+        closeFd(stdoutFd);
+        closeFd(stderrFd);
+        proc.on("error", (error) => {
+            console.error(`[pi-subagents] async spawn failed: ${error.message}`);
+        });
+        if (typeof proc.pid !== "number") {
+            return { error: `async runner did not produce a pid for cwd: ${cwd}` };
+        }
+        proc.unref();
+        if (startupPath && startupAckPath && startupProceedPath) {
+            const ready = waitForRunnerStartup(startupPath, "ready", RUNNER_STARTUP_TIMEOUT_MS);
+            if (!ready.ok) {
+                terminateRunnerBeforeProceed(proc.pid);
+                return { error: ready.error };
+            }
+            try {
+                writeRunnerStartupControl(startupAckPath, { action: "ack", token: ready.token });
+            }
+            catch (error) {
+                terminateRunnerBeforeProceed(proc.pid);
+                return { error: `Failed to acknowledge async runner startup: ${error instanceof Error ? error.message : String(error)}` };
+            }
+            const acknowledged = waitForRunnerStartup(startupPath, "acknowledged", RUNNER_STARTUP_TIMEOUT_MS, ready.token);
+            if (!acknowledged.ok) {
+                terminateRunnerBeforeProceed(proc.pid);
+                return { error: acknowledged.error };
+            }
+            try {
+                writeRunnerStartupControl(startupProceedPath, { action: "proceed", token: ready.token });
+            }
+            catch (error) {
+                terminateRunnerBeforeProceed(proc.pid);
+                return { error: `Failed to authorize async runner startup: ${error instanceof Error ? error.message : String(error)}` };
+            }
+            try {
+                fs.rmSync(startupPath, { force: true });
+            }
+            catch {
+                // Proceed is the commit point; handshake cleanup cannot turn a running revival into a start error.
+            }
+        }
+        return { pid: proc.pid };
+    }
+    catch (error) {
+        closeFd(stdoutFd);
+        closeFd(stderrFd);
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function formatAsyncStartError(mode, message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+        details: { mode, results: [] },
+    };
+}
+const UNAVAILABLE_SUBAGENT_SKILL_ERROR = "Skills not found: pi-subagents";
+class UnavailableSubagentSkillError extends Error {
+}
+class AsyncStartValidationError extends Error {
+}
+export function buildAsyncRunnerSteps(id, params) {
+    const { chain, agents, ctx, cwd, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeBaseDir, asyncDir, } = params;
+    const outputBaseDir = params.outputBaseDir;
+    const resultMode = params.resultMode ?? "chain";
+    const chainSkills = params.chainSkills ?? [];
+    const availableModels = params.availableModels;
+    const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
+    const progressDir = params.progressDir ?? runnerCwd;
+    const graphChain = params.attachRoot
+        ? [{
+                agent: params.attachRoot.agent,
+                task: `Attach async root ${params.attachRoot.runId}`,
+                label: params.attachRoot.label ?? `Attached root ${params.attachRoot.runId}`,
+                ...(params.attachRoot.outputName ? { as: params.attachRoot.outputName } : {}),
+            }, ...chain]
+        : chain;
+    const firstStep = chain[0];
+    const originalTask = params.task ?? (firstStep
+        ? (isParallelStep(firstStep)
+            ? firstStep.parallel[0]?.task
+            : isDynamicParallelStep(firstStep)
+                ? firstStep.parallel.task
+                : firstStep.task)
+        : undefined);
+    try {
+        if (params.validateOutputBindings !== false) {
+            validateChainOutputBindings(chain, { maxItems: params.dynamicFanoutMaxItems });
+        }
+    }
+    catch (error) {
+        if (error instanceof ChainOutputValidationError)
+            return { error: error.message };
+        throw error;
+    }
+    const workflowGraph = buildWorkflowGraphSnapshot({ runId: id, mode: resultMode, steps: graphChain });
+    for (const s of chain) {
+        const stepAgents = isParallelStep(s)
+            ? s.parallel.map((t) => t.agent)
+            : isDynamicParallelStep(s)
+                ? [s.parallel.agent]
+                : [s.agent];
+        for (const agentName of stepAgents) {
+            if (!agents.find((x) => x.name === agentName)) {
+                return { error: `Unknown agent: ${agentName}` };
+            }
+        }
+    }
+    let progressInstructionCreated = false;
+    const buildStepOverrides = (s) => {
+        const stepSkillInput = normalizeSkillInput(s.skill);
+        return {
+            ...(s.output !== undefined ? { output: s.output } : {}),
+            ...(s.outputMode !== undefined ? { outputMode: s.outputMode } : {}),
+            ...(s.reads !== undefined ? { reads: s.reads } : {}),
+            ...(s.progress !== undefined ? { progress: s.progress } : {}),
+            ...(stepSkillInput !== undefined ? { skills: stepSkillInput } : {}),
+            ...(s.model !== undefined ? { model: s.model } : {}),
+        };
+    };
+    const buildSeqStep = (s, sessionFile, behaviorCwd, progressPrecreated = false, resolvedBehavior, flatIndex, parallelOutputNamespace) => {
+        const a = agents.find((x) => x.name === s.agent);
+        const toolBudgetInput = s.toolBudget ?? params.toolBudget ?? a.toolBudget ?? params.configToolBudget;
+        const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, s.toolBudget ? "toolBudget" : a.toolBudget ? "agent.toolBudget" : "config.toolBudget");
+        if (resolvedToolBudget.error)
+            throw new AsyncStartValidationError(resolvedToolBudget.error);
+        const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
+        const instructionCwd = behaviorCwd ?? stepCwd;
+        let behavior = suppressProgressForReadOnlyTask(resolvedBehavior ?? resolveStepBehavior(a, buildStepOverrides(s), chainSkills), s.task, originalTask);
+        const inheritedRelativeParallelOutput = parallelOutputNamespace && s.output === undefined && typeof behavior.output === "string" && !path.isAbsolute(behavior.output);
+        if (inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex !== undefined) {
+            behavior = {
+                ...behavior,
+                output: path.join(`parallel-${parallelOutputNamespace.stepIndex}`, `${parallelOutputNamespace.taskIndex}-${s.agent}`, behavior.output),
+            };
+        }
+        const namespaceOutputPath = Boolean(inheritedRelativeParallelOutput && parallelOutputNamespace.taskIndex === undefined);
+        const skillNames = behavior.skills === false ? [] : behavior.skills;
+        const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd, a.skillPath, a.filePath ? path.dirname(a.filePath) : stepCwd);
+        if (missingSkills.includes("pi-subagents"))
+            throw new UnavailableSubagentSkillError(UNAVAILABLE_SUBAGENT_SKILL_ERROR);
+        let systemPrompt = a.systemPrompt?.trim() ?? "";
+        if (resolvedSkills.length > 0) {
+            const injection = buildSkillInjection(resolvedSkills);
+            systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
+        }
+        const memoryInjection = buildAgentMemoryInjection(a, stepCwd);
+        if (memoryInjection) {
+            systemPrompt = systemPrompt ? `${systemPrompt}\n\n${memoryInjection}` : memoryInjection;
+        }
+        const readInstructions = buildChainInstructions({ ...behavior, output: false, progress: false }, instructionCwd, false);
+        const isFirstProgressAgent = behavior.progress && !progressPrecreated && !progressInstructionCreated;
+        if (behavior.progress)
+            progressInstructionCreated = true;
+        const progressInstructions = buildChainInstructions({ ...behavior, output: false, reads: false }, progressDir, isFirstProgressAgent);
+        const outputPath = resolveSingleOutputPath(behavior.output, ctx.cwd, instructionCwd, outputBaseDir);
+        if (!namespaceOutputPath)
+            systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, a);
+        const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Async step (${s.agent})`);
+        if (validationError)
+            throw new AsyncStartValidationError(validationError);
+        let taskTemplate = s.task ?? "{previous}";
+        taskTemplate = taskTemplate.replace(/\{task\}/g, originalTask ?? "");
+        taskTemplate = taskTemplate.replace(/\{chain_dir\}/g, runnerCwd);
+        const taskText = `${readInstructions.prefix}${taskTemplate}${progressInstructions.suffix}`;
+        const task = namespaceOutputPath ? taskText : injectSingleOutputInstruction(taskText, outputPath, a);
+        const primaryModel = resolveEffectiveSubagentModel(s.model, a.model, ctx.currentModel, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope });
+        const thinkingOverride = flatIndex === undefined ? undefined : thinkingOverridesByFlatIndex?.[flatIndex];
+        const effectiveThinking = thinkingOverride ?? a.thinking;
+        const model = applyThinkingSuffix(primaryModel, effectiveThinking, thinkingOverride !== undefined);
+        return {
+            parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
+            agent: s.agent,
+            task,
+            phase: s.phase,
+            label: s.label,
+            outputName: s.as,
+            structured: Boolean(s.outputSchema),
+            cwd: stepCwd,
+            model,
+            thinking: resolveEffectiveThinking(model, effectiveThinking),
+            modelCandidates: buildModelCandidates(primaryModel, a.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, thinkingOverride !== undefined)),
+            tools: a.tools,
+            extensions: a.extensions,
+            subagentOnlyExtensions: a.subagentOnlyExtensions,
+            mcpDirectTools: a.mcpDirectTools,
+            completionGuard: a.completionGuard,
+            systemPrompt,
+            systemPromptMode: a.systemPromptMode,
+            inheritProjectContext: a.inheritProjectContext,
+            inheritSkills: a.inheritSkills,
+            skills: resolvedSkills.map((r) => r.name),
+            outputPath,
+            ...(namespaceOutputPath ? { namespaceOutputPath: true } : {}),
+            outputMode: behavior.outputMode,
+            sessionFile,
+            maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, a.maxSubagentDepth),
+            waitToolEnabled: params.waitToolEnabled,
+            effectiveAcceptance: resolveEffectiveAcceptance({
+                explicit: s.acceptance,
+                agentName: s.agent,
+                acceptanceRole: a.acceptanceRole,
+                task,
+                mode: resultMode,
+                async: true,
+                dynamic: false,
+            }),
+            acceptanceInput: s.acceptance,
+            acceptanceRole: a.acceptanceRole,
+            ...(s.outputSchema ? { structuredOutputSchema: s.outputSchema } : {}),
+            ...(s.outputSchema ? { structuredOutput: createStructuredOutputRuntime(s.outputSchema, path.join(asyncDir, "structured-output")) } : {}),
+            ...(resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}),
+        };
+    };
+    let flatStepIndex = 0;
+    const nextFlatStep = () => {
+        const index = flatStepIndex;
+        const sessionFile = sessionFilesByFlatIndex?.[flatStepIndex];
+        const thinkingOverride = thinkingOverridesByFlatIndex?.[flatStepIndex];
+        flatStepIndex++;
+        return {
+            index,
+            ...(sessionFile ? { sessionFile } : {}),
+            ...(thinkingOverride ? { thinkingOverride } : {}),
+        };
+    };
+    try {
+        const builtSteps = chain.map((s, stepIndex) => {
+            if (isParallelStep(s)) {
+                const parallelBehaviors = s.parallel.map((task) => {
+                    const agent = agents.find((candidate) => candidate.name === task.agent);
+                    return suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(task), chainSkills), task.task, originalTask);
+                });
+                const progressPrecreated = parallelBehaviors.some((behavior) => behavior.progress);
+                if (progressPrecreated) {
+                    if (!s.worktree || params.progressDir)
+                        writeInitialProgressFile(progressDir);
+                    progressInstructionCreated = true;
+                }
+                return {
+                    parallel: s.parallel.map((t, taskIndex) => {
+                        let behaviorCwd;
+                        if (s.worktree) {
+                            try {
+                                behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, taskIndex, worktreeBaseDir);
+                            }
+                            catch {
+                                behaviorCwd = undefined;
+                            }
+                        }
+                        const staticStep = nextFlatStep();
+                        return buildSeqStep(t, staticStep.sessionFile, behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex], staticStep.index, { stepIndex, taskIndex });
+                    }),
+                    concurrency: s.concurrency,
+                    failFast: s.failFast,
+                    worktree: s.worktree,
+                };
+            }
+            if (isDynamicParallelStep(s)) {
+                const agent = agents.find((candidate) => candidate.name === s.parallel.agent);
+                const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agent, buildStepOverrides(s.parallel), chainSkills), s.parallel.task, originalTask);
+                const progressPrecreated = behavior.progress;
+                if (progressPrecreated) {
+                    writeInitialProgressFile(progressDir);
+                    progressInstructionCreated = true;
+                }
+                const maxItems = s.expand.maxItems ?? params.dynamicFanoutMaxItems ?? 0;
+                const dynamicFlatSteps = Array.from({ length: maxItems }, () => nextFlatStep());
+                const parallel = buildSeqStep(s.parallel, undefined, undefined, progressPrecreated, behavior, undefined, { stepIndex });
+                return {
+                    expand: s.expand,
+                    parallel,
+                    collect: s.collect,
+                    concurrency: s.concurrency,
+                    failFast: s.failFast,
+                    phase: s.phase,
+                    label: s.label,
+                    sessionFiles: dynamicFlatSteps.map((step) => step.sessionFile),
+                    thinkingOverrides: dynamicFlatSteps.map((step) => step.thinkingOverride),
+                    effectiveAcceptance: resolveEffectiveAcceptance({
+                        explicit: s.acceptance,
+                        agentName: s.parallel.agent,
+                        acceptanceRole: agent.acceptanceRole,
+                        task: parallel.task,
+                        mode: resultMode,
+                        async: true,
+                        dynamicGroup: true,
+                    }),
+                    acceptanceInput: s.acceptance,
+                    acceptanceRole: agent.acceptanceRole,
+                };
+            }
+            const staticStep = nextFlatStep();
+            return buildSeqStep(s, staticStep.sessionFile, undefined, false, undefined, staticStep.index);
+        });
+        const steps = params.attachRoot
+            ? [{
+                    agent: params.attachRoot.agent,
+                    task: "",
+                    label: params.attachRoot.label ?? `Attached root ${params.attachRoot.runId}`,
+                    outputName: params.attachRoot.outputName,
+                    importAsyncRoot: {
+                        runId: params.attachRoot.runId,
+                        asyncDir: params.attachRoot.asyncDir,
+                        resultPath: params.attachRoot.resultPath,
+                        index: params.attachRoot.index,
+                    },
+                    inheritProjectContext: false,
+                    inheritSkills: false,
+                }, ...builtSteps]
+            : builtSteps;
+        for (const step of steps) {
+            if (!("parallel" in step) || !Array.isArray(step.parallel))
+                continue;
+            const seen = new Map();
+            for (let index = 0; index < step.parallel.length; index++) {
+                const task = step.parallel[index];
+                if (!task.outputPath)
+                    continue;
+                const previous = seen.get(task.outputPath);
+                if (previous) {
+                    throw new AsyncStartValidationError(`Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${task.outputPath}. Use distinct output paths.`);
+                }
+                seen.set(task.outputPath, { index, agent: task.agent });
+            }
+        }
+        return { steps, runnerCwd, workflowGraph, eventChain: graphChain, ...(originalTask !== undefined ? { originalTask } : {}) };
+    }
+    catch (error) {
+        if (error instanceof UnavailableSubagentSkillError || error instanceof AsyncStartValidationError)
+            return { error: error.message };
+        throw error;
+    }
+}
+/**
+ * Execute a chain asynchronously
+ */
+export function executeAsyncChain(id, params) {
+    const { chain, agents, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFilesByFlatIndex, thinkingOverridesByFlatIndex, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
+    const resultMode = params.resultMode ?? "chain";
+    const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
+    const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
+    const asyncDir = inheritedNestedRoute
+        ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id)
+        : path.join(ASYNC_DIR, id);
+    try {
+        fs.mkdirSync(asyncDir, { recursive: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Failed to create async run directory '${asyncDir}': ${message}` }],
+            isError: true,
+            details: { mode: resultMode, results: [] },
+        };
+    }
+    const built = buildAsyncRunnerSteps(id, {
+        chain,
+        task: params.task,
+        attachRoot: params.attachRoot,
+        resultMode,
+        agents,
+        ctx,
+        availableModels: params.availableModels,
+        cwd,
+        chainSkills: params.chainSkills,
+        sessionFilesByFlatIndex,
+        thinkingOverridesByFlatIndex,
+        progressDir: params.progressDir ?? (artifactsDir ? path.join(artifactsDir, "progress", id) : resultMode === "parallel" ? path.join(asyncDir, "progress") : undefined),
+        outputBaseDir: artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined,
+        dynamicFanoutMaxItems: params.dynamicFanoutMaxItems,
+        maxSubagentDepth,
+        waitToolEnabled: params.waitToolEnabled,
+        worktreeBaseDir,
+        asyncDir,
+        toolBudget: params.toolBudget,
+        configToolBudget: params.configToolBudget,
+    });
+    if ("error" in built) {
+        try {
+            fs.rmSync(asyncDir, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup for validation failures before the runner is spawned.
+        }
+        return formatAsyncStartError(resultMode, built.error);
+    }
+    const { steps, runnerCwd, workflowGraph, eventChain } = built;
+    const deadlineAt = params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined;
+    const initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : undefined;
+    let childTargetIndex = 0;
+    const childIntercomTargets = childIntercomTarget ? steps.flatMap((step) => {
+        if (!("parallel" in step) && step.importAsyncRoot) {
+            childTargetIndex++;
+            return [undefined];
+        }
+        if ("parallel" in step) {
+            if (!Array.isArray(step.parallel)) {
+                childTargetIndex++;
+                return [undefined];
+            }
+            return step.parallel.map((task) => childIntercomTarget(task.agent, childTargetIndex++));
+        }
+        return [childIntercomTarget(step.agent, childTargetIndex++)];
+    }) : undefined;
+    let spawnResult = {};
+    try {
+        spawnResult = spawnRunner({
+            id,
+            steps,
+            resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(RESULTS_DIR, `${id}.json`),
+            cwd: runnerCwd,
+            placeholder: "{previous}",
+            maxOutput,
+            artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+            artifactConfig,
+            share: shareEnabled,
+            sessionDir: sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined,
+            asyncDir,
+            sessionId: ctx.currentSessionId,
+            piPackageRoot,
+            piArgv1: process.argv[1],
+            worktreeSetupHook,
+            worktreeSetupHookTimeoutMs,
+            worktreeBaseDir,
+            controlConfig,
+            turnBudget: params.turnBudget,
+            toolBudget: params.toolBudget,
+            controlIntercomTarget,
+            childIntercomTargets,
+            resultMode,
+            dynamicFanoutMaxItems: params.dynamicFanoutMaxItems,
+            timeoutMs: params.timeoutMs,
+            deadlineAt,
+            globalConcurrencyLimit: params.globalConcurrencyLimit,
+            workflowGraph,
+            nestedRoute: nestedRoute ?? inheritedNestedRoute,
+            nestedSelf: inheritedNestedRoute && nestedAddress ? {
+                parentRunId: nestedAddress.parentRunId,
+                parentStepIndex: nestedAddress.parentStepIndex,
+                depth: nestedAddress.depth,
+                path: nestedAddress.path,
+            } : undefined,
+        }, id, runnerCwd);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${message}`);
+    }
+    if (spawnResult.error) {
+        return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${spawnResult.error}`);
+    }
+    if (spawnResult.pid) {
+        const eventFirstStep = eventChain[0];
+        const firstAgents = isParallelStep(eventFirstStep)
+            ? eventFirstStep.parallel.map((t) => t.agent)
+            : isDynamicParallelStep(eventFirstStep)
+                ? [eventFirstStep.parallel.agent]
+                : [eventFirstStep.agent];
+        const firstTask = isParallelStep(eventFirstStep)
+            ? eventFirstStep.parallel[0]?.task
+            : isDynamicParallelStep(eventFirstStep)
+                ? eventFirstStep.parallel.task
+                : eventFirstStep.task;
+        const workflowGoal = params.goal ?? (params.task?.trim() || firstTask);
+        const parallelGroups = [];
+        const flatAgents = [];
+        let flatStepStart = 0;
+        for (let stepIndex = 0; stepIndex < eventChain.length; stepIndex++) {
+            const step = eventChain[stepIndex];
+            if (isParallelStep(step)) {
+                parallelGroups.push({ start: flatStepStart, count: step.parallel.length, stepIndex });
+                flatAgents.push(...step.parallel.map((task) => task.agent));
+                flatStepStart += step.parallel.length;
+            }
+            else if (isDynamicParallelStep(step)) {
+                parallelGroups.push({ start: flatStepStart, count: 1, stepIndex });
+                flatAgents.push(step.parallel.agent);
+                flatStepStart++;
+            }
+            else {
+                flatAgents.push(step.agent);
+                flatStepStart++;
+            }
+        }
+        if (inheritedNestedRoute && nestedAddress) {
+            const now = Date.now();
+            try {
+                writeNestedEvent(inheritedNestedRoute, {
+                    type: "subagent.nested.started",
+                    ts: now,
+                    parentRunId: nestedAddress.parentRunId,
+                    parentStepIndex: nestedAddress.parentStepIndex,
+                    child: {
+                        id,
+                        parentRunId: nestedAddress.parentRunId,
+                        parentStepIndex: nestedAddress.parentStepIndex,
+                        depth: nestedAddress.depth,
+                        path: nestedAddress.path,
+                        asyncDir,
+                        pid: spawnResult.pid,
+                        ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
+                        leafIntercomTarget: childIntercomTargets?.[0],
+                        intercomTarget: childIntercomTargets?.[0],
+                        ownerState: "live",
+                        mode: resultMode,
+                        state: "running",
+                        agent: firstAgents[0],
+                        agents: flatAgents,
+                        chainStepCount: eventChain.length,
+                        parallelGroups,
+                        ...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}),
+                        ...(initialTurnBudget ? { turnBudget: initialTurnBudget } : {}),
+                        startedAt: now,
+                        lastUpdate: now,
+                    },
+                });
+            }
+            catch (error) {
+                console.error("Failed to emit nested async start event:", error);
+            }
+        }
+        ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+            lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+            id,
+            pid: spawnResult.pid,
+            sessionId: ctx.currentSessionId,
+            mode: resultMode,
+            agent: firstAgents[0],
+            agents: flatAgents,
+            task: firstTask?.slice(0, 50),
+            goal: workflowGoal?.slice(0, 120),
+            chain: eventChain.map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent),
+            chainStepCount: eventChain.length,
+            parallelGroups,
+            workflowGraph,
+            cwd: runnerCwd,
+            asyncDir,
+            ...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}),
+            ...(initialTurnBudget ? { turnBudget: initialTurnBudget } : {}),
+            nestedRoute,
+        });
+    }
+    const chainDesc = chain
+        .map((s) => isParallelStep(s) ? `[${s.parallel.map((t) => t.agent).join("+")}]` : isDynamicParallelStep(s) ? `expand:${s.parallel.agent}` : s.agent)
+        .join(" -> ");
+    return {
+        content: [{ type: "text", text: formatAsyncStartedMessage(`Async ${resultMode}: ${chainDesc} [${id}]`) }],
+        details: { mode: resultMode, runId: id, results: [], asyncId: id, asyncDir, workflowGraph, ...(params.timeoutMs !== undefined ? { timeoutMs: params.timeoutMs, deadlineAt } : {}), ...(params.turnBudget ? { turnBudget: params.turnBudget } : {}), ...(params.toolBudget ? { toolBudget: params.toolBudget } : {}) },
+    };
+}
+/**
+ * Execute a single agent asynchronously
+ */
+export function executeAsyncSingle(id, params) {
+    const { agent, agentConfig, ctx, cwd, maxOutput, artifactsDir, artifactConfig, shareEnabled, sessionRoot, sessionFile, maxSubagentDepth, worktreeSetupHook, worktreeSetupHookTimeoutMs, worktreeBaseDir, controlConfig, controlIntercomTarget, childIntercomTarget, nestedRoute, } = params;
+    const task = params.task ?? "";
+    const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
+    const skillNames = params.skills ?? agentConfig.skills ?? [];
+    const availableModels = params.availableModels;
+    const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, runnerCwd, ctx.cwd, agentConfig.skillPath, agentConfig.filePath ? path.dirname(agentConfig.filePath) : runnerCwd);
+    if (missingSkills.includes("pi-subagents"))
+        return formatAsyncStartError("single", UNAVAILABLE_SUBAGENT_SKILL_ERROR);
+    let systemPrompt = agentConfig.systemPrompt?.trim() ?? "";
+    if (resolvedSkills.length > 0) {
+        const injection = buildSkillInjection(resolvedSkills);
+        systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
+    }
+    const memoryInjection = buildAgentMemoryInjection(agentConfig, runnerCwd);
+    if (memoryInjection) {
+        systemPrompt = systemPrompt ? `${systemPrompt}\n\n${memoryInjection}` : memoryInjection;
+    }
+    const inheritedNestedRoute = resolveInheritedNestedRouteFromEnv();
+    const nestedAddress = inheritedNestedRoute ? resolveNestedParentAddressFromEnv() : undefined;
+    const asyncDir = inheritedNestedRoute
+        ? path.join(TEMP_ROOT_DIR, "nested-subagent-runs", inheritedNestedRoute.rootRunId, id)
+        : path.join(ASYNC_DIR, id);
+    try {
+        fs.mkdirSync(asyncDir, { recursive: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Failed to create async run directory '${asyncDir}': ${message}` }],
+            isError: true,
+            details: { mode: "single", results: [] },
+        };
+    }
+    const effectiveOutput = normalizeSingleOutputOverride(params.output, agentConfig.output);
+    const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, runnerCwd, params.outputBaseDir ?? (artifactsDir ? path.join(artifactsDir, "outputs", id) : undefined));
+    systemPrompt = injectOutputPathSystemPrompt(systemPrompt, outputPath, agentConfig);
+    const outputMode = params.outputMode ?? "inline";
+    const validationError = validateFileOnlyOutputMode(outputMode, outputPath, `Async single run (${agent})`);
+    if (validationError)
+        return formatAsyncStartError("single", validationError);
+    const taskWithOutputInstruction = injectSingleOutputInstruction(task, outputPath, agentConfig);
+    const primaryModel = resolveSubagentModelOverride(params.modelOverride ?? agentConfig.model, ctx.currentModel, availableModels, ctx.currentModelProvider);
+    const effectiveThinking = params.thinkingOverride ?? agentConfig.thinking;
+    const model = applyThinkingSuffix(primaryModel, effectiveThinking, params.thinkingOverride !== undefined);
+    const toolBudgetInput = params.toolBudget ?? agentConfig.toolBudget ?? params.configToolBudget;
+    const resolvedToolBudget = validateToolBudgetConfig(toolBudgetInput, params.toolBudget ? "toolBudget" : agentConfig.toolBudget ? "agent.toolBudget" : "config.toolBudget");
+    if (resolvedToolBudget.error)
+        return formatAsyncStartError("single", resolvedToolBudget.error);
+    const deadlineAt = params.absoluteDeadlineAt ?? (params.timeoutMs !== undefined ? Date.now() + params.timeoutMs : undefined);
+    const timeoutMs = params.absoluteDeadlineAt !== undefined && deadlineAt !== undefined
+        ? deadlineAt - Date.now()
+        : params.timeoutMs;
+    if (timeoutMs !== undefined && timeoutMs <= 0)
+        return formatAsyncStartError("single", "The source run's absolute deadline expired before recovery could launch.");
+    const initialTurnBudget = params.turnBudget ? initialTurnBudgetState(params.turnBudget) : undefined;
+    const resolvedSessionDir = params.sessionDir ?? (sessionRoot ? path.join(sessionRoot, `async-${id}`) : undefined);
+    const resolvedAcceptance = resolveEffectiveAcceptance({
+        explicit: params.acceptance,
+        agentName: agent,
+        acceptanceRole: agentConfig.acceptanceRole,
+        task,
+        mode: "single",
+        async: true,
+    });
+    const recoveryDescriptor = {
+        version: 1,
+        sourceRunId: id,
+        agent,
+        ...(sessionFile ? { sessionFile } : {}),
+        cwd: runnerCwd,
+        ...(model ? { model } : {}),
+        ...(agentConfig.fallbackModels ? { fallbackModels: [...agentConfig.fallbackModels] } : {}),
+        ...(effectiveThinking ? { thinking: resolveEffectiveThinking(model, effectiveThinking) } : {}),
+        ...(agentConfig.tools ? { tools: [...agentConfig.tools] } : {}),
+        ...(agentConfig.extensions ? { extensions: [...agentConfig.extensions] } : {}),
+        ...(agentConfig.subagentOnlyExtensions ? { subagentOnlyExtensions: [...agentConfig.subagentOnlyExtensions] } : {}),
+        ...(agentConfig.mcpDirectTools ? { mcpDirectTools: [...agentConfig.mcpDirectTools] } : {}),
+        ...(agentConfig.systemPrompt ? { systemPrompt: agentConfig.systemPrompt } : {}),
+        systemPromptMode: agentConfig.systemPromptMode,
+        inheritProjectContext: agentConfig.inheritProjectContext,
+        inheritSkills: agentConfig.inheritSkills,
+        ...(resolvedSkills.length ? { skills: resolvedSkills.map((skill) => skill.name) } : {}),
+        ...(agentConfig.skillPath ? { skillPath: [...agentConfig.skillPath] } : {}),
+        ...(agentConfig.filePath ? { agentFilePath: agentConfig.filePath } : {}),
+        ...(agentConfig.completionGuard !== undefined ? { completionGuard: agentConfig.completionGuard } : {}),
+        ...(agentConfig.memory ? { memory: { ...agentConfig.memory } } : {}),
+        ...(outputPath ? { outputPath } : {}),
+        outputMode,
+        ...(resolvedAcceptance ? { acceptance: resolvedAcceptance } : {}),
+        ...(controlConfig ? { controlConfig } : {}),
+        ...(deadlineAt !== undefined ? { absoluteDeadlineAt: deadlineAt } : {}),
+        ...(params.turnBudget ? { initialTurnBudget: params.turnBudget } : {}),
+        ...(resolvedToolBudget.budget ? { initialToolBudget: resolvedToolBudget.budget } : {}),
+        maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
+        ...(maxOutput ? { maxOutput } : {}),
+        share: shareEnabled,
+        ...(resolvedSessionDir ? { sessionDir: resolvedSessionDir } : {}),
+        ...(artifactsDir ? { artifactsDir } : {}),
+        artifactConfig,
+    };
+    try {
+        writePrivateAtomicJson(path.join(asyncDir, "recovery-descriptor.json"), recoveryDescriptor);
+    }
+    catch (error) {
+        return formatAsyncStartError("single", `Failed to persist async recovery descriptor for '${id}': ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let spawnResult = {};
+    try {
+        spawnResult = spawnRunner({
+            id,
+            steps: [
+                {
+                    parentSessionId: ctx.parentSessionId ?? ctx.currentSessionId,
+                    agent,
+                    task: taskWithOutputInstruction,
+                    cwd: runnerCwd,
+                    model,
+                    thinking: resolveEffectiveThinking(model, effectiveThinking),
+                    modelCandidates: buildModelCandidates(primaryModel, agentConfig.fallbackModels, availableModels, ctx.currentModelProvider, { scope: ctx.modelScope }).map((candidate) => applyThinkingSuffix(candidate, effectiveThinking, params.thinkingOverride !== undefined)),
+                    tools: agentConfig.tools,
+                    extensions: agentConfig.extensions,
+                    subagentOnlyExtensions: agentConfig.subagentOnlyExtensions,
+                    mcpDirectTools: agentConfig.mcpDirectTools,
+                    completionGuard: agentConfig.completionGuard,
+                    systemPrompt,
+                    systemPromptMode: agentConfig.systemPromptMode,
+                    inheritProjectContext: agentConfig.inheritProjectContext,
+                    inheritSkills: agentConfig.inheritSkills,
+                    skills: resolvedSkills.map((r) => r.name),
+                    outputPath,
+                    outputMode,
+                    sessionFile,
+                    maxSubagentDepth: resolveChildMaxSubagentDepth(maxSubagentDepth, agentConfig.maxSubagentDepth),
+                    waitToolEnabled: params.waitToolEnabled,
+                    effectiveAcceptance: resolvedAcceptance,
+                    ...(resolvedToolBudget.budget ? { toolBudget: resolvedToolBudget.budget } : {}),
+                },
+            ],
+            resultPath: inheritedNestedRoute ? nestedResultsPath(inheritedNestedRoute.rootRunId, id) : path.join(RESULTS_DIR, `${id}.json`),
+            cwd: runnerCwd,
+            placeholder: "{previous}",
+            maxOutput,
+            artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
+            artifactConfig,
+            share: shareEnabled,
+            sessionDir: resolvedSessionDir,
+            asyncDir,
+            sessionId: ctx.currentSessionId,
+            piPackageRoot,
+            piArgv1: process.argv[1],
+            worktreeSetupHook,
+            worktreeSetupHookTimeoutMs,
+            worktreeBaseDir,
+            controlConfig,
+            timeoutMs,
+            deadlineAt,
+            turnBudget: params.turnBudget,
+            toolBudget: params.toolBudget,
+            controlIntercomTarget,
+            childIntercomTargets: childIntercomTarget ? [childIntercomTarget(agent, 0)] : undefined,
+            resultMode: "single",
+            ...(params.revivalLease ? { revivalLease: params.revivalLease } : {}),
+            nestedRoute: nestedRoute ?? inheritedNestedRoute,
+            nestedSelf: inheritedNestedRoute && nestedAddress ? {
+                parentRunId: nestedAddress.parentRunId,
+                parentStepIndex: nestedAddress.parentStepIndex,
+                depth: nestedAddress.depth,
+                path: nestedAddress.path,
+            } : undefined,
+        }, id, runnerCwd);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return formatAsyncStartError("single", `Failed to start async run '${id}': ${message}`);
+    }
+    if (spawnResult.error) {
+        return formatAsyncStartError("single", `Failed to start async run '${id}': ${spawnResult.error}`);
+    }
+    if (spawnResult.pid) {
+        if (inheritedNestedRoute && nestedAddress) {
+            const now = Date.now();
+            try {
+                writeNestedEvent(inheritedNestedRoute, {
+                    type: "subagent.nested.started",
+                    ts: now,
+                    parentRunId: nestedAddress.parentRunId,
+                    parentStepIndex: nestedAddress.parentStepIndex,
+                    child: {
+                        id,
+                        parentRunId: nestedAddress.parentRunId,
+                        parentStepIndex: nestedAddress.parentStepIndex,
+                        depth: nestedAddress.depth,
+                        path: nestedAddress.path,
+                        asyncDir,
+                        pid: spawnResult.pid,
+                        ownerIntercomTarget: process.env.PI_SUBAGENT_INTERCOM_SESSION_NAME,
+                        leafIntercomTarget: childIntercomTarget?.(agent, 0),
+                        intercomTarget: childIntercomTarget?.(agent, 0),
+                        ownerState: "live",
+                        mode: "single",
+                        state: "running",
+                        agent,
+                        agents: [agent],
+                        chainStepCount: 1,
+                        ...(timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {}),
+                        ...(initialTurnBudget ? { turnBudget: initialTurnBudget } : {}),
+                        startedAt: now,
+                        lastUpdate: now,
+                    },
+                });
+            }
+            catch (error) {
+                console.error("Failed to emit nested async start event:", error);
+            }
+        }
+        ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
+            lifecycleArtifactVersion: SUBAGENT_LIFECYCLE_ARTIFACT_VERSION,
+            id,
+            pid: spawnResult.pid,
+            sessionId: ctx.currentSessionId,
+            mode: "single",
+            agent,
+            task: task?.slice(0, 50),
+            goal: (params.goal ?? task).slice(0, 120),
+            cwd: runnerCwd,
+            asyncDir,
+            ...(timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {}),
+            ...(initialTurnBudget ? { turnBudget: initialTurnBudget } : {}),
+            nestedRoute,
+        });
+    }
+    return {
+        content: [{ type: "text", text: formatAsyncStartedMessage(`Async: ${agent} [${id}]`) }],
+        details: { mode: "single", runId: id, results: [], asyncId: id, asyncDir, ...(timeoutMs !== undefined ? { timeoutMs, deadlineAt } : {}), ...(params.turnBudget ? { turnBudget: params.turnBudget } : {}), ...(params.toolBudget ? { toolBudget: params.toolBudget } : {}) },
+    };
+}
+//# sourceMappingURL=async-execution.js.map