@pi-archimedes/subagent 2.10.3 → 2.11.0

package/src/dispatch.ts

@@ -32,6 +32,7 @@
 
 import { dispatch, BridgeTransportError, BridgeCancelledError } from "@pi-archimedes/core/bridge";
 import { resolveModel } from "./spawn.js";
+import { resolveThinkingLevel } from "./thinking-validation.js";
 import type { ExecuteOptions } from "./execute.js";
 import type { SubagentProgress, SubagentResult } from "./types.js";
 
@@ -101,7 +102,9 @@ export function dispatchViaBridge(
     task: options.task,
     systemPrompt: options.agentConfig?.systemPrompt?.trim() || null,
     model: model ?? null,
-    thinking: options.agentConfig?.thinking ?? null,
+    // The same rule the fork path applies: a level pi's `--thinking` would warn
+    // about and drop is not handed to the runner either (`thinking-validation.ts`).
+    thinking: resolveThinkingLevel(options.agentConfig?.thinking).level ?? null,
     tools: options.agentConfig?.tools?.length ? options.agentConfig.tools : null,
   };
 
@@ -114,6 +117,11 @@ export function dispatchViaBridge(
       const progress: SubagentProgress = {
         agent: agentName,
         status: "completed",
+        // The Client ran the session and reported it finished; that is a
+        // completed run in this vocabulary. It has no stopReason to expose and
+        // no cancellation of its own to report — a local cancel settles below
+        // with BridgeCancelledError, which is a failure by contract.
+        outcome: "completed",
         task: options.task,
         currentTool: undefined,
         currentToolArgs: undefined,
@@ -134,6 +142,7 @@ export function dispatchViaBridge(
         agent: agentName,
         task: options.task,
         exitCode: 0,
+        outcome: "completed",
         usage: {
           input: res.metrics.inputTokens,
           output: res.metrics.outputTokens,
@@ -142,6 +151,9 @@ export function dispatchViaBridge(
           cost: res.metrics.cost,
           turns: 0,
         },
+        // The Client ran this as a session of its own and books its usage there;
+        // this session must not also report it. See `SubagentResult`.
+        usageAccountedElsewhere: true,
         model,
         finalOutput: res.output,
         error: undefined,
@@ -169,7 +181,13 @@ export function dispatchViaBridge(
       const isLocalCancel = err instanceof BridgeCancelledError;
       const errorMessage = isLocalCancel ? "cancelled" : err instanceof Error ? err.message : String(err);
       const durationMs = Date.now() - startTime;
-      return buildFailedResult(agentName, options.task, errorMessage, model, durationMs);
+      // Same ownership rule as the success path above: this settled from a
+      // desktop-side session (or a cancel of one), so its usage is that
+      // session's to report even if it ended badly.
+      return {
+        ...buildFailedResult(agentName, options.task, errorMessage, model, durationMs),
+        usageAccountedElsewhere: true,
+      };
     },
   );
 }

package/src/execute.test.ts

@@ -43,7 +43,9 @@ function activateBridge(socketPath: string): void {
   process.env.PI_ARCHIMEDES_BRIDGE_SESSION = "test-desktop-session";
   process.env.PI_ARCHIMEDES_BRIDGE_SERVER_PID = "12345";
   const onSpy = vi.fn();
-  registerBridge({ on: onSpy } as unknown as ExtensionAPI);
+  // The handle the relay subscribes on — inert here (these tests are about fork
+  // vs dispatch, not about the relay), but a real session always hands one over.
+  registerBridge({ on: onSpy, events: { emit: () => {}, on: () => () => {} } } as unknown as ExtensionAPI);
   const calls = onSpy.mock.calls as Array<[string, (e: unknown, ctx: unknown) => void]>;
   const startCall = calls.find((c) => c[0] === "session_start");
   expect(startCall).toBeTruthy();
@@ -75,6 +77,9 @@ function makeOptions(overrides: Partial<ExecuteOptions> = {}): ExecuteOptions {
     cwd: undefined,
     signal: undefined,
     onUpdate: undefined,
+    // These tests never fork, so the handle is inert — present because a real
+    // ExecuteOptions always carries one.
+    events: { emit: () => {}, on: () => () => {} },
     toolCallId: "tc-1",
     ...overrides,
   };
@@ -168,6 +173,9 @@ describe("executeSubagent (bridge branch)", () => {
     expect(result.error).toBe("cancelled");
     expect(result.progress!.status).toBe("failed");
     expect(result.progress!.error).toBe("cancelled");
+    // Bridge-mode bookkeeping: whatever the desktop did with the task, its
+    // session owns the usage — the parent must not fold it into its own totals.
+    expect(result.usageAccountedElsewhere).toBe(true);
     expect(spawnSpy).not.toHaveBeenCalled();
     // Exactly ONE update: the final-failure progress (no "dispatched"
     // placeholder — a cancelled task does not claim it was dispatched).

package/src/execute.ts

@@ -1,8 +1,8 @@
 import { getBridge } from "@pi-archimedes/core/bridge";
+import type { EventBus } from "@earendil-works/pi-coding-agent";
 import { spawnSubagent, resolveModel } from "./spawn.js";
 import { dispatchViaBridge, buildFailedResult } from "./dispatch.js";
 import { streamEvents } from "./stream.js";
-import { emitCostUpdate } from "./cost.js";
 import type { AgentConfig } from "./agents.js";
 import type { SubagentProgress, SubagentResult } from "./types.js";
 
@@ -15,6 +15,10 @@ export interface ExecuteOptions {
   cwd: string | undefined;
   signal: AbortSignal | undefined;
   onUpdate: ((progress: SubagentProgress) => void) | undefined;
+  /** The parent's host handle (`pi.events`) — forwarded to the ask bridge and to
+   *  the todo announcements in `streamEvents`. Neither is an extension, so
+   *  neither can reach a handle of its own. */
+  events: EventBus;
   /** The subagent tool-call id (the tool's `_id`) — rides the dispatch frame
    *  for Client correlation; `undefined` → the frame's `toolCallId` is absent.
    *  In `executeParallel` all N tasks share the single subagent tool-call's id. */
@@ -49,7 +53,11 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
     // so executeParallel's progress slot updates from the pending placeholder
     // to "failed" instead of a stale "Starting...".
     if (options.signal?.aborted) {
-      const result = buildFailedResult(agentName, options.task, "cancelled", model, Date.now() - startTime);
+      const result = {
+        ...buildFailedResult(agentName, options.task, "cancelled", model, Date.now() - startTime),
+        // Bridge mode: any usage this run ever had belongs to a desktop session.
+        usageAccountedElsewhere: true,
+      };
       options.onUpdate?.(result.progress!);
       return result;
     }
@@ -81,23 +89,21 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
     if (!("fallback" in outcome)) {
       // Bridge used (success or a response-carrying error, incl. the terminal
       // "cancelled" frame — the desktop is alive, its outcome is authoritative):
-      // return it — NO fork fallback, and NO emitCostUpdate here — the PARENT
-      // never pushes the subagent's usage on the PARENT's bus (the fork-delta
-      // semantics: only the fork path reports a child's usage, source
-      // `subagent:<name>`). The subagent process self-emits its own usage to
-      // its OWN bridge (the core self-usage emitter,
-      // `subagent-metrics-cost-push` Task 1) — a different bus, a different
-      // session; no double-count.
+      // return it, with no cost report of its own. The PARENT never reports a
+      // child's usage for a run it did not perform: the subagent process emits
+      // its OWN usage to its OWN bridge (the core self-usage emitter), which is a
+      // different session's total. Every result `dispatchViaBridge` settles
+      // carries `usageAccountedElsewhere`, which is how the tool knows to leave
+      // it off the tool result — pi folds that `usage` into THIS session's
+      // totals, so copying it across would bill the parent twice. The fork path
+      // below does report, through the tool result's native `usage`.
       return outcome;
     }
     // { fallback: true } — unreachable bridge: fall through to the fork path.
   }
 
-  // Track previously emitted values to only emit deltas
-  let lastEmittedInput = 0;
-  let lastEmittedOutput = 0;
-  let lastEmittedCost = 0;
-
+  // Progress is passed straight through: cost is reported once, on the tool
+  // result's native `usage`, so there is no delta bookkeeping left to do here.
   try {
     const child = spawnSubagent({
       task: options.task,
@@ -106,26 +112,14 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
       cwd: options.cwd,
       signal: options.signal,
       agent: options.agentConfig,
+      events: options.events,
     });
 
     const result = await streamEvents(child, {
       agent: agentName,
       task: options.task,
+      events: options.events,
       onProgress: (progress: SubagentProgress) => {
-        // Emit only deltas to avoid double-counting in CostAccumulator
-        const deltaInput = progress.inputTokens - lastEmittedInput;
-        const deltaOutput = progress.outputTokens - lastEmittedOutput;
-        const deltaCost = progress.cost - lastEmittedCost;
-        if (deltaInput > 0 || deltaOutput > 0 || deltaCost > 0) {
-          emitCostUpdate(agentName, {
-            inputTokens: deltaInput,
-            outputTokens: deltaOutput,
-            cost: deltaCost,
-          });
-          lastEmittedInput = progress.inputTokens;
-          lastEmittedOutput = progress.outputTokens;
-          lastEmittedCost = progress.cost;
-        }
         options.onUpdate?.(progress);
       },
     });
@@ -142,7 +136,8 @@ export async function executeSubagent(options: ExecuteOptions): Promise<Subagent
           // synthesize one so the parallel renderer stays aligned with results.
           {
             agent: agentName,
-            status: result.exitCode === 0 ? "completed" : "failed",
+            status: result.outcome || result.exitCode === 0 ? "completed" : "failed",
+            ...(result.outcome ? { outcome: result.outcome } : {}),
             task: options.task,
             currentTool: undefined,
             currentToolArgs: undefined,
@@ -187,6 +182,7 @@ export async function executeParallel(options: {
   tasks: Array<{ agent: string | undefined; agentConfig: AgentConfig | undefined; task: string; model: string | undefined; activeModel: string | undefined; cwd: string | undefined; toolCallId?: string }>;
   signal: AbortSignal | undefined;
   onUpdate: ((progress: SubagentProgress[]) => void) | undefined;
+  events: EventBus;
 }): Promise<SubagentResult[]> {
   // Pre-fill one pending slot per task, keyed by task index (NOT agent name).
   // This keeps all N lines stacked from t=0 in stable task order, with no
@@ -218,6 +214,7 @@ export async function executeParallel(options: {
       executeSubagent({
         ...taskDef,
         signal: options.signal,
+        events: options.events,
         onUpdate: (progress: SubagentProgress) => {
           // Store latest progress in this task's stable slot (by index).
           latestProgress[index] = progress;

package/src/expanded.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { buildExpandedText } from "./expanded.js";
+import type { RowSegment } from "./row-block.js";
+import type { SubagentResult } from "./types.js";
+
+// The expanded row is what the user reads after `ctrl+o`; the compact row is
+// what they see while it runs. Both have to carry the *Run outcome* vocabulary
+// (CONTEXT.md) rather than collapsing it into done/failed.
+
+const theme = { fg: (token: string, text: string) => `[${token}]${text}`, bold: (t: string) => t };
+
+/** The content these segments carry, ignoring how each is laid out at render time. */
+const drawnText = (segments: RowSegment[]): string => segments.map((s) => s.text).join("\n");
+
+function makeResult(overrides: Partial<SubagentResult> = {}): SubagentResult {
+  return {
+    agent: "reviewer",
+    task: "review the diff",
+    exitCode: 0,
+    usage: { input: 10, output: 5, cacheRead: 0, cacheWrite: 0, cost: 0.01, turns: 1 },
+    model: "anthropic/claude-opus-4.5",
+    finalOutput: "the answer",
+    error: undefined,
+    progress: undefined,
+    progressSummary: { toolCount: 2, tokens: 15, durationMs: 1000 },
+    ...overrides,
+  };
+}
+
+describe("expanded view: run outcomes", () => {
+  it("still says Done for a completed run", () => {
+    expect(drawnText(buildExpandedText(makeResult({ outcome: "completed" }), undefined, theme))).toContain("✓ Done");
+  });
+
+  it("says Truncated — and not Failed — for a cut-off answer", () => {
+    const out = drawnText(buildExpandedText(
+      makeResult({ outcome: "truncated", exitCode: 1, finalOutput: "partial" }),
+      undefined,
+      theme,
+    ));
+    expect(out).toMatch(/truncated/i);
+    expect(out).not.toMatch(/Failed/);
+  });
+
+  it("says Aborted for a cancelled run", () => {
+    const out = drawnText(buildExpandedText(
+      makeResult({ outcome: "aborted", exitCode: 143, error: undefined }),
+      undefined,
+      theme,
+    ));
+    expect(out).toMatch(/aborted/i);
+    expect(out).not.toMatch(/Failed/);
+  });
+
+  it("keeps reporting a real error as an error", () => {
+    const failed = makeResult({ exitCode: 1, error: "401 unauthorized" });
+    delete failed.outcome; // a failed run claims no outcome
+    const out = drawnText(buildExpandedText(failed, undefined, theme));
+    expect(out).toContain("401 unauthorized");
+  });
+});

package/src/expanded.ts

@@ -1,10 +1,18 @@
-import { Text } from "@earendil-works/pi-tui";
-import type { SubagentDetails, SubagentProgress, SubagentResult, SubagentToolCall } from "./types.js";
-import { formatDuration, truncLine, buildStatsLine, buildAgentLabel } from "./format.js";
+import type { RunOutcome, SubagentDetails, SubagentProgress, SubagentResult, SubagentToolCall } from "./types.js";
+import { formatDuration, buildStatsLine, buildAgentLabel, buildOutcomeLine } from "./format.js";
+import { block, row, type RowBlock, type RowSegment } from "./row-block.js";
 import { renderToolCallLine } from "@pi-archimedes/core/tool-render";
 
 type Theme = { fg: (token: string, text: string) => string; bold: (text: string) => string };
 
+// The expanded view mixes two kinds of line and says which is which (see
+// `row-block.ts`): a **row** (label, activity, outcome) stays one line and fills
+// the frame; a **block** (the stats line, the task text, the tool-call history,
+// the output) keeps wrapping, because the expanded view is where all of it is
+// meant to be readable (ADR 0020). The stats line is a block and not a row
+// because nothing else repeats its numbers: cut at the frame, its tail — tokens,
+// duration, cost — would simply be gone on a narrow terminal.
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 // A completed tool call renders with a status glyph (✓ ok / ✗ error) and its
@@ -19,17 +27,31 @@ function formatToolCall(call: SubagentToolCall | string, theme: Theme): string {
   return renderToolCallLine(status, call.name, suffix, theme);
 }
 
+// The bottom row of a finished view. The *Run outcome* wins over the done/failed
+// pair: a truncated answer is not a failed run, and labelling it "✗ Failed" is
+// how a useful answer gets thrown away by whoever reads it.
+function outcomeRow(
+  data: { outcome?: RunOutcome | undefined; error: string | undefined },
+  theme: Theme,
+  fallback: { failed: string },
+): string {
+  const line = buildOutcomeLine({ outcome: data.outcome, error: data.error }, theme);
+  if (line) return line;
+  if (data.error) return theme.fg("error", "✗ " + data.error);
+  return theme.fg("error", "✗ " + fallback.failed);
+}
+
 // ── Expanded completed result ───────────────────────────────────────────────
 
 export function buildExpandedText(
   result: SubagentResult,
   progress: SubagentProgress | undefined,
   theme: Theme,
-): string {
-  const lines: string[] = [];
+): RowSegment[] {
+  const lines: RowSegment[] = [];
 
-  lines.push(buildAgentLabel(result.agent, result.task, theme));
-  lines.push("");
+  lines.push(row(buildAgentLabel(result.agent, result.task, theme)));
+  lines.push(row(""));
 
   // Stats line (same as compact view)
   const modelName = progress?.model ?? result.model;
@@ -43,69 +65,73 @@ export function buildExpandedText(
   }, theme);
   const statsParts = [modelLabel, statsLine].filter(Boolean);
   if (statsParts.length > 0) {
-    lines.push(statsParts.join(" "));
+    // A block, not a row: this is the only place the run's numbers appear, and
+    // the expanded view is where they are meant to be readable however narrow
+    // the frame is (ADR 0020).
+    lines.push(block(statsParts.join(" ")));
   }
 
   // Task
   if (result.task) {
-    lines.push("");
-    lines.push(theme.fg("dim", "Task: " + result.task));
+    lines.push(row(""));
+    lines.push(block(theme.fg("dim", "Task: " + result.task)));
   }
 
   // Tool calls history
   const toolCalls = progress?.toolCalls;
   if (toolCalls && toolCalls.length > 0) {
-    lines.push("");
+    lines.push(row(""));
     for (const call of toolCalls) {
-      lines.push(formatToolCall(call, theme));
+      lines.push(block(formatToolCall(call, theme)));
     }
   }
 
   // Output - show live streaming output or final output
   const outputText = progress?.output ?? result.finalOutput;
   if (outputText) {
-    lines.push("");
-    lines.push(outputText);
+    lines.push(row(""));
+    lines.push(block(outputText));
   }
 
-  // Error
-  if (result.error) {
-    lines.push("");
-    lines.push(theme.fg("error", "✗ " + result.error));
-  } else if (result.exitCode === 0) {
-    lines.push("");
-    lines.push(theme.fg("success", "✓ Done"));
+  // Error / outcome at the bottom
+  if (result.error || result.outcome || result.exitCode === 0) {
+    lines.push(row(""));
+    if (result.outcome || result.error) {
+      lines.push(row(outcomeRow({ outcome: result.outcome, error: result.error }, theme, { failed: "Failed" })));
+    } else {
+      lines.push(row(theme.fg("success", "✓ Done")));
+    }
   } else {
-    lines.push("");
-    lines.push(theme.fg("error", "✗ Failed"));
+    lines.push(row(""));
+    lines.push(row(theme.fg("error", "✗ Failed")));
   }
 
-  return lines.join("\n");
+  return lines;
 }
 
 export function renderExpanded(
-  text: Text,
+  rows: RowBlock,
   result: SubagentResult,
   progress: SubagentProgress | undefined,
   theme: Theme,
-): Text {
-  text.setText(buildExpandedText(result, progress, theme));
-  return text;
+): RowBlock {
+  rows.setSegments(buildExpandedText(result, progress, theme));
+  return rows;
 }
 
 // ── Expanded streaming progress ─────────────────────────────────────────────
 
 export function renderProgressExpanded(
-  text: Text,
+  rows: RowBlock,
   progress: SubagentProgress,
   theme: Theme,
-): Text {
-  const lines: string[] = [];
+): RowBlock {
+  const lines: RowSegment[] = [];
 
-  lines.push(buildAgentLabel(progress.agent, progress.task, theme));
-  lines.push("");
+  lines.push(row(buildAgentLabel(progress.agent, progress.task, theme)));
+  lines.push(row(""));
 
-  // Stats line (same as compact view)
+  // Stats line (same as compact view) — a block: see buildExpandedText.
   const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
   const statsLine = buildStatsLine({
     turns: undefined,
@@ -116,51 +142,46 @@ export function renderProgressExpanded(
   }, theme);
   const statsParts = [modelLabel, statsLine].filter(Boolean);
   if (statsParts.length > 0) {
-    lines.push(statsParts.join(" "));
+    lines.push(block(statsParts.join(" ")));
   }
 
   // Task
   if (progress.task) {
-    lines.push("");
-    lines.push(theme.fg("dim", "Task: " + progress.task));
+    lines.push(row(""));
+    lines.push(block(theme.fg("dim", "Task: " + progress.task)));
   }
 
   // Tool calls history
   if (progress.toolCalls && progress.toolCalls.length > 0) {
-    lines.push("");
+    lines.push(row(""));
     for (const call of progress.toolCalls) {
-      lines.push(formatToolCall(call, theme));
+      lines.push(block(formatToolCall(call, theme)));
     }
   }
 
   // Activity (current tool, marked with the running glyph ▸)
   if (progress.currentTool) {
-    lines.push("");
-    const argsPreview = progress.currentToolArgs
-      ? truncLine(progress.currentToolArgs, 60)
-      : "";
+    lines.push(row(""));
+    const argsPreview = progress.currentToolArgs ?? "";
     const durationPart = progress.currentToolStartedAt
       ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
       : "";
     const suffix = (argsPreview ? ": " + argsPreview : "") + durationPart;
-    lines.push(renderToolCallLine("running", progress.currentTool, suffix, theme));
+    lines.push(row(renderToolCallLine("running", progress.currentTool, suffix, theme)));
   }
 
   // Status at bottom
-  if (progress.status === "completed") {
-    lines.push("");
-    lines.push(theme.fg("success", "✓ Done"));
+  if (progress.status === "completed" || progress.outcome) {
+    lines.push(row(""));
+    const outcomeLine = buildOutcomeLine({ outcome: progress.outcome, error: progress.error }, theme);
+    lines.push(row(outcomeLine ?? theme.fg("success", "✓ Done")));
   } else if (progress.status === "failed") {
-    lines.push("");
-    if (progress.error) {
-      lines.push(theme.fg("error", "✗ " + progress.error));
-    } else {
-      lines.push(theme.fg("error", "✗ Failed"));
-    }
+    lines.push(row(""));
+    lines.push(row(outcomeRow({ outcome: undefined, error: progress.error }, theme, { failed: "Failed" })));
   }
 
-  text.setText(lines.join("\n"));
-  return text;
+  rows.setSegments(lines);
+  return rows;
 }
 
 // ── Expanded parallel streaming progress ────────────────────────────────────
@@ -168,13 +189,13 @@ export function renderProgressExpanded(
 export function buildProgressExpandedText(
   progress: SubagentProgress,
   theme: Theme,
-): string {
-  const lines: string[] = [];
+): RowSegment[] {
+  const lines: RowSegment[] = [];
 
-  lines.push(buildAgentLabel(progress.agent, progress.task, theme));
-  lines.push("");
+  lines.push(row(buildAgentLabel(progress.agent, progress.task, theme)));
+  lines.push(row(""));
 
-  // Stats line (same as compact view)
+  // Stats line (same as compact view) — a block: see buildExpandedText.
   const modelLabel = progress.model ? theme.fg("accent", progress.model) : "";
   const statsLine = buildStatsLine({
     turns: undefined,
@@ -185,28 +206,26 @@ export function buildProgressExpandedText(
   }, theme);
   const statsParts = [modelLabel, statsLine].filter(Boolean);
   if (statsParts.length > 0) {
-    lines.push(statsParts.join(" "));
+    lines.push(block(statsParts.join(" ")));
   }
 
   // Task
   if (progress.task) {
-    lines.push("");
-    lines.push(theme.fg("dim", "Task: " + progress.task));
+    lines.push(row(""));
+    lines.push(block(theme.fg("dim", "Task: " + progress.task)));
   }
 
   // Tool calls history
   if (progress.toolCalls && progress.toolCalls.length > 0) {
-    lines.push("");
+    lines.push(row(""));
     for (const call of progress.toolCalls) {
-      lines.push(formatToolCall(call, theme));
+      lines.push(block(formatToolCall(call, theme)));
     }
   }
 
   // Activity
   if (progress.currentTool) {
-    const argsPreview = progress.currentToolArgs
-      ? truncLine(progress.currentToolArgs, 60)
-      : "";
+    const argsPreview = progress.currentToolArgs ?? "";
     const durationPart = progress.currentToolStartedAt
       ? " | " + formatDuration(Date.now() - progress.currentToolStartedAt)
       : "";
@@ -217,22 +236,19 @@ export function buildProgressExpandedText(
     if (durationPart) {
       line += theme.fg("dim", durationPart);
     }
-    lines.push("");
-    lines.push(line);
+    lines.push(row(""));
+    lines.push(row(line));
   }
 
   // Status at bottom
-  if (progress.status === "completed") {
-    lines.push("");
-    lines.push(theme.fg("success", "✓ Done"));
+  if (progress.status === "completed" || progress.outcome) {
+    lines.push(row(""));
+    const outcomeLine = buildOutcomeLine({ outcome: progress.outcome, error: progress.error }, theme);
+    lines.push(row(outcomeLine ?? theme.fg("success", "✓ Done")));
   } else if (progress.status === "failed") {
-    lines.push("");
-    if (progress.error) {
-      lines.push(theme.fg("error", "✗ " + progress.error));
-    } else {
-      lines.push(theme.fg("error", "✗ Failed"));
-    }
+    lines.push(row(""));
+    lines.push(row(outcomeRow({ outcome: undefined, error: progress.error }, theme, { failed: "Failed" })));
   }
 
-  return lines.join("\n");
+  return lines;
 }