@pi-archimedes/subagent 2.10.4 → 2.11.1

package/src/expanded.ts

@@ -1,10 +1,24 @@
-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, the first line of an outcome) stays
+// one line and fills the frame; a **block** (the stats line, the task text, the
+// tool-call history, the output, the lines of an error after the first) keeps
+// wrapping, because the expanded view is where all of it is meant to be readable
+// (issue #112; its counterpart — the collapsed view cutting at the first line — is
+// pinned in `tool-row.width-audit.test.ts`). The stats line is a block and not a
+// row so the view reads on its own, without the reader collapsing back to the row
+// to get the numbers back. They do live elsewhere too — `compact.ts` builds the
+// identical `buildStatsLine`, `formatParallelResults` puts tools / tokens /
+// seconds in the model-facing content, and `usage` reaches pi's `/session` — but
+// every row is cut at the frame, so the tail of the stats (tokens, duration,
+// cost) is exactly what a narrow terminal would drop from this view.
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 // A completed tool call renders with a status glyph (✓ ok / ✗ error) and its
@@ -19,17 +33,87 @@ function formatToolCall(call: SubagentToolCall | string, theme: Theme): string {
   return renderToolCallLine(status, call.name, suffix, theme);
 }
 
+// The bottom of an expanded 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.
+//
+// An error is often stderr or a thrown Error's message — the second kind never
+// touched a stream (`dispatch.ts`'s `buildFailedResult` carries `err.message`, and
+// `stream.ts` synthesises strings like "subagent failed with exit code N"). Either
+// way it arrives with newlines in it, and as one `row` the view could only ever
+// show its first line: `truncateRow` treats a newline as a hard boundary (see
+// `row-block.ts`), which is right for the collapsed view (the three-rows-per-agent
+// shape is pinned in `tool-row.width-audit.test.ts`) and wrong here: the expanded
+// view is where everything is meant to be readable (issue #112), and a stack
+// trace's last line is usually the informative one. So the first line stays the
+// row it was, and the lines after it are handed over as one `block` — this repo's
+// existing mechanism for "read this in full".
+//
+// The raw error is split *before* anything is coloured, and every line is
+// coloured on its own. `theme.fg("error", "✗ " + error)` wraps the whole
+// multi-line string in one span whose reset lands on the last line only, so
+// every earlier line would be drawn — padding included — inside an open span.
+// Measured against `wrapTextWithAnsi`: it re-opens the active codes at the start
+// of a continuation line but never invents a reset at the end of one.
+function outcomeSegments(
+  data: { outcome?: RunOutcome | undefined; error: string | undefined },
+  theme: Theme,
+  // The segment to draw when there is nothing to report, rendered by the caller
+  // rather than decided here, because the five call sites do not agree on it — and
+  // they disagree per *branch*, not per builder: the finished view's single call
+  // says `✗ Failed` (an `outcome` this build cannot name is not a success this
+  // build may claim), while each streaming builder passes `✓ Done` from its
+  // completed branch and `✗ Failed` from its failed one. So "nothing to report"
+  // means something different at each site, and the `✓ Done` ones are why the
+  // answer cannot be baked in here: `outcome` is optional on `SubagentProgress`
+  // (`types.ts:38`; `SubagentResult` at `:70`, `SubagentRunReport` at `:134`), so a
+  // run can report a terminal status with no outcome at all — every session
+  // persisted before #103 / 8cf0d12 added the field — and a helper-wide
+  // `✗ Failed` there would relabel a finished run a broken one.
+  fallback: RowSegment,
+): RowSegment[] {
+  // Same precedence as `buildOutcomeLine` (`format.ts:101`): `error` is read first,
+  // so a run that carries both reports the error and not the outcome. Pinned in
+  // `expanded.test.ts` rather than re-decided here. It is also why neither streaming
+  // branch may assume it has no error in hand: each opens on a completed *status* or
+  // on any reported outcome, and either can arrive together with a multi-line one,
+  // so a completed progress's error gets the same head-row-then-block treatment here
+  // that the failed branch gives its own (#112).
+  if (data.error) {
+    // `/\r\n|\r|\n/`, not `"\n"`: `stream.ts` reads stderr as
+    // `Buffer.concat(...).toString("utf-8").trim()` with no newline
+    // normalisation, so a Windows child's `\r\n` arrives intact. pi-tui's
+    // `wrapTextWithAnsi` splits on all three endings but `truncateRow` splits on
+    // `"\n"`, so a `\r` left inside a row would be *drawn*, and a terminal that
+    // honours a bare CR repaints the row from column 0.
+    const [head, ...tail] = data.error.split(/\r\n|\r|\n/);
+    const segments: RowSegment[] = [row(theme.fg("error", "✗ " + head))];
+    // A tail of nothing but blanks gets no block: a synthesised error, or any
+    // producer that does not `trim()` its stderr, can end in a newline, and
+    // opening a block for that would add a blank row under every failed run.
+    if (tail.some((line) => line.trim() !== "")) {
+      segments.push(block(tail.map((line) => (line ? theme.fg("error", line) : "")).join("\n")));
+    }
+    return segments;
+  }
+  const line = buildOutcomeLine({ outcome: data.outcome, error: undefined }, theme);
+  // The outcome vocabulary stays `buildOutcomeLine`'s and this helper still owns
+  // the row decision; only "nothing to report" hands back the segment the caller
+  // rendered for itself.
+  return [line === undefined ? fallback : row(line)];
+}
+
 // ── 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 +127,91 @@ export function buildExpandedText(
   }, theme);
   const statsParts = [modelLabel, statsLine].filter(Boolean);
   if (statsParts.length > 0) {
-    lines.push(statsParts.join(" "));
+    // A block, not a row: the expanded view has to read on its own, so the
+    // numbers cannot depend on the reader collapsing the row to get them back
+    // however narrow the frame is.
+    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(""));
+    // A block, uncapped: ADR 0020 is the precedent that this package does not cap
+    // output where the reader has no other source for it. Read it precisely — ADR
+    // 0020 governs the *tool-result content* the model reads, not this view — and
+    // the same reasoning carries over: the answer shown here is the child's, and
+    // nothing else spells it out for whoever is reading the transcript.
+    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) {
+      // The fallback covers exactly one case here: an `outcome` this build cannot
+      // name, which leaves `buildOutcomeLine` with nothing to return. It is
+      // Failed, because a run whose ending this code cannot read is not a success
+      // this code may claim. The never-settled legacy shape — no outcome, no
+      // error, a non-zero exit — is not this fallback's: the `else` below prints
+      // it. The streaming builders' completed branch passes ✓ Done instead (see
+      // `outcomeSegments`' third parameter for why it is not decided here).
+      lines.push(
+        ...outcomeSegments(
+          { outcome: result.outcome, error: result.error },
+          theme,
+          row(theme.fg("error", "✗ 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 +222,57 @@ 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"));
+  // Status at bottom. Which fallback each branch hands the helper, and why the
+  // helper is not the one to decide it, is written once above `outcomeSegments`.
+  if (progress.status === "completed" || progress.outcome) {
+    lines.push(row(""));
+    // `✓ Done`: this branch's agent reached a terminal state, so a run with nothing
+    // to name its outcome by is finished work here — the ✗ below would bury it.
+    lines.push(...outcomeSegments(
+      { outcome: progress.outcome, error: progress.error },
+      theme,
+      row(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(""));
+    // The only branch here that may call a run broken, so it passes `✗ Failed`.
+    lines.push(...outcomeSegments(
+      { outcome: undefined, error: progress.error },
+      theme,
+      row(theme.fg("error", "✗ Failed")),
+    ));
   }
 
-  text.setText(lines.join("\n"));
-  return text;
+  rows.setSegments(lines);
+  return rows;
 }
 
 // ── Expanded parallel streaming progress ────────────────────────────────────
@@ -168,13 +280,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 +297,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 +327,32 @@ 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"));
+  // Status at bottom — the same pair of branches `renderProgressExpanded` draws for
+  // the single running agent, here as one block of the parallel view. What each
+  // branch passes, and why the helper cannot decide it, is written once above
+  // `outcomeSegments`.
+  if (progress.status === "completed" || progress.outcome) {
+    lines.push(row(""));
+    // `✓ Done`, and never the failed branch's segment: this block claims its agent
+    // finished, and a batch read as failed is a batch whose answers get discarded.
+    lines.push(...outcomeSegments(
+      { outcome: progress.outcome, error: progress.error },
+      theme,
+      row(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(""));
+    // `✗ Failed`: this branch got a broken run, the only one allowed to say so.
+    lines.push(...outcomeSegments(
+      { outcome: undefined, error: progress.error },
+      theme,
+      row(theme.fg("error", "✗ Failed")),
+    ));
   }
 
-  return lines.join("\n");
+  return lines;
 }

package/src/format.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { truncLine, formatParallelResults } from "./format.js";
+import { formatParallelResults } from "./format.js";
 import type { SubagentResult } from "./types.js";
 
 function makeResult(overrides: Partial<SubagentResult> = {}): SubagentResult {
@@ -17,33 +17,14 @@ function makeResult(overrides: Partial<SubagentResult> = {}): SubagentResult {
   };
 }
 
-// ── truncLine ───────────────────────────────────────────────────────────────
+// ── Row truncation: moved ─────────────────────────────────────────────────
 
-describe("truncLine", () => {
-  it("returns text unchanged when within limit", () => {
-    expect(truncLine("hello", 10)).toBe("hello");
-  });
-
-  it("truncates with '...' when exceeding limit", () => {
-    expect(truncLine("hello world", 8)).toBe("hello...");
-  });
-
-  it("stops at newline boundary instead of bleeding into next line", () => {
-    expect(truncLine("line one\nline two\nline three", 15)).toBe("line one...");
-  });
-
-  it("truncates first line if it itself exceeds limit", () => {
-    expect(truncLine("this is a very long first line\nsecond", 12)).toBe("this is a...");
-  });
-
-  it("handles multiple consecutive newlines", () => {
-    expect(truncLine("a\n\n\nb", 10)).toBe("a...");
-  });
-
-  it("handles text starting with newline", () => {
-    expect(truncLine("\nhello", 10)).toBe("...");
-  });
-});
+// The character cap this section used to pin (`truncLine`, at 60/80 characters)
+// is gone. Rows are now cut at the width pi renders them at, which keeps the two
+// properties the cap existed for — the ellipsis stays inside the styled span, and
+// a newline is a hard boundary — while letting a row fill the frame. Those
+// properties are pinned with measured bytes in `row-block.test.ts`, and the width
+// contract itself in `tool-row.width-audit.test.ts`.
 
 describe("formatParallelResults", () => {
   it("renders header + body per task with exactly one blank line between sections", () => {
@@ -90,9 +71,9 @@ describe("formatParallelResults", () => {
     expect(formatParallelResults([r])).toBe("✗ test-agent 5 tools · 0k tok · 3s\nspawn failed");
   });
 
-  it("prefers finalOutput over error when both are set", () => {
+  it("prefers finalOutput as the body when both are set, and still marks the failure", () => {
     const r = makeResult({ finalOutput: "out", error: "boom" });
-    expect(formatParallelResults([r])).toBe("✓ test-agent 5 tools · 0k tok · 3s\nout");
+    expect(formatParallelResults([r])).toBe("✗ test-agent 5 tools · 0k tok · 3s\nout");
   });
 
   it("keeps internal newlines in a multi-line body and trims only the tail", () => {
@@ -117,3 +98,64 @@ describe("formatParallelResults", () => {
     );
   });
 });
+
+describe("formatParallelResults: run outcomes", () => {
+  it("says truncated on the header row of a cut-off result", () => {
+    const out = formatParallelResults([
+      makeResult({ outcome: "truncated", finalOutput: "partial answer" }),
+    ]);
+    expect(out.split("\n")[0]).toMatch(/truncated/i);
+    expect(out).toContain("partial answer");
+  });
+
+  it("marks a run that failed at exit 0 with ✗, because the exit code is not the signal", () => {
+    // `--mode json` — what the child actually runs — never maps `stopReason`
+    // onto the exit code (that mapping is print mode's text branch), so a child
+    // whose last response errored exits **0**. `streamEvents` reports that as
+    // `error` with no `outcome`; a header that read only `exitCode` handed the
+    // calling model a ✓ for a run that produced nothing, while `index.ts` set
+    // `isError` on the very same result.
+    const out = formatParallelResults([
+      makeResult({ exitCode: 0, error: "401 unauthorized" }),
+    ]);
+    expect(out.split("\n")[0]?.startsWith("✗")).toBe(true);
+    expect(out).toContain("401 unauthorized");
+  });
+
+  it("marks a run the parent cancelled through the bridge (exit 0, error set)", () => {
+    // The bridge contract: a local cancel settles as a FAILED result carrying
+    // error "cancelled" and exitCode 0 — same shape, same wrong ✓ without the
+    // error check.
+    const out = formatParallelResults([
+      makeResult({ exitCode: 0, error: "cancelled" }),
+    ]);
+    expect(out.split("\n")[0]?.startsWith("✗")).toBe(true);
+  });
+
+  it("never shows a success marker for a result the tool reports as an error", () => {
+    // The single assertion that ties the two halves together: `index.ts` decides
+    // `isError` from `error`, so the header has to agree with it.
+    const out = formatParallelResults([
+      makeResult({ exitCode: 0, error: "boom" }),
+      makeResult({ agent: "ok", exitCode: 0, finalOutput: "fine" }),
+    ]);
+    const rows = out.split("\n").filter((l) => l.startsWith("✓") || l.startsWith("✗"));
+    expect(rows[0]).toContain("✗");
+    expect(rows[1]).toContain("✓");
+  });
+
+  it("says aborted on the header row of a cancelled result", () => {
+    const out = formatParallelResults([makeResult({ outcome: "aborted" })]);
+    expect(out.split("\n")[0]).toMatch(/aborted/i);
+  });
+
+  it("leaves a completed header byte-identical to the pre-outcome contract", () => {
+    const r = makeResult({
+      outcome: "completed",
+      agent: "reviewer",
+      progressSummary: { toolCount: 4, tokens: 2000, durationMs: 12000 },
+      finalOutput: "Looks good.",
+    });
+    expect(formatParallelResults([r])).toBe("✓ reviewer 4 tools · 2k tok · 12s\nLooks good.");
+  });
+});