@heyhuynhgiabuu/pi-pretty 0.6.26 → 0.6.28

package/src/tools/bash.ts

@@ -2,14 +2,71 @@
 
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { resolveBaseBackground, TOOL_RESULT_INDENT, termWidth } from "../config.js";
-import { compactErrorLines, inferBashExitCode, stripBashExitStatusLine } from "../helpers.js";
-import { fillToolBackground, renderToolDuration, renderToolError } from "../render.js";
+import {
+	CHARS_KEY,
+	compactErrorLines,
+	ELAPSED_KEY,
+	formatCharCount,
+	inferBashExitCode,
+	stripBashExitStatusLine,
+} from "../helpers.js";
+import {
+	fillToolBackground,
+	fillToolBody,
+	rememberToolTitle,
+	renderToolDuration,
+	renderToolError,
+	setCollapsedToolTitle,
+} from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { BashDetails, ComponentLike, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
-import { wrapExecuteWithMetrics } from "./metrics.js";
+import { type RejectedExecutionMetrics, wrapExecuteWithMetrics } from "./metrics.js";
 
 type Result = AgentToolResult<Record<string, unknown>>;
 
+const BASH_REJECTED_METRICS_KEY = "__piPrettyBashRejectedMetrics";
+const BASH_RESULT_RENDER_KEY = "__piPrettyBashResultRender";
+const REJECTED_METRICS_TTL_MS = 60_000;
+const rejectedBashMetrics = new Map<string, RejectedExecutionMetrics>();
+
+function rememberRejectedBashMetrics(toolCallId: string, metrics: RejectedExecutionMetrics): void {
+	rejectedBashMetrics.set(toolCallId, metrics);
+	const timer = setTimeout(() => {
+		if (rejectedBashMetrics.get(toolCallId) === metrics) rejectedBashMetrics.delete(toolCallId);
+	}, REJECTED_METRICS_TTL_MS);
+	timer.unref?.();
+}
+
+function takeRejectedBashMetrics(ctx: RenderCtxLike): RejectedExecutionMetrics | undefined {
+	const state = ctx.state;
+	const cached = state[BASH_REJECTED_METRICS_KEY] as RejectedExecutionMetrics | undefined;
+	if (cached) return cached;
+	if (!ctx.toolCallId) return undefined;
+	const metrics = rejectedBashMetrics.get(ctx.toolCallId);
+	if (metrics) {
+		rejectedBashMetrics.delete(ctx.toolCallId);
+		state[BASH_REJECTED_METRICS_KEY] = metrics;
+	}
+	return metrics;
+}
+
+function addRejectedMetrics(result: Result, metrics: RejectedExecutionMetrics): Result {
+	const details = {
+		...((result.details ?? {}) as Record<string, unknown>),
+		[ELAPSED_KEY]: metrics.elapsedMs,
+		[CHARS_KEY]: metrics.chars,
+	};
+	return { ...result, details } as Result;
+}
+
+function restoreBashResultRender(ctx: RenderCtxLike, text: ComponentLike): void {
+	const state = ctx.state;
+	const original = state[BASH_RESULT_RENDER_KEY] as ((width: number) => string[]) | undefined;
+	if (!original) return;
+	(text as unknown as { render: (width: number) => string[] }).render = original;
+	delete state[BASH_RESULT_RENDER_KEY];
+}
+
 export function registerBashTool(
 	pi: ExtensionAPI,
 	_cwd: string,
@@ -27,29 +84,22 @@ export function registerBashTool(
 			: "Execute shell commands. For text search: `rg -n`.",
 		promptSnippet: "Execute commands via bash. For text search: `rg -n`.",
 		promptGuidelines: [
-			"For text search: `rg -n`. If no results, try `rg -u` (respects .gitignore by default).",
-			"In rg: | means alternation, \\| means literal pipe. Opposite of GNU grep. Never use \\| for alternation.",
+			// Re-registering by name drops the host's built-in bash guidelines; keep them.
+			...(sdkTool.promptGuidelines ?? []),
+			"rg skips .gitignored and hidden files by default. On no results use `--hidden` for dotfiles (add `-g '!.git'`), `--no-ignore` for ignored files, or name the path directly; `-u` = `--no-ignore`, `-uu` adds hidden.",
+			"Quote rg patterns: `rg -n 'foo|bar'`. `|` is alternation, `\\|` is a literal pipe (unlike GNU grep); use `-F` for literal text.",
+			"Keep output small: `-l` lists files only, `-m N` caps matches per file.",
 		],
 		parameters: sdkTool.parameters,
+		constrainedSampling: sdkTool.constrainedSampling,
 		renderShell: "self",
 
-		execute: wrapExecuteWithMetrics(async (tid, params, sig, _upd, ctx: ExtensionContext) => {
-			try {
-				return (await sdkTool.execute(tid, params, sig, undefined, ctx)) as Result;
-			} catch (error: unknown) {
-				const msg = error instanceof Error ? error.message : String(error);
-				return {
-					content: [{ type: "text" as const, text: msg }],
-					isError: true,
-					details: {
-						_type: "bashResult",
-						text: msg,
-						exitCode: 1,
-						command: String((params as any).command ?? ""),
-					} as BashDetails,
-				};
-			}
-		}),
+		execute: wrapExecuteWithMetrics(async (tid, params, sig, upd, ctx: ExtensionContext) => {
+			// Let the host derive the tool-error flag from the rejected execution.
+			// AgentToolResult has no portable `isError` field, so converting a bash
+			// failure into a successful-looking result hides the failure from the model.
+			return (await sdkTool.execute(tid, params, sig, upd, ctx)) as Result;
+		}, rememberRejectedBashMetrics),
 
 		renderCall(args: any, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
@@ -65,9 +115,14 @@ export function registerBashTool(
 						? `${rawCmd.slice(0, Math.max(1, headerBudget))}…`
 						: rawCmd;
 			const commandLabel = theme.fg(ctx.isError ? "error" : "toolTitle", theme.bold(`$ ${cmd}`));
-			text.setText(
-				fillToolBackground(`\n${TOOL_RESULT_INDENT}${commandLabel}${t}`, undefined, ctx.expanded ? undefined : tw),
-			);
+			const renderTitle = (suffix = ""): string =>
+				fillToolBackground(
+					`\n${TOOL_RESULT_INDENT}${commandLabel}${t}${suffix}\n`,
+					undefined,
+					ctx.expanded ? undefined : tw,
+				);
+			rememberToolTitle(ctx, text, renderTitle);
+			text.setText(renderTitle());
 			return text;
 		},
 
@@ -75,9 +130,12 @@ export function registerBashTool(
 			resolveBaseBackground(theme);
 
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
+			restoreBashResultRender(ctx, text as ComponentLike);
+			const rejectedMetrics = takeRejectedBashMetrics(ctx);
+			const displayResult = rejectedMetrics ? addRejectedMetrics(result, rejectedMetrics) : result;
 
-			const details = result.details;
-			const tc = getText(result);
+			const details = displayResult.details;
+			const tc = getText(displayResult);
 			const d: BashDetails | undefined =
 				(details as BashDetails)?._type === "bashResult"
 					? (details as BashDetails)
@@ -95,29 +153,37 @@ export function registerBashTool(
 				const cleaned = stripBashExitStatusLine(d.text);
 				const output = isErr ? compactErrorLines(cleaned).join("\n") : cleaned;
 				const lineCount = output.split("\n").length;
-				const info = [`${lineCount} lines`, renderToolDuration(result), !ctx.expanded ? "ctrl+o to expand" : ""]
+				const info = [
+					`${lineCount} lines`,
+					renderToolDuration(displayResult),
+					rejectedMetrics ? formatCharCount(rejectedMetrics.chars) : "",
+					!ctx.expanded ? "ctrl+o to expand" : "",
+				]
 					.filter(Boolean)
 					.map((part) => theme.fg("dim", part))
 					.join(theme.fg("dim", " · "));
 				const header = `${TOOL_RESULT_INDENT}${info}`;
 				const rw = termWidth();
 
+				if (setCollapsedToolTitle(ctx, text, ` ${info}`)) return text;
+
 				const renderFn = (w: number) => {
-					if (!ctx.expanded) return fillToolBackground(`${header}\n`, undefined, w);
-					if (!output.trim()) return fillToolBackground(`${header}\n`, undefined, w);
+					if (!ctx.expanded) return fillToolBody(header, undefined, w);
+					if (!output.trim()) return fillToolBody(header, undefined, w);
 					const show = output.split("\n");
 					const out = [header, "", ...show.map((line: string) => `${TOOL_RESULT_INDENT}${line}`)];
-					return fillToolBackground(`${out.join("\n")}\n`, undefined, w);
+					return fillToolBody(out.join("\n"), undefined, w);
 				};
 
 				text.setText(renderFn(rw));
 				const baseRender =
 					typeof (text as ComponentLike).render === "function" ? (text as ComponentLike).render.bind(text) : null;
 				if (baseRender) {
+					ctx.state[BASH_RESULT_RENDER_KEY] = baseRender;
 					let key: string | undefined;
 					(text as unknown as Record<string, unknown>).render = (w: number) => {
 						const width = Math.max(1, Math.floor(w || termWidth()));
-						const k = `bash:${ctx.expanded ? "1" : "0"}:${width}:${d.exitCode ?? "killed"}:${output.length}:${renderToolDuration(result)}`;
+						const k = `bash:${ctx.expanded ? "1" : "0"}:${width}:${d.exitCode ?? "killed"}:${output.length}:${renderToolDuration(displayResult)}`;
 						if (key !== k) {
 							text.setText(renderFn(width));
 							key = k;
@@ -132,9 +198,9 @@ export function registerBashTool(
 				text.setText(renderToolError(tc || "Error", theme));
 				return text;
 			}
-			const fc = result.content?.[0];
+			const fc = displayResult.content?.[0];
 			text.setText(
-				fillToolBackground(
+				fillToolBody(
 					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
 				),
 			);

package/src/tools/find.ts

@@ -6,7 +6,15 @@ import { BG_ERROR, FG_DIM, RST, resolveBaseBackground, TOOL_RESULT_INDENT } from
 import { isLikelyGlobPattern, normalizeFindGlobPattern } from "../find-glob.js";
 import { shortPath } from "../helpers.js";
 import { NOTICE_PARTIAL_FILE_INDEX } from "../notices.js";
-import { fillToolBackground, renderFindResults, renderToolDuration, renderToolError } from "../render.js";
+import {
+	fillToolBackground,
+	fillToolBody,
+	rememberToolTitle,
+	renderFindResults,
+	renderToolDuration,
+	renderToolError,
+	setCollapsedToolTitle,
+} from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { FffServiceWithCursor, FindDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
@@ -40,6 +48,19 @@ function buildGlobPattern(pattern: string, path: string | undefined, basePath: s
 	return normalized.startsWith("**/") || normalized.includes("/") ? normalized : `**/${normalized}`;
 }
 
+function normalizeSdkFindOutput(text: string): { text: string; matchCount: number; notices: string[] } {
+	const trimmed = text.trim();
+	if (!trimmed || trimmed === "No files found matching pattern") {
+		return { text: "", matchCount: 0, notices: [] };
+	}
+
+	const noticeMatch = /\n\n\[([^\r\n]*)\]\s*$/.exec(text);
+	const body = noticeMatch ? text.slice(0, noticeMatch.index) : text;
+	const notices = noticeMatch ? noticeMatch[1].split(". ").filter(Boolean) : [];
+	const matchCount = body.trim() ? body.trim().split("\n").filter(Boolean).length : 0;
+	return { text: body, matchCount, notices };
+}
+
 async function sdkFindAsFindResult(
 	sdkTool: SdkToolDef,
 	tid: string,
@@ -50,14 +71,14 @@ async function sdkFindAsFindResult(
 	extraNotices: string[],
 ): Promise<Result> {
 	const result = (await sdkTool.execute(tid, params, sig, undefined, ctx)) as Result;
-	const tc = getText(result);
+	const parsed = normalizeSdkFindOutput(getText(result));
 	const prev = (result.details as FindDetails | undefined)?.notices ?? [];
-	const notices = [...(Array.isArray(prev) ? prev : []), ...extraNotices];
+	const notices = [...parsed.notices, ...(Array.isArray(prev) ? prev : []), ...extraNotices];
 	result.details = {
 		_type: "findResult",
-		text: tc,
+		text: parsed.text,
 		pattern,
-		matchCount: tc ? tc.trim().split("\n").filter(Boolean).length : 0,
+		matchCount: parsed.matchCount,
 		notices,
 	};
 	return result;
@@ -150,7 +171,10 @@ export function registerFindTool(
 			const pathPart = theme.fg("toolOutput", pathArg);
 			const limitPart = limit !== undefined && limit !== null ? theme.fg("dim", ` limit ${limit}`) : "";
 			const out = `${findLabel} ${patternPart}${inPart}${pathPart}${limitPart}`;
-			text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}`, ctx.isError ? BG_ERROR : undefined));
+			const renderTitle = (suffix = ""): string =>
+				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+			rememberToolTitle(ctx, text, renderTitle);
+			text.setText(renderTitle());
 			return text;
 		},
 
@@ -165,19 +189,19 @@ export function registerFindTool(
 			const d = r.details as FindDetails | undefined;
 			if (d?._type === "findResult") {
 				if (!d.text.trim()) {
+					const notice = d.notices?.length ? ` ${theme.fg("warning", `[${d.notices.join(". ")}]`)}` : "";
+					if (setCollapsedToolTitle(ctx, text, ` ${FG_DIM}0 files${RST}${notice}`)) return text;
 					const noticeStr = d.notices?.length
 						? `\n${TOOL_RESULT_INDENT}${theme.fg("warning", `[${d.notices.join(". ")}]`)}`
 						: "";
-					text.setText(fillToolBackground(`${TOOL_RESULT_INDENT}${theme.fg("dim", "0 files")}${noticeStr}\n`));
+					text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", "0 files")}${noticeStr}`));
 					return text;
 				}
 				if (!ctx.expanded) {
 					const duration = renderToolDuration(r);
-					text.setText(
-						fillToolBackground(
-							`${TOOL_RESULT_INDENT}${FG_DIM}${d.matchCount} files — ctrl+o to expand${RST}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n`,
-						),
-					);
+					const summary = `${FG_DIM}${d.matchCount} files — ctrl+o to expand${RST}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}`;
+					if (setCollapsedToolTitle(ctx, text, ` ${summary}`)) return text;
+					text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${summary}`));
 					return text;
 				}
 				const rendered = renderFindResults(d.text, theme)
@@ -189,16 +213,14 @@ export function registerFindTool(
 					: "";
 				const duration = renderToolDuration(r);
 				text.setText(
-					fillToolBackground(
-						`${TOOL_RESULT_INDENT}${theme.fg("dim", `${d.matchCount} files`)}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n${rendered}${noticeStr}\n`,
+					fillToolBody(
+						`${TOOL_RESULT_INDENT}${theme.fg("dim", `${d.matchCount} files`)}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n${rendered}${noticeStr}`,
 					),
 				);
 				return text;
 			}
 			const fc = r.content?.[0] as TextContent | undefined;
-			text.setText(
-				fillToolBackground(`${TOOL_RESULT_INDENT}${theme.fg("dim", fc?.text?.slice(0, 120) ?? "0 files")}\n`),
-			);
+			text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", fc?.text?.slice(0, 120) ?? "0 files")}`));
 			return text;
 		},
 	} as unknown as ToolDefinition);

package/src/tools/grep.ts

@@ -5,7 +5,13 @@ import { BG_ERROR, FG_DIM, RST, resolveBaseBackground, TOOL_RESULT_INDENT } from
 import { fffFormatGrepText } from "../fff-helpers.js";
 import { normalizeLineEndings, shortPath } from "../helpers.js";
 import { NOTICE_PARTIAL_FILE_INDEX } from "../notices.js";
-import { fillToolBackground, renderToolError } from "../render.js";
+import {
+	fillToolBackground,
+	fillToolBody,
+	rememberToolTitle,
+	renderToolError,
+	setCollapsedToolTitle,
+} from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { FffServiceWithCursor, GrepDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
@@ -40,7 +46,10 @@ export function registerGrepTool(
 			const limit = typeof p.limit === "number" ? p.limit : 200;
 			const literal = p.literal === true;
 
-			if (fffService?.isAvailable && !path && !glob) {
+			// FFF exposes smart-case, not the SDK's explicit ignoreCase mode.
+			// Fall back when callers request case-insensitive matching so the SDK
+			// remains the semantic source of truth for that option.
+			if (fffService?.isAvailable && !path && !glob && p.ignoreCase !== true) {
 				try {
 					const fff = fffService.getFinder();
 					if (!fff) throw new Error("FFF finder not available");
@@ -48,6 +57,7 @@ export function registerGrepTool(
 					const grepResult = fff.grep(pattern, {
 						pageSize: effectiveLimit,
 						mode: literal ? "plain" : "regex",
+						smartCase: false,
 						beforeContext: context,
 						afterContext: context,
 					});
@@ -68,7 +78,7 @@ export function registerGrepTool(
 							content: [{ type: "text" as const, text }],
 							details: {
 								_type: "grepResult",
-								text,
+								text: items.length > 0 ? text : "",
 								pattern,
 								matchCount: items.length,
 							} as GrepDetails,
@@ -88,11 +98,12 @@ export function registerGrepTool(
 					.filter((c) => c.type === "text")
 					.map((c) => c.text)
 					.join("\n") ?? "";
+			const normalizedText = tc.trim() === "No matches found" ? "" : tc;
 			result.details = {
 				_type: "grepResult",
-				text: tc,
+				text: normalizedText,
 				pattern,
-				matchCount: tc ? tc.trim().split("\n").filter(Boolean).length : 0,
+				matchCount: normalizedText ? normalizedText.trim().split("\n").filter(Boolean).length : 0,
 			} as GrepDetails;
 			return result;
 		}),
@@ -111,7 +122,10 @@ export function registerGrepTool(
 			if (limit !== undefined && limit !== null) out += theme.fg("dim", ` limit ${limit}`);
 			if (literal) out += theme.fg("dim", ` (literal)`);
 			if (caseInsensitive) out += theme.fg("dim", ` (case-insensitive)`);
-			text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}`, ctx.isError ? BG_ERROR : undefined));
+			const renderTitle = (suffix = ""): string =>
+				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+			rememberToolTitle(ctx, text, renderTitle);
+			text.setText(renderTitle());
 			return text;
 		},
 
@@ -134,12 +148,9 @@ export function registerGrepTool(
 			if (d?._type === "grepResult" && d.text) {
 				const lines = d.text.split("\n");
 				if (!ctx.expanded) {
-					text.setText(
-						fillToolBackground(
-							`${TOOL_RESULT_INDENT}${FG_DIM}${lines.length} lines — ctrl+o to expand${RST}\n`,
-							ctx.isError ? BG_ERROR : undefined,
-						),
-					);
+					const summary = `${FG_DIM}${lines.length} lines — ctrl+o to expand${RST}`;
+					if (setCollapsedToolTitle(ctx, text, ` ${summary}`)) return text;
+					text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${summary}`, ctx.isError ? BG_ERROR : undefined));
 					return text;
 				}
 				const maxShow = lines.length;
@@ -153,14 +164,14 @@ export function registerGrepTool(
 				if (remaining > 0) {
 					out.push(theme.fg("muted", `… (${remaining} more ${remaining === 1 ? "line" : "lines"}, to expand)`));
 				}
-				const body = `${out.map((l) => `${TOOL_RESULT_INDENT}${l}`).join("\n")}\n\n`;
-				text.setText(fillToolBackground(body, ctx.isError ? BG_ERROR : undefined));
+				const body = out.map((l) => `${TOOL_RESULT_INDENT}${l}`).join("\n");
+				text.setText(fillToolBody(body, ctx.isError ? BG_ERROR : undefined));
 				return text;
 			}
 			const fc = result.content?.[0];
 			const fallback = fc && "text" in fc ? String(fc.text).slice(0, 120) : "no matches";
 			text.setText(
-				fillToolBackground(`${TOOL_RESULT_INDENT}${theme.fg("dim", fallback)}`, ctx.isError ? BG_ERROR : undefined),
+				fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", fallback)}`, ctx.isError ? BG_ERROR : undefined),
 			);
 			return text;
 		},

package/src/tools/ls.ts

@@ -3,7 +3,15 @@
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { BG_ERROR, FG_DIM, RST, resolveBaseBackground, TOOL_RESULT_INDENT } from "../config.js";
 import { shortPath } from "../helpers.js";
-import { fillToolBackground, renderToolError, renderToolMetrics, renderTree } from "../render.js";
+import {
+	fillToolBackground,
+	fillToolBody,
+	rememberToolTitle,
+	renderToolError,
+	renderToolMetrics,
+	renderTree,
+	setCollapsedToolTitle,
+} from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { LsDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
 import { wrapExecuteWithMetrics } from "./metrics.js";
@@ -25,6 +33,7 @@ export function registerLsTool(
 		label: "List",
 		description: sdkTool.description ?? "List directory contents",
 		parameters: sdkTool.parameters,
+		promptSnippet: sdkTool.promptSnippet,
 		renderShell: "self",
 
 		execute: wrapExecuteWithMetrics(async (tid, params, sig, _upd, ctx: ExtensionContext) => {
@@ -51,7 +60,10 @@ export function registerLsTool(
 			let out = theme.fg("toolTitle", theme.bold("ls"));
 			if (path) out += ` ${theme.fg("accent", path)}`;
 			if (limit !== undefined && limit !== null) out += theme.fg("toolOutput", ` (limit ${limit})`);
-			text.setText(fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}`, ctx.isError ? BG_ERROR : undefined));
+			const renderTitle = (suffix = ""): string =>
+				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+			rememberToolTitle(ctx, text, renderTitle);
+			text.setText(renderTitle());
 			return text;
 		},
 
@@ -66,11 +78,9 @@ export function registerLsTool(
 			const d = result.details as LsDetails | undefined;
 			if (d?._type === "lsResult" && d.text) {
 				if (!ctx.expanded) {
-					text.setText(
-						fillToolBackground(
-							`${TOOL_RESULT_INDENT}${FG_DIM}${d.entryCount} entries — ctrl+o to expand${RST}${renderToolMetrics(result)}\n`,
-						),
-					);
+					const summary = `${FG_DIM}${d.entryCount} entries — ctrl+o to expand${RST}${renderToolMetrics(result)}`;
+					if (setCollapsedToolTitle(ctx, text, ` ${summary}`)) return text;
+					text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${summary}`));
 					return text;
 				}
 				const rendered = renderTree(d.text, d.path)
@@ -78,15 +88,15 @@ export function registerLsTool(
 					.map((l) => `${TOOL_RESULT_INDENT}${l}`)
 					.join("\n");
 				text.setText(
-					fillToolBackground(
-						`${TOOL_RESULT_INDENT}${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result)}\n${rendered}\n`,
+					fillToolBody(
+						`${TOOL_RESULT_INDENT}${FG_DIM}${d.entryCount} entries${RST}${renderToolMetrics(result)}\n${rendered}`,
 					),
 				);
 				return text;
 			}
 			const fc = result.content?.[0];
 			text.setText(
-				fillToolBackground(
+				fillToolBody(
 					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
 				),
 			);

package/src/tools/metrics.ts

@@ -15,19 +15,39 @@ type ExecuteFn = (
 	ctx: ExtensionContext,
 ) => Promise<AgentToolResult<Record<string, unknown>>>;
 
-export function wrapExecuteWithMetrics(execute: ExecuteFn): ExecuteFn {
+export interface RejectedExecutionMetrics {
+	elapsedMs: number;
+	chars: number;
+}
+
+export type RejectedExecutionHandler = (toolCallId: string, metrics: RejectedExecutionMetrics) => void;
+
+export function wrapExecuteWithMetrics(execute: ExecuteFn, onRejected?: RejectedExecutionHandler): ExecuteFn {
 	return async (tid, params, sig, upd, ctx) => {
 		const start = performance.now();
-		const result = await execute(tid, params, sig, upd, ctx);
-		const elapsedMs = performance.now() - start;
-		const details = (result.details ?? {}) as Record<string, unknown>;
-		details[ELAPSED_KEY] = elapsedMs;
-		details[CHARS_KEY] = getOutputCharCount(result);
-		(result as { details: Record<string, unknown> }).details = details;
-		return result;
+		try {
+			const result = await execute(tid, params, sig, upd, ctx);
+			const elapsedMs = performance.now() - start;
+			const details = (result.details ?? {}) as Record<string, unknown>;
+			details[ELAPSED_KEY] = elapsedMs;
+			details[CHARS_KEY] = getOutputCharCount(result);
+			(result as { details: Record<string, unknown> }).details = details;
+			return result;
+		} catch (error) {
+			onRejected?.(tid, {
+				elapsedMs: performance.now() - start,
+				chars: getErrorCharCount(error),
+			});
+			throw error;
+		}
 	};
 }
 
+function getErrorCharCount(error: unknown): number {
+	const text = error instanceof Error ? error.message : String(error);
+	return text.replace(/\r/g, "").length;
+}
+
 function getOutputCharCount(result: AgentToolResult<unknown>): number {
 	const content = result.content;
 	if (!Array.isArray(content)) return 0;