@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/runs/shared/owned-run-results.js

@@ -0,0 +1,202 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { compactForegroundResult, getSingleResultOutput } from "../../shared/utils.js";
+import { readAsyncResultFile } from "../background/async-result-file.js";
+import { exactAsyncRunLocation } from "../background/async-resume.js";
+import { getRunMetadataDir } from "./supervisor-questions.js";
+import { ASYNC_DIR, DEFAULT_MAX_OUTPUT, RESULTS_DIR, truncateOutput, } from "../../shared/types.js";
+import { repairOwnedRunAccounting } from "./run-persistence.js";
+import { ownedRunView } from "./owned-run-view.js";
+import { ownedRunProgressResult } from "./owned-run-progress.js";
+import { workflowDetails } from "./owned-workflow-details.js";
+export { ownedRunProgressResult } from "./owned-run-progress.js";
+function initialOutput(result, limits, artifactPath) {
+    const initial = result.initialOutput;
+    return initial !== undefined && initial !== ""
+        ? { initialOutput: truncateOutput(initial, limits, artifactPath).text }
+        : {};
+}
+function projectChild(child, limits) {
+    if (!child.result) {
+        return { ...child, result: undefined };
+    }
+    const { artifactPaths, ...result } = child.result;
+    const truncation = result.outputMode === "file-only" && result.exitCode === 0 && result.outputReference
+        ? { text: result.outputReference.message, truncated: false }
+        : truncateOutput(getSingleResultOutput(result), limits, artifactPaths?.outputPath);
+    const compacted = compactForegroundResult({
+        ...result,
+        finalOutput: truncation.text,
+        ...(truncation.truncated ? { truncation } : {}),
+        ...initialOutput(result, limits, artifactPaths?.outputPath),
+    });
+    return { ...child, result: { ...compacted, ...(artifactPaths ? { artifactPaths } : {}) } };
+}
+function publicResult(child) {
+    if (!child.result) {
+        return [];
+    }
+    const { artifactPaths, ...result } = child.result;
+    if (artifactPaths?.inputPath !== undefined &&
+        artifactPaths.inputPath !== "" &&
+        artifactPaths.outputPath !== undefined &&
+        artifactPaths.outputPath !== "" &&
+        artifactPaths.metadataPath !== undefined &&
+        artifactPaths.metadataPath !== "") {
+        return [
+            {
+                ...result,
+                artifactPaths: {
+                    inputPath: artifactPaths.inputPath,
+                    outputPath: artifactPaths.outputPath,
+                    metadataPath: artifactPaths.metadataPath,
+                },
+            },
+        ];
+    }
+    return [result];
+}
+function resultFailed(view, children, index) {
+    return index === undefined
+        ? ["failed", "unknown"].includes(view.state)
+        : children.length === 0 ||
+            children.some((child) => ["failed", "unknown"].includes(child.state));
+}
+function resultText(view, children, saved, index) {
+    const summary = index === undefined ? saved?.summary : undefined;
+    let text = summary !== undefined && summary !== ""
+        ? summary
+        : [
+            ...children.map((child) => {
+                if (!child.result) {
+                    return;
+                }
+                const output = getSingleResultOutput(child.result);
+                return output !== "" ? output : child.result.error;
+            }),
+            view.diagnosis,
+        ]
+            .filter((part) => part !== undefined && part !== "")
+            .join("\n\n");
+    const error = saved?.error;
+    if (resultFailed(view, children, index) &&
+        error !== undefined &&
+        error !== "" &&
+        !text.includes(error)) {
+        text = `${error}\n\n${text}`;
+    }
+    return text;
+}
+function outputArtifact(run, results, directory) {
+    if (run.mode === "single") {
+        return results[0]?.artifactPaths?.outputPath;
+    }
+    const logPath = path.join(directory, `subagent-log-${run.runId}.md`);
+    return fs.existsSync(logPath) ? logPath : undefined;
+}
+function summaryTruncation(view, results, output) {
+    const { text, limits } = output;
+    const only = results.length === 1 ? results[0] : undefined;
+    if (view.state === "completed" &&
+        view.mode === "single" &&
+        only?.outputMode === "file-only" &&
+        only.outputReference) {
+        return { text: only.outputReference.message, truncated: false };
+    }
+    if (view.state === "blocked") {
+        return { text, truncated: false };
+    }
+    const directory = view.asyncDir ?? getRunMetadataDir(view.runId);
+    return truncateOutput(text, limits, outputArtifact(view, results, directory));
+}
+function progressSummary(results, duration) {
+    return {
+        toolCount: results.reduce((total, result) => total + (result.progressSummary?.toolCount ?? 0), 0),
+        tokens: results.reduce((total, result) => total + (result.progressSummary?.tokens ?? 0), 0),
+        durationMs: duration ?? Math.max(0, ...results.map((result) => result.progressSummary?.durationMs ?? 0)),
+    };
+}
+function resultIdentity(run) {
+    return (run.predecessorRunId ?? "") !== ""
+        ? [
+            `Run: ${run.runId}\nPredecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`,
+        ]
+        : [];
+}
+function sharingText(saved) {
+    if (saved?.shareUrl !== undefined && saved.shareUrl !== "") {
+        return [`Session: ${saved.shareUrl}`];
+    }
+    return saved?.shareError !== undefined && saved.shareError !== ""
+        ? [`Session share error: ${saved.shareError}`]
+        : [];
+}
+function savedDetails(saved, results) {
+    if (!saved) {
+        return resultArtifacts(results);
+    }
+    return {
+        ...((saved.shareUrl ?? "") !== "" ? { shareUrl: saved.shareUrl } : {}),
+        ...((saved.gistUrl ?? "") !== "" ? { gistUrl: saved.gistUrl } : {}),
+        ...((saved.shareError ?? "") !== "" ? { shareError: saved.shareError } : {}),
+        ...(saved.outputs ? { outputs: saved.outputs } : {}),
+        ...workflowDetails(saved.workflowGraph),
+        ...resultArtifacts(results, saved.artifactsDir),
+    };
+}
+function resultArtifacts(results, directory) {
+    const files = results.flatMap((result) => (result.artifactPaths ? [result.artifactPaths] : []));
+    const first = files.at(0);
+    return first ? { artifacts: { dir: directory ?? path.dirname(first.outputPath), files } } : {};
+}
+function loadSavedResult(file) {
+    return file !== null && file !== "" ? readAsyncResultFile(file) : undefined;
+}
+function outputLimits(saved, view) {
+    return { ...DEFAULT_MAX_OUTPUT, ...(saved?.maxOutput ?? view.children.at(0)?.launch?.maxOutput) };
+}
+export function ownedRunExecutionResult(run, state, index, includeProgress = false) {
+    try {
+        repairOwnedRunAccounting(run);
+    }
+    catch (error) {
+        console.error(`Native accounting for ${run.runId} remains incomplete:`, error);
+    }
+    const view = ownedRunView(run, state);
+    const location = exactAsyncRunLocation(run.runId, ASYNC_DIR, RESULTS_DIR);
+    const saved = loadSavedResult(location.resultPath);
+    const limits = outputLimits(saved, view);
+    const children = view.children.filter((child) => index === undefined || child.index === index);
+    const projected = view.children.map((child) => projectChild(child, limits));
+    const results = projected
+        .filter((child) => index === undefined || child.index === index)
+        .flatMap(publicResult);
+    const truncation = summaryTruncation({ ...view, asyncDir: location.asyncDir ?? view.asyncDir }, results, { text: resultText(view, children, saved, index), limits });
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    ...resultIdentity(run),
+                    truncation.text !== "" ? truncation.text : `Run ${run.runId}: ${view.state}.`,
+                    ...sharingText(saved),
+                ].join("\n\n"),
+            },
+        ],
+        ...(resultFailed(view, children, index) ? { isError: true } : {}),
+        details: {
+            mode: run.mode,
+            runId: run.runId,
+            asyncId: run.runId,
+            asyncDir: location.asyncDir ?? run.asyncDir,
+            results,
+            run: { ...view, children: projected },
+            progressSummary: progressSummary(results, saved?.durationMs),
+            ...(includeProgress
+                ? { progress: ownedRunProgressResult(run, state, index).details.progress }
+                : {}),
+            ...savedDetails(saved, results),
+            ...(truncation.truncated ? { truncation } : {}),
+        },
+    };
+}

package/dist/runs/shared/owned-run-status.js

@@ -0,0 +1,180 @@
+import * as fs from "node:fs";
+import { getSingleResultOutput } from "../../shared/utils.js";
+import { buildManagementControl, formatAgentProcessExit, formatRunAction, } from "../../shared/status-format.js";
+import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.js";
+import { acceptanceHumanAction } from "./acceptance-evaluation.js";
+import { ownedRunView } from "./owned-run-view.js";
+export function compact(value, max = 180) {
+    const text = value.replace(/\s+/g, " ").trim();
+    return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+export function ownedRunControl(view) {
+    const active = view.children.find((child) => child.state === "live" && child.activity?.status !== "pending");
+    const resumable = active ??
+        view.children.find((child) => child.state !== "live" && (child.sessionFile ?? "") !== "" && child.missingSession !== true);
+    return buildManagementControl({
+        state: view.state,
+        runId: view.runId,
+        index: resumable?.index,
+        canReview: view.state !== "live",
+        canResume: resumable !== undefined,
+        canNudge: active !== undefined,
+        canInterrupt: view.canInterrupt,
+        intercomTarget: active
+            ? resolveSubagentIntercomTarget(view.runId, active.agent, active.index)
+            : undefined,
+    });
+}
+function reviewDescription(run, full) {
+    const message = run.review?.message;
+    const suffix = message !== undefined && message !== "" ? ` — ${full ? message : compact(message)}` : "";
+    return `Parent review (not sent to child): ${run.review?.decision ?? "unreviewed"}${suffix}`;
+}
+function notificationDescription(run) {
+    if (!run.delivery) {
+        return "Notification: not recorded";
+    }
+    return `Notification: recorded ${new Date(run.delivery.notifiedAt).toISOString()}; intercom ${run.delivery.intercomDelivered ? "delivered" : "not confirmed"}`;
+}
+function optionalLine(prefix, value) {
+    return value !== undefined && value !== "" ? [`${prefix}${value}`] : [];
+}
+function runDescription(run, view, full) {
+    return [
+        `Run: ${run.runId}`,
+        `State: ${view.state}`,
+        `Mode: ${run.mode} (${run.source})`,
+        `Task: ${full ? run.task : compact(run.task)}`,
+        `Launch cwd: ${run.cwd}`,
+        `Root: ${run.rootRunId}`,
+        ...((run.predecessorRunId ?? "") !== ""
+            ? [`Predecessor: ${run.predecessorRunId ?? ""} (child ${run.predecessorIndex ?? 0})`]
+            : []),
+        reviewDescription(run, full),
+        notificationDescription(run),
+        ...(view.attention.length > 0 ? [`Attention: ${view.attention.join(", ")}`] : []),
+        ...optionalLine("Result: ", view.resultPath),
+        ...optionalLine("", view.diagnosis),
+    ];
+}
+function fileDescription(label, file) {
+    if (file === undefined || file === "") {
+        return [];
+    }
+    return [`  ${label}: ${file}${fs.existsSync(file) ? "" : " (missing)"}`];
+}
+function childEvidence(child) {
+    const result = child.result;
+    const output = result ? getSingleResultOutput(result) : "";
+    const humanAction = acceptanceHumanAction(result?.acceptance);
+    return [
+        ...optionalLine("  Needs your action — acceptance incomplete:\n", humanAction),
+        ...(child.state !== "live" ? [`  ${formatAgentProcessExit(result?.agentProcessExit)}`] : []),
+        ...childOutputPaths(child),
+        ...(output !== "" ? [`  Result: ${compact(output, 600)}`] : []),
+        ...optionalLine("  Error: ", result?.error),
+    ];
+}
+function childOutputPaths(child) {
+    const result = child.result;
+    return [
+        ...optionalLine("  Child observations / uncommitted output: ", result?.auditPath),
+        ...optionalLine("  Full output: ", result?.fullOutputPath),
+        ...fileDescription("Artifact", result?.artifactPaths?.outputPath),
+        ...fileDescription("Result metadata (acceptance details when configured)", result?.artifactPaths?.metadataPath),
+    ];
+}
+function childConfiguration(child, full) {
+    const launch = child.launch;
+    if (!launch) {
+        return ["  Configuration: legacy-partial; original profile snapshot was not recorded."];
+    }
+    return [
+        `  Effective model: ${launch.model ?? "native default"}; thinking: ${launch.thinking ?? "native default"}`,
+        `  Output: ${launch.output === false || launch.output === "" ? "disabled" : launch.output} (${launch.outputMode}); configuration: saved launch snapshot`,
+        ...(full ? [`  Saved launch configuration:\n${JSON.stringify(launch, null, 2)}`] : []),
+    ];
+}
+function childSession(child) {
+    const file = child.sessionFile;
+    if (file === undefined || file === "") {
+        return [];
+    }
+    return [
+        `  Session: ${file}${child.missingSession === true ? " (missing; continuation unavailable)" : ""}`,
+    ];
+}
+function childAccounting(child) {
+    const accounting = child.result?.accounting;
+    return accounting?.state === "incomplete"
+        ? [
+            `  Accounting incomplete: ${accounting.error ?? "Native billing evidence is unavailable; no work was repeated."}`,
+        ]
+        : [];
+}
+function childDescription(child, full) {
+    const result = child.result;
+    return [
+        `Child ${child.index}: ${child.agent} | ${child.state}${result?.acceptance ? ` | validation: ${result.acceptance.status}` : ""}`,
+        ...childEvidence(child),
+        ...childSession(child),
+        ...childAccounting(child),
+        ...childConfiguration(child, full),
+    ];
+}
+function actionDescription(view, control, options) {
+    const resumeIndex = control.nextActions.find((action) => action.action === "resume")?.index ?? 0;
+    return [
+        ...(control.capabilities.includes("review")
+            ? [
+                `Review (parent-only, not sent to child): ${formatRunAction("review", view.runId, { decision: "accepted" }, options.childSafe)} or decision: "needs_changes".`,
+            ]
+            : []),
+        ...(view.continuations.length > 0
+            ? [
+                "Continuation history:",
+                ...view.continuations.map((next) => `  ${next.predecessorRunId}:${next.predecessorIndex ?? 0} -> ${next.runId}`),
+            ]
+            : []),
+        ...(control.capabilities.includes("resume")
+            ? [
+                `Continue: ${formatRunAction("resume", view.runId, { ...(view.children.length > 1 ? { index: resumeIndex } : {}), message: "..." }, options.childSafe)}`,
+            ]
+            : []),
+        ...(options.full !== true
+            ? [
+                `Full task/configuration: ${formatRunAction("status", view.runId, { full: true }, options.childSafe)}`,
+            ]
+            : []),
+    ];
+}
+function runtimeDescription(runtime, include) {
+    if (!runtime || runtime.isError === true || !include) {
+        return [];
+    }
+    return runtime.content.flatMap((part) => (part.type === "text" ? [part.text] : []));
+}
+export function ownedRunStatusResult(run, state, runtime, options = {}) {
+    const view = ownedRunView(run, state);
+    const liveControl = view.state === "live" && runtime?.details.managementControl?.state === "live"
+        ? runtime.details.managementControl
+        : undefined;
+    const control = liveControl ?? ownedRunControl(view);
+    const runtimeText = runtimeDescription(runtime, run.source === "async" || liveControl !== undefined);
+    const lines = [
+        ...runDescription(run, view, options.full === true),
+        ...runtimeText,
+        ...view.children.flatMap((child) => childDescription(child, options.full === true)),
+        ...actionDescription(view, control, options),
+    ];
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            ...runtime?.details,
+            mode: "management",
+            results: [],
+            run: view,
+            managementControl: control,
+        },
+    };
+}

package/dist/runs/shared/owned-run-view.js

@@ -0,0 +1,51 @@
+import * as path from "node:path";
+import { listOwnedRunQuestions } from "./supervisor-questions.js";
+import { RunObservation } from "./owned-run-observation.js";
+function runAttention(run, state, pendingInput) {
+    return [
+        ...(pendingInput ? ["awaiting_input"] : []),
+        ...(run.review?.decision === "needs_changes" ? ["needs_changes"] : []),
+        ...(run.review?.decision !== "accepted" &&
+            ["failed", "blocked", "paused", "unknown"].includes(state)
+            ? [state]
+            : []),
+        ...(state === "completed" && !run.review ? ["unreviewed"] : []),
+    ];
+}
+function continuations(run, state) {
+    return [...(state.ownedRuns?.values() ?? [])]
+        .filter((candidate) => candidate.rootRunId === run.rootRunId)
+        .sort((a, b) => a.startedAt - b.startedAt)
+        .flatMap((candidate) => candidate.predecessorRunId !== undefined && candidate.predecessorRunId !== ""
+        ? [
+            {
+                runId: candidate.runId,
+                predecessorRunId: candidate.predecessorRunId,
+                predecessorIndex: candidate.predecessorIndex,
+            },
+        ]
+        : []);
+}
+export function ownedRunView(requestedRun, state, options = {}) {
+    const run = state.ownedRuns?.get(requestedRun.runId) ?? requestedRun;
+    const observed = new RunObservation(run, state, options);
+    const children = observed.indices.map((index) => observed.child(index));
+    const pendingInput = options.pendingInput ??
+        listOwnedRunQuestions(run.ownerSessionId, run.runId).some((question) => question.state === "awaiting_input" || question.state === "answer_pending");
+    const summary = observed.summary(children, pendingInput);
+    const resultPath = observed.result ? observed.resultPath : undefined;
+    return {
+        ...run,
+        state: summary.state,
+        children,
+        attention: runAttention(run, summary.state, pendingInput),
+        canInterrupt: summary.canInterrupt,
+        updatedAt: summary.updatedAt,
+        continuations: options.includeContinuations === false ? [] : continuations(run, state),
+        ...(resultPath !== undefined ? { resultPath } : {}),
+        ...(!observed.result && observed.foreground
+            ? { resultPath: path.join(observed.root, "foreground.json") }
+            : {}),
+        diagnosis: summary.diagnosis,
+    };
+}

package/dist/runs/shared/owned-workflow-details.js

@@ -0,0 +1,17 @@
+/** Saved graph facts shared by result and activity projections, never workflow execution. */
+export function workflowDetails(graph) {
+    if (!graph) {
+        return {};
+    }
+    if (graph.mode !== "chain") {
+        return { workflowGraph: graph };
+    }
+    const current = graph.nodes.find((node) => node.id === graph.currentNodeId ||
+        node.children?.some((child) => child.id === graph.currentNodeId) === true);
+    return {
+        workflowGraph: graph,
+        chainAgents: graph.nodes.map((node) => node.agent ?? node.label),
+        totalSteps: graph.nodes.length,
+        ...(current?.stepIndex !== undefined ? { currentStepIndex: current.stepIndex } : {}),
+    };
+}

package/dist/runs/shared/owner-output.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getRunMetadataDir, QUESTIONS_DIR } from "./run-metadata-paths.js";
+function writeOwnedOutput(slot, text, initial) {
+    const name = initial ? `${slot.index}.initial.txt` : `${slot.index}.txt`;
+    const file = path.join(getRunMetadataDir(slot.runId, slot.root), "outputs", name);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text, { mode: 0o600 });
+    return file;
+}
+function terminalOutputPath(result, slot) {
+    const output = result.finalOutput ?? result.output;
+    let file = result.fullOutputPath;
+    if (output === undefined || output.length <= 8192) {
+        return file;
+    }
+    file ??= result.artifactPaths?.outputPath;
+    return file === undefined || file === "" ? writeOwnedOutput(slot, output, false) : file;
+}
+function initialOutputPath(result, slot) {
+    const output = result.initialOutput;
+    const file = result.initialOutputPath;
+    if (output === undefined || output.length <= 8192) {
+        return file;
+    }
+    return file === undefined || file === "" ? writeOwnedOutput(slot, output, true) : file;
+}
+export function compactOwnerResult(runId, index, result, root = QUESTIONS_DIR) {
+    const slot = { runId, index, root };
+    const fullOutputPath = terminalOutputPath(result, slot);
+    const initialPath = initialOutputPath(result, slot);
+    return {
+        ...result,
+        messages: undefined,
+        ...((fullOutputPath ?? "") !== "" ? { fullOutputPath } : {}),
+        ...((initialPath ?? "") !== "" ? { initialOutputPath: initialPath } : {}),
+        ...(result.finalOutput !== undefined ? { finalOutput: result.finalOutput.slice(-8192) } : {}),
+        ...(result.output !== undefined ? { output: result.output.slice(-8192) } : {}),
+        ...(result.initialOutput !== undefined
+            ? { initialOutput: result.initialOutput.slice(-8192) }
+            : {}),
+    };
+}

package/dist/runs/shared/parallel-utils.js

@@ -2,14 +2,15 @@ export function isParallelGroup(step) {
     return "parallel" in step && Array.isArray(step.parallel);
 }
 export function isDynamicRunnerGroup(step) {
-    return "expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel);
+    return ("expand" in step && "collect" in step && "parallel" in step && !Array.isArray(step.parallel));
 }
 export function flattenSteps(steps) {
     const flat = [];
     for (const step of steps) {
         if (isParallelGroup(step)) {
-            for (const task of step.parallel)
+            for (const task of step.parallel) {
                 flat.push(task);
+            }
         }
         else if (isDynamicRunnerGroup(step)) {
             continue;
@@ -20,36 +21,43 @@ export function flattenSteps(steps) {
     }
     return flat;
 }
-export async function mapConcurrent(items, limit, fn) {
-    const safeLimit = Math.max(1, Math.floor(limit) || 1);
-    const results = new Array(items.length);
-    let next = 0;
-    async function worker(_workerIndex) {
-        while (next < items.length) {
-            const i = next++;
-            results[i] = await fn(items[i], i);
-        }
+export { mapConcurrent } from "../../shared/concurrency.js";
+function parallelResultStatus(result, hasOutput) {
+    const error = result.error ?? "";
+    const suffix = error.length > 0 ? `: ${error}` : "";
+    if (result.exitCode === -1) {
+        return `SKIPPED${suffix}`;
+    }
+    if (result.exitCode !== 0 && result.exitCode !== null) {
+        return `FAILED (exit code ${result.exitCode})${suffix}`;
     }
-    await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)));
-    return results;
+    if (error.length > 0) {
+        return `WARNING: ${error}`;
+    }
+    return emptyOutputStatus(result, hasOutput);
+}
+function emptyOutputStatus(result, hasOutput) {
+    if (hasOutput) {
+        return "";
+    }
+    const target = result.outputTargetPath ?? "";
+    if (target.length === 0) {
+        return "EMPTY OUTPUT (no textual response returned)";
+    }
+    return result.outputTargetExists === false
+        ? `EMPTY OUTPUT (expected output file missing: ${target})`
+        : "";
 }
 export function aggregateParallelOutputs(results, headerFormat = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`) {
     return results
-        .map((r, i) => {
-        const header = headerFormat(r.taskIndex ?? i, r.agent);
-        const hasOutput = Boolean(r.output?.trim());
-        const status = r.exitCode === -1
-            ? `SKIPPED${r.error ? `: ${r.error}` : ""}`
-            : r.exitCode !== 0 && r.exitCode !== null
-                ? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
-                : r.error
-                    ? `WARNING: ${r.error}`
-                    : !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-                        ? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
-                        : !hasOutput && !r.outputTargetPath
-                            ? "EMPTY OUTPUT (no textual response returned)"
-                            : "";
-        const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
+        .map((result, index) => {
+        const header = headerFormat(result.taskIndex ?? index, result.agent);
+        const hasOutput = result.output.trim().length > 0;
+        const status = parallelResultStatus(result, hasOutput);
+        let body = result.output;
+        if (status.length > 0) {
+            body = hasOutput ? `${status}\n${result.output}` : status;
+        }
         return `${header}\n${body}`;
     })
         .join("\n\n");