@heyhuynhgiabuu/pi-pretty 0.6.26 → 0.6.27

package/src/fff.ts

@@ -6,11 +6,44 @@
  * Graceful fallback: if FFF is not installed or fails, tools degrade to SDK.
  */
 
-import { mkdirSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, parse, resolve } from "node:path";
 
 import type { FileFinder as FffFileFinder, GrepCursor } from "@ff-labs/fff-node";
 
+export interface FffInitOptions {
+	enableHomeDirScanning: boolean;
+	enableFsRootScanning: boolean;
+}
+
+export type FffInitFailureKind = "restricted-base-path" | "native";
+export type FffRestrictedScanScope = "home" | "root";
+
+export class FffInitError extends Error {
+	readonly kind: FffInitFailureKind;
+	readonly restrictedScope: FffRestrictedScanScope | undefined;
+
+	constructor(kind: FffInitFailureKind, message: string, restrictedScope?: FffRestrictedScanScope) {
+		super(message);
+		this.name = "FffInitError";
+		this.kind = kind;
+		this.restrictedScope = restrictedScope;
+	}
+}
+
+export function isFffRestrictedBasePathError(error: unknown, options: FffInitOptions): boolean {
+	if (!(error instanceof FffInitError) || error.kind !== "restricted-base-path") return false;
+	if (error.restrictedScope === "home") return !options.enableHomeDirScanning;
+	if (error.restrictedScope === "root") return !options.enableFsRootScanning;
+	return false;
+}
+
+const DEFAULT_FFF_INIT_OPTIONS: FffInitOptions = {
+	enableHomeDirScanning: false,
+	enableFsRootScanning: false,
+};
+
 // ---------------------------------------------------------------------------
 // Cursor store — pagination cursors for grep
 // ---------------------------------------------------------------------------
@@ -53,6 +86,12 @@ type SharedFffState = {
 	service: FffService;
 };
 
+type FinderConfig = {
+	basePath: string;
+	enableHomeDirScanning: boolean;
+	enableFsRootScanning: boolean;
+};
+
 type GlobalWithFffService = typeof globalThis & {
 	[SHARED_FFF_SERVICE_KEY]?: SharedFffState;
 };
@@ -83,7 +122,9 @@ export class FffService {
 
 	private fffModule: typeof import("@ff-labs/fff-node") | null = null;
 	private dbDir: string | null = null;
+	private finderConfig: FinderConfig | null = null;
 	private finderPromise: Promise<void> | null = null;
+	private finderPromiseConfig: FinderConfig | null = null;
 
 	constructor(fffModule?: typeof import("@ff-labs/fff-node"), agentDir?: string) {
 		this.configure(fffModule, agentDir);
@@ -130,47 +171,97 @@ export class FffService {
 		}
 	}
 
-	async ensureFinder(cwd: string): Promise<void> {
-		if (this.finder && !this.finder.isDestroyed) return;
-		if (this.finderPromise) return this.finderPromise;
+	async ensureFinder(cwd: string, options: FffInitOptions = DEFAULT_FFF_INIT_OPTIONS): Promise<void> {
+		const requestedConfig = finderConfig(cwd, options);
 
-		const promise = this._createFinder(cwd);
-		this.finderPromise = promise;
-		try {
-			await promise;
-		} finally {
-			if (this.finderPromise === promise) this.finderPromise = null;
+		for (;;) {
+			if (this.finder && !this.finder.isDestroyed && sameFinderConfig(this.finderConfig, requestedConfig)) return;
+
+			const pending = this.finderPromise;
+			if (pending) {
+				const pendingConfig = this.finderPromiseConfig;
+				try {
+					await pending;
+				} catch (error) {
+					// A concurrent request for the same scope must observe the same
+					// failure. A different scope can retry after the pending attempt.
+					if (sameFinderConfig(pendingConfig, requestedConfig)) throw error;
+				}
+				continue;
+			}
+
+			const promise = this._createFinder(cwd, options, requestedConfig);
+			this.finderPromise = promise;
+			this.finderPromiseConfig = requestedConfig;
+			try {
+				await promise;
+				return;
+			} finally {
+				if (this.finderPromise === promise) {
+					this.finderPromise = null;
+					this.finderPromiseConfig = null;
+				}
+			}
 		}
 	}
 
-	private async _createFinder(cwd: string): Promise<void> {
+	private async _createFinder(cwd: string, options: FffInitOptions, config: FinderConfig): Promise<void> {
 		if (!this.fffModule) return;
 
-		if (this.finder && !this.finder.isDestroyed) {
-			this.finder.destroy();
-			this.finder = null;
+		const result = this.createFinder(cwd, this.dbDir, options);
+		if (!result.ok) {
+			const kind = isRestrictedBasePathMessage(result.error) ? "restricted-base-path" : "native";
+			throw new FffInitError(
+				kind,
+				result.error,
+				kind === "restricted-base-path" ? restrictedScanScope(cwd) : undefined,
+			);
 		}
 
-		const result = this.createFinder(cwd, this.dbDir);
-		if (!result.ok) {
-			throw new Error(`FFF init failed: ${result.error}`);
+		const candidate = result.value;
+		let scan: Awaited<ReturnType<typeof candidate.waitForScan>>;
+		try {
+			scan = await candidate.waitForScan(15_000);
+		} catch (error) {
+			if (!candidate.isDestroyed) {
+				try {
+					candidate.destroy();
+				} catch {
+					// Preserve the scan failure; the candidate is no longer selected.
+				}
+			}
+			throw error;
 		}
 
-		this.finder = result.value;
-		const scan = await this.finder.waitForScan(15_000);
+		const previous = this.finder;
+		this.finder = candidate;
 		this.partialIndex = scan.ok && !scan.value;
+		this.finderConfig = config;
+		if (previous && previous !== candidate && !previous.isDestroyed) {
+			try {
+				previous.destroy();
+			} catch {
+				// Keep the replacement active; native cleanup is best effort.
+			}
+		}
 	}
 
 	private createFinder(
 		cwd: string,
 		dbDir: string | null,
+		options: FffInitOptions,
 	): ReturnType<typeof import("@ff-labs/fff-node").FileFinder.create> {
 		if (!this.fffModule) throw new Error("FFF module is not loaded");
-		const result = this.fffModule.FileFinder.create({
+		const commonOptions = {
 			basePath: cwd,
+			aiMode: true,
+			enableHomeDirScanning: options.enableHomeDirScanning,
+			enableFsRootScanning: options.enableFsRootScanning,
+		};
+		const result = this.fffModule.FileFinder.create({
+			...commonOptions,
 			frecencyDbPath: dbDir ? join(dbDir, "frecency.mdb") : "",
 			historyDbPath: dbDir ? join(dbDir, "history.mdb") : "",
-			aiMode: true,
 		});
 		if (result.ok || !isAlreadyOpenError(result.error) || !dbDir) return result;
 
@@ -181,20 +272,23 @@ export class FffService {
 			return result;
 		}
 		return this.fffModule.FileFinder.create({
-			basePath: cwd,
+			...commonOptions,
 			frecencyDbPath: join(isolatedDir, "frecency.mdb"),
 			historyDbPath: join(isolatedDir, "history.mdb"),
-			aiMode: true,
 		});
 	}
 
 	destroy(): void {
-		if (this.finder && !this.finder.isDestroyed) {
-			this.finder.destroy();
-			this.finder = null;
-		}
-		this.partialIndex = false;
+		this.disposeFinder();
 		this.finderPromise = null;
+		this.finderPromiseConfig = null;
+	}
+
+	private disposeFinder(): void {
+		if (this.finder && !this.finder.isDestroyed) this.finder.destroy();
+		this.finder = null;
+		this.finderConfig = null;
+		this.partialIndex = false;
 	}
 
 	getFinder(): import("@ff-labs/fff-node").FileFinder | null {
@@ -206,6 +300,41 @@ export class FffService {
 	}
 }
 
+function finderConfig(cwd: string, options: FffInitOptions): FinderConfig {
+	return {
+		basePath: canonicalPath(cwd),
+		enableHomeDirScanning: options.enableHomeDirScanning,
+		enableFsRootScanning: options.enableFsRootScanning,
+	};
+}
+
+function sameFinderConfig(left: FinderConfig | null, right: FinderConfig): boolean {
+	return (
+		left?.basePath === right.basePath &&
+		left.enableHomeDirScanning === right.enableHomeDirScanning &&
+		left.enableFsRootScanning === right.enableFsRootScanning
+	);
+}
+
 function isAlreadyOpenError(error: string): boolean {
 	return /environment already open/i.test(error);
 }
+
+function isRestrictedBasePathMessage(error: string): boolean {
+	return /certain FFF features in a file system root or home directories/i.test(error);
+}
+
+function restrictedScanScope(cwd: string): FffRestrictedScanScope | undefined {
+	const basePath = canonicalPath(cwd);
+	if (basePath === parse(basePath).root) return "root";
+	if (basePath === canonicalPath(homedir())) return "home";
+	return undefined;
+}
+
+function canonicalPath(path: string): string {
+	try {
+		return realpathSync.native(path);
+	} catch {
+		return resolve(path);
+	}
+}

package/src/index.ts

@@ -21,8 +21,16 @@ import type {
 } 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";
@@ -41,7 +49,6 @@ import {
 	thinkingBlockActive,
 	WORKING_INTERVAL_MS,
 	type WorkingIndicatorController,
-	workingTokens,
 } from "./working-indicator.js";
 
 // ---------------------------------------------------------------------------
@@ -49,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(",")));
@@ -63,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"),
@@ -171,12 +204,29 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	let thinkingHiddenCheckedAt = 0;
 	let workingSessionName: string | undefined;
 	let workingStreaming = false;
-	let workingStatsUpdatedAt = 0;
+	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>();
-	const TOKEN_COUNT_FORMAT = new Intl.NumberFormat("en-US");
 
 	/** Message timestamps are the per-row identity the label patch keys on. */
 	const messageTimestamp = (message: unknown): number | undefined => {
@@ -217,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();
@@ -244,6 +294,7 @@ 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
@@ -267,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 {
@@ -281,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");
 		}
 	});
 
@@ -294,12 +348,10 @@ 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;
-		workingStatsUpdatedAt = 0;
-		workingController?.setStats(undefined);
 		workingController?.start();
 	});
 	const stopStreaming = async (_event: unknown, ctx: ExtensionContext): Promise<void> => {
@@ -388,8 +440,8 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 						return;
 					}
 					thinkingTimer?.tick();
-					// The label has no widget of its own — reuse the working widget's
-					// TUI handle so the frame lands even when deltas pause mid-thinking.
+					// 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
@@ -411,13 +463,6 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	pi.on("message_update", async (event: MessageUpdateEvent, ctx: ExtensionContext) => {
 		if (ctx.mode !== "tui" || !workingStreaming) return;
 		thinkingLastMessage = event.message;
-		// Live token suffix on the working row (throttled to one update/second).
-		const now = Date.now();
-		if (now - workingStatsUpdatedAt >= 1000) {
-			workingStatsUpdatedAt = now;
-			const tokens = workingTokens(event.message);
-			workingController?.setStats(tokens > 0 ? ` (↓ ${TOKEN_COUNT_FORMAT.format(tokens)} tokens)` : undefined);
-		}
 		if (thinkingInterval) {
 			// Complete immediately on the first text/tool delta instead of waiting
 			// for the next animation frame.
@@ -436,14 +481,22 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	// 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).
+	// 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;

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;
 	};