@linxiraos/pi-tui 1.1.26 → 1.2.0

package/src/tools/task.ts

@@ -1,8 +1,8 @@
 import type { Usage } from "@linxiraos/pi-ai";
-import { isRecord } from "@linxiraos/pi-utils";
+import { isRecord, sanitizeText } from "@linxiraos/pi-utils";
 import type { ThemeColor } from "../theme/theme";
 import type { ConfiguredThinkingLevel } from "../render/render-utils";
-import type { ToolRenderer } from "./renderer";
+import type { ToolRenderer, RenderResultOptions, NativeToolView, ToolRenderResult } from "./renderer";
 /**
  * TUI rendering for task tool.
  *
@@ -14,8 +14,6 @@ import { Container, type Component } from "../tui";
 import { Markdown } from "../components/markdown";
 import { Text } from "../components/text";
 import { visibleWidth, wrapTextWithAnsi } from "../utils";
-import { sanitizeText } from "@linxiraos/pi-utils";
-import type { RenderResultOptions } from "./renderer";
 import { formatAgentStatRun, renderAgentTreeRow } from "./agent-tree";
 import { getMarkdownTheme, type Theme } from "../theme/theme";
 import { stripGeneratedOutputNotice, stripRawOutputArtifactNotice, stripTrailingNotice } from "./output-meta";
@@ -42,19 +40,17 @@ import {
 } from "../render/render-utils";
 import { renderStatusLine } from "../render/index";
 import { framedToolCard } from "../render/tool-card";
-import { formatOutputInline, renderJsonTreeLines } from "./json-tree";
+import { formatOutputInline, renderJsonTreeLines, describeJsonTree } from "./json-tree";
 import { repairDoubleEncodedJsonString } from "./task-repair-args";
 import { getSubprocessToolRenderer } from "./subprocess";
 import { assembleYieldResult, type YieldSectionShapes } from "./task-yield-assembly";
 import type { TspAgentProps, TspTone } from "@linxiraos/pi-wire";
 import { compact, kv, md, node, span, text } from "../native/describe";
 import type { NativeNode } from "../native/node";
-import { OwnerMemo } from "../native/memo";
+import { OwnerMemo, sameItems } from "../native/memo";
 import { plainText } from "../native/spans";
 import { errorText, noteText, resultText } from "./native-view";
-import { describeJsonTree } from "./json-tree";
 import { taskSummary } from "../overlays/agent-hub-renderer";
-import type { NativeToolView, ToolRenderResult } from "./renderer";
 
 /** Render context threaded in from `ToolExecutionComponent.#buildRenderContext`. */
 interface TaskRenderContext {
@@ -246,6 +242,39 @@ function renderTypedYieldSections(value: unknown, continuePrefix: string, expand
 	return lines;
 }
 
+/**
+ * Per-frame memo for derived agent rows. Live task cards re-render at spinner
+ * cadence, while yield/recent-output arrays only change when the subagent
+ * reports. Entries are keyed by the source array (or object) and validated
+ * against a shallow snapshot of its elements plus the render deps, so in-place
+ * pushes/shifts invalidate correctly.
+ */
+interface SnapshotMemoEntry<T> {
+	items: unknown[];
+	deps: unknown[];
+	value: T;
+}
+
+function memoBySnapshot<T>(
+	cache: WeakMap<object, SnapshotMemoEntry<T>>,
+	source: unknown,
+	deps: unknown[],
+	compute: () => T,
+): T {
+	if (source === null || typeof source !== "object") return compute();
+	const items: unknown[] = Array.isArray(source) ? source.slice() : [source];
+	const entry = cache.get(source);
+	if (entry && sameItems(entry.items, items) && sameItems(entry.deps, deps)) return entry.value;
+	const value = compute();
+	cache.set(source, { items, deps, value });
+	return value;
+}
+
+const yieldSectionsMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+const completedReviewMemo = new WeakMap<object, SnapshotMemoEntry<string[] | null>>();
+const recentOutputMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+const agentResultMemo = new WeakMap<object, SnapshotMemoEntry<string[]>>();
+
 /** Formats sanitized task identifiers as hierarchy breadcrumbs. */
 export function formatTaskId(id: string): string {
 	// Ids are name-based (e.g. "Anna", "Anna-2"); a "." separates nesting levels
@@ -780,27 +809,32 @@ function renderAgentProgress(
 		// For completed tasks, render review verdicts assembled from incremental
 		// yield sections.
 		if (progress.status === "completed") {
-			const completeData = normalizeYieldData(progress.extractedToolData.yield);
-			const incrementalReview = extractIncrementalReviewResult(completeData);
-			if (incrementalReview) {
-				lines.push(
-					...renderReviewResult(
-						incrementalReview.summary,
-						incrementalReview.findings,
-						continuePrefix,
-						expanded,
-						theme,
-					),
-				);
-				return lines; // Review result handles its own rendering
-			}
-			const reviewData = completeData
-				.map(c => c.data as SubmitReviewDetails)
-				.filter(d => d && typeof d === "object" && "overall_correctness" in d);
-			if (reviewData.length > 0) {
-				const summary = reviewData[reviewData.length - 1];
-				const findings: FindingDetails[] = [];
-				lines.push(...renderReviewResult(summary, findings, continuePrefix, expanded, theme));
+			const yieldValue = progress.extractedToolData.yield;
+			const reviewLines = memoBySnapshot(
+				completedReviewMemo,
+				yieldValue,
+				[continuePrefix, expanded, theme],
+				(): string[] | null => {
+					const completeData = normalizeYieldData(yieldValue);
+					const incrementalReview = extractIncrementalReviewResult(completeData);
+					if (incrementalReview) {
+						return renderReviewResult(
+							incrementalReview.summary,
+							incrementalReview.findings,
+							continuePrefix,
+							expanded,
+							theme,
+						);
+					}
+					const reviewData = completeData
+						.map(c => c.data as SubmitReviewDetails)
+						.filter(d => d && typeof d === "object" && "overall_correctness" in d);
+					if (reviewData.length === 0) return null;
+					return renderReviewResult(reviewData[reviewData.length - 1], [], continuePrefix, expanded, theme);
+				},
+			);
+			if (reviewLines) {
+				lines.push(...reviewLines);
 				return lines; // Review result handles its own rendering
 			}
 		}
@@ -808,7 +842,11 @@ function renderAgentProgress(
 		for (const toolName in progress.extractedToolData) {
 			const dataArray = progress.extractedToolData[toolName];
 			if (toolName === "yield") {
-				lines.push(...renderTypedYieldSections(dataArray, continuePrefix, expanded, theme));
+				lines.push(
+					...memoBySnapshot(yieldSectionsMemo, dataArray, [continuePrefix, expanded, theme], () =>
+						renderTypedYieldSections(dataArray, continuePrefix, expanded, theme),
+					),
+				);
 				continue;
 			}
 
@@ -866,15 +904,19 @@ function renderAgentProgress(
 	// Expanded view: recent output and tools
 	if (expanded && progress.status === "running") {
 		const previewRows = previewWindowRows();
-		const output = capPreviewLines(
-			sanitizeRecentOutput([...progress.recentOutput].reverse().join("\n")).split("\n"),
-			theme,
-			{
-				max: previewRows,
-				expandHint: false,
-			},
-		).join("\n");
-		lines.push(...renderOutputSection(output, continuePrefix, expanded, theme, 2, previewRows));
+		lines.push(
+			...memoBySnapshot(recentOutputMemo, progress.recentOutput, [continuePrefix, theme, previewRows], () => {
+				const output = capPreviewLines(
+					sanitizeRecentOutput([...progress.recentOutput].reverse().join("\n")).split("\n"),
+					theme,
+					{
+						max: previewRows,
+						expandHint: false,
+					},
+				).join("\n");
+				return renderOutputSection(output, continuePrefix, expanded, theme, 2, previewRows);
+			}),
+		);
 	}
 
 	return lines;
@@ -1377,6 +1419,25 @@ export function renderResult(
 		theme,
 	);
 
+	// Fallback text is fixed for this snapshot; derive its trailing notice rows
+	// once instead of re-splitting on every spinner frame.
+	const fallbackExtraLines: string[] = [];
+	if (fallbackText.trim()) {
+		const summaryLines = fallbackText.split("\n");
+		const markerIndex = summaryLines.findIndex(
+			line =>
+				line.includes("<system-notification>") ||
+				line.startsWith("Applied patches:") ||
+				line.startsWith("No changes to apply."),
+		);
+		if (markerIndex >= 0) {
+			for (let i = markerIndex; i < summaryLines.length; i++) {
+				const line = summaryLines[i];
+				if (line.trim()) fallbackExtraLines.push(theme.fg("dim", line));
+			}
+		}
+	}
+
 	return framedToolCard(theme, ({ width, contentWidth }) => {
 		const { expanded, isPartial, spinnerFrame } = options;
 		const frozen = options.renderContext?.frozen === true;
@@ -1418,7 +1479,11 @@ export function renderResult(
 			const ordered = orderResultsForDisplay(details.results);
 			const visible = expanded ? ordered : selectCollapsedResults(ordered);
 			for (const res of visible) {
-				lines.push(...renderAgentResult(res, "", "  ", expanded, theme, undefined, 0, contentWidth));
+				lines.push(
+					...memoBySnapshot(agentResultMemo, res, [expanded, theme, contentWidth, isFeedModelBadgeEnabled()], () =>
+						renderAgentResult(res, "", "  ", expanded, theme, undefined, 0, contentWidth),
+					),
+				);
 			}
 			if (visible.length < ordered.length) {
 				const hint = formatExpandHint(theme, false, true);
@@ -1431,11 +1496,14 @@ export function renderResult(
 			// (their payloads deliver through jobs) — keep their rows visible
 			// beside the finalized inline results, live while running and
 			// settled once their jobs finish.
-			const supplementalProgress = details.progress
-				? orderProgressForDisplay(
-						details.progress.filter(progress => !details.results.some(res => res.id === progress.id)),
-					)
-				: [];
+			let supplementalProgress: AgentProgress[] = [];
+			if (details.progress) {
+				const resultIds = new Set<string>();
+				for (const res of details.results) resultIds.add(res.id);
+				supplementalProgress = orderProgressForDisplay(
+					details.progress.filter(progress => !resultIds.has(progress.id)),
+				);
+			}
 			for (const progress of supplementalProgress) {
 				lines.push(
 					...renderAgentProgress(
@@ -1488,22 +1556,7 @@ export function renderResult(
 			};
 		}
 
-		if (fallbackText.trim()) {
-			const summaryLines = fallbackText.split("\n");
-			const markerIndex = summaryLines.findIndex(
-				line =>
-					line.includes("<system-notification>") ||
-					line.startsWith("Applied patches:") ||
-					line.startsWith("No changes to apply."),
-			);
-			if (markerIndex >= 0) {
-				const extra = summaryLines.slice(markerIndex);
-				for (const line of extra) {
-					if (!line.trim()) continue;
-					lines.push(theme.fg("dim", line));
-				}
-			}
-		}
+		for (const line of fallbackExtraLines) lines.push(line);
 
 		while (lines.length > 0 && lines[0].trim() === "") lines.shift();
 		return {
@@ -2314,7 +2367,7 @@ export interface AgentProgress {
 	resolvedModelRoute?: string;
 	/** True when a live advisor was attached to this run's session, not merely enabled in settings. */
 	advisor?: boolean;
-	/** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbeMs` side request. */
+	/** The agent's latest self-estimate of task completion (0–100), from the periodic `task.completionProbe` side request. */
 	completionPercent?: number;
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */
 	extractedToolData?: Record<string, unknown[]>;

package/src/tools/todo.ts

@@ -65,11 +65,31 @@ export interface TodoToolDetails {
  * that would collide across unrelated todos. */
 const TODO_DESCRIPTION_MIN_OVERLAP = 6;
 
+/** Bound on {@link normalizedTodoCache}; cleared wholesale when exceeded. */
+const NORMALIZED_TODO_CACHE_LIMIT = 1024;
+const normalizedTodoCache = new Map<string, string>();
+
 function normalizeForTodoMatch(value: string): string {
-	return value
+	let normalized = normalizedTodoCache.get(value);
+	if (normalized !== undefined) return normalized;
+	normalized = value
 		.toLowerCase()
 		.replace(/[^\p{L}\p{N}]+/gu, " ")
 		.trim();
+	if (normalizedTodoCache.size >= NORMALIZED_TODO_CACHE_LIMIT) normalizedTodoCache.clear();
+	normalizedTodoCache.set(value, normalized);
+	return normalized;
+}
+
+/** Match a pre-normalized target against pre-normalized, non-empty candidates. */
+function matchesNormalizedCandidates(target: string, candidates: readonly string[]): boolean {
+	if (!target) return false;
+	for (const candidate of candidates) {
+		if (target === candidate) return true;
+		if (target.length >= TODO_DESCRIPTION_MIN_OVERLAP && candidate.includes(target)) return true;
+		if (candidate.length >= TODO_DESCRIPTION_MIN_OVERLAP && target.includes(candidate)) return true;
+	}
+	return false;
 }
 
 /**
@@ -88,14 +108,12 @@ function normalizeForTodoMatch(value: string): string {
 export function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean {
 	const target = normalizeForTodoMatch(content);
 	if (!target) return false;
+	const candidates: string[] = [];
 	for (const desc of descriptions) {
 		const candidate = normalizeForTodoMatch(desc);
-		if (!candidate) continue;
-		if (target === candidate) return true;
-		if (target.length >= TODO_DESCRIPTION_MIN_OVERLAP && candidate.includes(target)) return true;
-		if (candidate.length >= TODO_DESCRIPTION_MIN_OVERLAP && target.includes(candidate)) return true;
+		if (candidate) candidates.push(candidate);
 	}
-	return false;
+	return matchesNormalizedCandidates(target, candidates);
 }
 
 /** Whether a todo is settled: completed or deliberately abandoned. Shared so
@@ -144,13 +162,16 @@ const COLLAPSED_CLOSED_CONTEXT = 1;
  * 3. When active tasks alone exceed `cap`, only the first `cap` active tasks are
  *    shown and the summary counts the hidden *active* todos, never replacing
  *    them with unrelated pending rows.
+ *
+ * The summary occupies a row, so a summary that would hide exactly one task is
+ * replaced by that task: the selection spends at most `cap + 1` rows.
  */
 function selectWithinCap<T extends { status: TodoStatus }>(
 	base: T[],
 	isMatched: (task: T) => boolean,
 	cap: number,
 ): CollapsedTodoSelection<T> {
-	if (base.length <= cap) return { items: base, summary: "" };
+	if (base.length <= cap + 1) return { items: base, summary: "" };
 
 	const active = base.filter(task => isActiveTodo(task, isMatched));
 	// Only when active work strictly exceeds the cap do we drop pending rows and
@@ -311,24 +332,37 @@ function strikethroughText(text: string): string {
 	return `${STRIKE_START}${text}${STRIKE_END}`;
 }
 
-function partialStrikethrough(text: string, visibleChars: number): string {
+/** Display label for a todo row, with its code points split once for the strike animation. */
+interface TodoLabel {
+	text: string;
+	chars?: string[];
+}
+
+function labelChars(label: TodoLabel): string[] {
+	label.chars ??= [...label.text];
+	return label.chars;
+}
+
+function partialStrikethrough(label: TodoLabel, visibleChars: number): string {
+	const text = label.text;
 	if (visibleChars <= 0) return text;
-	const chars = [...text];
+	const chars = labelChars(label);
 	if (visibleChars >= chars.length) return strikethroughText(text);
 	return `${strikethroughText(chars.slice(0, visibleChars).join(""))}${chars.slice(visibleChars).join("")}`;
 }
 
-function strikeRevealCount(text: string, frame: number | undefined): number | undefined {
+function strikeRevealCount(label: TodoLabel, frame: number | undefined): number | undefined {
 	if (frame === undefined) return undefined;
 	if (frame <= TODO_STRIKE_HOLD_FRAMES) return 0;
-	const chars = [...text];
-	if (chars.length === 0) return undefined;
+	const count = labelChars(label).length;
+	if (count === 0) return undefined;
 	const revealFrame = Math.min(frame - TODO_STRIKE_HOLD_FRAMES, TODO_STRIKE_REVEAL_FRAMES);
-	return Math.ceil((chars.length * revealFrame) / TODO_STRIKE_REVEAL_FRAMES);
+	return Math.ceil((count * revealFrame) / TODO_STRIKE_REVEAL_FRAMES);
 }
 
 function formatTodoLine(
 	item: TodoItem,
+	label: TodoLabel,
 	uiTheme: Theme,
 	prefix: string,
 	completionKeys: Set<string>,
@@ -336,31 +370,27 @@ function formatTodoLine(
 	matched = false,
 ): string {
 	const checkbox = uiTheme.checkbox;
-	// Sanitize only for display. A mirrored Cursor snapshot carries provider text
-	// verbatim, and a label holding ANSI/C0 sequences would otherwise rewrite the
-	// terminal every time the list renders or replays. `item.content` stays raw
-	// everywhere else: it is the identity key the local list is looked up by
-	// (`findTaskByContent`) and what gets persisted.
-	const label = forDisplay(item.content);
+	// `label` is the display-sanitized content (see `forDisplay`); `item.content`
+	// stays raw everywhere else as the identity key and persisted value.
+	const text = label.text;
 	switch (item.status) {
 		case "completed": {
 			const revealCount = completionKeys.has(item.content) ? strikeRevealCount(label, frame) : undefined;
-			const content =
-				revealCount === undefined ? strikethroughText(label) : partialStrikethrough(label, revealCount);
+			const content = revealCount === undefined ? strikethroughText(text) : partialStrikethrough(label, revealCount);
 			return uiTheme.fg("success", `${prefix}${checkbox.checked} ${content}`);
 		}
 		case "in_progress":
-			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${label}`);
+			return uiTheme.fg("accent", `${prefix}${checkbox.unchecked} ${text}`);
 		case "abandoned":
-			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(label)}`);
+			return uiTheme.fg("error", `${prefix}${checkbox.unchecked} ${strikethroughText(text)}`);
 		case "blocked": {
 			const note = item.blocker ? `blocked: ${forDisplay(item.blocker)}` : "blocked";
-			return uiTheme.fg("warning", `${prefix}${checkbox.unchecked} ${label} (${note})`);
+			return uiTheme.fg("warning", `${prefix}${checkbox.unchecked} ${text} (${note})`);
 		}
 		default:
 			// A pending todo lit by a live subagent match renders accent, matching
 			// the sticky HUD's convention (#5873).
-			return uiTheme.fg(matched ? "accent" : "dim", `${prefix}${checkbox.unchecked} ${label}`);
+			return uiTheme.fg(matched ? "accent" : "dim", `${prefix}${checkbox.unchecked} ${text}`);
 	}
 }
 
@@ -499,6 +529,7 @@ function describeTodoResult(
 		tool: { title: "Todo", target: `${closed}/${total}`, targetKind: "text" },
 		body: [node("checklist", { mode: "full", phases: todoChecklistPhases(phases, isMatched) }, [], "checklist")],
 		preview: "none",
+		open: true,
 	};
 }
 
@@ -592,6 +623,40 @@ export const todoToolRenderer = {
 			return new Text(`${header}\n  ${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
+		// Everything below is fixed for this result; only the spinner frame and
+		// the live subagent description set vary per frame, so derive labels,
+		// touched phases and normalized match state once and reuse them.
+		const labels = new Map<TodoItem, TodoLabel>();
+		const labelFor = (task: TodoItem): TodoLabel => {
+			let label = labels.get(task);
+			if (!label) {
+				// Sanitize only for display: a mirrored Cursor snapshot carries
+				// provider text verbatim (ANSI/C0 would rewrite the terminal).
+				label = { text: forDisplay(task.content) };
+				labels.set(task, label);
+			}
+			return label;
+		};
+		let touchedComputed = false;
+		let touchedPhases: Set<string> | null = null;
+		let lastDescs: readonly string[] | undefined;
+		let candidates: string[] = [];
+		const matchByContent = new Map<string, boolean>();
+		const syncActiveDescs = (descs: readonly string[]): void => {
+			if (lastDescs === descs) return;
+			if (lastDescs && lastDescs.length === descs.length && lastDescs.every((d, i) => d === descs[i])) {
+				lastDescs = descs;
+				return;
+			}
+			lastDescs = descs;
+			candidates = [];
+			for (const desc of descs) {
+				const candidate = normalizeForTodoMatch(desc);
+				if (candidate) candidates.push(candidate);
+			}
+			matchByContent.clear();
+		};
+
 		return framedToolCard(uiTheme, () => {
 			const { expanded, spinnerFrame } = options;
 			const multiPhase = phases.length > 1;
@@ -599,13 +664,28 @@ export const todoToolRenderer = {
 			// Collapse phases this update didn't touch down to a one-line summary so
 			// a single task flip doesn't redraw every phase's full task list. The
 			// manual expand toggle (and the no-signal fallback) still shows all.
-			const touched = expanded || !multiPhase ? null : computeTouchedPhases(args, phases, completedTasks);
+			let touched: Set<string> | null = null;
+			if (!expanded && multiPhase) {
+				if (!touchedComputed) {
+					touchedPhases = computeTouchedPhases(args, phases, completedTasks);
+					touchedComputed = true;
+				}
+				touched = touchedPhases;
+			}
 			// A pending todo counts as active work when an in-flight subagent is
 			// executing it — the transient result surfaces the same active set the
 			// sticky HUD does (#5873). Empty outside an interactive session.
 			const activeDescs = expanded ? [] : activeTodoDescriptionsProvider();
-			const isMatched = (task: TodoItem): boolean =>
-				activeDescs.length > 0 && todoMatchesAnyDescription(task.content, activeDescs);
+			if (activeDescs.length > 0) syncActiveDescs(activeDescs);
+			const isMatched = (task: TodoItem): boolean => {
+				if (activeDescs.length === 0) return false;
+				let matched = matchByContent.get(task.content);
+				if (matched === undefined) {
+					matched = matchesNormalizedCandidates(normalizeForTodoMatch(task.content), candidates);
+					matchByContent.set(task.content, matched);
+				}
+				return matched;
+			};
 			const bodyLines: string[] = [];
 			for (let p = 0; p < phases.length; p++) {
 				const phase = phases[p];
@@ -631,7 +711,8 @@ export const todoToolRenderer = {
 								items: phase.tasks,
 								expanded,
 								itemType: "todo",
-								renderItem: todo => formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame),
+								renderItem: todo =>
+									formatTodoLine(todo, labelFor(todo), uiTheme, "", completionKeys, spinnerFrame),
 							},
 							uiTheme,
 						)
@@ -643,7 +724,15 @@ export const todoToolRenderer = {
 									itemType: "todo",
 									trailingSummary: selection.summary,
 									renderItem: todo =>
-										formatTodoLine(todo, uiTheme, "", completionKeys, spinnerFrame, isMatched(todo)),
+										formatTodoLine(
+											todo,
+											labelFor(todo),
+											uiTheme,
+											"",
+											completionKeys,
+											spinnerFrame,
+											isMatched(todo),
+										),
 								},
 								uiTheme,
 							);

package/src/tools/wait.ts

@@ -275,6 +275,39 @@ function jobsRenderResult(
 	});
 
 	let cached: RenderCache | undefined;
+	// Per-job preview rows are invariant across spinner/shimmer frames (the job
+	// snapshots are frozen for this result), so the envelope strip, flatten and
+	// wrap run once per (job, expanded, width) instead of every animated frame.
+	const previewRows = new Map<JobSnapshot, { expanded: boolean; width: number; lines: readonly string[] }>();
+	const jobPreviewRows = (job: JobSnapshot, expanded: boolean, continuationWidth: number): readonly string[] => {
+		const hit = previewRows.get(job);
+		if (hit !== undefined && hit.expanded === expanded && hit.width === continuationWidth) return hit.lines;
+		const artifactError = job.meta?.artifactError ?? job.artifactError;
+		// Legacy rows did not retain full metadata. Strip the known warning
+		// footer so the dedicated row/root warning remains the only copy.
+		const previewError =
+			artifactError ?? (outputMeta?.source?.type !== "report" ? outputMeta?.artifactError : undefined);
+		const previewMeta = job.meta ?? (previewError ? { artifactError: previewError } : undefined);
+		const preview = flattenStructuredPreview(
+			stripTaskResultEnvelope(
+				stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", previewMeta).trim(),
+			),
+		);
+		const lines: string[] = [];
+		if (preview) {
+			const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
+			const previewLines = getPreviewLines(
+				preview,
+				maxLines,
+				Math.min(PREVIEW_LINE_WIDTH, continuationWidth),
+				Ellipsis.Unicode,
+			);
+			const tone = job.errorText ? "error" : "dim";
+			for (const pl of previewLines) lines.push(`  ${uiTheme.fg(tone, pl)}`);
+		}
+		previewRows.set(job, { expanded, width: continuationWidth, lines });
+		return lines;
+	};
 	return {
 		render(width: number): readonly string[] {
 			const expanded = options.expanded;
@@ -377,30 +410,7 @@ function jobsRenderResult(
 							);
 						}
 
-						// Legacy rows did not retain full metadata. Strip the known warning
-						// footer so the dedicated row/root warning remains the only copy.
-						const previewError =
-							artifactError ?? (outputMeta?.source?.type !== "report" ? outputMeta?.artifactError : undefined);
-						const previewMeta = job.meta ?? (previewError ? { artifactError: previewError } : undefined);
-
-						const preview = flattenStructuredPreview(
-							stripTaskResultEnvelope(
-								stripOutputNotice(job.errorText?.trim() || job.resultText?.trim() || "", previewMeta).trim(),
-							),
-						);
-						if (preview) {
-							const maxLines = expanded ? PREVIEW_LINES_EXPANDED : PREVIEW_LINES_COLLAPSED;
-							const previewLines = getPreviewLines(
-								preview,
-								maxLines,
-								Math.min(PREVIEW_LINE_WIDTH, continuationWidth),
-								Ellipsis.Unicode,
-							);
-							const tone = job.errorText ? "error" : "dim";
-							for (const pl of previewLines) {
-								lines.push(`  ${uiTheme.fg(tone, pl)}`);
-							}
-						}
+						for (const previewLine of jobPreviewRows(job, expanded, continuationWidth)) lines.push(previewLine);
 						return lines;
 					},
 				},

package/src/tools/web-search.ts

@@ -171,7 +171,7 @@ export function renderSearchResult(
 		if (renderedAnswer.length === 0) {
 			answerLines = [theme.fg("muted", tuiText("wsNoAnswerText", "No answer text returned"))];
 		} else if (args?.maxAnswerLines !== undefined && !expanded) {
-			// CLI compact mode (`omp q`) caps the answer; the TUI passes no cap and shows it in full.
+			// CLI compact mode (`zetacode q`) caps the answer; the TUI passes no cap and shows it in full.
 			// `renderedAnswer` is the Markdown component's shared cache — slice copies before appending.
 			const capped = renderedAnswer.slice(0, args.maxAnswerLines);
 			const remaining = renderedAnswer.length - capped.length;

package/src/tools/write.d.ts

@@ -6,7 +6,7 @@ import { type ProcWriteDetails } from "./proc-render";
 import { type CfgWriteDetails } from "./cfg-render";
 import type { FileDiagnosticsResult } from "./lsp";
 import type { OutputMeta } from "./output-meta";
-import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary } from "./renderer";
+import type { NativeToolView, RenderResultOptions, ToolActivityContext, ToolActivitySummary, ToolFigure } from "./renderer";
 import { type XdevRenderDispatch, type XdevMountedRenderer } from "./xdev";
 /** Details returned by the write tool for transcript rendering. */
 export interface WriteToolDetails {
@@ -37,6 +37,12 @@ interface WriteResult {
     details?: WriteToolDetails;
     isError?: boolean;
 }
+/**
+ * The fence a file write draws as while its content streams and after: its
+ * extension names a figure language and it has content, closed once the args
+ * are final. None for URL-card writes, or after an error.
+ */
+declare function writeFigure(args: WriteRenderArgs | undefined, result: WriteResult | undefined, options: RenderResultOptions): ToolFigure | undefined;
 declare const writeStreamingPreviewStateKey: unique symbol;
 /**
  * Per-component state for incrementally rendering a streamed write.
@@ -75,7 +81,7 @@ export declare const writeToolRenderer: {
     renderCall(args: WriteRenderArgs, options: RenderResultOptions & WriteStreamingPreviewStateCarrier & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme): Component | undefined;
-    renderResult(result: WriteResult, options: RenderResultOptions & {
+    renderResult(result: WriteResult, options: RenderResultOptions & WriteStreamingPreviewStateCarrier & {
         renderContext?: WriteRenderContext;
     }, uiTheme: Theme, args?: WriteRenderArgs): Component;
     describeCall(args: WriteRenderArgs, options: RenderResultOptions & {
@@ -84,6 +90,7 @@ export declare const writeToolRenderer: {
     describeResult(result: WriteResult, options: RenderResultOptions & {
         renderContext?: WriteRenderContext;
     }, args?: WriteRenderArgs): NativeToolView | undefined;
+    figure: typeof writeFigure;
     mergeCallAndResult: true;
     forceFirstResultViewportRepaint: (args: unknown, options: RenderResultOptions) => boolean;
 };