@mrclrchtr/supi-code-intelligence 6.4.0 → 7.0.1

package/src/ui/tui/candidate-legacy-body.ts

@@ -0,0 +1,69 @@
+/** Bounded raw Markdown rendering for legacy target-selection results. */
+import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Markdown, Text, truncateToWidth } from "@earendil-works/pi-tui";
+
+/** Maximum source characters rendered by the legacy candidate body. */
+const MAX_LEGACY_SOURCE_CHARACTERS = 4096;
+
+/** Maximum physical rows rendered by the legacy candidate body. */
+const MAX_LEGACY_BODY_ROWS = 40;
+
+const LEGACY_TRUNCATION_NOTICE = `Legacy candidate body truncated for display (source limit: ${MAX_LEGACY_SOURCE_CHARACTERS} characters; body limit: ${MAX_LEGACY_BODY_ROWS} rows).`;
+
+/** Read valid Markdown text blocks without trusting persisted content shape. */
+export function readLegacyCandidateText(value: unknown): string {
+  if (!Array.isArray(value)) return "";
+  return value
+    .flatMap((block) => {
+      if (block === null || typeof block !== "object" || Array.isArray(block)) return [];
+      const record = block as Record<string, unknown>;
+      return record.type === "text" && typeof record.text === "string" ? [record.text] : [];
+    })
+    .join("\n");
+}
+
+/** Create a bounded legacy candidate body, or null when no valid text exists. */
+export function createLegacyCandidateBody(markdownText: string, theme: Theme): Component | null {
+  if (!markdownText.trim()) return null;
+  return new BoundedLegacyCandidateBody(markdownText, theme);
+}
+
+class BoundedLegacyCandidateBody implements Component {
+  private readonly markdownText: string;
+  private readonly sourceTruncated: boolean;
+
+  constructor(
+    markdownText: string,
+    private readonly theme: Theme,
+  ) {
+    const sourceCharacters = Array.from(markdownText);
+    this.sourceTruncated = sourceCharacters.length > MAX_LEGACY_SOURCE_CHARACTERS;
+    this.markdownText = this.sourceTruncated
+      ? sourceCharacters.slice(0, MAX_LEGACY_SOURCE_CHARACTERS).join("")
+      : markdownText;
+  }
+
+  render(width: number): string[] {
+    const safeWidth = Math.max(1, width);
+    const markdownRows = new Markdown(this.markdownText, 0, 0, getMarkdownTheme())
+      .render(safeWidth)
+      .map((row) => truncateToWidth(row, safeWidth, ""));
+
+    if (!this.sourceTruncated && markdownRows.length <= MAX_LEGACY_BODY_ROWS) {
+      return markdownRows;
+    }
+
+    const noticeRows = new Text(this.theme.fg("warning", LEGACY_TRUNCATION_NOTICE), 0, 0).render(
+      safeWidth,
+    );
+    const markdownRowBudget = Math.max(0, MAX_LEGACY_BODY_ROWS - noticeRows.length);
+    return [...markdownRows.slice(0, markdownRowBudget), ...noticeRows].slice(
+      0,
+      MAX_LEGACY_BODY_ROWS,
+    );
+  }
+
+  invalidate(): void {
+    // The Markdown and notice components are rebuilt for each render.
+  }
+}

package/src/ui/tui/candidate-selection.ts

@@ -0,0 +1,366 @@
+/** Shared human transcript renderer for target-candidate selections. */
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import { formatCandidateRow } from "../../tool/result/candidate-row.ts";
+import {
+  MAX_TUI_DISPLAY_ITEMS,
+  readToolDisplaySections,
+  truncateDisplayText,
+} from "../../tool/result/display.ts";
+import type { ToolDisplaySection } from "../../tool/result/types.ts";
+import { createLegacyCandidateBody, readLegacyCandidateText } from "./candidate-legacy-body.ts";
+import {
+  type EvidenceEntry,
+  formatEvidenceEntry,
+  type ResultOptios,
+  readEvidenceEntries,
+  renderTruncationDisclosure,
+  type ToolResult,
+} from "./common.ts";
+
+/** Display-section keys that identify candidate-selection results. */
+export type CandidateSelectionKey =
+  | "graph.candidates"
+  | "resolve.candidates"
+  | "orientation.candidates";
+
+interface CandidateRow {
+  targetId: string;
+  name: string;
+  kind: string | null;
+  file: string;
+  line: number;
+  character: number;
+  rank: number;
+  container: string | null;
+}
+
+interface CandidateSelectionData {
+  reason: string | null;
+  evidence: EvidenceEntry | null;
+  display: ToolDisplaySection | null;
+  rows: string[];
+  guidance: string[];
+  legacyGuidance: string[];
+  legacyMarkdownText: string;
+  rawFallback: boolean;
+}
+
+/** Render a candidate-selection result, or return null for unrelated results. */
+export function renderCandidateSelection(
+  result: ToolResult,
+  options: ResultOptios,
+  theme: Theme,
+  key: CandidateSelectionKey,
+): Component | null {
+  const selection = readCandidateSelection(result, key);
+  if (!selection) return null;
+  return new CandidateSelectionComponent(result, options, theme, selection);
+}
+
+function readCandidateSelection(
+  result: ToolResult,
+  key: CandidateSelectionKey,
+): CandidateSelectionData | null {
+  const data = asRecord(result.details?.data);
+  const legacyMarkdownText = readLegacyCandidateText(result.content);
+  const display =
+    readToolDisplaySections(result.details?.displaySections).find(
+      (section) => section.key === key,
+    ) ?? null;
+  const evidence =
+    readEvidenceEntries(data?.evidenceLists).find((entry) => entry.key === key) ?? null;
+  const structuredCandidates = readCandidateRows(data?.candidates);
+
+  // A status or message alone is not a candidate-selection marker. Require a
+  // candidate key or a structured candidate collection before changing views.
+  if (!display && !evidence && !structuredCandidates) return null;
+
+  const rows = candidateRowsFor(display, structuredCandidates, key);
+  const selectionEvidence = candidateEvidenceFor({
+    display,
+    evidence,
+    structuredCandidates,
+    rows,
+    key,
+  });
+  const reason = selectionReason(result, data);
+  const structuredGuidance = readStructuredNextQueries(data);
+  const guidance = selectionGuidance(result, data, key);
+
+  return {
+    reason,
+    evidence: selectionEvidence,
+    display,
+    rows,
+    guidance,
+    legacyGuidance: key === "orientation.candidates" ? structuredGuidance.slice(0, 2) : [],
+    legacyMarkdownText,
+    rawFallback:
+      rows.length === 0 ||
+      !hasStructuredSelectionReason(result, data) ||
+      !hasStructuredSelectionGuidance(data),
+  };
+}
+
+function candidateRowsFor(
+  display: ToolDisplaySection | null,
+  structuredCandidates: CandidateRow[] | null,
+  key: CandidateSelectionKey,
+): string[] {
+  if (display?.lines.length) return [...display.lines];
+  return (structuredCandidates ?? []).map((candidate, index) =>
+    formatCandidateRow(
+      candidate,
+      key === "graph.candidates" ? "handle-first" : "rank-first",
+      index + 1,
+    ),
+  );
+}
+
+function candidateEvidenceFor(input: {
+  display: ToolDisplaySection | null;
+  evidence: EvidenceEntry | null;
+  structuredCandidates: CandidateRow[] | null;
+  rows: string[];
+  key: CandidateSelectionKey;
+}): EvidenceEntry | null {
+  if (input.display?.lines.length) return displayEvidence(input.display, input.key);
+  if (input.evidence && input.structuredCandidates?.length) {
+    return evidenceForRows(input.evidence, input.rows.length);
+  }
+  if (input.display) return displayEvidence(input.display, input.key);
+  return input.evidence;
+}
+
+function displayEvidence(display: ToolDisplaySection, key: CandidateSelectionKey): EvidenceEntry {
+  const shownCount = display.lines.length;
+  return {
+    key,
+    shownCount,
+    totalCount: display.totalCount,
+    omittedCount:
+      display.totalCount === null
+        ? unknownOmittedCount(display.omittedCount, Math.max(0, display.shownCount - shownCount))
+        : Math.max(0, display.totalCount - shownCount),
+    partialReason: display.partialReason,
+  };
+}
+
+function evidenceForRows(evidence: EvidenceEntry, shownCount: number): EvidenceEntry {
+  return {
+    ...evidence,
+    shownCount,
+    omittedCount:
+      evidence.totalCount === null
+        ? unknownOmittedCount(evidence.omittedCount, Math.max(0, evidence.shownCount - shownCount))
+        : Math.max(0, evidence.totalCount - shownCount),
+  };
+}
+
+function readCandidateRows(value: unknown): CandidateRow[] | null {
+  if (!Array.isArray(value)) return null;
+  const rows = value.slice(0, MAX_TUI_DISPLAY_ITEMS).map(readCandidateRow);
+  return rows.every((row): row is CandidateRow => row !== null) ? rows : null;
+}
+
+function readCandidateRow(value: unknown): CandidateRow | null {
+  const record = asRecord(value);
+  if (
+    !record ||
+    typeof record.targetId !== "string" ||
+    record.targetId.length === 0 ||
+    typeof record.name !== "string" ||
+    typeof record.file !== "string" ||
+    !isPosition(record.line) ||
+    !isPosition(record.character) ||
+    (record.rank !== undefined && !isCount(record.rank)) ||
+    (record.kind !== undefined && !isNullableString(record.kind)) ||
+    (record.container !== undefined && !isNullableString(record.container))
+  ) {
+    return null;
+  }
+  return {
+    targetId: record.targetId,
+    name: record.name,
+    kind: typeof record.kind === "string" ? record.kind : null,
+    file: record.file,
+    line: record.line,
+    character: record.character,
+    rank: isCount(record.rank) ? record.rank : 0,
+    container: typeof record.container === "string" ? record.container : null,
+  };
+}
+
+function selectionReason(result: ToolResult, data: Record<string, unknown> | null): string | null {
+  const message = typeof result.details?.message === "string" ? result.details.message.trim() : "";
+  if (message) return truncateDisplayText(message, 160);
+
+  const resultKind = data?.resultKind;
+  if (resultKind === "kind-mismatch" && typeof data?.requestedKind === "string") {
+    return `No target matched provider kind ${data.requestedKind}.`;
+  }
+  if (resultKind === "disambiguation") return "Multiple target matches require one candidate.";
+  return null;
+}
+
+function hasStructuredSelectionReason(
+  result: ToolResult,
+  data: Record<string, unknown> | null,
+): boolean {
+  const message = typeof result.details?.message === "string" && result.details.message.trim();
+  if (message) return true;
+  return (
+    data?.resultKind === "disambiguation" ||
+    (data?.resultKind === "kind-mismatch" && typeof data.requestedKind === "string")
+  );
+}
+
+function hasStructuredSelectionGuidance(data: Record<string, unknown> | null): boolean {
+  return readStructuredNextQueries(data).length > 0;
+}
+
+function readStructuredNextQueries(data: Record<string, unknown> | null): string[] {
+  return Array.isArray(data?.nextQueries)
+    ? data.nextQueries.filter(
+        (query): query is string => typeof query === "string" && query.length > 0,
+      )
+    : [];
+}
+
+function selectionGuidance(
+  result: ToolResult,
+  data: Record<string, unknown> | null,
+  key: CandidateSelectionKey,
+): string[] {
+  const nextQueries = readStructuredNextQueries(data);
+  if (nextQueries.length > 0) return nextQueries.slice(0, 2);
+
+  const mismatch =
+    data?.resultKind === "kind-mismatch" || result.details?.status === "invalid-input";
+  if (key === "orientation.candidates") {
+    return ["Use one candidate handle as focus.target.handle"];
+  }
+  if (mismatch) {
+    return [
+      "Retry without symbolKind, use an observed provider kind, or choose a candidate handle",
+    ];
+  }
+  return ["Choose one candidate handle, or narrow the symbol selector with scope or symbolKind"];
+}
+
+class CandidateSelectionComponent implements Component {
+  constructor(
+    private readonly result: ToolResult,
+    private readonly options: ResultOptios,
+    private readonly theme: Theme,
+    private readonly selection: CandidateSelectionData,
+  ) {}
+
+  render(width: number): string[] {
+    const container = new Container();
+    const reason = this.selection.reason ? `: ${this.selection.reason}` : "";
+    container.addChild(new Text(this.theme.fg("warning", `Choose a target${reason}`), 0, 0));
+
+    if (!this.options.expanded) return this.renderCollapsed(container, width);
+    if (this.appendLegacyFallback(container)) return this.renderContainer(container, width);
+
+    this.appendStructuredSelection(container);
+    this.appendTruncation(container);
+    return this.renderContainer(container, width);
+  }
+
+  invalidate(): void {}
+
+  private renderCollapsed(container: Container, width: number): string[] {
+    const summary = this.selection.evidence ? formatEvidenceEntry(this.selection.evidence) : null;
+    if (summary) container.addChild(new Text(this.theme.fg("muted", summary), 0, 0));
+    this.appendTruncation(container);
+    return this.renderContainer(container, width);
+  }
+
+  private appendLegacyFallback(container: Container): boolean {
+    if (!this.selection.rawFallback || !this.selection.legacyMarkdownText.trim()) return false;
+    const legacyBody = createLegacyCandidateBody(this.selection.legacyMarkdownText, this.theme);
+    if (!legacyBody) return false;
+
+    const divider = `${this.theme.fg("border", "────")} ${this.theme.fg("dim", "raw markdown")} ${this.theme.fg("border", "────")}`;
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(divider, 0, 0));
+    container.addChild(legacyBody);
+    this.appendLegacyGuidance(container);
+    this.appendTruncation(container);
+    return true;
+  }
+
+  private appendLegacyGuidance(container: Container): void {
+    if (this.selection.legacyGuidance.length === 0) return;
+    container.addChild(new Spacer(1));
+    container.addChild(
+      new Text(this.theme.fg("muted", `next: ${this.selection.legacyGuidance.join(" · ")}`), 0, 0),
+    );
+  }
+
+  private appendStructuredSelection(container: Container): void {
+    container.addChild(new Spacer(1));
+    const title = this.selection.display?.title ?? "Candidates";
+    const bounds = this.selection.evidence ? formatSectionBounds(this.selection.evidence) : "";
+    container.addChild(
+      new Text(this.theme.fg("dim", `${title}${bounds ? ` (${bounds})` : ""}`), 0, 0),
+    );
+    for (const row of this.selection.rows) {
+      container.addChild(new Text(this.theme.fg("muted", row), 0, 0));
+    }
+
+    if (this.selection.guidance.length === 0) return;
+    container.addChild(new Spacer(1));
+    container.addChild(
+      new Text(this.theme.fg("muted", `next: ${this.selection.guidance.join(" · ")}`), 0, 0),
+    );
+  }
+
+  private renderContainer(container: Container, width: number): string[] {
+    return container.render(Math.max(1, width));
+  }
+
+  private appendTruncation(container: Container): void {
+    const truncation = renderTruncationDisclosure(this.result, this.theme);
+    if (!truncation) return;
+    container.addChild(new Spacer(1));
+    container.addChild(truncation);
+  }
+}
+
+function formatSectionBounds(entry: EvidenceEntry): string {
+  if (entry.totalCount === null) {
+    const omitted = entry.omittedCount ? `; ${entry.omittedCount} collected omitted` : "";
+    const reason = entry.partialReason ? `; more may exist — ${entry.partialReason}` : "; partial";
+    return `${entry.shownCount}${omitted}${reason}`;
+  }
+  if (entry.omittedCount)
+    return `${entry.shownCount} of ${entry.totalCount}; ${entry.omittedCount} omitted`;
+  return `${entry.totalCount}`;
+}
+
+function unknownOmittedCount(base: number | null, additional: number): number | null {
+  const omitted = (base ?? 0) + additional;
+  return omitted > 0 ? omitted : null;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function isPosition(value: unknown): value is number {
+  return isCount(value);
+}
+
+function isCount(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
+function isNullableString(value: unknown): value is string | null {
+  return value === null || typeof value === "string";
+}

package/src/ui/tui/common.ts

@@ -1,9 +1,6 @@
 /**
- * Shared TUI rendering utilities for code-intelligence tool results.
- *
- * Extracted from the per-tool renderers to eliminate duplication:
- * evidence section rendering, markdown detail, count badges,
- * partial/error guards, and the shared simple-result pattern.
+ * Shared transcript helpers for structured Code Intelligence results.
+ * Tool renderers own presentation; these helpers read assembled details.
  */
 
 import {
@@ -11,12 +8,14 @@ import {
   type Theme,
   type ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
-import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import { type Component, Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import { formatEvidenceBadge } from "@mrclrchtr/supi-core/evidence-badge";
 import { truncateDisplayText } from "../../tool/result/display.ts";
 import { renderToolDisplaySections } from "./display.ts";
+import { renderExecutionError } from "./execution-error.ts";
 
 export { formatCallPath, formatCallValue, renderToolDisplaySections } from "./display.ts";
+export { renderExecutionError } from "./execution-error.ts";
 
 import type {
   ToolDisplaySection,
@@ -58,6 +57,8 @@ export const EVIDENCE_KEY_LABELS: Record<string, string> = {
   "imports.modules": "imports",
   "inspect.definitions": "definitions",
   "inspect.diagnostics": "nearby diagnostics",
+  "graph.candidates": "candidates",
+  "orientation.candidates": "candidates",
   "references.locations": "references",
   "refactor.edits": "edits",
   "resolve.candidates": "candidates",
@@ -135,12 +136,14 @@ function isOptionalCount(value: unknown): value is number | undefined {
 
 /** Format one assembled evidence list without recomputing its bounds. */
 export function formatEvidenceEntry(entry: EvidenceEntry): string {
+  const label = evidenceLabel(entry.key);
+  const singleCandidate = label === "candidates" && (entry.totalCount ?? entry.shownCount) === 1;
   const badge = formatEvidenceBadge({
     shownCount: entry.shownCount,
     totalCount: entry.totalCount,
     omittedCount: entry.omittedCount,
     partialReason: entry.partialReason,
-    label: evidenceLabel(entry.key),
+    label: singleCandidate ? "candidate" : label,
   });
   if (!entry.invalidLocationCount) return badge;
   const noun = entry.invalidLocationCount === 1 ? "location" : "locations";
@@ -181,19 +184,6 @@ export function renderPartial(label: string, theme: Theme): Text {
   return new Text(theme.fg("warning", label), 0, 0);
 }
 
-export function renderError(label: string, theme: Theme): Text {
-  return new Text(theme.fg("error", label), 0, 0);
-}
-
-/** Render an execution failure from PI's renderer context. */
-export function renderExecutionError(
-  context: ToolRendererContext | undefined,
-  label: string,
-  theme: Theme,
-): Text | null {
-  return context?.isError ? renderError(label, theme) : null;
-}
-
 /** Render a domain error encoded in structured result details. */
 export function renderDomainError(result: ToolResult, theme: Theme): Text | null {
   const status = result.details?.status;
@@ -210,7 +200,7 @@ export function renderDomainError(result: ToolResult, theme: Theme): Text | null
   const message = result.details?.message
     ? `: ${truncateDisplayText(result.details.message, 160)}`
     : "";
-  return renderError(`${label}${message}`, theme);
+  return new Text(theme.fg("error", `${label}${message}`), 0, 0);
 }
 
 /** Render an invalid-input or unavailable result with its structured body. */
@@ -231,16 +221,17 @@ export function renderDomainResult(
 /** Render the structured output-truncation disclosure. */
 export function renderTruncationDisclosure(result: ToolResult, theme: Theme): Text | null {
   const truncation = result.details?.truncation;
-  if (!truncation?.truncated) return null;
+  if (!truncation?.truncated && !truncation?.displayTruncated) return null;
 
+  const label = truncation.truncated ? "Output truncated" : "Display limited";
   const path = truncation.fullOutputPath
-    ? `; full output: ${truncateDisplayText(truncation.fullOutputPath, 160)}`
-    : "";
-  return new Text(theme.fg("warning", `Output truncated${path}`), 0, 0);
+    ? `; ${truncation.truncated ? "full output" : "full returned evidence"}: ${truncateDisplayText(truncation.fullOutputPath, 160)}`
+    : truncation.displayTruncated
+      ? "; full returned evidence file unavailable"
+      : "";
+  return new Text(theme.fg("warning", `${label}${path}`), 0, 0);
 }
 
-// ── Result options ───────────────────────────────────────────────
-
 // ── Shared simple-result renderer ─────────────────────────────────
 
 /**
@@ -254,12 +245,16 @@ export function renderSimpleResult(
   result: ToolResult,
   options: ResultOptios,
   theme: Theme,
-  partialLabel: string,
+  labels: { progress: string; failure: string },
   context?: ToolRendererContext,
-): Container | Text {
-  if (options.isPartial) return renderPartial(partialLabel, theme);
+): Component {
+  if (options.isPartial) return renderPartial(labels.progress, theme);
 
-  const executionError = renderExecutionError(context, "Tool failed", theme);
+  const executionError = renderExecutionError(
+    result,
+    { isError: context?.isError, expanded: options.expanded, label: labels.failure },
+    theme,
+  );
   if (executionError) return executionError;
 
   const domainError = renderDomainError(result, theme);

package/src/ui/tui/execution-error.ts

@@ -0,0 +1,92 @@
+import { stripVTControlCharacters } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+import type { ToolResult } from "./common.ts";
+
+const MAX_FAILURE_TEXT_CHARACTERS = 4096;
+const MAX_COLLAPSED_FAILURE_ROWS = 2;
+const MAX_EXPANDED_FAILURE_ROWS = 20;
+
+/** PI execution state and presentation for a failed tool call. */
+interface ExecutionErrorOptions {
+  isError?: boolean;
+  expanded: boolean;
+  label: string;
+}
+
+interface FailureReason {
+  text: string;
+  limited: boolean;
+}
+
+/**
+ * Show a failure reason only when PI marks the execution as failed.
+ * PI throws can have plain content without details. This text is a failure
+ * body, not Markdown from which the renderer infers tool evidence.
+ */
+export function renderExecutionError(
+  result: ToolResult,
+  options: ExecutionErrorOptions,
+  theme: Theme,
+): Component | null {
+  if (!options.isError) return null;
+  return new ExecutionError(readFailureReason(result), options, theme);
+}
+
+function readFailureReason(result: ToolResult): FailureReason {
+  const message = plainFailureText(result.details?.message);
+  if (message) return boundFailureReason(message);
+  let text = "";
+  for (const block of Array.isArray(result.content) ? result.content : []) {
+    if (block?.type !== "text") continue;
+    const part = plainFailureText(block.text);
+    if (!part) continue;
+    text += `${text ? "\n" : ""}${part}`;
+    if (text.length > MAX_FAILURE_TEXT_CHARACTERS) break;
+  }
+  return boundFailureReason(text);
+}
+
+function boundFailureReason(text: string): FailureReason {
+  return {
+    text: text.slice(0, MAX_FAILURE_TEXT_CHARACTERS),
+    limited: text.length > MAX_FAILURE_TEXT_CHARACTERS,
+  };
+}
+
+function plainFailureText(value: unknown): string {
+  if (typeof value !== "string") return "";
+  return stripVTControlCharacters(value)
+    .replace(/\r\n?/g, "\n")
+    .replace(/\t/g, " ")
+    .replace(/[\p{Cc}\p{Bidi_Control}]/gu, (character) => (character === "\n" ? character : ""))
+    .trim();
+}
+
+/** Bound physical rows after wrapping, so narrow terminals keep the same row limit. */
+class ExecutionError implements Component {
+  constructor(
+    private readonly reason: FailureReason,
+    private readonly options: ExecutionErrorOptions,
+    private readonly theme: Theme,
+  ) {}
+
+  render(width: number): string[] {
+    const { expanded, label } = this.options;
+    const body = expanded ? this.reason.text : this.reason.text.replace(/\s+/g, " ");
+    const text = `${label}${body ? `\n${body}` : ""}`;
+    const rows = new Text(this.theme.fg("error", text), 0, 0).render(width);
+    const maxRows = expanded ? MAX_EXPANDED_FAILURE_ROWS : MAX_COLLAPSED_FAILURE_ROWS;
+    if (!this.reason.limited && rows.length <= maxRows) return rows;
+    const disclosure = expanded
+      ? "Failure text limited."
+      : "Failure text limited; expand for more.";
+    return [
+      ...rows.slice(0, maxRows),
+      ...new Text(this.theme.fg("dim", disclosure), 0, 0).render(width),
+    ];
+  }
+
+  /** Text and theme formatting are rebuilt on every render; there is no cache. */
+  invalidate(): void {}
+}