@iowarp/clio-coder 0.4.7 → 0.4.9

package/src/interactive/overlays/tree-selector.ts

@@ -1,3 +1,4 @@
+import { resolve } from "node:path";
 import type { SessionContract } from "../../domains/session/contract.js";
 import type { TreeSnapshot, TreeSnapshotNode } from "../../domains/session/tree/navigator.js";
 import {
@@ -21,17 +22,19 @@ const VISIBLE_ROWS = 16;
  * /tree navigator overlay. Behaviors:
  *   - One row per node, indented two spaces per branch level (not per message)
  *   - Shift+T toggles operator-local timestamps on/off
+ *   - `p` filters to nodes whose session cwd matches the current cwd
+ *   - `s` cycles between tree order and most recent first
  *   - `e` enters label edit submode (Enter commits, Esc cancels)
  *   - Enter on a row switches the active append point to that turn id
  *   - Esc closes the overlay
  *
- * Cwd-toggle (`p`) and sort-order (`s`) are not implemented.
- *
  * The overlay queries `session.tree()` on open and after any mutation so
  * label edits are reflected without a close/reopen cycle.
  */
 export interface OpenTreeOverlayDeps {
-	session: SessionContract;
+	session: Pick<SessionContract, "tree" | "editLabel">;
+	/** The current workspace directory. Defaults to the process cwd. */
+	cwd?: string;
 	onSwitchTurn: (turnId: string) => void;
 	onClose: () => void;
 }
@@ -204,6 +207,8 @@ export class TreeOverlayView implements Component {
 	private highlight = 0;
 	private scrollTop = 0;
 	private showTimestamps = false;
+	private currentCwdOnly = false;
+	private sortOrder: "tree" | "recent" = "tree";
 	private submode: Submode = "browse";
 	private labelBuffer = "";
 	private readonly labelInput = new Input();
@@ -221,7 +226,8 @@ export class TreeOverlayView implements Component {
 		initial: TreeSnapshot | null,
 	) {
 		this.snapshot = initial;
-		this.rows = initial ? flattenTreeSnapshot(initial) : [];
+		this.rows = [];
+		this.rebuildRows();
 	}
 
 	private invalidateLayout(): void {
@@ -242,15 +248,27 @@ export class TreeOverlayView implements Component {
 		return this.rows[this.highlight] ?? null;
 	}
 
+	private rebuildRows(): void {
+		const selectedId = this.currentRow()?.node.id;
+		const snapshot = this.snapshot;
+		const matchesCwd = snapshot?.meta.cwd && resolve(snapshot.meta.cwd) === resolve(this.deps.cwd ?? process.cwd());
+		this.rows = snapshot && (!this.currentCwdOnly || matchesCwd) ? flattenTreeSnapshot(snapshot) : [];
+		if (this.sortOrder === "recent") {
+			this.rows.sort((a, b) => Date.parse(b.node.at) - Date.parse(a.node.at));
+			this.rows = this.rows.map((row) => ({ ...row, depth: 0 }));
+		}
+		const selectedIndex = this.rows.findIndex((row) => row.node.id === selectedId);
+		this.highlight = selectedIndex < 0 ? 0 : selectedIndex;
+		this.invalidateLayout();
+	}
+
 	private refresh(): void {
 		try {
 			this.snapshot = this.deps.session.tree();
-			this.rows = flattenTreeSnapshot(this.snapshot);
 		} catch {
 			this.snapshot = null;
-			this.rows = [];
 		}
-		this.invalidateLayout();
+		this.rebuildRows();
 	}
 
 	render(width: number): string[] {
@@ -262,7 +280,14 @@ export class TreeOverlayView implements Component {
 		if (this.rows.length === 0) {
 			// The overlay navigates the CURRENT session's turn tree; an empty
 			// tree means no turns yet, not a missing session list.
-			lines.push(theme.fg("muted", "(no turns in this session yet)"));
+			lines.push(
+				theme.fg(
+					"muted",
+					this.currentCwdOnly && this.snapshot && Object.keys(this.snapshot.nodesById).length > 0
+						? "(no turns match the current cwd; press p to show all)"
+						: "(no turns in this session yet)",
+				),
+			);
 		} else {
 			const end = Math.min(this.rows.length, this.scrollTop + VISIBLE_ROWS);
 			for (let i = this.scrollTop; i < end; i++) {
@@ -303,6 +328,8 @@ export class TreeOverlayView implements Component {
 			{ key: "↑↓", verb: "move" },
 			{ key: "Enter", verb: "switch" },
 			{ key: "e", verb: "label" },
+			{ key: "p", verb: `cwd:${this.currentCwdOnly ? "current" : "all"}` },
+			{ key: "s", verb: this.sortOrder },
 			{ key: "Shift+T", verb: `ts:${tsLabel}` },
 		]);
 	}
@@ -328,7 +355,17 @@ export class TreeOverlayView implements Component {
 			this.deps.onClose();
 			return;
 		}
-		// Empty snapshot: only Esc is meaningful; swallow everything else.
+		if (data === "p") {
+			this.currentCwdOnly = !this.currentCwdOnly;
+			this.rebuildRows();
+			return;
+		}
+		if (data === "s") {
+			this.sortOrder = this.sortOrder === "tree" ? "recent" : "tree";
+			this.rebuildRows();
+			return;
+		}
+		// Filtering and sorting remain available when the visible list is empty.
 		if (this.rows.length === 0) return;
 		// Arrows: CSI A/B for up/down.
 		if (matchesKey(data, "up")) {
@@ -406,7 +443,7 @@ export class TreeOverlayView implements Component {
 	}
 }
 
-function loadInitialSnapshot(session: SessionContract): TreeSnapshot | null {
+function loadInitialSnapshot(session: OpenTreeOverlayDeps["session"]): TreeSnapshot | null {
 	try {
 		return session.tree();
 	} catch {

package/src/interactive/panes-runtime.ts

@@ -6,7 +6,7 @@
  * ladder *before* the pane is split: `openUtilityPane` delivers its command by
  * sending `exec <argv>` into the pane's shell, so a binary that is not there
  * kills the pane the instant it appears, and the operator sees a flicker
- * instead of an install hint (phase 1 report, open question 3). And every
+ * instead of an install hint. Every
  * mutation is scoped to panes Clio created, because the contract's registry
  * refuses anything else.
  *

package/src/interactive/prewarm.ts

@@ -1,197 +1,11 @@
-/**
- * The session pre-warm round: the request the next turn would send, minus the
- * operator's text, issued as soon as the prefix is known.
- *
- * On a local server prefill is the cost. A fresh session's first turn prefills
- * the whole compiled prompt plus the tool schemas before the model emits a
- * token, and a resumed session's first turn prefills the entire replayed
- * history. Both are paid after the operator presses Enter, and both are fully
- * determined before they type anything. llama.cpp picks the slot with the
- * longest common prefix and re-evaluates only the suffix, so sending the prefix
- * early leaves the processed KV in the slot for the real turn to land on.
- *
- * The payload is not hand-assembled. It goes through `streamSimple`, the same
- * dispatcher `createEngineAgent` hands pi-agent-core as its `streamFn`, with the
- * same system prompt, the same tool schemas, the same replayed messages, and the
- * same thinking level, so `withSamplingOverrides`, the thinking composition, and
- * `cache_prompt` resolve exactly as they do for a turn. Any byte that differs
- * ahead of the user turn would defeat the purpose.
- */
-
-import type { BackendCompletionTimings } from "../core/cache-telemetry.js";
-import { streamSimple } from "../engine/ai.js";
-import type { AgentMessage, AgentTool, EngineModel, Usage } from "../engine/types.js";
-
-/**
- * The one user message appended so the chat template renders the prefix up to
- * the user turn. One character: it has to exist for the template to close the
- * prefix, and everything after the last shared byte is re-evaluated by the real
- * turn anyway.
- */
-export const PREWARM_USER_TEXT = ".";
-
-/** Output budget for the round. The tokens the model produces are not the point. */
-export const PREWARM_MAX_TOKENS = 1;
-
-/** Which trigger asked for the pre-warm. Recorded on the ledger entry. */
-export type PrewarmTrigger = "session-start" | "resume" | "compaction";
-
-export interface PrewarmContext {
-	systemPrompt: string;
-	messages: ReadonlyArray<AgentMessage>;
-	tools: ReadonlyArray<AgentTool>;
-}
-
-/**
- * The roles pi-agent-core's default `convertToLlm` keeps when it turns the
- * agent's message list into provider messages. The pre-warm applies the same
- * filter so its message array is the one a turn would send, not the agent's
- * internal list.
- */
-const LLM_MESSAGE_ROLES: ReadonlySet<string> = new Set(["user", "assistant", "toolResult"]);
-
-/**
- * The prefix of the next turn's request: system prompt, tool schemas, and the
- * replayed conversation, with no user turn yet.
- */
-function prewarmPrefix(state: {
-	systemPrompt: string;
-	messages: ReadonlyArray<AgentMessage>;
-	tools: ReadonlyArray<AgentTool>;
-}): PrewarmContext {
-	return {
-		systemPrompt: state.systemPrompt,
-		messages: state.messages.filter((message) => LLM_MESSAGE_ROLES.has((message as { role?: string }).role ?? "")),
-		tools: [...state.tools],
-	};
-}
-
-export interface PrewarmRoundInput {
-	model: EngineModel;
-	/** Live agent state the next turn would send. Read-only; the round copies it. */
-	state: {
-		systemPrompt: string;
-		messages: ReadonlyArray<AgentMessage>;
-		tools: ReadonlyArray<AgentTool>;
-		thinkingLevel: string;
-	};
-	apiKey?: string;
-	signal?: AbortSignal;
-	/** Test seam. Production uses the engine dispatcher a turn runs on. */
-	streamFn?: typeof streamSimple;
-}
-
-export interface PrewarmRoundResult {
-	/** True when the operator submitted (or the session moved) before the round settled. */
-	aborted: boolean;
-	/** Provider usage for the round; null when the backend reported none. */
-	usage: Usage | null;
-	/** Backend prefill and prediction timings when the server reported them. */
-	backend: BackendCompletionTimings | null;
-	/** Wall clock the round spent, in the shape a turn's assistant entry uses. */
-	timing: { ttftMs: number | null; apiMs: number };
-	/** Provider error text when the round failed outright. */
-	errorMessage: string | null;
-}
-
-function usageOf(message: unknown): Usage | null {
-	if (message === null || typeof message !== "object") return null;
-	const usage = (message as { usage?: unknown }).usage;
-	return usage !== null && typeof usage === "object" ? (usage as Usage) : null;
-}
-
-function backendOf(message: unknown): BackendCompletionTimings | null {
-	if (message === null || typeof message !== "object") return null;
-	const backend = (message as { backendTimings?: unknown }).backendTimings;
-	return backend !== null && typeof backend === "object" ? (backend as BackendCompletionTimings) : null;
-}
-
-/**
- * Prompt tokens the backend actually processed for one pre-warm. The server's
- * own prompt count is authoritative when it reported one; otherwise the
- * provider usage prompt side, cached tokens folded in, is the honest figure.
- * Null when neither exists, which is different from a measured zero.
- */
-export function prewarmPromptTokens(result: Pick<PrewarmRoundResult, "usage" | "backend">): number | null {
-	if (result.backend) return result.backend.promptTokens;
-	const usage = result.usage;
-	if (!usage) return null;
-	const total = (usage.input || 0) + (usage.cacheRead || 0) + (usage.cacheWrite || 0);
-	return total > 0 ? total : null;
-}
-
-/**
- * Send the prefix and wait for the backend to acknowledge it. Resolves rather
- * than rejects on a provider failure: a pre-warm is an optimization, and a
- * backend that refuses it must not be able to break the session it was warming.
- */
-export async function runPrewarmRound(input: PrewarmRoundInput): Promise<PrewarmRoundResult> {
-	const prefix = prewarmPrefix(input.state);
-	const context = {
-		systemPrompt: prefix.systemPrompt,
-		messages: [
-			...prefix.messages,
-			{ role: "user", content: [{ type: "text", text: PREWARM_USER_TEXT }], timestamp: Date.now() },
-		],
-		tools: prefix.tools,
-	};
-	// pi-agent-core maps `thinkingLevel: "off"` onto an absent `reasoning`; the
-	// pre-warm has to make the same mapping or the thinking composition resolves
-	// against a different level and the rendered template moves.
-	const options: Record<string, unknown> = { maxTokens: PREWARM_MAX_TOKENS };
-	if (input.state.thinkingLevel !== "off") options.reasoning = input.state.thinkingLevel;
-	if (input.apiKey !== undefined) options.apiKey = input.apiKey;
-	if (input.signal !== undefined) options.signal = input.signal;
-
-	const send = input.streamFn ?? streamSimple;
-	const startedAt = performance.now();
-	let firstDeltaAt: number | null = null;
-	const elapsed = (): number => Math.round(Math.max(0, performance.now() - startedAt));
-	const ttft = (): number | null => (firstDeltaAt === null ? null : Math.round(Math.max(0, firstDeltaAt - startedAt)));
-
-	try {
-		const events = send(
-			input.model,
-			context as unknown as Parameters<typeof streamSimple>[1],
-			options as unknown as Parameters<typeof streamSimple>[2],
-		);
-		for await (const event of events) {
-			if (firstDeltaAt === null && event.type !== "start") firstDeltaAt = performance.now();
-			if (event.type === "done") {
-				return {
-					aborted: false,
-					usage: usageOf(event.message),
-					backend: backendOf(event.message),
-					timing: { ttftMs: ttft(), apiMs: elapsed() },
-					errorMessage: null,
-				};
-			}
-			if (event.type === "error") {
-				const failed = event.error as { stopReason?: unknown; errorMessage?: unknown };
-				const aborted = event.reason === "aborted" || failed.stopReason === "aborted" || input.signal?.aborted === true;
-				return {
-					aborted,
-					usage: usageOf(event.error),
-					backend: backendOf(event.error),
-					timing: { ttftMs: ttft(), apiMs: elapsed() },
-					errorMessage: aborted ? null : typeof failed.errorMessage === "string" ? failed.errorMessage : "pre-warm failed",
-				};
-			}
-		}
-	} catch (error) {
-		return {
-			aborted: input.signal?.aborted === true,
-			usage: null,
-			backend: null,
-			timing: { ttftMs: ttft(), apiMs: elapsed() },
-			errorMessage: input.signal?.aborted === true ? null : error instanceof Error ? error.message : String(error),
-		};
-	}
-	return {
-		aborted: input.signal?.aborted === true,
-		usage: null,
-		backend: null,
-		timing: { ttftMs: ttft(), apiMs: elapsed() },
-		errorMessage: null,
-	};
-}
+/** Compatibility entry point; engine preparation is shared with headless callers. */
+export {
+	PREWARM_MAX_TOKENS,
+	PREWARM_USER_TEXT,
+	type PrewarmContext,
+	type PrewarmRoundInput,
+	type PrewarmRoundResult,
+	type PrewarmTrigger,
+	prewarmPromptTokens,
+	runPrewarmRound,
+} from "../engine/prewarm.js";

package/src/interactive/renderers/compaction-summary.ts

@@ -1,5 +1,5 @@
 /**
- * Renderers for CompactionSummary session entries (Phase 12 slice 12c).
+ * Renderers for CompactionSummary session entries.
  *
  * Two output shapes live here:
  *   1. `renderCompactionSummaryLine` is the inline one-liner chat-loop

package/src/interactive/renderers/provider-error.ts

@@ -0,0 +1,118 @@
+import { stripVTControlCharacters } from "node:util";
+import { redactSecretsText } from "../../domains/evidence/redact.js";
+import { redactSecretString } from "../../domains/safety/redaction.js";
+
+const SCAN_LIMIT = 8_192;
+const DISPLAY_LIMIT = 600;
+const ROUTE_ADVICE_TAIL = 1_024;
+
+/** Discard incomplete control sequences at the scan boundary, including their payload. */
+function terminalSafePrefix(value: string, limit: number): string {
+	const end = Math.min(value.length, limit);
+	const parts: string[] = [];
+	let start = 0;
+	let i = 0;
+	while (i < end) {
+		const code = value.charCodeAt(i);
+		if (code !== 27 && !(code >= 0x80 && code <= 0x9f)) {
+			i++;
+			continue;
+		}
+		parts.push(value.slice(start, i));
+		const introducer = code === 27 ? value.charCodeAt(++i) : code;
+		i++;
+		if (introducer === 91 || introducer === 0x9b) {
+			while (i < end) {
+				const next = value.charCodeAt(i++);
+				if (next >= 0x40 && next <= 0x7e) break;
+			}
+		} else if ([93, 80, 88, 94, 95, 0x9d, 0x90, 0x98, 0x9e, 0x9f].includes(introducer)) {
+			while (i < end) {
+				const next = value.charCodeAt(i++);
+				if (next === 7 || next === 0x9c) break;
+				if (next === 27 && i < end && value.charCodeAt(i) === 92) {
+					i++;
+					break;
+				}
+			}
+		}
+		start = i;
+	}
+	parts.push(value.slice(start, end));
+	return stripVTControlCharacters(parts.join(""));
+}
+
+/** Available evidence is sanitized and redacted only when explicitly inspected. */
+export function providerErrorEvidence(value: string, scanLimit = value.length): string {
+	return redactSecretsText(
+		redactSecretString(terminalSafePrefix(value, scanLimit)).replace(
+			/(\b(?:authorization["']?\s*[:=]\s*["']?\s*)?(?:Bearer|Basic)\s+)[^\s"'<>]+/gi,
+			"$1[redacted]",
+		),
+		{ count: 0 },
+	).replace(/[\p{Cc}\p{Cf}]/gu, (char) => (char === "\n" || char === "\t" ? char : " "));
+}
+
+/** A bounded projection; never use this to replace a persisted diagnostic. */
+export function presentProviderError(value: string): string {
+	const available = providerErrorEvidence(value, SCAN_LIMIT);
+	// Preserve the actual Clio wrapper suffix; never infer a retry policy from
+	// provider error codes. A restored body can push this advice past the scan
+	// window, so a long diagnostic is matched on its bounded tail instead.
+	const beyondScan = value.length > SCAN_LIMIT;
+	const routeParts = (beyondScan ? providerErrorEvidence(value.slice(-ROUTE_ADVICE_TAIL)) : available).match(
+		/\n\n((LiteLLM route [^\n]+ failed\.) (Clio did not retry or substitute another model); (select a different route with \/model, then resend\.))$/,
+	);
+	const routeAdvice = routeParts?.[1];
+	const sample =
+		routeAdvice && !beyondScan ? available.slice(0, available.length - routeAdvice.length).trimEnd() : available;
+	let summary = sample;
+	const jsonStart = sample.indexOf("{");
+	const html = /<!doctype\s+html|<html\b/i.test(sample);
+	if (html) {
+		const title = sample.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1];
+		const prefix = sample.slice(0, sample.indexOf("<")).trim();
+		summary = [
+			prefix,
+			title,
+			routeAdvice ? "" : "Provider returned an HTML error page. Check the provider or gateway endpoint.",
+		]
+			.filter(Boolean)
+			.join("; ");
+	} else if (jsonStart >= 0) {
+		// Decode only quoted diagnostic strings, never parse and round numeric
+		// source facts. The scan and every allocation are bounded by SCAN_LIMIT.
+		const fields = [...sample.matchAll(/"(?:message|detail|type|code)"\s*:\s*"((?:[^"\\]|\\.)*)/g)].map((match) => {
+			const quoted = match[1];
+			if (quoted === undefined) return "";
+			try {
+				// A bounded prefix of an unfinished quoted field is still useful
+				// prose. The matcher excludes a dangling escape at the boundary.
+				const decoded: unknown = JSON.parse(`"${quoted}"`);
+				return typeof decoded === "string" ? providerErrorEvidence(decoded) : "";
+			} catch {
+				return "";
+			}
+		});
+		if (fields.some(Boolean))
+			summary = [sample.slice(0, jsonStart).trim(), ...new Set(fields)].filter(Boolean).join("; ");
+	}
+	const status =
+		sample.match(/\b(?:HTTP(?:\/\d(?:\.\d)?)?\s*|status(?:_code)?["']?\s*[:=]\s*)([45]\d\d)\b/i)?.[1] ??
+		sample.match(/"(?:status|status_?code)"\s*:\s*([45]\d{2})(?=\s*[,}])/i)?.[1] ??
+		sample.match(/"error"\s*:\s*\{[^{}]*?"code"\s*:\s*([45]\d{2})(?=\s*[,}])/i)?.[1];
+	if (status && !summary.includes(status)) summary = `HTTP ${status}; ${summary}`;
+	summary = summary.replace(/\s+/g, " ").trim();
+	if (routeAdvice) {
+		// Keep route recovery ahead of long body detail so row clipping cannot
+		// spend the entire primary preview on the provider payload.
+		const prefix = summary.slice(0, 60);
+		const identity = routeParts?.[2];
+		const policy = routeParts?.[3];
+		const remedy = routeParts?.[4];
+		const advice = identity && policy && remedy ? `${remedy} ${policy}. ${identity}` : routeAdvice;
+		summary = `${prefix}${summary.length > 60 ? " ..." : ""}; ${advice}`;
+	}
+	const shortened = summary.length > DISPLAY_LIMIT || value.length > SCAN_LIMIT || summary !== sample.trim();
+	return `${summary.slice(0, DISPLAY_LIMIT)}${shortened ? " ... [available diagnostic: /view transcript]" : ""}`;
+}

package/src/interactive/renderers/retry-status.ts

@@ -1,32 +1,30 @@
+import { truncateToWidth, wrapTextWithAnsi } from "../../engine/tui.js";
 import type { RetryStatusPayload } from "../chat-loop.js";
+import { clioTheme } from "../theme/index.js";
+import type { TranscriptDetailPolicy } from "../transcript-detail.js";
 import { styleTaggedNotice } from "./notice.js";
+import { previewBudget, previewRows } from "./preview.js";
+import { presentProviderError, providerErrorEvidence } from "./provider-error.js";
 
-const RETRY_ERROR_MAX_CHARS = 2_000;
-const RETRY_ERROR_TRUNCATION_MARKER = "… [retry error truncated]";
-
-function boundedRetryError(value: string): string {
-	const characters = Array.from(value);
-	if (characters.length <= RETRY_ERROR_MAX_CHARS) return value;
-	return `${characters.slice(0, RETRY_ERROR_MAX_CHARS).join("").trimEnd()}${RETRY_ERROR_TRUNCATION_MARKER}`;
-}
-
-function rawRetryStatus(status: RetryStatusPayload): string {
-	// Both live and replay renderers wrap this notice to their terminal width, so
-	// ordinary errors keep their complete remedy. Raw provider failures can also
-	// be an HTML proxy page, though; keep a generous ceiling so one retry does not
-	// turn that page into hundreds of transcript rows.
-	const suffix = status.errorMessage ? `: ${boundedRetryError(status.errorMessage)}` : "";
+function rawRetryStatus(status: RetryStatusPayload, unbounded: boolean): string {
+	const showError = unbounded || (status.phase !== "waiting" && status.phase !== "retrying");
+	const suffix =
+		showError && status.errorMessage
+			? `: ${unbounded ? providerErrorEvidence(status.errorMessage) : presentProviderError(status.errorMessage)}`
+			: "";
 	if (status.phase === "waiting") {
-		return `[retry] attempt ${status.attempt}/${status.maxAttempts} in ${status.seconds ?? 0}s${suffix}`;
+		return `[retry] provider retry ${status.attempt}/${status.maxAttempts} in ${status.seconds ?? 0}s${suffix}`;
 	}
 	if (status.phase === "scheduled") {
 		const seconds = Math.ceil((status.delayMs ?? 0) / 1000);
-		return `[retry] attempt ${status.attempt}/${status.maxAttempts} scheduled in ${seconds}s${suffix}`;
+		return `[retry] provider retry ${status.attempt}/${status.maxAttempts} scheduled in ${seconds}s${suffix}`;
 	}
-	if (status.phase === "retrying") return `[retry] attempt ${status.attempt}/${status.maxAttempts} running${suffix}`;
-	if (status.phase === "cancelled") return `[retry] cancelled attempt ${status.attempt}/${status.maxAttempts}${suffix}`;
-	if (status.phase === "exhausted") return `[retry] exhausted after ${status.attempt} attempt(s)${suffix}`;
-	return `[retry] recovered after ${status.attempt} attempt(s)`;
+	if (status.phase === "retrying")
+		return `[retry] provider retry ${status.attempt}/${status.maxAttempts} running${suffix}`;
+	if (status.phase === "cancelled")
+		return `[retry] provider retry cancelled (${status.attempt}/${status.maxAttempts})${suffix}`;
+	if (status.phase === "exhausted") return `[retry] provider retry exhausted (${status.attempt})${suffix}`;
+	return `[retry] provider retry recovered after ${status.attempt} attempt(s)`;
 }
 
 /**
@@ -34,6 +32,44 @@ function rawRetryStatus(status: RetryStatusPayload): string {
  * renders in warning and the body in muted via the shared notice styler, so the
  * live retry line and the replayed one read identically.
  */
-export function formatRetryStatus(status: RetryStatusPayload): string {
-	return styleTaggedNotice(rawRetryStatus(status));
+export function formatRetryStatus(status: RetryStatusPayload, unbounded = false): string {
+	return styleTaggedNotice(rawRetryStatus(status, unbounded));
+}
+
+/** Reserve diagnosis space even when a short terminal permits only two rows. */
+export function renderRetryStatus(
+	status: RetryStatusPayload,
+	width: number,
+	detail: TranscriptDetailPolicy,
+	unbounded = false,
+	terminalRows = 40,
+): string[] {
+	if (unbounded) return wrapTextWithAnsi(formatRetryStatus(status, true), width);
+	const limit = previewBudget(detail.errorRows, terminalRows);
+	const { errorMessage, ...heading } = status;
+	if (!errorMessage || status.phase === "waiting" || status.phase === "retrying" || status.phase === "recovered") {
+		return previewRows(wrapTextWithAnsi(formatRetryStatus(heading), width), limit, width);
+	}
+	// One heading row leaves room for the failure itself, not just a View hint.
+	const headingRow = truncateToWidth(formatRetryStatus(heading), width);
+	const diagnosis = presentProviderError(errorMessage);
+	const rows = wrapTextWithAnsi(diagnosis, width);
+	if (limit === 2 && rows.length > 1) {
+		const hint = " /view";
+		return [
+			headingRow,
+			clioTheme().fg(
+				"muted",
+				truncateToWidth(`${truncateToWidth(diagnosis, Math.max(1, width - hint.length))}${hint}`, width),
+			),
+		];
+	}
+	return [
+		headingRow,
+		...previewRows(
+			rows.map((row) => clioTheme().fg("muted", row)),
+			limit - 1,
+			width,
+		),
+	];
 }