pi-subagents 0.69.0 → 0.70.0

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

@@ -0,0 +1,826 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { safeTerminalText } from "../../shared/display-text.js";
+import { getArtifactPaths, getArtifactsDir } from "../../shared/artifacts.js";
+import { readFleetTranscript } from "../../tui/fleet-transcript.js";
+import { formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, formatWorkflowStageLine, listAsyncRuns } from "./async-status.js";
+import { formatAsyncResultTranscript, formatAsyncRunTranscript, formatNestedRunTranscript, inspectSubagentFleet } from "./fleet-view.js";
+import { formatNestedRunStatusLines } from "../shared/nested-render.js";
+import { formatModelThinking } from "../../shared/formatters.js";
+import { formatActivityLabel } from "../../shared/status-format.js";
+import { DIRS } from "../../shared/types.js";
+import { inspectActiveAsyncCapacityOwner } from "./active-async-capacity.js";
+import { readStatus } from "../../shared/utils.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { normalizeExternalCliRunnerStatus } from "../shared/external-cli-contract.js";
+import { resolveSubagentResultStatus } from "../../intercom/result-intercom.js";
+import { readProcessTerminal, sanitizeProcessTerminal } from "./process-terminal.js";
+import { formatWaitSubscriptions } from "./wait-subscriptions.js";
+import { resolveAsyncRunLocation } from "./async-resume.js";
+import { resolveSubagentRunId } from "./run-id-resolver.js";
+import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.js";
+import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
+import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot } from "../shared/nested-events.js";
+import { readMissionBinding } from "../../missions/lifecycle.js";
+import { formatWorkflowJsonPreview } from "../../workflows/scripted-workflow.js";
+import { parseWorkflowChildSummary } from "../../workflows/workflow-child-summary.js";
+import { formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary } from "../../workflows/workflow-preflight.js";
+import { formatRunFanoutBudget, getRunFanoutBudgetSnapshot, readRunFanoutBudgetDescriptor } from "../shared/run-fanout-budget.js";
+import { workflowGraphStageNodes } from "../shared/workflow-graph.js";
+import { getExternalJobProvider } from "../../api/external-job-provider.js";
+import { formatTimeoutRecoveryLines } from "../shared/mutation-evidence.js";
+import { formatWorkflowChecklistText, projectWorkflowChecklist } from "../../workflows/workflow-checklist.js";
+import { validHostStepNodes } from "../shared/host-step-status.js";
+import { workflowAsyncChildSteeringGuidance } from "../shared/workflow-async-child-guidance.js";
+function formatProcessTerminal(value) {
+    if (!value)
+        return "missing";
+    return `${value.state}${value.reason ? ` (${value.reason})` : ""}${value.runnerProcessInstanceId ? ` · runner ${value.runnerProcessInstanceId}` : ""}`;
+}
+function debugProcessTerminal(asyncDir, status) {
+    const expected = { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId };
+    return {
+        sidecar: readProcessTerminal(asyncDir, expected),
+        overlay: sanitizeProcessTerminal(status.processTerminal, expected, path.join(asyncDir, "status.json")),
+    };
+}
+function formatCapacityOwner(inspect) {
+    if (!inspect.owner)
+        return [`Active capacity: ${inspect.release.state} — ${inspect.release.reason}`];
+    const owner = inspect.owner;
+    return [
+        `Active capacity: ${inspect.release.state} — ${inspect.release.reason}`,
+        `Capacity owner: ${inspect.relation} slot ${owner.slot}, ${owner.kind}, generation ${owner.generation}`,
+        `Capacity session: ${owner.ownerSessionId}`,
+        owner.sourceRunId ? `Capacity source run: ${owner.sourceRunId}` : undefined,
+        `Capacity async dir: ${owner.asyncDir}`,
+        owner.runnerProcessInstanceId ? `Capacity runner: ${owner.runnerProcessInstanceId}` : undefined,
+        owner.runnerStartedAt !== undefined ? `Capacity runner started: ${new Date(owner.runnerStartedAt).toISOString()}` : undefined,
+    ].filter((line) => line !== undefined);
+}
+function formatWorkflowDebug(status) {
+    if (status.mode !== "workflow" && !status.parentWorkflowRunId && !status.workflowKey && !status.lane)
+        return [];
+    const lines = [
+        status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
+        status.mode === "workflow" ? `Workflow children: ${(status.steps ?? []).length}` : undefined,
+        status.lane ? `Lane: ${status.lane.key}${status.lane.mode ? ` (${status.lane.mode})` : ""}` : undefined,
+    ].filter((line) => line !== undefined);
+    for (const [index, step] of (status.steps ?? []).entries()) {
+        lines.push(`  ${index + 1}. key ${step.workflowKey ?? "n/a"} · ${runStatusStepDisplayName(step)} · ${step.status} · async ${step.async === undefined ? "unknown" : step.async ? "yes" : "no"}${step.runId ? ` · run ${step.runId}` : ""}${step.lane ? ` · lane ${step.lane.key}` : ""}${step.worktreePath ? ` · worktree ${step.worktreePath} · branch ${step.branch ?? "unknown"}${step.provider ? ` · provider ${step.provider}` : ""}` : ""}`);
+    }
+    return lines;
+}
+function formatRunLifecycleDebug(input) {
+    const { status, asyncDir, sidecarProcessTerminal, overlayProcessTerminal, capacity } = input;
+    const lines = [
+        "Run lifecycle debug",
+        `Run: ${status.runId}`,
+        `Dir: ${asyncDir}`,
+        `Status file: ${path.join(asyncDir, "status.json")}`,
+        status.workflowReceiptPath ? `Workflow receipt: ${status.workflowReceiptPath}` : undefined,
+        `Process terminal file: ${path.join(asyncDir, "process-terminal.json")}`,
+        `Session: ${status.sessionId ?? "unknown"}`,
+        `State: ${status.state}`,
+        `Mode: ${status.mode}`,
+        status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}` : undefined,
+        status.workflowKey ? `Workflow key: ${status.workflowKey}` : undefined,
+        status.lane ? `Lane: ${status.lane.key}${status.lane.mode ? ` (${status.lane.mode})` : ""}` : undefined,
+        `Status process terminal: ${formatProcessTerminal(overlayProcessTerminal)}`,
+        `Sidecar process terminal: ${formatProcessTerminal(sidecarProcessTerminal)}`,
+        ...formatCapacityOwner(capacity),
+        ...formatWorkflowDebug(status),
+    ].filter((line) => line !== undefined);
+    return lines.join("\n");
+}
+function hasExistingSessionFile(value) {
+    return typeof value === "string" && fs.existsSync(value);
+}
+function formatResumeGuidance(runId, children, fallbackSessionFile, options = {}) {
+    if (options.stopped)
+        return "Resume: unavailable; stopped runs are not resumable. Start a new run instead.";
+    const knownChildren = children
+        .map((child, index) => ({ child, index }))
+        .filter(({ child }) => typeof child.agent === "string");
+    if (!runId || knownChildren.length === 0)
+        return "Resume: unavailable; no child session file was persisted.";
+    const workflowChildren = knownChildren.filter(({ child }) => typeof child.runId === "string" && child.runId.trim() && hasExistingSessionFile(child.sessionFile));
+    const supervisorDetachedWorkflowChildren = workflowChildren.filter(({ child }) => child.status === "paused" && child.activityState === "needs_attention");
+    const resumableWorkflowChildren = workflowChildren.filter(({ child }) => !(child.status === "paused" && child.activityState === "needs_attention"));
+    if (workflowChildren.length > 0) {
+        return [
+            ...supervisorDetachedWorkflowChildren.map(({ child }) => `Recovery workflow child${typeof child.workflowKey === "string" && child.workflowKey.trim() ? ` '${child.workflowKey}'` : ""}: reply to the supervisor request first, then wait with bg_wait({ id: "${child.runId}" }). Use subagent({ action: "status", id: "${child.runId}" }) to recover the result; do not resume or launch a replacement while it remains detached.`),
+            ...resumableWorkflowChildren.map(({ child }) => `Revive workflow child${typeof child.workflowKey === "string" && child.workflowKey.trim() ? ` '${child.workflowKey}'` : ""}: subagent({ action: "resume", id: "${child.runId}", message: "..." })`),
+        ].join("\n");
+    }
+    const singleSessionFile = knownChildren[0]?.child.sessionFile ?? fallbackSessionFile;
+    if (children.length === 1 && knownChildren.length === 1 && hasExistingSessionFile(singleSessionFile)) {
+        return `Revive: subagent({ action: "resume", id: "${runId}", message: "..." })`;
+    }
+    const childWithSession = knownChildren.find(({ child }) => hasExistingSessionFile(child.sessionFile));
+    if (childWithSession) {
+        return `Revive child: subagent({ action: "resume", id: "${runId}", index: ${childWithSession.index}, message: "..." })`;
+    }
+    return "Resume: unavailable; no child session file was persisted.";
+}
+function stepLineLabel(status, index) {
+    const steps = status.steps ?? [];
+    if (status.mode === "parallel")
+        return `Agent ${index + 1}/${steps.length || 1}`;
+    if (status.mode === "workflow")
+        return `Workflow child ${steps[index]?.workflowKey ?? index + 1}`;
+    if (status.mode === "chain") {
+        const chainStepCount = status.chainStepCount ?? (steps.length || 1);
+        const groups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
+        const group = groups.find((candidate) => index >= candidate.start && index < candidate.start + candidate.count);
+        if (group)
+            return `Step ${group.stepIndex + 1}/${chainStepCount} Agent ${index - group.start + 1}/${group.count}`;
+        return `Step ${flatToLogicalStepIndex(index, chainStepCount, groups) + 1}/${chainStepCount}`;
+    }
+    return `Step ${index + 1}`;
+}
+function runStatusStepDisplayName(step) {
+    return step.sessionName?.trim() || (step.label ? `${step.label} (${step.agent})` : step.agent);
+}
+function nestedRunDisplayName(run) {
+    if (run.sessionName?.trim())
+        return run.sessionName.trim();
+    if (run.agent)
+        return run.agent;
+    if (run.agents?.length)
+        return run.agents.join(", ");
+    return run.id;
+}
+function formatSteeringSummary(input) {
+    const steering = input.steering;
+    if (!steering || steering.requested === 0)
+        return undefined;
+    const lateAcknowledgments = steering.recent.reduce((count, request) => count + request.targets.filter((target) => target.lateDeliveredAt !== undefined).length, 0);
+    return `${steering.requested} requested, ${steering.scheduled} scheduled, ${steering.pending} pending, ${steering.delivered} delivered, ${steering.failed} failed, ${steering.recovered} recovered${lateAcknowledgments ? `, ${lateAcknowledgments} late acknowledged` : ""}`;
+}
+function externalJobFollowUpSupported(provider) {
+    try {
+        return typeof getExternalJobProvider(provider)?.followUp === "function";
+    }
+    catch {
+        return false;
+    }
+}
+function rememberedForegroundChildOutput(child) {
+    const outputPath = child.artifactPaths?.outputPath ?? child.savedOutputPath;
+    if (outputPath && fs.existsSync(outputPath)) {
+        try {
+            const artifactOutput = fs.readFileSync(outputPath, "utf-8").trim();
+            if (artifactOutput)
+                return artifactOutput;
+        }
+        catch {
+            // Fall back to the remembered snapshot below.
+        }
+    }
+    return child.finalOutput ?? "";
+}
+function formatRememberedForegroundStatus(run) {
+    const lines = [
+        `Run: ${run.runId}`,
+        "State: remembered foreground",
+        `Mode: ${run.mode}`,
+        `Updated: ${new Date(run.updatedAt).toISOString()}`,
+        `Cwd: ${run.cwd}`,
+    ];
+    for (const child of run.children) {
+        const output = rememberedForegroundChildOutput(child).trim().split(/\r?\n/).find((line) => line.trim());
+        const parts = [
+            `${child.index + 1}. ${child.sessionName?.trim() || child.agent} ${child.status}`,
+            child.exitCode !== undefined ? `exit ${child.exitCode}` : undefined,
+            child.detachedReason ? `detached: ${child.detachedReason}` : undefined,
+            child.acceptance ? `acceptance: ${child.acceptance.status}` : undefined,
+            child.error ? `error: ${child.error}` : undefined,
+            output ? `output: ${output.slice(0, 160)}` : undefined,
+        ].filter(Boolean);
+        lines.push(parts.join(", "));
+        if (child.sessionFile)
+            lines.push(`  Session: ${child.sessionFile}`);
+        if (child.transcriptPath)
+            lines.push(`  Transcript: ${child.transcriptPath}`);
+        if (child.artifactPaths?.outputPath)
+            lines.push(`  Output: ${child.artifactPaths.outputPath}`);
+        if (child.savedOutputPath && child.savedOutputPath !== child.artifactPaths?.outputPath)
+            lines.push(`  Saved output: ${child.savedOutputPath}`);
+        if (child.outputSaveError)
+            lines.push(`  Output warning: ${child.outputSaveError}`);
+        if (child.transcriptError)
+            lines.push(`  Transcript warning: ${child.transcriptError}`);
+    }
+    lines.push("", `Status: subagent({ action: "status", id: "${run.runId}" })`);
+    if (run.children.length === 1)
+        lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", view: "transcript" })`);
+    else
+        lines.push(`Transcript: subagent({ action: "status", id: "${run.runId}", index: 0, view: "transcript" })`);
+    const detached = run.children.some((child) => child.status === "detached");
+    const resumable = run.children.find((child) => hasExistingSessionFile(child.sessionFile));
+    if (detached) {
+        lines.push(`Recovery: reply to the supervisor request first, then wait with bg_wait({ id: "${run.runId}" }); do not resume or launch a replacement while any child remains detached.`);
+    }
+    else if (resumable) {
+        lines.push(run.children.length === 1
+            ? `Revive: subagent({ action: "resume", id: "${run.runId}", message: "..." })`
+            : `Revive child: subagent({ action: "resume", id: "${run.runId}", index: ${resumable.index}, message: "..." })`);
+    }
+    else {
+        lines.push("Resume: unavailable; no child session file was persisted.");
+    }
+    return lines.join("\n");
+}
+/** Request-only snapshot of the same artifact used by Fleet; no session or output fallback. */
+function formatLiveForegroundTranscript(control, state, options) {
+    if (!state.currentSessionId || control.sessionId !== state.currentSessionId) {
+        throw new Error(`Foreground run '${control.runId}' is not owned by the current session.`);
+    }
+    if (options.index !== undefined && (!Number.isInteger(options.index) || options.index < 0)) {
+        throw new Error("Transcript index must be a non-negative integer.");
+    }
+    const children = control.activeChildren
+        ? [...control.activeChildren.values()]
+        : control.currentAgent ? [{ index: control.currentIndex ?? 0, agent: control.currentAgent, sessionName: control.sessionName }] : [];
+    const header = [`Run: ${control.runId}`, "State: live foreground"];
+    if (children.length === 0)
+        return `${header.map((line) => safeTerminalText(line)).join("\n")}\nTranscript unavailable: no active foreground child.`;
+    if (options.index === undefined && children.length > 1) {
+        throw new Error(`Transcript view requires index for foreground run '${control.runId}'. Active child indexes: ${children.map((child) => child.index).join(", ")}.`);
+    }
+    const child = options.index === undefined ? children[0] : children.find((child) => child.index === options.index);
+    if (!child)
+        throw new Error(`Transcript index ${options.index} is not an active foreground child of '${control.runId}'.`);
+    const root = getArtifactsDir(state.parentSessionFile ?? null, control.cwd ?? state.baseCwd, state.artifactDirPreference);
+    const transcriptPath = getArtifactPaths(root, control.runId, child.agent, child.index).transcriptPath;
+    const transcript = readFleetTranscript(transcriptPath, { trustedRoots: [root] });
+    const lineLimit = Number.isFinite(options.lines) ? Math.max(1, Math.min(500, Math.trunc(options.lines))) : 80;
+    const allLines = transcript.events.flatMap((event) => {
+        const text = event.kind === "tool"
+            ? [`Tool: ${event.name} (${event.status})`, event.argsPayload ?? event.args, event.output ?? event.error].filter(Boolean).join("\n")
+            : event.kind === "notice" ? event.text : `${event.kind === "assistant" ? "Assistant" : "Supervisor"}: ${event.text}`;
+        return text.split(/\r?\n/);
+    });
+    let body = allLines.slice(-lineLimit).join("\n");
+    let truncated = transcript.truncated || allLines.length > lineLimit
+        || transcript.events.some((event) => event.kind === "tool" && event.outputTruncated)
+        || body.includes("… message truncated");
+    const maxOutputBytes = 32 * 1024;
+    const bytes = Buffer.from(body);
+    if (bytes.length > maxOutputBytes) {
+        // Skip UTF-8 continuation bytes at the beginning of the bounded tail.
+        let start = bytes.length - maxOutputBytes;
+        while ((bytes[start] & 0xc0) === 0x80)
+            start++;
+        body = bytes.subarray(start).toString("utf-8");
+        truncated = true;
+    }
+    header.push(`Child: ${child.index} (${child.sessionName?.trim() || child.agent})`, `Transcript: ${transcriptPath}`);
+    if (transcript.warning)
+        header.push(`Transcript warning: ${transcript.warning}`);
+    header.push(`Live transcript tail${truncated ? " (tail truncated)" : ""}:`);
+    if (!body)
+        header.push("Transcript unavailable: no readable activity in the bounded artifact tail yet.");
+    return [...header.map((line) => safeTerminalText(line)), body].filter(Boolean).join("\n");
+}
+function formatRememberedForegroundTranscript(run, options) {
+    let index = options.index;
+    if (index !== undefined && !Number.isInteger(index))
+        throw new Error("Transcript index must be an integer.");
+    if (index === undefined && run.children.length === 1)
+        index = 0;
+    if (index === undefined)
+        return `Transcript view requires index for foreground run '${run.runId}' with ${run.children.length} children.`;
+    if (index < 0 || index >= run.children.length)
+        throw new Error(`Transcript index ${index} is out of range for ${run.children.length} foreground children.`);
+    const child = run.children[index];
+    const lineLimit = Math.max(1, Math.min(options.lines ?? 80, 1000));
+    const outputLines = rememberedForegroundChildOutput(child).split(/\r?\n/).filter((line) => line.trim()).slice(-lineLimit);
+    const lines = [
+        `Run: ${run.runId}`,
+        `State: ${child.status}`,
+        `Child: ${index} (${child.sessionName?.trim() || child.agent})`,
+        child.sessionFile ? `Session: ${child.sessionFile}` : undefined,
+        child.transcriptPath ? `Transcript: ${child.transcriptPath}` : undefined,
+        child.artifactPaths?.outputPath ? `Output: ${child.artifactPaths.outputPath}` : undefined,
+        child.savedOutputPath && child.savedOutputPath !== child.artifactPaths?.outputPath ? `Saved output: ${child.savedOutputPath}` : undefined,
+        child.outputSaveError ? `Output warning: ${child.outputSaveError}` : undefined,
+    ].filter((line) => Boolean(line));
+    lines.push("Result transcript tail:");
+    if (outputLines.length === 0)
+        lines.push("  (no recovered final output available yet)");
+    else
+        for (const line of outputLines)
+            lines.push(`  ${line}`);
+    return lines.map((line) => safeTerminalText(line)).join("\n");
+}
+function formatNestedExactStatus(rootRunId, run) {
+    const lines = [
+        `Nested run: ${run.id}`,
+        `Root: ${rootRunId}`,
+        `Parent: ${run.parentRunId}${run.parentStepIndex !== undefined ? ` step ${run.parentStepIndex + 1}` : ""}`,
+        `State: ${run.state}`,
+        run.activityState || run.lastActivityAt ? `Activity: ${formatActivityLabel(run.lastActivityAt, run.activityState)}` : undefined,
+        run.mode ? `Mode: ${run.mode}` : undefined,
+        `Agent: ${nestedRunDisplayName(run)}`,
+        run.currentStep !== undefined ? `Progress: step ${run.currentStep + 1}/${run.chainStepCount ?? run.steps?.length ?? 1}` : undefined,
+        run.turnBudget ? `Turn budget: ${run.turnBudget.turnCount}/${run.turnBudget.maxTurns}+${run.turnBudget.graceTurns} (${run.turnBudget.outcome})` : undefined,
+        run.asyncDir ? `Dir: ${run.asyncDir}` : undefined,
+        run.sessionFile ? `Session: ${run.sessionFile}` : undefined,
+        run.error ? `Error: ${run.error}` : undefined,
+    ].filter((line) => Boolean(line));
+    if (run.path.length) {
+        lines.push(`Path: ${run.path.map((part) => `${part.runId}${part.stepIndex !== undefined ? `:${part.stepIndex + 1}` : ""}${part.agent ? `:${part.agent}` : ""}`).join(" > ")} > ${run.id}`);
+    }
+    if (run.steps?.length) {
+        lines.push("Steps:");
+        for (const [index, step] of run.steps.entries()) {
+            const activity = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
+            const budget = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
+            lines.push(`  ${index + 1}. ${step.sessionName?.trim() || step.agent} ${step.status}${activity ? `, ${activity}` : ""}${budget}${step.error ? `, error: ${step.error}` : ""}`);
+            lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: true }));
+        }
+    }
+    lines.push(...formatNestedRunStatusLines(run.children, { indent: "  ", commandHints: true }));
+    lines.push("Commands:", `  Status: subagent({ action: "status", id: "${run.id}" })`, `  Interrupt: subagent({ action: "interrupt", id: "${run.id}" })`, `  Resume: subagent({ action: "resume", id: "${run.id}", message: "..." })`, `  Steer: subagent({ action: "steer", id: "${run.id}", message: "..." })`, `  Root status: subagent({ action: "status", id: "${rootRunId}" })`);
+    return lines.join("\n");
+}
+export function inspectSubagentStatus(params, deps = {}) {
+    const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
+    const resultsDir = deps.resultsDir ?? DIRS.results;
+    const currentSessionId = deps.state?.currentSessionId ?? undefined;
+    if (params.view && params.view !== "fleet" && params.view !== "transcript") {
+        return {
+            content: [{ type: "text", text: `Unknown status view: ${params.view}. Valid: fleet, transcript.` }],
+            isError: true,
+            details: { mode: "single", results: [] },
+        };
+    }
+    if (params.view === "fleet") {
+        return inspectSubagentFleet(params, { asyncDirRoot, resultsDir, kill: deps.kill, now: deps.now, state: deps.state, childSafe: Boolean(deps.nested) });
+    }
+    if (!params.id && !params.runId && !params.dir) {
+        if (params.view === "transcript" && deps.state?.currentSessionId) {
+            const controls = [...deps.state.foregroundControls.values()].filter((control) => control.sessionId === currentSessionId);
+            const foreground = controls.find((control) => control.runId === deps.state?.lastForegroundControlId)
+                ?? controls.sort((left, right) => right.updatedAt - left.updatedAt)[0];
+            if (foreground)
+                return inspectSubagentStatus({ ...params, id: foreground.runId }, deps);
+        }
+        if (deps.nested) {
+            return {
+                content: [{ type: "text", text: "Child-safe subagent status requires an id when no foreground run is active." }],
+                isError: true,
+                details: { mode: "single", results: [] },
+            };
+        }
+        try {
+            const runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: currentSessionId, resultsDir, kill: deps.kill, now: deps.now });
+            if (params.view === "transcript") {
+                if (runs.length === 1)
+                    return inspectSubagentStatus({ ...params, id: runs[0].id }, deps);
+                return {
+                    content: [{ type: "text", text: runs.length === 0 ? "No active async run transcript is available." : `Transcript view requires an id when ${runs.length} active async runs exist. Use subagent({ action: "status", view: "fleet" }) to choose one.` }],
+                    isError: true,
+                    details: { mode: "single", results: [] },
+                };
+            }
+            const waitSubscriptions = deps.state ? formatWaitSubscriptions(deps.state, deps.now?.() ?? Date.now()) : undefined;
+            return {
+                content: [{ type: "text", text: [formatAsyncRunList(runs), waitSubscriptions].filter(Boolean).join("\n\n") }],
+                details: { mode: "single", results: [] },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: message }],
+                isError: true,
+                details: { mode: "single", results: [] },
+            };
+        }
+    }
+    let location;
+    try {
+        const requestedId = params.id ?? params.runId;
+        if (params.action === "debug.run") {
+            location = resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
+        }
+        else if (!params.dir && requestedId) {
+            const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+            if (resolved?.kind === "foreground") {
+                const control = deps.state?.foregroundControls.get(resolved.id);
+                if (control && deps.state && params.view === "transcript") {
+                    return {
+                        content: [{ type: "text", text: formatLiveForegroundTranscript(control, deps.state, params) }],
+                        details: { mode: "management", results: [] },
+                    };
+                }
+                const run = deps.state?.foregroundRuns?.get(resolved.id);
+                if (run) {
+                    try {
+                        return {
+                            content: [{ type: "text", text: params.view === "transcript" ? formatRememberedForegroundTranscript(run, { index: params.index, lines: params.lines }) : formatRememberedForegroundStatus(run) }],
+                            details: { mode: "single", results: [] },
+                        };
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+                    }
+                }
+            }
+            if (resolved?.kind === "nested") {
+                reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
+                const refreshed = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
+                const nested = refreshed?.kind === "nested" ? refreshed : resolved;
+                if (params.view === "transcript") {
+                    try {
+                        return { content: [{ type: "text", text: formatNestedRunTranscript(nested.match.run, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+                    }
+                }
+                return { content: [{ type: "text", text: formatNestedExactStatus(nested.match.rootRunId, nested.match.run) }], details: { mode: "single", results: [] } };
+            }
+            if (resolved?.kind === "async")
+                location = resolved.location;
+            else
+                location = { asyncDir: null, resultPath: null, resolvedId: requestedId };
+        }
+        else {
+            location = resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: message }],
+            isError: true,
+            details: { mode: "single", results: [] },
+        };
+    }
+    const { asyncDir, resultPath, resolvedId } = location;
+    if (!asyncDir && !resultPath) {
+        return {
+            content: [{ type: "text", text: "Async run not found. Provide id or dir." }],
+            isError: true,
+            details: { mode: "single", results: [] },
+        };
+    }
+    if (asyncDir) {
+        const diskStatus = readStatus(asyncDir);
+        let reconciliation;
+        try {
+            reconciliation = reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: message }],
+                isError: true,
+                details: { mode: "single", results: [] },
+            };
+        }
+        const status = reconciliation.status;
+        if (!status && diskStatus?.displayDismissedAt !== undefined) {
+            if (params.action === "debug.run") {
+                const { sidecar, overlay } = debugProcessTerminal(asyncDir, diskStatus);
+                const capacity = inspectActiveAsyncCapacityOwner({ runId: diskStatus.runId, sessionId: diskStatus.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
+                return {
+                    content: [{ type: "text", text: formatRunLifecycleDebug({ status: diskStatus, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
+                    details: { mode: "single", results: [], ...(diskStatus.workflowReceiptPath ? { workflowReceiptPath: diskStatus.workflowReceiptPath } : {}), ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
+                };
+            }
+            if (params.view === "transcript") {
+                if (currentSessionId && diskStatus.sessionId !== currentSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+                        isError: true,
+                        details: { mode: "single", results: [] },
+                    };
+                }
+                return { content: [{ type: "text", text: formatAsyncRunTranscript(diskStatus, asyncDir, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+            }
+            return {
+                content: [{ type: "text", text: `Run: ${diskStatus.runId}\nState: display-dismissed\nDismissed: ${new Date(diskStatus.displayDismissedAt).toISOString()}\nNo running work was terminated.` }],
+                details: { mode: "single", results: [] },
+            };
+        }
+        const effectiveRunId = status?.runId ?? resolvedId ?? "unknown";
+        const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
+        const eventsPath = path.join(asyncDir, "events.jsonl");
+        if (status) {
+            if (params.action === "debug.run") {
+                const { sidecar, overlay } = debugProcessTerminal(asyncDir, status);
+                const capacity = inspectActiveAsyncCapacityOwner({ runId: status.runId, sessionId: status.sessionId, asyncDir }, { rootDir: deps.activeCapacityRoot, liveWorkflowRunIds: new Set(deps.state?.workflowControllers?.keys() ?? []), abandonedSlotReleaseAfterMs: deps.abandonedSlotReleaseAfterMs });
+                return {
+                    content: [{ type: "text", text: formatRunLifecycleDebug({ status, asyncDir, sidecarProcessTerminal: sidecar, overlayProcessTerminal: overlay, capacity }) }],
+                    details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...((sidecar ?? overlay) ? { lifecycleStatus: { processTerminal: sidecar ?? overlay } } : {}) },
+                };
+            }
+            if (params.view === "transcript") {
+                if (currentSessionId && status.sessionId !== currentSessionId) {
+                    return {
+                        content: [{ type: "text", text: "Transcript view is only available for async runs owned by the current session." }],
+                        isError: true,
+                        details: { mode: "single", results: [] },
+                    };
+                }
+                try {
+                    return { content: [{ type: "text", text: formatAsyncRunTranscript(status, asyncDir, { index: params.index, lines: params.lines, sessionRoots: deps.sessionRoots }) }], details: { mode: "single", results: [] } };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+                }
+            }
+            let nestedChildren = [];
+            let nestedWarning;
+            try {
+                const nestedRoute = findNestedRouteForRootId(status.runId);
+                if (nestedRoute)
+                    reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
+                nestedChildren = projectNestedRegistryForRoot(status.runId)?.children ?? [];
+                attachRootChildrenToSteps(status.runId, status.steps, nestedChildren);
+            }
+            catch (error) {
+                nestedWarning = `Nested status unavailable: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            const outputPath = formatAsyncRunOutputPath({ asyncDir, outputFile: status.outputFile });
+            const progressLabel = formatAsyncRunProgressLabel({
+                mode: status.mode,
+                state: status.state,
+                currentStep: status.currentStep,
+                chainStepCount: status.chainStepCount,
+                parallelGroups: status.parallelGroups,
+                workflowGraph: status.workflowGraph,
+                steps: (status.steps ?? []).map((step, index) => ({ index, agent: step.agent, status: step.status })),
+            });
+            const started = new Date(status.startedAt).toISOString();
+            const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
+            const statusActivityText = status.state === "running" ? formatActivityLabel(status.lastActivityAt, status.activityState) : undefined;
+            const steeringText = formatSteeringSummary(status);
+            const processTerminal = readProcessTerminal(asyncDir, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId })
+                ?? sanitizeProcessTerminal(status.processTerminal, { runId: status.runId, runnerProcessInstanceId: status.processTerminal?.runnerProcessInstanceId }, path.join(asyncDir, "status.json"));
+            const runFanoutBudgetDescriptor = readRunFanoutBudgetDescriptor(asyncDir);
+            const runFanoutBudget = runFanoutBudgetDescriptor ? getRunFanoutBudgetSnapshot(runFanoutBudgetDescriptor) : status.runFanoutBudget;
+            let missionId;
+            try {
+                missionId = readMissionBinding(asyncDir)?.missionId;
+            }
+            catch (error) {
+                nestedWarning = `${nestedWarning ? `${nestedWarning}; ` : ""}Mission binding unavailable: ${error instanceof Error ? error.message : String(error)}`;
+            }
+            const workflowReturnPreview = status.workflow?.value !== undefined ? formatWorkflowJsonPreview(status.workflow.value, 240) : undefined;
+            const workflowEmitPreview = status.workflow?.emits.length ? formatWorkflowJsonPreview(status.workflow.emits.at(-1), 240) : undefined;
+            const lines = [
+                `Run: ${status.runId}`,
+                status.toolCallId ? `Tool call: ${status.toolCallId}` : undefined,
+                missionId ? `Mission: ${missionId}` : undefined,
+                `State: ${status.state}`,
+                processTerminal ? `Process terminal: ${processTerminal.state}${processTerminal.reason ? ` (${processTerminal.reason})` : ""}` : undefined,
+                status.capabilityCeiling ? `Capability ceiling: ${status.capabilityCeiling.allowedTools === undefined ? "names unrestricted" : status.capabilityCeiling.allowedTools.length === 0 ? "none" : status.capabilityCeiling.allowedTools.join(", ")}\nExtensions denied: ${status.capabilityCeiling.denyExtensions ? "yes" : "no"} (sources: ${status.capabilityCeiling.sources.join(", ")})` : undefined,
+                status.capabilityAudit ? `Capability audit: ${status.capabilityAudit.removedTools.length} tools removed, ${status.capabilityAudit.removedExtensionCount} extension entries removed` : undefined,
+                status.error ? `Error: ${status.error}` : undefined,
+                statusActivityText ? `Activity: ${statusActivityText}` : undefined,
+                steeringText ? `Steering: ${steeringText}` : undefined,
+                `Mode: ${status.mode}`,
+                ...(status.preflight ? [formatWorkflowPreflightPlanSummary(status.preflight)] : []),
+                ...(status.workflow?.preflightWarnings?.length ? [formatWorkflowPreflightWarningSummary(status.workflow.preflightWarnings)] : []),
+                runFanoutBudget ? formatRunFanoutBudget(runFanoutBudget) : undefined,
+                status.parentWorkflowRunId ? `Workflow parent: ${status.parentWorkflowRunId}${status.workflowKey ? ` (${status.workflowKey})` : ""}` : undefined,
+                status.mode === "workflow" && workflowReturnPreview !== undefined ? `Return: ${workflowReturnPreview}` : undefined,
+                status.mode === "workflow" && workflowEmitPreview !== undefined ? `Latest emit: ${workflowEmitPreview}` : undefined,
+                `Progress: ${progressLabel}`,
+                ...(status.mode === "workflow" ? formatWorkflowChecklistText(projectWorkflowChecklist({
+                    graph: status.workflowGraph,
+                    steps: status.steps,
+                    hostSteps: validHostStepNodes(status.workflowGraph),
+                    preflight: status.preflight,
+                    trace: status.workflow?.trace,
+                    now: status.lastUpdate ?? status.endedAt ?? Date.now(),
+                }), "", { includeItems: false }) : []),
+                status.pendingAppends ? `Pending appends: ${status.pendingAppends}` : undefined,
+                `Started: ${started}`,
+                `Updated: ${updated}`,
+                status.turnBudget ? `Turn budget: ${status.turnBudget.turnCount}/${status.turnBudget.maxTurns}+${status.turnBudget.graceTurns} (${status.turnBudget.outcome})` : undefined,
+                `Dir: ${asyncDir}`,
+                outputPath ? `Output: ${outputPath}` : undefined,
+                status.parallelHandoff ? `Parallel handoff: ${status.parallelHandoff.path}` : undefined,
+                reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
+                reconciliation.resultPath && fs.existsSync(reconciliation.resultPath) ? `Result: ${reconciliation.resultPath}` : undefined,
+            ].filter((line) => Boolean(line));
+            const liveWorkflowControls = status.mode === "workflow" && deps.state?.currentSessionId === status.sessionId && deps.state?.workflowControllers?.has(status.runId)
+                ? [...(deps.state?.foregroundControls.values() ?? [])].filter((control) => control.parentWorkflowRunId === status.runId
+                    && control.sessionId === status.sessionId
+                    && (control.activeChildren?.size ?? 0) > 0)
+                : [];
+            let hasExternalJobFollowUpHint = false;
+            for (const [index, step] of (status.steps ?? []).entries()) {
+                const stepActivityText = step.status === "running" ? formatActivityLabel(step.lastActivityAt, step.activityState) : undefined;
+                const modelThinking = formatModelThinking(step.model, step.thinking);
+                const modelText = modelThinking ? ` (${modelThinking})` : "";
+                const steeringText = formatSteeringSummary(step);
+                const steeringSuffix = steeringText ? `, steering: ${steeringText}` : "";
+                const errorText = step.error ? `, error: ${step.error}` : "";
+                const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}` : "";
+                const budgetText = step.turnBudget ? `, turn budget: ${step.turnBudget.turnCount}/${step.turnBudget.maxTurns}+${step.turnBudget.graceTurns} (${step.turnBudget.outcome})` : "";
+                const display = runStatusStepDisplayName(step);
+                const phase = step.phase ? `[${step.phase}] ` : "";
+                lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${steeringSuffix}${acceptanceText}${budgetText}${errorText}`);
+                if (status.mode === "workflow" && step.runId)
+                    lines.push(`  Child run: ${step.runId}`);
+                const structuredOutputPreview = step.structuredOutput === undefined ? undefined : formatWorkflowJsonPreview(step.structuredOutput, 4_000);
+                if (structuredOutputPreview !== undefined)
+                    lines.push(`  Structured output: ${structuredOutputPreview}`);
+                if (step.structuredOutputPath)
+                    lines.push(`  Structured output path: ${step.structuredOutputPath}`);
+                lines.push(...formatTimeoutRecoveryLines(step.timeoutRecovery, "  "));
+                if (step.runner?.type === "external-cli") {
+                    const runner = normalizeExternalCliRunnerStatus(step.runner);
+                    if (runner) {
+                        lines.push(`  Runner: external-cli (${runner.command}${runner.args.length ? ` ${runner.args.join(" ")}` : ""})`);
+                        lines.push(`  Adapter: ${runner.adapter.id} v${runner.adapter.version} (${runner.adapter.executionMode})`);
+                        if (runner.safety) {
+                            if ("approvalPolicy" in runner.safety)
+                                lines.push(`  Safety: ${"access" in runner.safety ? `access=${runner.safety.access}, ` : ""}sandbox=${runner.safety.sandbox}, approval=${runner.safety.approvalPolicy}, ephemeral=${runner.safety.ephemeral}`);
+                            else if ("mode" in runner.safety)
+                                lines.push(`  Safety: access=${runner.safety.access}, auth=${runner.safety.authentication}, mode=${runner.safety.mode}, sandbox=${runner.safety.sandbox}, workspaceTrust=${runner.safety.workspaceTrust}, sessionReuse=${runner.safety.sessionReuse}`);
+                            else if ("authentication" in runner.safety)
+                                lines.push(`  Safety: access=${runner.safety.access}, auth=${runner.safety.authentication}, permission=${runner.safety.permissionMode}, tools=${runner.safety.tools}, mcp=${runner.safety.mcp}, settings=${runner.safety.settingSources}, settingsTrust=${runner.safety.userSettingsTrust}, persistence=${runner.safety.sessionPersistence}`);
+                            else
+                                lines.push(`  Safety: access=read-only, permission=${runner.safety.permissionMode}, tools=${runner.safety.tools}, mcp=${runner.safety.mcp}, settings=${runner.safety.settingSources}, persistence=${runner.safety.sessionPersistence}`);
+                        }
+                        lines.push(`  Capabilities: stop=${runner.capabilities.stop}, steer=false, resume=false, structuredOutput=false, toolEvents=false, supervisor=unsupported, forkContext=false, extensionBindings=false`);
+                        lines.push(`  Unsupported steer: ${runner.unsupportedReasons.steer}`);
+                        lines.push(`  Unsupported resume: ${runner.nonResumableReason}`);
+                        lines.push(`  Unsupported supervisor: ${runner.unsupportedReasons.supervisor}`);
+                        lines.push(`  Context handoff: fresh only (${runner.unsupportedReasons.forkContext})`);
+                    }
+                    else {
+                        lines.push("  Runner: external-cli (invalid persisted runner metadata)");
+                    }
+                    if (step.externalProcess?.pid !== undefined)
+                        lines.push(`  Process: ${step.externalProcess.pid}`);
+                    if (step.externalProcess) {
+                        lines.push(`  Stdout: ${step.externalProcess.stdoutPath}`, `  Stderr: ${step.externalProcess.stderrPath}`);
+                        if (step.externalProcess.finalOutputPath)
+                            lines.push(`  Final output: ${step.externalProcess.finalOutputPath}`);
+                    }
+                }
+                else if (step.runner?.type === "external-job") {
+                    lines.push(`  Runner: external-job (${step.runner.provider})`);
+                    if (step.externalJob?.providerJobId)
+                        lines.push(`  Provider job: ${step.externalJob.providerJobId}`);
+                    if (step.externalJob?.state)
+                        lines.push(`  Provider state: ${step.externalJob.state}`);
+                    if (step.externalJob?.conversationUrl)
+                        lines.push(`  Conversation: ${step.externalJob.conversationUrl}`);
+                    if (step.externalJob?.resultArtifactPath)
+                        lines.push(`  Result artifact: ${step.externalJob.resultArtifactPath}`);
+                    if ((step.status === "complete" || step.status === "completed") && step.externalJob?.state === "completed" && step.externalJob.providerJobId && externalJobFollowUpSupported(step.runner.provider)) {
+                        hasExternalJobFollowUpHint = true;
+                        lines.push(`  Follow-up: subagent({ action: "resume", id: "${status.runId}", index: ${index}, message: "..." })`);
+                    }
+                }
+                lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: true, maxLines: 20 }));
+                const stepOutputPath = path.join(asyncDir, `output-${index}.log`);
+                if (stepOutputPath !== outputPath && fs.existsSync(stepOutputPath))
+                    lines.push(`  Output: ${stepOutputPath}`);
+                if (step.status === "running" && step.runner?.type !== "external-cli" && step.runner?.type !== "external-job" && status.mode !== "workflow") {
+                    lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.agent, index)} (if registered)`);
+                    lines.push(`  Steer: subagent({ action: "steer", id: "${status.runId}", index: ${index}, message: "..." })`);
+                }
+                else if (step.status === "running" && (step.runner?.type === "external-cli" || step.runner?.type === "external-job")) {
+                    lines.push("  Steer: unavailable; external runners do not accept live messages.");
+                }
+            }
+            const loadedWorkflowKeys = new Set((status.steps ?? []).flatMap((step) => step.workflowKey ? [step.workflowKey] : []));
+            const graphStages = status.mode === "workflow" ? workflowGraphStageNodes(status.workflowGraph) : [];
+            for (const [index, node] of graphStages.entries()) {
+                if (!loadedWorkflowKeys.has(node.id))
+                    lines.push(`  ${formatWorkflowStageLine(node, index, graphStages.length)}`);
+            }
+            const attached = new Set((status.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? []));
+            const unattached = nestedChildren.filter((child) => !attached.has(child.id));
+            lines.push(...formatNestedRunStatusLines(unattached, { indent: "", commandHints: true, maxLines: 20 }));
+            if (status.mode === "workflow" && status.state === "running") {
+                if (liveWorkflowControls.length === 0)
+                    lines.push("Steer: unavailable; no live foreground route is registered in the active session.");
+                else
+                    for (const control of liveWorkflowControls) {
+                        for (const index of [...control.activeChildren.keys()].sort((left, right) => left - right)) {
+                            lines.push(`Steer live foreground child: subagent({ action: "steer", id: "${control.runId}", index: ${index}, message: "..." })`);
+                        }
+                    }
+                lines.push(...workflowAsyncChildSteeringGuidance(status, deps.state));
+            }
+            if (nestedWarning)
+                lines.push(`Warning: ${nestedWarning}`);
+            if (status.workflowReceiptPath)
+                lines.push(`Workflow receipt: ${status.workflowReceiptPath}`);
+            if (status.sessionFile)
+                lines.push(`Session: ${status.sessionFile}`);
+            const allExternal = (status.steps?.length ?? 0) > 0 && status.steps.every((step) => step.runner?.type === "external-cli" || step.runner?.type === "external-job");
+            if (status.state === "running" && !allExternal && status.mode !== "workflow")
+                lines.push(`Steer running child: subagent({ action: "steer", id: "${status.runId}", message: "..." })`);
+            if (status.state !== "running") {
+                lines.push(allExternal
+                    ? hasExternalJobFollowUpHint ? "Resume: use the external-job follow-up hint above." : "Resume: unavailable; external runners do not persist Pi sessions."
+                    : formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, { stopped: status.state === "stopped" || status.stopped === true }));
+            }
+            if (fs.existsSync(logPath))
+                lines.push(`Log: ${logPath}`);
+            if (fs.existsSync(eventsPath))
+                lines.push(`Events: ${eventsPath}`);
+            const workflowChildren = parseWorkflowChildSummary(status.workflowChildren);
+            if (workflowChildren && workflowChildren.workflowRunId !== status.runId)
+                throw new Error("workflowChildren.workflowRunId does not match async status runId.");
+            return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(status.workflowReceiptPath ? { workflowReceiptPath: status.workflowReceiptPath } : {}), ...(status.preflight ? { preflight: status.preflight } : {}), ...(status.workflow?.preflightWarnings?.length ? { preflightWarnings: status.workflow.preflightWarnings } : {}), ...(workflowChildren ? { workflowChildren } : {}), ...(runFanoutBudget ? { runFanoutBudget } : {}), ...(processTerminal ? { lifecycleStatus: { processTerminal } } : {}) } };
+        }
+    }
+    if (resultPath) {
+        if (params.action === "debug.run") {
+            return {
+                content: [{ type: "text", text: "Run lifecycle debug needs an async run directory with status.json." }],
+                isError: true,
+                details: { mode: "single", results: [] },
+            };
+        }
+        try {
+            const raw = fs.readFileSync(resultPath, "utf-8");
+            const data = JSON.parse(raw);
+            if (params.view === "transcript") {
+                try {
+                    return { content: [{ type: "text", text: formatAsyncResultTranscript(data, resultPath, { index: params.index, lines: params.lines }) }], details: { mode: "single", results: [] } };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    return { content: [{ type: "text", text: message }], isError: true, details: { mode: "single", results: [] } };
+                }
+            }
+            const childStatuses = Array.isArray(data.results)
+                ? data.results.map((child) => resolveSubagentResultStatus({
+                    success: child.success,
+                    state: child.state,
+                    interrupted: child.interrupted,
+                    timedOut: child.timedOut,
+                    stopped: child.stopped,
+                    turnBudgetExceeded: child.turnBudgetExceeded,
+                    processSignal: child.processSignal,
+                    exitCode: typeof child.exitCode === "number" ? child.exitCode : undefined,
+                }))
+                : [];
+            const status = data.state === "stopped" || data.stopped === true || childStatuses.includes("stopped")
+                ? "stopped"
+                : data.success ? "complete" : data.state === "paused" || data.exitCode === 0 ? "paused" : "failed";
+            const runId = data.runId ?? data.id ?? resolvedId;
+            const lines = [`Run: ${runId}`, data.toolCallId ? `Tool call: ${data.toolCallId}` : undefined, `State: ${status}`, `Result: ${resultPath}`].filter((line) => Boolean(line));
+            if (data.parallelHandoff?.path)
+                lines.push(`Parallel handoff: ${data.parallelHandoff.path}`);
+            const receipt = data.workflowReceipt;
+            const receiptPath = receipt && typeof receipt === "object" && !Array.isArray(receipt)
+                ? receipt.path : undefined;
+            const workflowReceiptPath = typeof receiptPath === "string" && receiptPath ? receiptPath : undefined;
+            if (workflowReceiptPath)
+                lines.push(`Workflow receipt: ${workflowReceiptPath}`);
+            const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
+            lines.push(...formatTimeoutRecoveryLines(data.timeoutRecovery, "  "));
+            for (const [index, child] of children.entries()) {
+                const structuredOutput = child.structuredOutput;
+                const structuredOutputPreview = structuredOutput === undefined ? undefined : formatWorkflowJsonPreview(structuredOutput, 4_000);
+                if (structuredOutputPreview !== undefined)
+                    lines.push(`  Structured output${children.length > 1 ? ` (${index + 1})` : ""}: ${structuredOutputPreview}`);
+                const structuredOutputPath = child.structuredOutputPath;
+                if (typeof structuredOutputPath === "string" && structuredOutputPath.trim())
+                    lines.push(`  Structured output path${children.length > 1 ? ` (${index + 1})` : ""}: ${structuredOutputPath}`);
+                lines.push(...formatTimeoutRecoveryLines(child.timeoutRecovery, "  "));
+            }
+            lines.push(formatResumeGuidance(runId, children, data.sessionFile, { stopped: status === "stopped" }));
+            if (data.summary)
+                lines.push("", data.summary);
+            const workflowChildren = parseWorkflowChildSummary(data.workflowChildren);
+            if (workflowChildren && workflowChildren.workflowRunId !== runId)
+                throw new Error("workflowChildren.workflowRunId does not match the result run id.");
+            return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "single", results: [], ...(workflowReceiptPath ? { workflowReceiptPath } : {}), ...(workflowChildren ? { workflowChildren } : {}) } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `Failed to read async result file: ${message}` }],
+                isError: true,
+                details: { mode: "single", results: [] },
+            };
+        }
+    }
+    return {
+        content: [{ type: "text", text: "Status file not found." }],
+        isError: true,
+        details: { mode: "single", results: [] },
+    };
+}
+//# sourceMappingURL=run-status.js.map