@heyhuynhgiabuu/pi-pretty 0.6.25 → 0.6.27

package/src/index.ts

@@ -15,13 +15,22 @@ import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
 	ExtensionContext,
+	MessageEndEvent,
 	MessageUpdateEvent,
 	SessionInfoChangedEvent,
 } from "@earendil-works/pi-coding-agent";
 import * as hostSdk from "@earendil-works/pi-coding-agent";
 import { createFffAutocompleteProvider } from "./autocomplete.js";
-import { applyConfig, getDefaultAgentDir, loadConfig, normalizeToolList, resolveToolSets } from "./config.js";
-import { type FffService, getSharedFffService } from "./fff.js";
+import {
+	applyConfig,
+	getDefaultAgentDir,
+	loadConfig,
+	normalizeToolList,
+	resolveFffScanSettings,
+	resolveToolSets,
+} from "./config.js";
+import { type FffInitOptions, type FffService, getSharedFffService, isFffRestrictedBasePathError } from "./fff.js";
+import { createPromptEditorClass } from "./prompt-editor.js";
 import { registerBashTool } from "./tools/bash.js";
 import { registerFindTool } from "./tools/find.js";
 import { registerGrepTool } from "./tools/grep.js";
@@ -30,10 +39,13 @@ import { registerReadTool } from "./tools/read.js";
 import type { PiPrettyDeps, SdkTools } from "./types.js";
 import {
 	createThinkingLabelAnimator,
+	createThinkingTimer,
+	installPerRowThinkingLabels,
 	installWorkingIndicator,
+	type PerRowThinkingLabels,
 	resolveThinkingIndicatorSettings,
 	resolveWorkingIndicatorSettings,
-	type ThinkingLabelAnimator,
+	type ThinkingTimer,
 	thinkingBlockActive,
 	WORKING_INTERVAL_MS,
 	type WorkingIndicatorController,
@@ -44,6 +56,12 @@ import {
 // ---------------------------------------------------------------------------
 
 const DEFAULT_DISABLED_TOOLS = new Set(["ls"]);
+const USER_MESSAGE_ICON = "❯";
+type EditorFactory = Parameters<ExtensionContext["ui"]["setEditorComponent"]>[0];
+type EditorUiCompatibility = {
+	setEditorComponent?: (factory: EditorFactory) => void;
+	getEditorComponent?: () => EditorFactory;
+};
 
 function envTools(name: "PRETTY_DISABLE_TOOLS" | "PRETTY_ENABLE_TOOLS"): Set<string> {
 	return new Set(normalizeToolList((process.env[name] ?? "").split(",")));
@@ -58,6 +76,26 @@ export type { PiPrettyDeps };
 export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrettyDeps): Promise<void> {
 	const config = loadConfig();
 	applyConfig(config);
+	pi.registerMarkdownTransformer?.((markdown, context) => {
+		if (context.messageType !== "user" || markdown.trim() === "") return markdown;
+		return ` ${USER_MESSAGE_ICON} ${markdown}`;
+	});
+	pi.registerFlag?.("pretty-fff-home-scan", {
+		description: "Allow FFF to index the home directory when Pi starts there",
+		type: "boolean",
+	});
+	pi.registerFlag?.("pretty-fff-root-scan", {
+		description: "Allow FFF to index the filesystem root when Pi starts there",
+		type: "boolean",
+	});
+	const fffScanSettings = resolveFffScanSettings(config, {
+		enableHomeScanning: pi.getFlag?.("pretty-fff-home-scan"),
+		enableRootScanning: pi.getFlag?.("pretty-fff-root-scan"),
+	});
+	const fffInitOptions: FffInitOptions = {
+		enableHomeDirScanning: fffScanSettings.enableHomeScanning,
+		enableFsRootScanning: fffScanSettings.enableRootScanning,
+	};
 	const { disabledTools, enabledTools } = resolveToolSets(
 		envTools("PRETTY_DISABLE_TOOLS"),
 		envTools("PRETTY_ENABLE_TOOLS"),
@@ -160,13 +198,41 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	const workingSettings = resolveWorkingIndicatorSettings(config.workingIndicator);
 	const thinkingSettings = resolveThinkingIndicatorSettings(config.thinkingIndicator);
 	let workingController: WorkingIndicatorController | undefined;
-	let thinkingAnimator: ThinkingLabelAnimator | undefined;
+	let thinkingTimer: ThinkingTimer | undefined;
 	let thinkingInterval: ReturnType<typeof setInterval> | undefined;
 	let thinkingLastMessage: unknown;
-	let thinkingHiddenCache = true;
 	let thinkingHiddenCheckedAt = 0;
 	let workingSessionName: string | undefined;
 	let workingStreaming = false;
+	let promptEditorInstalled = false;
+	let previousEditorFactory: EditorFactory;
+	const hostCustomEditor =
+		deps?.customEditorClass ??
+		(hostSdk as unknown as { CustomEditor?: PiPrettyDeps["customEditorClass"] }).CustomEditor;
+	const installPromptEditor = (ctx: ExtensionContext): void => {
+		if (ctx.mode !== "tui" || promptEditorInstalled || typeof hostCustomEditor !== "function") return;
+		const editorUi = ctx.ui as unknown as EditorUiCompatibility;
+		if (typeof editorUi.setEditorComponent !== "function") return;
+		previousEditorFactory = editorUi.getEditorComponent?.();
+		const PromptEditor = createPromptEditorClass(hostCustomEditor, (icon) => {
+			const theme = ctx.ui.theme;
+			return typeof theme.getThinkingBorderColor === "function"
+				? theme.getThinkingBorderColor(ctx.thinkingLevel ?? "off")(icon)
+				: theme.fg("thinkingText", icon);
+		});
+		editorUi.setEditorComponent((tui, theme, keybindings) => new PromptEditor(tui, theme, keybindings));
+		promptEditorInstalled = true;
+	};
+	let perRowLabels: PerRowThinkingLabels | undefined;
+	/** Accumulated thinking time per message timestamp — later runs in the same
+	 * message resume from this total instead of rewinding to zero. */
+	const thinkingElapsedMs = new Map<number, number>();
+
+	/** Message timestamps are the per-row identity the label patch keys on. */
+	const messageTimestamp = (message: unknown): number | undefined => {
+		const ts = (message as { timestamp?: unknown } | undefined)?.timestamp;
+		return typeof ts === "number" ? ts : undefined;
+	};
 
 	/** pi persists the thinking-visibility toggle as a top-level settings key. */
 	const thinkingHidden = (): boolean => {
@@ -182,6 +248,17 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 		}
 	};
 
+	/**
+	 * True when the 500ms-cached hidden check is stale and settings now show
+	 * thinking revealed — the single re-check shared by the ticker and the
+	 * completed-phase message_update path (timestamp guard runs before the read).
+	 */
+	const thinkingRevealed = (): boolean => {
+		if (Date.now() - thinkingHiddenCheckedAt <= 500) return false;
+		thinkingHiddenCheckedAt = Date.now();
+		return !thinkingHidden();
+	};
+
 	const safeSessionName = (ctx: ExtensionContext): string | undefined => {
 		try {
 			return ctx.sessionManager?.getSessionName?.() ?? undefined;
@@ -190,8 +267,8 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 		}
 	};
 
-	// (Re-)install the widget: new session, reload, or session rename (the
-	// accent tint tracks the name, omp-style). Preserves streaming state so a
+	// (Re-)install the working indicator: new session, reload, or session rename
+	// (the accent tint tracks the name, omp-style). Preserves streaming state so a
 	// mid-stream rename does not drop the row.
 	const installIndicator = async (ctx: ExtensionContext): Promise<void> => {
 		workingController?.dispose();
@@ -217,7 +294,17 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 
 	pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
 		if (ctx.mode === "tui") {
+			installPromptEditor(ctx);
 			ctx.ui.setToolsExpanded(false);
+			// Per-row hidden-thinking labels: intercept the host's label fan-out so
+			// each row keeps its own duration. Falls back to the global-label
+			// behavior whenever the host class is missing or reshaped.
+			perRowLabels = thinkingSettings.enabled
+				? installPerRowThinkingLabels(
+						deps?.assistantMessageComponent ??
+							(hostSdk as { AssistantMessageComponent?: unknown }).AssistantMessageComponent,
+					)
+				: undefined;
 			workingSessionName = safeSessionName(ctx);
 			await installIndicator(ctx);
 		}
@@ -231,7 +318,7 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 				if (!loaded) return;
 			}
 
-			await fffService.ensureFinder(ctx.cwd);
+			await fffService.ensureFinder(ctx.cwd, fffInitOptions);
 			if (fffService.partialIndex) {
 				ctx.ui?.notify?.("FFF: scan timed out — using partial index. Run /fff-rescan when ready.", "warning");
 			} else {
@@ -245,7 +332,10 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 				createFffAutocompleteProvider(current, () => fffService?.getFinder() ?? null),
 			);
 		} catch (error: unknown) {
-			ctx.ui?.notify?.(`FFF init failed: ${error instanceof Error ? error.message : String(error)}`, "error");
+			// Root/home refusal is an intentional FFF safety boundary. FFF is an
+			// accelerator, so fall back to the SDK without interrupting startup.
+			if (isFffRestrictedBasePathError(error, fffInitOptions)) return;
+			ctx.ui?.notify?.(`FFF init failed: ${error instanceof Error ? error.message : String(error)}`, "warning");
 		}
 	});
 
@@ -258,7 +348,7 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 		if (workingSettings.enabled) await installIndicator(ctx);
 	});
 
-	// Drive the widget with the streaming lifecycle (host loader is hidden).
+	// Drive the working indicator with the streaming lifecycle (the host row is hidden until agent_start).
 	pi.on("agent_start", async (_event: unknown, ctx: ExtensionContext) => {
 		if (ctx.mode !== "tui") return;
 		workingStreaming = true;
@@ -273,77 +363,147 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	pi.on("agent_end", stopStreaming);
 	pi.on("agent_settled", stopStreaming);
 
+	const clearThinkingInterval = (): void => {
+		if (!thinkingInterval) return;
+		clearInterval(thinkingInterval);
+		thinkingInterval = undefined;
+	};
+
 	const stopThinkingShimmer = (): void => {
-		if (thinkingInterval) {
-			clearInterval(thinkingInterval);
-			thinkingInterval = undefined;
+		clearThinkingInterval();
+		perRowLabels?.clearActive();
+		try {
+			thinkingTimer?.restore();
+		} catch {
+			// Teardown must never throw — a host that explodes on restore is left
+			// with whatever label it has; the interval is already gone.
+		}
+		thinkingTimer = undefined;
+		thinkingLastMessage = undefined;
+	};
+
+	const completeThinkingShimmer = (): void => {
+		clearThinkingInterval();
+		const ts = messageTimestamp(thinkingLastMessage);
+		const frozenMs = thinkingTimer?.complete();
+		if (ts !== undefined && frozenMs !== undefined) {
+			thinkingElapsedMs.set(ts, frozenMs);
+			perRowLabels?.complete(ts, frozenMs);
 		}
-		thinkingAnimator?.restore();
-		thinkingAnimator = undefined;
+		// The completed row is no longer the animating one — drop the active mark
+		// so subsequent global writes freeze it at its own duration.
+		perRowLabels?.clearActive();
 		thinkingLastMessage = undefined;
 	};
 
+	/** Surface one warning without letting a throwing host escape the crash guard. */
+	const notifyThinkingFailure = (ctx: ExtensionContext, error: unknown): void => {
+		try {
+			ctx.ui?.notify?.(
+				`pi-pretty thinking indicator failed: ${error instanceof Error ? error.message : String(error)}`,
+				"warning",
+			);
+		} catch {
+			// A host that throws on notify too must not crash the timer path.
+		}
+	};
+
 	// Same 30fps cadence as the working row — but the interval lives ONLY while
 	// the streaming message is actively emitting a thinking block (each label
 	// change rebuilds chat children, so the moment text or tool calls stream the
-	// shimmer stops and pi's default label is restored).
+	// label freezes as `Thought for {duration}` until the run ends).
 	const startThinkingShimmer = (ctx: ExtensionContext): void => {
 		if (thinkingInterval || !thinkingSettings.enabled) return;
 		try {
-			thinkingAnimator = createThinkingLabelAnimator(ctx.ui, workingSettings, workingSessionName, thinkingSettings);
-			thinkingHiddenCache = thinkingHidden();
 			thinkingHiddenCheckedAt = Date.now();
-			if (!thinkingHiddenCache) {
-				stopThinkingShimmer();
-				return;
-			}
-			thinkingAnimator.tick();
+			if (!thinkingHidden()) return; // thinking visible: no label writes at all
+			const animator = createThinkingLabelAnimator(ctx.ui, workingSettings, workingSessionName, thinkingSettings);
+			const activeTs = messageTimestamp(thinkingLastMessage);
+			// Same message thinking again (interleaved runs): resume its total.
+			const resumeMs = activeTs !== undefined ? (thinkingElapsedMs.get(activeTs) ?? 0) : 0;
+			thinkingTimer = createThinkingTimer(animator, Date.now, resumeMs);
+			if (activeTs !== undefined) perRowLabels?.setActive(activeTs);
+			thinkingTimer.tick();
 			thinkingInterval = setInterval(() => {
-				if (!workingStreaming) {
-					stopThinkingShimmer();
-					return;
-				}
-				const now = Date.now();
-				if (now - thinkingHiddenCheckedAt > 500) {
-					thinkingHiddenCache = thinkingHidden();
-					thinkingHiddenCheckedAt = now;
-					if (!thinkingHiddenCache) {
+				try {
+					if (!workingStreaming) {
 						stopThinkingShimmer();
 						return;
 					}
-				}
-				if (!thinkingBlockActive(thinkingLastMessage)) {
-					// Thinking phase over: restore pi's default label and stop.
+					if (thinkingRevealed()) {
+						stopThinkingShimmer();
+						return;
+					}
+					if (!thinkingBlockActive(thinkingLastMessage)) {
+						// Thinking phase over: freeze its duration until the run ends.
+						completeThinkingShimmer();
+						return;
+					}
+					thinkingTimer?.tick();
+					// The label has no widget of its own — ask the working indicator to
+					// request a host render even when deltas pause mid-thinking.
+					workingController?.requestRender();
+				} catch (error: unknown) {
+					// A throwing host call inside our timer would crash pi (uncaught in
+					// setInterval) — tear the label down and surface one warning instead.
 					stopThinkingShimmer();
-					return;
+					notifyThinkingFailure(ctx, error);
 				}
-				thinkingAnimator?.tick();
 			}, WORKING_INTERVAL_MS);
 		} catch (error: unknown) {
 			stopThinkingShimmer();
-			ctx.ui?.notify?.(
-				`pi-pretty thinking indicator failed: ${error instanceof Error ? error.message : String(error)}`,
-				"warning",
-			);
+			notifyThinkingFailure(ctx, error);
 		}
 	};
 
 	// Remember the streaming message; lazily start the shimmer on the first
-	// thinking delta (thinkingHidden() is re-checked at most every 500ms).
+	// thinking delta (thinkingHidden() is re-checked at most every 500ms). After
+	// the phase completes, deltas keep refreshing the visibility cache so a
+	// mid-run `hideThinkingBlock` toggle-off restores the default label.
 	pi.on("message_update", async (event: MessageUpdateEvent, ctx: ExtensionContext) => {
 		if (ctx.mode !== "tui" || !workingStreaming) return;
 		thinkingLastMessage = event.message;
-		if (thinkingInterval) return;
-		if (!thinkingBlockActive(event.message)) return;
-		startThinkingShimmer(ctx);
+		if (thinkingInterval) {
+			// Complete immediately on the first text/tool delta instead of waiting
+			// for the next animation frame.
+			if (!thinkingBlockActive(event.message)) completeThinkingShimmer();
+			return;
+		}
+		if (thinkingBlockActive(event.message)) {
+			// First thinking delta — or a later phase after tool calls — starts a
+			// fresh timer (the completed one is replaced wholesale).
+			startThinkingShimmer(ctx);
+			return;
+		}
+		if (thinkingTimer && thinkingRevealed()) stopThinkingShimmer();
+	});
+
+	// The completed wording belongs to the message that produced it. The label
+	// is global, so once that assistant message ends, restore pi's default —
+	// otherwise every later phase stamps its frozen duration onto every hidden
+	// thinking row in the transcript (the image-read " Thought for 5s" stack).
+	pi.on("message_end", async (event: MessageEndEvent, ctx: ExtensionContext) => {
+		if (ctx.mode !== "tui" || event.message.role !== "assistant") return;
+		if (thinkingInterval || thinkingTimer) stopThinkingShimmer();
 	});
 
-	pi.on("session_shutdown", async () => {
-		// Tear down the widget animation; pi re-runs session_start (and our
+	pi.on("session_shutdown", async (_event: unknown, ctx?: ExtensionContext) => {
+		if (promptEditorInstalled) {
+			if (ctx) {
+				const editorUi = ctx.ui as unknown as EditorUiCompatibility;
+				if (typeof editorUi.setEditorComponent === "function") editorUi.setEditorComponent(previousEditorFactory);
+			}
+			promptEditorInstalled = false;
+			previousEditorFactory = undefined;
+		}
+		// Tear down the indicator animation; pi re-runs session_start (and our
 		// install) after resume or session switching.
 		workingController?.dispose();
 		workingController = undefined;
 		stopThinkingShimmer();
+		perRowLabels?.uninstall();
+		perRowLabels = undefined;
+		thinkingElapsedMs.clear();
 		workingStreaming = false;
 		// Intentionally keep the native FFF finder on session shutdown.
 		// Pi can emit shutdown/start during resume or session switching while the

package/src/prompt-editor.ts

@@ -0,0 +1,102 @@
+import type { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { sliceByColumn, visibleWidth } from "@earendil-works/pi-tui";
+
+/** Constructor shape used to preserve compatibility with older Pi hosts. */
+export type CustomEditorConstructor = new (...args: ConstructorParameters<typeof CustomEditor>) => CustomEditor;
+
+type PromptColor = (text: string) => string;
+
+const PROMPT_ICON = "❯";
+const PROMPT_WIDTH = 3; // one space on either side of the icon
+
+/**
+ * Build a CustomEditor subclass that reserves room for, and renders, the
+ * user-message prompt. The host still owns all editing and app keybindings.
+ */
+export function createPromptEditorClass(
+	Base: CustomEditorConstructor,
+	colorPrompt: PromptColor,
+): CustomEditorConstructor {
+	const basePrototype = Base.prototype as unknown as {
+		renderTopBorder?: unknown;
+		renderBottomBorder?: unknown;
+	};
+	const supportsBorderHooks =
+		typeof basePrototype.renderTopBorder === "function" && typeof basePrototype.renderBottomBorder === "function";
+
+	class PromptEditor extends Base {
+		private userPaddingX = 0;
+		private isScrolled = false;
+		private bottomBorderLine = "";
+
+		constructor(...args: ConstructorParameters<CustomEditorConstructor>) {
+			const [tui, theme, keybindings, options] = args;
+			super(tui, theme, keybindings, { ...(options ?? {}), embedWorkingStatus: true });
+			this.userPaddingX = super.getPaddingX();
+			super.setPaddingX(this.userPaddingX + this.promptWidth());
+		}
+
+		private promptWidth(): number {
+			// At zero user padding, reserve one extra column so the border leaves
+			// the same visible gap before the icon as padded editors.
+			return PROMPT_WIDTH + (supportsBorderHooks && this.userPaddingX === 0 ? 1 : 0);
+		}
+
+		override getPaddingX(): number {
+			return this.userPaddingX;
+		}
+
+		override setPaddingX(padding: number): void {
+			this.userPaddingX = Math.max(0, padding);
+			super.setPaddingX(this.userPaddingX + this.promptWidth());
+		}
+
+		protected override renderTopBorder(width: number, hiddenLineCount: number): string {
+			this.isScrolled = hiddenLineCount > 0;
+			return this.roundBorder(super.renderTopBorder(width, hiddenLineCount), width, "╭", "╮");
+		}
+
+		protected override renderBottomBorder(width: number, hiddenLineCount: number): string {
+			this.bottomBorderLine = this.roundBorder(super.renderBottomBorder(width, hiddenLineCount), width, "╰", "╯");
+			return this.bottomBorderLine;
+		}
+
+		private roundBorder(line: string, width: number, left: string, right: string): string {
+			if (width < 2 || visibleWidth(line) !== width) return line;
+			return `${this.borderColor(left)}${sliceByColumn(line, 1, width - 2, true)}${this.borderColor(right)}`;
+		}
+
+		override render(width: number): string[] {
+			this.bottomBorderLine = "";
+			const lines = super.render(width);
+			if (lines.length < 2) return lines;
+
+			if (!this.isScrolled) {
+				const firstContentLine = lines[1];
+				if (firstContentLine) {
+					const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
+					const promptPadding = Math.min(this.userPaddingX + this.promptWidth(), maxPadding);
+					if (promptPadding >= PROMPT_WIDTH && firstContentLine.startsWith(" ".repeat(promptPadding))) {
+						const promptStart = promptPadding - PROMPT_WIDTH;
+						const prompt = ` ${colorPrompt(PROMPT_ICON)} `;
+						lines[1] = `${firstContentLine.slice(0, promptStart)}${prompt}${firstContentLine.slice(promptPadding)}`;
+					}
+				}
+			}
+
+			if (!supportsBorderHooks || !this.bottomBorderLine) return lines;
+
+			const bottomBorderIndex = lines.lastIndexOf(this.bottomBorderLine);
+			const contentEnd = bottomBorderIndex > 0 ? bottomBorderIndex : lines.length - 1;
+			for (let i = 1; i < contentEnd; i++) {
+				const line = lines[i];
+				if (!line || visibleWidth(line) !== width || !line.startsWith(" ") || !line.endsWith(" ")) continue;
+				lines[i] = `${this.borderColor("│")}${line.slice(1, -1)}${this.borderColor("│")}`;
+			}
+
+			return lines;
+		}
+	}
+
+	return PromptEditor;
+}

package/src/render.ts

@@ -39,12 +39,7 @@ import {
 	formatElapsedMs,
 	normalizeLineEndings,
 } from "./helpers.js";
-import type { RenderCtxLike as RenderContext, ThemeLike } from "./types.js";
-
-/** Thin wrapper over pi-tui's truncateToWidth (imported at top level above). */
-function _truncateToWidth(text: string, maxWidth: number, ellipsis?: string, pad?: boolean): string {
-	return truncateToWidth(text, maxWidth, ellipsis, pad);
-}
+import type { RenderCtxLike as RenderContext, TextLike, ThemeLike } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Shiki ANSI cache
@@ -215,13 +210,37 @@ export function fillToolBackground(text: string, bg = BG_BASE, width?: number):
 			}
 			const plainLead = line.replace(ANSI_CAPTURE_RE, "");
 			const skipPad = line.startsWith(TOOL_RESULT_INDENT) || plainLead.startsWith(TOOL_RESULT_INDENT);
-			const fitted = _truncateToWidth(line, width, "", !skipPad);
+			const fitted = truncateToWidth(line, width, "", !skipPad);
 			const stripped = preserveBoxBackground(fitted);
 			return bg ? bg + stripped : stripped;
 		})
 		.join("\n");
 }
 
+/** Add exactly the missing terminal row after a rendered tool body. */
+export function fillToolBody(text: string, bg = BG_BASE, width?: number): string {
+	return fillToolBackground(text.endsWith("\n") ? text : `${text}\n`, bg, width);
+}
+
+const TOOL_TITLE_STATE_KEY = "__piPrettyToolTitle";
+type ToolTitleRenderer = (suffix?: string) => string;
+type ToolTitleState = { component: TextLike; render: ToolTitleRenderer };
+
+/** Keep a self-rendered tool's call title mutable while its result arrives. */
+export function rememberToolTitle(ctx: RenderContext, component: TextLike, render: ToolTitleRenderer): void {
+	ctx.state[TOOL_TITLE_STATE_KEY] = { component, render } satisfies ToolTitleState;
+}
+
+/** Move collapsed result metadata into the call title and hide the result slot. */
+export function setCollapsedToolTitle(ctx: RenderContext, result: TextLike, suffix: string): boolean {
+	if (ctx.expanded) return false;
+	const title = ctx.state[TOOL_TITLE_STATE_KEY] as ToolTitleState | undefined;
+	if (!title || typeof title.render !== "function") return false;
+	title.component.setText(title.render(suffix));
+	result.setText("");
+	return true;
+}
+
 function lnum(n: number, w: number): string {
 	const v = String(n);
 	return `${FG_LNUM}${" ".repeat(Math.max(0, w - v.length))}${v}${RST}`;
@@ -253,7 +272,7 @@ export function renderToolError(error: string, theme: ThemeLike): string {
 	const body = compactErrorLines(error)
 		.map((line) => `${TOOL_RESULT_INDENT}${line ? theme.fg("error", line) : ""}`)
 		.join("\n");
-	return fillToolBackground(body, BG_ERROR);
+	return fillToolBody(body, BG_ERROR);
 }
 
 // ---------------------------------------------------------------------------
@@ -277,7 +296,7 @@ export async function renderFileContent(
 
 	const out: string[] = [];
 	for (const line of hl) {
-		out.push(_truncateToWidth(line ?? "", Math.max(1, tw), `${FG_DIM}›`));
+		out.push(truncateToWidth(line ?? "", Math.max(1, tw), `${FG_DIM}›`));
 	}
 	return out.join("\n");
 }
@@ -448,14 +467,14 @@ export function makeRenderResult() {
 			const more = lines.length > maxShow ? `\n${FG_DIM}... ${lines.length - maxShow} more lines${RST}` : "";
 			const metrics = renderToolMetrics(result);
 			text.setText(
-				fillToolBackground(
+				fillToolBody(
 					`${TOOL_RESULT_INDENT}${preview}${more}${metrics ? `\n${TOOL_RESULT_INDENT}${metrics}` : ""}`,
 					undefined,
 					renderWidth,
 				),
 			);
 		} else {
-			text.setText(fillToolBackground(`${TOOL_RESULT_INDENT}${theme.fg("dim", "(no text output)")}`));
+			text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", "(no text output)")}`));
 		}
 		return text;
 	};