@iowarp/clio-coder 0.4.8 → 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/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,
+		),
+	];
 }

package/src/interactive/renderers/tool-execution.ts

@@ -16,12 +16,13 @@ import { previewBudget, previewRows } from "./preview.js";
  */
 
 import { trustStateWord } from "../../domains/evidence/trust-projection.js";
-import { sanitizeCallTargetText } from "../../domains/safety/call-target.js";
+import { sanitizeCallTargetText, sanitizeMultilineDisplayText } from "../../domains/safety/call-target.js";
 import { redactSecretString, redactToolArgs } from "../../domains/safety/redaction.js";
 import { formatSize } from "../../engine/truncate.js";
 import { visibleWidth, wrapTextWithAnsi } from "../../engine/tui.js";
 import { classifyResourceRead, toolPresentationPolicy } from "../../tools/presentation.js";
 import { toolResultPresentationPolicy, toolResultPresentationText } from "../../tools/result-disposition.js";
+import { effectiveToolCall } from "../../tools/surface.js";
 import { mutationFactsLine } from "../mutation-preview.js";
 import type { ApprovalRequestView } from "../permission-overlay.js";
 import { clioTheme, formatCompactMs, GLYPH } from "../theme/index.js";
@@ -214,11 +215,16 @@ const PRIMARY_ARG_FIELD: Record<string, string> = {
 	bash: "command",
 	grep: "pattern",
 	find: "pattern",
+	web_read: "url",
 	web_fetch: "url",
 	git: "op",
 	verify: "check",
+	run_script: "script",
 	code_nav: "query",
 	context: "scope",
+	clio_docs: "query",
+	clio_library: "query",
+	data: "path",
 	artifact: "kind",
 	monitor: "run_id",
 	steer: "run_id",
@@ -252,10 +258,31 @@ function summarizeWebFetchArgs(args: unknown): string {
 	return truncate(jsonStringifySafe(Object.keys(compact).length > 0 ? compact : args), WEB_FETCH_ARG_PREVIEW_LIMIT);
 }
 
+/**
+ * A gateway call reads as the capability it reached: `find` and `describe`
+ * name what was asked, `call` renders the capability's own summary so a row
+ * says `git status` rather than an opaque gateway argument dump.
+ */
+function summarizeGatewayArgs(args: unknown): string {
+	if (!isPlainObject(args)) return truncate(jsonStringifySafe(redactToolArgs(args)), ARG_PREVIEW_LIMIT);
+	const op = typeof args.op === "string" ? args.op : "";
+	if (op === "find") {
+		const query = readStringField(args, "query");
+		return truncate(query === null || query.length === 0 ? "find" : `find ${query}`, ARG_PREVIEW_LIMIT);
+	}
+	const capability = readStringField(args, "capability") ?? "";
+	if (op === "describe") return truncate(`describe ${capability}`.trim(), ARG_PREVIEW_LIMIT);
+	const effective = effectiveToolCall("gateway", args);
+	if (!effective.viaGateway) return truncate(jsonStringifySafe(redactToolArgs(args)), ARG_PREVIEW_LIMIT);
+	const inner = summarizeArgs(effective.toolName, effective.args);
+	return truncate(inner.length > 0 ? `${effective.toolName} ${inner}` : effective.toolName, ARG_PREVIEW_LIMIT);
+}
+
 function summarizeArgs(toolName: string, args: unknown): string {
 	if (isEmptyArgs(args)) return "";
 	const safeArgs = redactToolArgs(args);
-	if (toolName === "web_fetch") return summarizeWebFetchArgs(safeArgs);
+	if (toolName === "web_fetch" || toolName === "web_read") return summarizeWebFetchArgs(safeArgs);
+	if (toolName === "gateway") return summarizeGatewayArgs(args);
 	const primary = capturedPrimaryArg(toolName, args);
 	if (primary !== null) return truncate(displayArg(toolName, primary), ARG_PREVIEW_LIMIT);
 	return truncate(jsonStringifySafe(safeArgs), ARG_PREVIEW_LIMIT);
@@ -589,7 +616,12 @@ function buildFieldSublineBody(
 ): string | null {
 	const value = readStringField(args, key);
 	if (value === null) return null;
-	const preview = truncate(key === "command" ? stripShellWrapperForDisplay(value) : value, ARG_PREVIEW_LIMIT);
+	// One array element is one terminal row to the diff renderer. A multi-line
+	// command or an escape sequence inside this row shifted every row below it.
+	const preview = truncate(
+		sanitizeCallTargetText(key === "command" ? stripShellWrapperForDisplay(value) : value),
+		ARG_PREVIEW_LIMIT,
+	);
 	if (options.wrapInBackticks) return `${lead}\`${preview}\``;
 	return `${lead}${preview}`;
 }
@@ -635,9 +667,32 @@ const SUBLINE_BODY_BUILDERS: Readonly<Record<string, (args: unknown) => string |
 	bash: (args) => buildFieldSublineBody(args, "command", "running ", { wrapInBackticks: true }),
 	grep: (args) => buildFieldSublineBody(args, "pattern", "searching for ", { wrapInBackticks: true }),
 	find: (args) => buildFieldSublineBody(args, "pattern", "finding ", { wrapInBackticks: true }),
+	web_read: (args) => buildFieldSublineBody(args, "url", "reading "),
 	web_fetch: (args) => buildFieldSublineBody(args, "url", "fetching "),
 	git: (args) => buildFieldSublineBody(args, "op", "git "),
 	verify: (args) => buildFieldSublineBody(args, "check", "verifying "),
+	run_script: (args) => buildFieldSublineBody(args, "script", "running ", { wrapInBackticks: true }),
+	data: (args) => {
+		const op = readStringField(args, "op") ?? "inspecting";
+		const path = readStringField(args, "path");
+		return path === null ? op : `${op} ${path}`;
+	},
+	gateway: (args) => {
+		if (!isPlainObject(args)) return null;
+		const op = typeof args.op === "string" ? args.op : "";
+		if (op === "find") {
+			const query = readStringField(args, "query");
+			return query === null || query.length === 0 ? "finding capabilities" : `finding capabilities \`${query}\``;
+		}
+		if (op === "describe") {
+			const capability = readStringField(args, "capability");
+			return capability === null ? "describing a capability" : `describing ${capability}`;
+		}
+		const effective = effectiveToolCall("gateway", args);
+		if (!effective.viaGateway) return null;
+		const inner = SUBLINE_BODY_BUILDERS[effective.toolName]?.(effective.args);
+		return inner !== null && inner !== undefined ? `${inner} (via gateway)` : `calling ${effective.toolName}`;
+	},
 	code_nav: (args) => {
 		const mode = readStringField(args, "mode");
 		const query = readStringField(args, "query")?.trim() ?? "";
@@ -715,9 +770,9 @@ function buildSublineBody(
 		}
 		return SUBLINE_BODY_BUILDERS[toolName]?.(args) ?? buildGenericToolBody(toolName, args);
 	}
-	if (toolName === "web_fetch") {
+	if (toolName === "web_fetch" || toolName === "web_read") {
 		const meta = status === undefined ? null : webFetchMeta(result);
-		const body = SUBLINE_BODY_BUILDERS.web_fetch?.(args) ?? buildGenericToolBody(toolName, args);
+		const body = SUBLINE_BODY_BUILDERS[toolName]?.(args) ?? buildGenericToolBody(toolName, args);
 		return `${body}${meta ? dim(` · ${meta}`) : ""}`;
 	}
 	if (toolName === "bash") {
@@ -909,9 +964,14 @@ function isEmptyResult(result: unknown): boolean {
 	return false;
 }
 
+/**
+ * Tool output is untrusted terminal input. Cursor movement, backspaces and
+ * carriage returns inside a row break the diff renderer's one-row-per-line
+ * accounting, so everything but the line structure is neutralized here.
+ */
 function resultText(result: unknown, limit = FULL_RESULT_PREVIEW_LIMIT): string {
-	if (typeof result === "string") return truncate(result, limit);
-	return truncate(jsonStringifySafe(result), limit);
+	const text = typeof result === "string" ? result : jsonStringifySafe(result);
+	return truncate(sanitizeMultilineDisplayText(text).text, limit);
 }
 
 function truncateRowsMiddle(rows: ReadonlyArray<string>, rowLimit: number, isError: boolean): string[] {