brl-subagent 2.4.0 → 2.5.1

package/src/tui-format.ts

@@ -7,7 +7,8 @@
  * without a TUI harness.
  */
 
-import { formatTokens } from "./types";
+import { formatTokens, isInterruptedRun } from "./types";
+import type { SubagentRun } from "./types";
 
 /** Braille spinner frames, indexed by Math.floor(now / 150) % 10. */
 export const LIVE_SPINNER_FRAMES: readonly string[] = [
@@ -50,3 +51,58 @@ export function formatLiveRowDim(
 ): string {
 	return `  [${id.slice(0, 8)}]  \u2191${formatTokens(usage.input)} \u2193${formatTokens(usage.output)}  ${elapsedStr}`;
 }
+
+/**
+ * Display name for a Run History / retry-surface row, shared by BOTH surfaces
+ * so they can never name the same run differently (Fix B item 5). Explicit
+ * label wins, else the task truncated to 60 chars, else the short id — the last
+ * case being a task-less foreground-interrupted row (no task persisted).
+ */
+export function runDisplayName(run: Pick<SubagentRun, "id" | "label" | "task">): string {
+	return run.label || run.task.slice(0, 60) || run.id.slice(0, 8);
+}
+
+// ---------------------------------------------------------------------------
+// U3 (D1/D3): Run History / retry-surface row projection
+// ---------------------------------------------------------------------------
+
+/**
+ * The human status of a Run History row. Keys on `isInterruptedRun` FIRST, so a
+ * run marked interrupted renders as `interrupted` and NEVER falls through to its
+ * raw `\"running\"` status (D1). The raw status is only consulted for an
+ * unmarked record.
+ */
+export type RunHistoryStatus = "interrupted" | "running" | "done" | "failed";
+
+export function runHistoryStatus(run: SubagentRun): RunHistoryStatus {
+	if (isInterruptedRun(run)) return "interrupted";
+	if (run.status === "done" || run.status === "failed") return run.status;
+	return "running";
+}
+
+/** Human label for a Run History row's status. */
+export function runHistoryStatusLabel(run: SubagentRun): string {
+	switch (runHistoryStatus(run)) {
+		case "interrupted":
+			return "Interrupted";
+		case "done":
+			return "Completed";
+		case "failed":
+			return "Failed";
+		default:
+			return "Running";
+	}
+}
+
+/**
+ * The offer text shown when a retry-surface row is selected. Names the run id
+ * and the `retryRunId` parameter explicitly (D3), so the conductor re-dispatches
+ * the recorded task/params without a new delegate_task parameter.
+ */
+export function buildRetryOfferMessage(run: SubagentRun): string {
+	const statusWord = isInterruptedRun(run) ? "interrupted" : "failed";
+	return (
+		`Ask the LLM to retry: "Use delegate_task with retryRunId: ${run.id} ` +
+		`to retry the ${statusWord} run ${run.id.slice(0, 8)} with its recorded params."`
+	);
+}

package/src/tui.ts

@@ -14,7 +14,7 @@ import type {
 	ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
 import { DynamicBorder, getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { Container, type SelectItem, SelectList, Spacer, Text, Markdown } from "@earendil-works/pi-tui";
+import { Container, type Component, type SelectItem, SelectList, Spacer, Text, Markdown, matchesKey } from "@earendil-works/pi-tui";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type {
@@ -32,15 +32,18 @@ import type {
 	UsageStats,
 	FileDiff,
 	CompletionNotifyMode,
+	RecoveryMode,
 } from "./types";
 import {
 	THINKING_LEVELS,
 	NAV_FOOTER,
 	COMPLETION_NOTIFY_MODES,
+	RECOVERY_MODES,
 	TASK_PREVIEW_MAX_LENGTH,
 	COLLAPSED_OUTPUT_LINES,
 	COLLAPSED_DIFF_FILES_PREVIEW,
 	EXPANDED_HUNKS_PER_FILE,
+	DEFAULT_OUTPUT_CAP_BYTES,
 	formatTokens,
 	formatUsageStats,
 	formatModel,
@@ -49,18 +52,21 @@ import {
 	isSubagentError,
 	isMultiSubagentDetails,
 	isGraphDetails,
+	isUnsettledPartial,
+	isInterruptedRun,
 } from "./types";
 import { buildFileAccessReport, buildSecretsExposureReport, generateComplianceSummary } from "./reports";
 import { extractParamNames } from "./templates";
 import { parseDiff } from "./diff";
 import { formatPresetSummary, getPreset, loadCustomPresets } from "./presets";
-import { formatRunDuration } from "./history";
+import { buildOutputHonestyLines, formatRunDuration } from "./history";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { sweepStaleLiveSubagents, type SessionState } from "./state";
+import { collapseRunsForHistory, retryableRuns, sweepStaleLiveSubagents, type SessionState } from "./state";
 import { getAgent } from "./session-manager";
+import { visibleRunEntriesForSession } from "./recovery-surface";
 import { computeSLAMetrics, computeCostTrend, formatSparkline } from "./metrics";
-import { formatElapsed, liveRowName, liveSpinner, formatLiveRowDim } from "./tui-format";
+import { formatElapsed, liveRowName, liveSpinner, formatLiveRowDim, runHistoryStatus, runHistoryStatusLabel, buildRetryOfferMessage, runDisplayName } from "./tui-format";
 import {
 	renderTranscriptMessages,
 	type TranscriptLineStyle,
@@ -334,6 +340,32 @@ export async function showCompletionNotifySelector(
 	onConfigChanged(ctx, `Completion notify mode set to ${result}`);
 }
 
+/**
+ * Option B U3 (D4): recovery posture selector. Modeled on the completionNotify
+ * selector; `RECOVERY_MODES` excludes "auto" by construction.
+ */
+export async function showRecoverySelector(
+	ctx: ExtensionContext,
+	state: SessionState,
+	onConfigChanged: (ctx: ExtensionContext, msg: string) => void,
+): Promise<void> {
+	const modeDescriptions: Record<RecoveryMode, string> = {
+		offer: "Surface interrupted runs (Run History row + one boot notice) - default",
+		off: "Do not surface interrupted runs",
+	};
+	const items: SelectItem[] = RECOVERY_MODES.map((mode) => ({
+		value: mode,
+		label: mode,
+		description: modeDescriptions[mode],
+	}));
+
+	const result = await showSelectList(ctx, "Recovery Posture", items, 5);
+	if (!result) return;
+
+	state.config.recovery = result as RecoveryMode;
+	onConfigChanged(ctx, `Recovery posture set to ${result}`);
+}
+
 // ---------------------------------------------------------------------------
 // E4: SLA tracking configuration
 // ---------------------------------------------------------------------------
@@ -936,6 +968,13 @@ export function getConfigMenuItems(state: SessionState): SelectItem[] {
 					? "Wake only on failed/stopped"
 					: "Never wake (passive delivery)",
 		},
+		{
+			value: "recovery",
+			label: "Set Recovery Posture",
+			description: state.config.recovery === "offer"
+				? "Surface interrupted runs (default)"
+				: "Do not surface interrupted runs",
+		},
 
 		{
 			value: "historyentries",
@@ -1083,132 +1122,274 @@ export async function showConfigMenu(
 // Run history viewer
 // ---------------------------------------------------------------------------
 
+/**
+ * U3 Fix A: the recovery visibility bridge wired for a TUI surface. Session
+ * run entries UNIONED with synthetic durable interrupted records the session
+ * has never seen (a genuine fresh boot), deduped by id. Both the history list
+ * and the retry menu read THIS, so they can never disagree about an interrupted
+ * run that exists only in the durable registry.
+ */
+function recoverableRunEntries(ctx: ExtensionContext, state: SessionState): SubagentRun[] {
+	return visibleRunEntriesForSession(state.getRunEntries(ctx), getAgent);
+}
+
 export async function showRunHistory(
 	ctx: ExtensionContext,
 	state: SessionState,
 	persistState: () => void,
 ): Promise<void> {
-	const runs = state.getRunEntries(ctx).reverse();
-
-	if (runs.length === 0) {
-		ctx.ui.notify("No subagent runs recorded yet. Delegate a task to see history.", "info");
-		return;
-	}
-
 	const statusIcon: Record<string, string> = {
 		running: ctx.ui.theme.fg("accent", "◉"),
 		done: ctx.ui.theme.fg("success", "✓"),
 		failed: ctx.ui.theme.fg("error", "✗"),
+		interrupted: ctx.ui.theme.fg("warning", "◌"),
 	};
 
-	const items: SelectItem[] = runs.map((r) => {
-		const icon = statusIcon[r.status] || "·";
-		const name = r.label || r.task.slice(0, 60);
-		const model = r.model.split("/").pop() || r.model;
-		const when = r.finishedAt ? formatRunDuration(r.durationMs || 0) : "running...";
-		const cost = r.cost ? ` $${r.cost.toFixed(4)}` : "";
-		const desc = `${r.thinkingLevel} · ${model} · ${when}${cost}`;
-		return { value: r.id, label: `${icon} ${name}`, description: desc };
-	});
+	// Browse loop (issue #260): list → detail → list … until the LIST is exited
+	// with Esc. Closing a detail returns here, not to the /brl-subagent menu.
+	while (true) {
+		// One row per SETTLED run (issue #259): collapse each run's spawn+terminal
+		// entry pair to its terminal-preferred record; in-flight runs are omitted
+		// (the live monitor owns running state).
+		const runs = collapseRunsForHistory(recoverableRunEntries(ctx, state));
+
+		if (runs.length === 0) {
+			ctx.ui.notify("No subagent runs recorded yet. Delegate a task to see history.", "info");
+			return;
+		}
 
-	const selectedId = await showSelectList(ctx, "Subagent History", items, 15);
-	if (!selectedId) return;
+		const items: SelectItem[] = runs.map((r) => {
+			const status = runHistoryStatus(r);
+			const icon = statusIcon[status] || "·";
+			const name = runDisplayName(r);
+			const model = r.model.split("/").pop() || r.model;
+			const when = r.finishedAt
+				? formatRunDuration(r.durationMs || 0)
+				: status === "interrupted"
+					? "interrupted"
+					: "running...";
+			const cost = r.cost ? ` $${r.cost.toFixed(4)}` : "";
+			const desc = `${r.thinkingLevel} · ${model} · ${when}${cost}`;
+			return { value: r.id, label: `${icon} ${name}`, description: desc };
+		});
 
-	const run = runs.find((r) => r.id === selectedId);
-	if (!run) return;
+		const selectedId = await showSelectList(ctx, "Subagent History", items, 15);
+		if (!selectedId) return; // Esc at the list exits to the menu
 
-	// Mark as seen
-	if (state.markRunSeen(run.id)) {
-		persistState();
-		import("./concurrency").then(({ updateProgressStatus }) => {
-			updateProgressStatus(state, ctx);
-		});
+		const run = runs.find((r) => r.id === selectedId);
+		if (!run) continue; // selected run pruned since listing — re-show the list
+
+		// Mark as seen
+		if (state.markRunSeen(run.id)) {
+			persistState();
+			import("./concurrency").then(({ updateProgressStatus }) => {
+				updateProgressStatus(state, ctx);
+			});
+		}
+
+		await showRunDetail(ctx, run);
 	}
+}
 
-	// Show detail view
-	await ctx.ui.custom<void>((tui, theme, _kb, done) => {
-		const container = new Container();
-		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+/**
+ * Number of output lines a run-detail viewport shows at once (issue #261):
+ * the stored text can be up to the 100 KB cap, so the panel is height-capped
+ * and scrolled rather than dumped whole (which would push the footer and
+ * header off-screen).
+ */
+const RUN_DETAIL_OUTPUT_VIEWPORT_LINES = 12;
 
-		const statusLabel =
-			run.status === "done" ? "Completed" : run.status === "failed" ? "Failed" : "Running";
-		container.addChild(
-			new Text(
-				theme.fg(
-					"toolTitle",
-					theme.bold(`${run.label || "Subagent"} — ${statusLabel}`),
-				),
-				1,
-				0,
-			),
-		);
-		container.addChild(new Text("", 0, 0));
-		container.addChild(
-			new Text(theme.fg("dim", `Task: ${run.task.slice(0, 200)}`), 1, 0),
-		);
-		container.addChild(
-			new Text(
-				theme.fg("dim", `Model: ${run.model} · Thinking: ${run.thinkingLevel}`),
-				1,
-				0,
-			),
-		);
-		container.addChild(new Text(theme.fg("dim", `Started: ${run.startedAt}`), 1, 0));
-		if (run.finishedAt) {
-			container.addChild(
+/**
+ * Detail view for one settled run (issue #260, #261): ↑/↓ and PgUp/PgDn scroll
+ * the stored output; any OTHER key — including Esc — closes it. The
+ * showRunHistory browse loop re-shows the list on return.
+ *
+ * The output region follows the approval dialog's full-diff view structure
+ * (see `showApprovalDialog.buildDiffView` / `withDiffKeybinding`: a bordered
+ * Container with a title, the content, and a return footer) but adds the
+ * height cap + scroll state that view lacks. Output is wrapped through the
+ * same `Text` component those views use, so wrapping/padding stay consistent.
+ */
+async function showRunDetail(ctx: ExtensionContext, run: SubagentRun): Promise<void> {
+	const outputText = run.fullOutput ?? run.outputSummary ?? "";
+	await ctx.ui.custom<void>((tui, theme, kb, done) => {
+		// First line of the viewport (0 = top). Mutated by scroll keys and
+		// clamped to the wrapped-content length on every render.
+		let scrollTop = 0;
+		// Wrapped output lines for the current width, and the width they were
+		// produced at, so a resize re-wraps and a redraw does not.
+		let wrappedLines: string[] = [];
+		let wrappedWidth = -1;
+
+		const wrapOutput = (width: number): string[] => {
+			if (width === wrappedWidth) return wrappedLines;
+			wrappedLines = new Text(theme.fg("toolOutput", outputText), 1, 0).render(width);
+			wrappedWidth = width;
+			return wrappedLines;
+		};
+
+		const buildOutputSection = (width: number): Container => {
+			const section = new Container();
+			const lines = wrapOutput(width);
+			const total = lines.length;
+			const maxScroll = Math.max(0, total - RUN_DETAIL_OUTPUT_VIEWPORT_LINES);
+			if (scrollTop > maxScroll) scrollTop = maxScroll;
+			if (scrollTop < 0) scrollTop = 0;
+			const from = total === 0 ? 0 : Math.min(scrollTop + 1, total);
+			const to = Math.min(scrollTop + RUN_DETAIL_OUTPUT_VIEWPORT_LINES, total);
+			const indicator =
+				total > RUN_DETAIL_OUTPUT_VIEWPORT_LINES
+					? `  (lines ${from}\u2013${to} of ${total} \u00b7 \u2191\u2193 / PgUp\u00b7PgDn)`
+					: `  (${total} line${total === 1 ? "" : "s"})`;
+
+			section.addChild(
 				new Text(
-					theme.fg(
-						"dim",
-						`Finished: ${run.finishedAt} (${formatRunDuration(run.durationMs || 0)})`,
-					),
+					theme.fg("muted", "\u2500\u2500\u2500 Output \u2500\u2500\u2500") + theme.fg("dim", indicator),
 					1,
 					0,
 				),
 			);
-		}
-		if (run.cost) {
+
+			if (total === 0) {
+				section.addChild(new Text(theme.fg("dim", "(no output recorded)"), 1, 0));
+				return section;
+			}
+
+			// Height-capped viewport: the output was already wrapped to `width`
+			// above, so hand the sliced lines back directly instead of feeding them
+			// through another Text (which would re-wrap at the padded width).
+			const viewport: Component = {
+				render: () => lines.slice(scrollTop, scrollTop + RUN_DETAIL_OUTPUT_VIEWPORT_LINES),
+				invalidate: () => {
+					wrappedWidth = -1;
+				},
+			};
+			section.addChild(viewport);
+			return section;
+		};
+
+		const buildDetailView = (width: number): Container => {
+			const container = new Container();
+			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+			const statusLabel = runHistoryStatusLabel(run);
 			container.addChild(
 				new Text(
 					theme.fg(
-						"dim",
-						`Cost: $${run.cost.toFixed(4)} · ↑${formatTokens(run.tokensIn || 0)} ↓${formatTokens(run.tokensOut || 0)}`,
+						"toolTitle",
+						theme.bold(`${run.label || "Subagent"} — ${statusLabel}`),
 					),
 					1,
 					0,
 				),
 			);
-		}
-		if (run.errorMessage) {
-			container.addChild(new Spacer(1));
+			container.addChild(new Text("", 0, 0));
 			container.addChild(
-				new Text(theme.fg("error", `Error: ${run.errorMessage}`), 1, 0),
+				new Text(theme.fg("dim", `Task: ${run.task.slice(0, 200)}`), 1, 0),
 			);
-		}
-		if (run.outputSummary) {
-			container.addChild(new Spacer(1));
 			container.addChild(
 				new Text(
-					theme.fg("muted", "\u2500\u2500\u2500 Output Preview \u2500\u2500\u2500"),
+					theme.fg("dim", `Model: ${run.model} · Thinking: ${run.thinkingLevel}`),
 					1,
 					0,
 				),
 			);
-			container.addChild(
-				new Text(theme.fg("toolOutput", run.outputSummary), 1, 0),
-			);
-			if ((run.outputSummary || "").length >= 200) {
-				container.addChild(new Text(theme.fg("dim", "(first 200 characters)"), 1, 0));
+			container.addChild(new Text(theme.fg("dim", `Started: ${run.startedAt}`), 1, 0));
+			if (run.finishedAt) {
+				container.addChild(
+					new Text(
+						theme.fg(
+							"dim",
+							`Finished: ${run.finishedAt} (${formatRunDuration(run.durationMs || 0)})`,
+						),
+						1,
+						0,
+					),
+				);
+			}
+			if (run.cost) {
+				container.addChild(
+					new Text(
+						theme.fg(
+							"dim",
+							`Cost: $${run.cost.toFixed(4)} · ↑${formatTokens(run.tokensIn || 0)} ↓${formatTokens(run.tokensOut || 0)}`,
+						),
+						1,
+						0,
+					),
+				);
+			}
+			if (run.errorMessage) {
+				container.addChild(new Spacer(1));
+				container.addChild(
+					new Text(theme.fg("error", `Error: ${run.errorMessage}`), 1, 0),
+				);
 			}
-		}
 
-		container.addChild(new Spacer(1));
-		container.addChild(new Text(theme.fg("dim", "Press any key to close"), 1, 0));
-		container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+			container.addChild(new Spacer(1));
+			container.addChild(buildOutputSection(width));
+			// Honest disclosures (issue #261): the transcript is the only place the
+			// uncapped text lives, and the cap is stated when it was hit.
+			for (const line of buildOutputHonestyLines(run, DEFAULT_OUTPUT_CAP_BYTES)) {
+				container.addChild(new Text(theme.fg("dim", line), 1, 0));
+			}
+
+			container.addChild(new Spacer(1));
+			container.addChild(
+				new Text(
+					theme.fg("dim", "\u2191\u2193 scroll \u00b7 alt+\u2191\u2193 page \u00b7 any other key to close"),
+					1,
+					0,
+				),
+			);
+			container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+			return container;
+		};
 
 		return {
-			render: (w: number) => container.render(w),
-			invalidate: () => container.invalidate(),
-			handleInput: (_data: string) => done(),
+			render: (w: number) => buildDetailView(w).render(w),
+			invalidate: () => {},
+			handleInput: (data: string) => {
+				// Paging: alt+↑ / alt+↓. Checked BEFORE the plain arrows so an
+				// alt-modified sequence can never be consumed as a line step.
+				// PgUp/PgDn are unusable here: the host binds them to the
+				// alt-screen transcript scroll (`tui.altScreen.pageUp/pageDown`)
+				// and consumes them before a `ctx.ui.custom` overlay sees input —
+				// pi 1.0.2 has no viewport-owner registration for overlays. The
+				// PgUp/PgDn checks below stay for inline mode, where they do
+				// reach the overlay.
+				if (matchesKey(data, "alt+up")) {
+					scrollTop -= RUN_DETAIL_OUTPUT_VIEWPORT_LINES;
+					tui.requestRender();
+					return;
+				}
+				if (matchesKey(data, "alt+down")) {
+					scrollTop += RUN_DETAIL_OUTPUT_VIEWPORT_LINES;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.select.up")) {
+					scrollTop -= 1;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.select.down")) {
+					scrollTop += 1;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.select.pageUp")) {
+					scrollTop -= RUN_DETAIL_OUTPUT_VIEWPORT_LINES;
+					tui.requestRender();
+					return;
+				}
+				if (kb.matches(data, "tui.select.pageDown")) {
+					scrollTop += RUN_DETAIL_OUTPUT_VIEWPORT_LINES;
+					tui.requestRender();
+					return;
+				}
+				done();
+			},
 		};
 	});
 }
@@ -1865,32 +2046,59 @@ export async function showDashboard(
 // Retry menu
 // ---------------------------------------------------------------------------
 
-export async function showRetryMenu(ctx: ExtensionContext, state: SessionState): Promise<void> {
-	const failedRuns = state.getRunEntries(ctx).filter((r) => r.status === "failed").reverse();
+export async function showRetryMenu(
+	ctx: ExtensionContext,
+	state: SessionState,
+	// U3 (D5): the abandon action is injected by the extension entry point (it
+	// owns the session-manager/registry wiring). Omitted in read-only contexts.
+	onAbandon?: (id: string) => void | Promise<void>,
+): Promise<void> {
+	// U3 (D3): failed AND unresolved interrupted runs share this surface, one row
+	// per run, built on the same terminal-preferred collapse the history uses.
+	const candidates = retryableRuns(recoverableRunEntries(ctx, state));
 
-	if (failedRuns.length === 0) {
-		ctx.ui.notify("No failed subagent runs to retry.", "info");
+	if (candidates.length === 0) {
+		ctx.ui.notify("No failed or interrupted subagent runs to retry.", "info");
 		return;
 	}
 
-	const items: SelectItem[] = failedRuns.map((r) => {
-		const name = r.label || r.task.slice(0, 60);
+	const items: SelectItem[] = candidates.map((r) => {
+		const interrupted = isInterruptedRun(r);
+		const name = runDisplayName(r);
 		const model = r.model.split("/").pop() || r.model;
-		const err = r.errorMessage ? r.errorMessage.slice(0, 40) : "error";
+		const err = r.errorMessage ? r.errorMessage.slice(0, 40) : interrupted ? "interrupted" : "error";
 		return {
 			value: r.id,
-			label: `✗ ${name}`,
-			description: `${model} · ${err}`,
+			label: `${interrupted ? "◌" : "✗"} ${name}`,
+			description: `${interrupted ? "interrupted · " : ""}${model} · ${err}`,
 		};
 	});
 
-	const selectedId = await showSelectList(ctx, "Retry Failed Run", items, 10);
+	const selectedId = await showSelectList(ctx, "Retry Failed or Interrupted Run", items, 10);
 	if (!selectedId) return;
 
-	ctx.ui.notify(
-		`Ask the LLM to retry: "Use delegate_task to retry failed run ${selectedId.slice(0, 8)}..."`,
-		"info",
-	);
+	const run = candidates.find((r) => r.id === selectedId);
+	if (!run) return;
+
+	if (isInterruptedRun(run) && onAbandon) {
+		const action = await showSelectList(
+			ctx,
+			"Interrupted Run",
+			[
+				{ value: "retry", label: "Retry", description: "Re-dispatch with its recorded params (retryRunId)" },
+				{ value: "abandon", label: "Abandon", description: "Finalize as stopped and prune its session file" },
+			],
+			5,
+		);
+		if (!action) return;
+		if (action === "abandon") {
+			await onAbandon(run.id);
+			ctx.ui.notify(`Abandoned interrupted run ${run.id.slice(0, 8)}.`, "info");
+			return;
+		}
+	}
+
+	ctx.ui.notify(buildRetryOfferMessage(run), "info");
 }
 
 // ---------------------------------------------------------------------------
@@ -2803,7 +3011,19 @@ export function renderDelegateResult(
 	}
 
 	// Single subagent mode (original)
-	if (!details || details.exitCode === -1) {
+	// Issue #298 (C2): the partial-vs-settled decision lives in ONE place —
+	// `isUnsettledPartial` (src/types.ts) owns the overloaded `exitCode === -1`
+	// disambiguation (the #206 streaming sentinel vs the #295 settled signal
+	// death). Do not re-derive it here; the terminal-status structural ratchet
+	// fails a local copy. A genuine partial (or a result with no details yet)
+	// renders the raw running text; a classified -1 is a settled FAILURE and
+	// takes the verdict branch below (✗ + error line + expanded-transcript
+	// binding), never raw text.
+	//
+	// The leading `!details` is a type-narrowing aid for the settled branch below
+	// (TS cannot narrow through a function call); it is NOT a second copy of the
+	// decision — the predicate owns the no-details case too.
+	if (!details || isUnsettledPartial(details)) {
 		const text = result.content[0];
 		return new Text(text?.type === "text" ? text.text : "(running\u2026)", 0, 0);
 	}