@fitchmultz/pi-subagents 0.44.6 → 0.45.0

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

@@ -1,382 +1,274 @@
-import * as fs from "node:fs";
-import { readOutputPage } from "../../shared/journal-reader.js";
-import * as path from "node:path";
-import { formatActivityFacts, formatAsyncRunList, formatAsyncRunOutputPath, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.js";
-import { formatNestedRunStatusLines } from "../shared/nested-render.js";
-import { formatModelThinking } from "../../shared/formatters.js";
-import { buildManagementControl, formatActivityLabel, formatLiveIntercomActionLines, formatRunAction } from "../../shared/status-format.js";
-import { ASYNC_DIR, RESULTS_DIR } from "../../shared/types.js";
+import { formatAsyncRunList, listAsyncRuns } from "./async-status.js";
+import { buildManagementControl, formatRunAction } from "../../shared/status-format.js";
+import { ASYNC_DIR, RESULTS_DIR, } from "../../shared/types.js";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
-import { exactAsyncRunLocation, resolveAsyncRunLocation } from "./async-resume.js";
+import { exactAsyncRunLocation, resolveAsyncRunLocation } from "./async-run-location.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, findNestedRun } from "../shared/nested-events.js";
+import { attachRootChildrenToSteps, findNestedRouteForRootId, findNestedRun, } from "../shared/nested-events.js";
 import { readAsyncResultFile } from "./async-result-file.js";
 import { readStatus } from "../../shared/utils.js";
-const ASYNC_COMPLETION_REMINDER = "Completion will be delivered automatically. If you are only waiting, end your turn instead of polling status again.";
-function hasExistingSessionFile(value) {
-    return typeof value === "string" && fs.existsSync(value);
+import { ASYNC_COMPLETION_REMINDER, hasExistingSessionFile, normalizedState, } from "./run-status-contracts.js";
+import { canExtend, formatNestedExactStatus, formatResumeGuidance, runtimeHeader, runtimeSteps, runtimeFooter, } from "./run-status-render.js";
+import { errorMessage, hasText } from "./async-value.js";
+function errorResult(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+        details: { mode: "single", results: [] },
+    };
 }
-function completionTargetsCurrentSession(run, state) {
-    if (!state)
-        return true;
-    if (run.sessionId)
-        return run.sessionId === state.currentSessionId;
-    return false;
+function completionTargetsSession(run, state) {
+    return (state === undefined || (hasText(run.sessionId) && run.sessionId === state.currentSessionId));
 }
-function nestedCompletionTargetsCurrentSession(rootRunId, asyncDirRoot, state) {
-    if (!state || state.ownedRuns?.has(rootRunId))
+function nestedCompletionTargetsSession(rootRunId, asyncDirRoot, state) {
+    if (!state || state.ownedRuns?.has(rootRunId) === true) {
         return true;
+    }
     const tracked = state.asyncJobs.get(rootRunId);
-    if (tracked)
-        return completionTargetsCurrentSession(tracked, state);
+    if (tracked) {
+        return completionTargetsSession(tracked, state);
+    }
     try {
         const location = exactAsyncRunLocation(rootRunId, asyncDirRoot, RESULTS_DIR);
-        const status = location.asyncDir ? readStatus(location.asyncDir) : null;
-        return status ? completionTargetsCurrentSession(status, state) : false;
+        const status = location.asyncDir === null ? null : readStatus(location.asyncDir);
+        return status === null ? false : completionTargetsSession(status, state);
     }
     catch {
         return false;
     }
 }
-function formatResumeGuidance(runId, children, fallbackSessionFile, childSafe = false) {
-    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 singleSessionFile = knownChildren[0]?.child.sessionFile ?? fallbackSessionFile;
-    if (children.length === 1 && knownChildren.length === 1 && hasExistingSessionFile(singleSessionFile)) {
-        return `Continue: ${formatRunAction("resume", runId, { message: "..." }, childSafe)}`;
-    }
-    const childWithSession = knownChildren.find(({ child }) => hasExistingSessionFile(child.sessionFile));
-    if (childWithSession) {
-        return `Continue child: ${formatRunAction("resume", runId, { index: childWithSession.index, message: "..." }, childSafe)}`;
+function listControl(run) {
+    const running = run.steps.find((step) => step.status === "running");
+    const target = running
+        ? resolveSubagentIntercomTarget(run.id, running.agent, running.index)
+        : undefined;
+    const resumable = run.steps.find((step) => hasExistingSessionFile(step.sessionFile));
+    return buildManagementControl({
+        state: normalizedState(run.state),
+        runId: run.id,
+        index: running?.index ?? resumable?.index,
+        intercomTarget: target,
+        canNudge: running !== undefined,
+        canResume: running !== undefined ||
+            resumable !== undefined ||
+            (run.steps.length <= 1 && hasExistingSessionFile(run.sessionFile)),
+        canInterrupt: run.state === "running",
+    });
+}
+function inspectList(deps) {
+    if (deps.nested) {
+        return errorResult("Child-safe subagent status requires a run id.");
     }
-    return "Resume: unavailable; no child session file was persisted.";
+    const runs = listAsyncRuns(deps.asyncDirRoot ?? ASYNC_DIR, {
+        resultsDir: deps.resultsDir ?? RESULTS_DIR,
+        kill: deps.kill,
+        now: deps.now,
+    }).filter((run) => completionTargetsSession(run, deps.state));
+    const text = formatAsyncRunList(runs, "Async runs");
+    const reminder = runs.some((run) => run.state === "running" || run.state === "queued");
+    return {
+        content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
+        details: { mode: "single", results: [], managementControls: runs.map(listControl) },
+    };
 }
-function formatAcceptanceFinalizationSummary(finalization) {
-    if (!finalization)
-        return "";
-    return `, finalization: ${finalization.status} after ${finalization.turns.length}/${finalization.maxTurns} turns`;
+function inspectNested(nested, deps) {
+    const children = reconcileNestedAsyncDescendants(nested.match.route, {
+        resultsDir: deps.resultsDir ?? RESULTS_DIR,
+        kill: deps.kill,
+        now: deps.now,
+    });
+    const run = findNestedRun(children, nested.id) ?? nested.match.run;
+    const state = normalizedState(run.state);
+    const text = formatNestedExactStatus(nested.match.rootRunId, run, deps.nested !== undefined);
+    const reminder = state === "live" &&
+        nestedCompletionTargetsSession(nested.match.rootRunId, deps.asyncDirRoot ?? ASYNC_DIR, deps.state);
+    return {
+        content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
+        details: {
+            mode: "single",
+            results: [],
+            managementControl: buildManagementControl({
+                state,
+                runId: run.id,
+                intercomTarget: run.intercomTarget ?? run.leafIntercomTarget,
+                canNudge: false,
+                canResume: state === "live" || hasText(run.sessionFile),
+                canInterrupt: state === "live",
+            }),
+        },
+    };
 }
-function formatOutputExcerpt(outputPath, maxBytes = 4096, maxLines = 12) {
-    if (!outputPath || !fs.existsSync(outputPath))
-        return [];
+function resolveInspection(params, deps) {
+    const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
+    const resultsDir = deps.resultsDir ?? RESULTS_DIR;
+    const requestedId = params.id ?? params.runId;
+    if (!hasText(params.dir) && hasText(requestedId)) {
+        const resolved = resolveSubagentRunId(requestedId, {
+            asyncDirRoot,
+            resultsDir,
+            state: deps.state,
+            nested: deps.nested,
+        });
+        if (resolved?.kind === "nested") {
+            return inspectNested(resolved, deps);
+        }
+        return resolved?.kind === "async"
+            ? resolved.location
+            : { asyncDir: null, resultPath: null, resolvedId: requestedId };
+    }
+    return resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
+}
+function nestedProjection(status, deps) {
+    let children = [];
     try {
-        const page = readOutputPage(outputPath, { length: maxBytes });
-        const truncatedBytes = page.offset > 0;
-        const text = page.text.trim();
-        if (!text)
-            return [];
-        const allLines = text.split(/\r?\n/);
-        const lines = allLines.slice(-maxLines);
-        const truncatedLines = allLines.length > maxLines;
-        const suffix = truncatedBytes || truncatedLines ? " (tail, truncated)" : "";
-        return [`Output excerpt${suffix}:`, ...lines.map((line) => `  ${line}`)];
+        const route = findNestedRouteForRootId(status.runId);
+        if (route) {
+            children = reconcileNestedAsyncDescendants(route, {
+                resultsDir: deps.resultsDir ?? RESULTS_DIR,
+                kill: deps.kill,
+                now: deps.now,
+            });
+        }
+        // Step attachment happens on a fresh display projection, never persisted status.
+        return { children };
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return [`Output excerpt unavailable: ${message}`];
+        return { children, warning: `Nested status unavailable: ${errorMessage(error)}` };
     }
 }
-function stepLineLabel(status, index) {
-    const steps = status.steps ?? [];
-    if (status.mode === "parallel")
-        return `Agent ${index + 1}/${steps.length || 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}`;
+function runtimeControl(status) {
+    const state = normalizedState(status.state);
+    const steps = (status.steps ?? []).map((step, index) => ({ step, index }));
+    const running = steps.find(({ step }) => step.status === "running");
+    const target = running
+        ? resolveSubagentIntercomTarget(status.runId, running.step.agent, running.index)
+        : undefined;
+    const resumable = steps.find(({ step }) => hasExistingSessionFile(step.sessionFile));
+    const persisted = resumable !== undefined || (steps.length <= 1 && hasExistingSessionFile(status.sessionFile));
+    return buildManagementControl({
+        state,
+        runId: status.runId,
+        index: running?.index ?? resumable?.index,
+        intercomTarget: target,
+        canNudge: running !== undefined,
+        canResume: state === "live" ? running !== undefined : persisted,
+        canInterrupt: status.state === "running",
+        canExtend: canExtend(status),
+    });
+}
+function inspectRuntime(asyncDir, deps) {
+    const reconciliation = reconcileAsyncRun(asyncDir, {
+        resultsDir: deps.resultsDir ?? RESULTS_DIR,
+        kill: deps.kill,
+        now: deps.now,
+    });
+    const status = reconciliation.status;
+    if (!status) {
+        return undefined;
+    }
+    const nested = nestedProjection(status, deps);
+    const projected = { ...status, steps: status.steps?.map((step) => ({ ...step })) };
+    attachRootChildrenToSteps(status.runId, projected.steps, nested.children);
+    const steps = runtimeSteps(projected, asyncDir, deps);
+    const lines = [
+        ...runtimeHeader(projected, asyncDir, deps, reconciliation),
+        ...steps.lines,
+        ...runtimeFooter(projected, asyncDir, deps, nested),
+    ];
+    if ((status.state === "running" || status.state === "queued") &&
+        completionTargetsSession(status, deps.state)) {
+        lines.push(ASYNC_COMPLETION_REMINDER);
     }
-    return `Step ${index + 1}`;
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            mode: "single",
+            results: [],
+            intercomTargets: steps.intercomTargets,
+            managementControl: runtimeControl(status),
+        },
+    };
 }
-function nestedRunDisplayName(run) {
-    if (run.agent)
-        return run.agent;
-    if (run.agents?.length)
-        return run.agents.join(", ");
-    return run.id;
+function savedResultLines(data, resultPath, runId, options) {
+    const lines = [
+        ...(options.includeRunHeader !== false
+            ? [`Run: ${runId ?? "unknown"}`, `State: ${data.terminalState}`]
+            : []),
+        `${options.includeRunHeader === false ? "Runtime result" : "Result"}: ${resultPath}`,
+        `Status: ${formatRunAction("status", runId ?? "unknown", {}, options.childSafe)}`,
+    ];
+    const children = data.results ??
+        (hasText(data.agent) ? [{ agent: data.agent, sessionFile: data.sessionFile }] : []);
+    lines.push(formatResumeGuidance(runId, children, data.sessionFile, options.childSafe));
+    if (hasText(data.summary)) {
+        const summary = options.full === true || data.summary.length <= 600
+            ? data.summary
+            : `${data.summary.slice(0, 599)}…`;
+        lines.push("", summary);
+    }
+    return lines;
 }
-function normalizedState(state) {
-    if (state === "running" || state === "queued")
-        return "live";
-    if (state === "complete")
-        return "completed";
-    if (state === "paused" || state === "blocked" || state === "failed")
-        return state;
-    return "unknown";
+function inspectResult(resultPath, resolvedId, params, deps) {
+    const data = readAsyncResultFile(resultPath);
+    const runId = data.runId ?? data.id ?? resolvedId;
+    const lines = savedResultLines(data, resultPath, runId, {
+        includeRunHeader: deps.includeRunHeader,
+        childSafe: deps.nested !== undefined,
+        full: params.full,
+    });
+    const children = data.results ??
+        (hasText(data.agent) ? [{ agent: data.agent, sessionFile: data.sessionFile }] : []);
+    const state = normalizedState(data.terminalState);
+    const resumable = children
+        .map((child, index) => ({ child, index }))
+        .find(({ child }) => hasExistingSessionFile(child.sessionFile));
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            mode: "single",
+            results: [],
+            managementControl: buildManagementControl({
+                state,
+                runId: runId ?? "unknown",
+                index: resumable?.index,
+                canResume: state !== "live" && resumable !== undefined,
+            }),
+        },
+    };
 }
-function formatNestedExactStatus(rootRunId, run, childSafe) {
-    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.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}`);
+function inspectLocation(location, params, deps) {
+    if (location.asyncDir === null && location.resultPath === null) {
+        return errorResult("Async run not found. Provide id or dir.");
     }
-    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;
-            lines.push(`  ${index + 1}. ${step.agent} ${step.status}${activity ? `, ${activity}` : ""}${step.error ? `, error: ${step.error}` : ""}`);
-            lines.push(...formatNestedRunStatusLines(step.children, { indent: "    ", commandHints: true, childSafe }));
+    if (location.asyncDir !== null) {
+        const runtime = inspectRuntime(location.asyncDir, deps);
+        if (runtime) {
+            return runtime;
         }
     }
-    lines.push(...formatNestedRunStatusLines(run.children, { indent: "  ", commandHints: true, childSafe }));
-    const state = normalizedState(run.state);
-    lines.push("Commands:", `  Status: ${formatRunAction("status", run.id, {}, childSafe)}`);
-    if (state === "live")
-        lines.push(`  ${childSafe ? "Interrupt" : "Stop"}: ${formatRunAction("interrupt", run.id, {}, childSafe)}`);
-    if (state === "live" || run.sessionFile)
-        lines.push(`  ${childSafe ? "Resume" : "Continue"}: ${formatRunAction("resume", run.id, { message: "..." }, childSafe)}`);
-    lines.push(`  Root status: ${formatRunAction("status", rootRunId, {}, childSafe)}`);
-    return lines.join("\n");
-}
-export function inspectSubagentStatus(params, deps = {}) {
-    const childSafe = Boolean(deps.nested);
-    const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
-    const resultsDir = deps.resultsDir ?? RESULTS_DIR;
-    if (!params.id && !params.runId && !params.dir) {
-        if (deps.nested) {
-            return {
-                content: [{ type: "text", text: "Child-safe subagent status requires a run id." }],
-                isError: true,
-                details: { mode: "single", results: [] },
-            };
-        }
+    if (location.resultPath !== null) {
         try {
-            const runs = listAsyncRuns(asyncDirRoot, {
-                resultsDir,
-                kill: deps.kill,
-                now: deps.now,
-            }).filter((run) => completionTargetsCurrentSession(run, deps.state));
-            const text = formatAsyncRunList(runs, "Async runs");
-            const reminder = runs.some((run) => run.state === "running" || run.state === "queued");
-            return {
-                content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
-                details: {
-                    mode: "single", results: [],
-                    managementControls: runs.map((run) => {
-                        const running = run.steps.find((step) => step.status === "running");
-                        const target = running ? resolveSubagentIntercomTarget(run.id, running.agent, running.index) : undefined;
-                        const resumable = run.steps.find((step) => hasExistingSessionFile(step.sessionFile));
-                        return buildManagementControl({ state: normalizedState(run.state), runId: run.id, index: running?.index ?? resumable?.index, intercomTarget: target, canNudge: Boolean(running), canResume: Boolean(running || resumable || (run.steps.length <= 1 && hasExistingSessionFile(run.sessionFile))), canInterrupt: run.state === "running" });
-                    }),
-                },
-            };
+            return inspectResult(location.resultPath, location.resolvedId, params, deps);
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                content: [{ type: "text", text: message }],
-                isError: true,
-                details: { mode: "single", results: [] },
-            };
+            return errorResult(`Failed to read async result file: ${errorMessage(error)}`);
         }
     }
-    let location;
+    return errorResult("Status file not found.");
+}
+export function inspectSubagentStatus(params, deps = {}) {
     try {
-        const requestedId = params.id ?? params.runId;
-        if (!params.dir && requestedId) {
-            const resolved = resolveSubagentRunId(requestedId, { asyncDirRoot, resultsDir, state: deps.state, nested: deps.nested });
-            if (resolved?.kind === "nested") {
-                const children = reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
-                const nested = resolved;
-                const run = findNestedRun(children, nested.id) ?? nested.match.run;
-                const state = normalizedState(run.state);
-                const intercomTarget = run.intercomTarget ?? run.leafIntercomTarget;
-                const text = formatNestedExactStatus(nested.match.rootRunId, run, childSafe);
-                const reminder = state === "live" && nestedCompletionTargetsCurrentSession(nested.match.rootRunId, asyncDirRoot, deps.state);
-                return {
-                    content: [{ type: "text", text: reminder ? `${text}\n${ASYNC_COMPLETION_REMINDER}` : text }],
-                    details: {
-                        mode: "single", results: [],
-                        managementControl: buildManagementControl({ state, runId: run.id, intercomTarget, canNudge: false, canResume: state === "live" || Boolean(run.sessionFile), canInterrupt: state === "live" }),
-                    },
-                };
-            }
-            if (resolved?.kind === "async")
-                location = resolved.location;
-            else
-                location = { asyncDir: null, resultPath: null, resolvedId: requestedId };
+        if (!hasText(params.id) && !hasText(params.runId) && !hasText(params.dir)) {
+            return inspectList(deps);
         }
-        else {
-            location = resolveAsyncRunLocation(params, asyncDirRoot, resultsDir);
+        const location = resolveInspection(params, deps);
+        if ("content" in location) {
+            return location;
         }
+        return inspectLocation(location, params, deps);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            content: [{ type: "text", text: message }],
-            isError: true,
-            details: { mode: "single", results: [] },
-        };
+        return errorResult(errorMessage(error));
     }
-    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) {
-        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;
-        const effectiveRunId = status?.runId ?? resolvedId ?? "unknown";
-        const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
-        const eventsPath = path.join(asyncDir, "events.jsonl");
-        if (status) {
-            const intercomTargets = [];
-            let nestedChildren = [];
-            let nestedWarning;
-            try {
-                const nestedRoute = findNestedRouteForRootId(status.runId);
-                if (nestedRoute)
-                    nestedChildren = reconcileNestedAsyncDescendants(nestedRoute, { resultsDir, kill: deps.kill, now: deps.now });
-                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,
-                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" ? formatActivityFacts(status) : undefined;
-            const canExtend = status.runtimeVersion === 2 && status.state === "running" && !status.timedOut && Boolean(status.timeoutAt);
-            const lines = [
-                ...(deps.includeRunHeader !== false ? [`Run: ${status.runId}`, `State: ${status.state}`, `Mode: ${status.mode}`] : []),
-                statusActivityText ? `Activity: ${statusActivityText}` : undefined,
-                `Progress: ${progressLabel}`,
-                `Started: ${started}`,
-                `Updated: ${updated}`,
-                status.timeoutAt ? `Timeout: ${new Date(status.timeoutAt).toISOString()}` : undefined,
-                canExtend ? `Extend: ${formatRunAction("extend", status.runId, { extendMs: 300000 }, childSafe)}` : undefined,
-                `Dir: ${asyncDir}`,
-                `Status: ${formatRunAction("status", status.runId, {}, childSafe)}`,
-                outputPath ? `Output: ${outputPath}` : undefined,
-                reconciliation.message ? `Diagnosis: ${reconciliation.message}` : undefined,
-                reconciliation.resultPath && fs.existsSync(reconciliation.resultPath) ? `${deps.includeRunHeader === false ? "Runtime result" : "Result"}: ${reconciliation.resultPath}` : undefined,
-            ].filter((line) => Boolean(line));
-            if (status.state !== "running")
-                lines.push(...formatOutputExcerpt(outputPath));
-            for (const [index, step] of (status.steps ?? []).entries()) {
-                const stepActivityText = step.status === "running" ? formatActivityFacts(step) : undefined;
-                const modelThinking = formatModelThinking(step.model, step.thinking);
-                const modelText = modelThinking ? ` (${modelThinking})` : "";
-                const errorText = step.error ? `, error: ${step.error}` : "";
-                const finalizationText = formatAcceptanceFinalizationSummary(step.acceptance?.finalization);
-                const acceptanceText = step.acceptance?.status ? `, acceptance: ${step.acceptance.status}${finalizationText}` : "";
-                const display = step.label ? `${step.label} (${step.agent})` : step.agent;
-                const phase = step.phase ? `[${step.phase}] ` : "";
-                lines.push(`${stepLineLabel(status, index)}: ${phase}${display} ${step.status}${modelText}${stepActivityText ? `, ${stepActivityText}` : ""}${acceptanceText}${errorText}`);
-                if (step.tokens)
-                    lines.push(`  ${step.tokens.total} tokens`);
-                lines.push(...formatNestedRunStatusLines(step.children, { indent: "  ", commandHints: true, maxLines: 20, childSafe }));
-                const stepOutputPath = path.join(asyncDir, `output-${index}.log`);
-                if (stepOutputPath !== outputPath && fs.existsSync(stepOutputPath))
-                    lines.push(`  Output: ${stepOutputPath}`);
-                if (step.status === "running") {
-                    const target = resolveSubagentIntercomTarget(status.runId, step.agent, index);
-                    intercomTargets.push(target);
-                    lines.push(...formatLiveIntercomActionLines({ runId: status.runId, index, target, health: deps.intercomHealth?.get(target), indent: "  ", childSafe }));
-                }
-            }
-            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, childSafe }));
-            if (nestedWarning)
-                lines.push(`Warning: ${nestedWarning}`);
-            if (status.sessionFile)
-                lines.push(`Session: ${status.sessionFile}`);
-            if (status.state !== "running") {
-                lines.push(formatResumeGuidance(status.runId, status.steps ?? [], status.sessionFile, childSafe));
-            }
-            if (fs.existsSync(logPath))
-                lines.push(`Log: ${logPath}`);
-            if (fs.existsSync(eventsPath))
-                lines.push(`Events: ${eventsPath}`);
-            if ((status.state === "running" || status.state === "queued") && completionTargetsCurrentSession(status, deps.state))
-                lines.push(ASYNC_COMPLETION_REMINDER);
-            const state = normalizedState(status.state);
-            const runningStep = (status.steps ?? []).map((step, index) => ({ step, index })).find(({ step }) => step.status === "running");
-            const target = runningStep ? resolveSubagentIntercomTarget(status.runId, runningStep.step.agent, runningStep.index) : undefined;
-            const resumableStep = (status.steps ?? []).map((step, index) => ({ step, index })).find(({ step }) => hasExistingSessionFile(step.sessionFile));
-            const canResume = state !== "live" && Boolean(resumableStep || ((status.steps?.length ?? 0) <= 1 && hasExistingSessionFile(status.sessionFile)));
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: {
-                    mode: "single", results: [], intercomTargets,
-                    managementControl: buildManagementControl({ state, runId: status.runId, index: runningStep?.index ?? resumableStep?.index, intercomTarget: target, canNudge: Boolean(runningStep), canResume: state === "live" ? Boolean(runningStep) : canResume, canInterrupt: status.state === "running", canExtend }),
-                },
-            };
-        }
-    }
-    if (resultPath) {
-        try {
-            const data = readAsyncResultFile(resultPath);
-            const status = data.terminalState;
-            const runId = data.runId ?? data.id ?? resolvedId;
-            const lines = [...(deps.includeRunHeader !== false ? [`Run: ${runId}`, `State: ${status}`] : []), `${deps.includeRunHeader === false ? "Runtime result" : "Result"}: ${resultPath}`, `Status: ${formatRunAction("status", runId ?? "unknown", {}, childSafe)}`];
-            const children = Array.isArray(data.results) ? data.results : data.agent ? [{ agent: data.agent, sessionFile: data.sessionFile }] : [];
-            lines.push(formatResumeGuidance(runId, children, data.sessionFile, childSafe));
-            if (data.summary)
-                lines.push("", params.full ? data.summary : data.summary.length > 600 ? `${data.summary.slice(0, 599)}…` : data.summary);
-            const state = normalizedState(status);
-            const resumableChild = children.map((child, index) => ({ child, index })).find(({ child }) => hasExistingSessionFile(child.sessionFile));
-            return {
-                content: [{ type: "text", text: lines.join("\n") }],
-                details: {
-                    mode: "single", results: [],
-                    managementControl: buildManagementControl({ state, runId: runId ?? "unknown", index: resumableChild?.index, canResume: state !== "live" && Boolean(resumableChild) }),
-                },
-            };
-        }
-        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: [] },
-    };
 }