@heyhuynhgiabuu/pi-pretty 0.6.30 → 0.7.0

package/src/index.ts

@@ -21,6 +21,12 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import * as hostSdk from "@earendil-works/pi-coding-agent";
 import { createFffAutocompleteProvider } from "./autocomplete.js";
+import {
+	installClaudeChatGrouping,
+	installClaudeExternalToolRenderers,
+	setClaudeStyleTheme,
+	withClaudeToolStyleApi,
+} from "./claude-style.js";
 import {
 	applyConfig,
 	getDefaultAgentDir,
@@ -45,6 +51,7 @@ import {
 	type PerRowThinkingLabels,
 	resolveThinkingIndicatorSettings,
 	resolveWorkingIndicatorSettings,
+	setClaudeThinkingLabels,
 	type ThinkingTimer,
 	thinkingBlockActive,
 	WORKING_INTERVAL_MS,
@@ -76,10 +83,15 @@ 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}`;
-	});
+	const claudeStyle = config.toolStyle === "claudecode";
+	setClaudeThinkingLabels(claudeStyle);
+	// claudecode style keeps user messages plain; the default style prefixes them with a prompt icon.
+	if (!claudeStyle) {
+		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",
@@ -214,12 +226,16 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 		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);
-		});
+		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);
+			},
+			!claudeStyle,
+		);
 		editorUi.setEditorComponent((tui, theme, keybindings) => new PromptEditor(tui, theme, keybindings));
 		promptEditorInstalled = true;
 	};
@@ -294,6 +310,9 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 
 	pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
 		if (ctx.mode === "tui") {
+			setClaudeStyleTheme(ctx.ui.theme);
+			installClaudeChatGrouping(claudeStyle);
+			installClaudeExternalToolRenderers(hostSdk.ToolExecutionComponent, claudeStyle);
 			installPromptEditor(ctx);
 			ctx.ui.setToolsExpanded(false);
 			// Per-row hidden-thinking labels: intercept the host's label fan-out so
@@ -536,19 +555,20 @@ export default async function piPrettyExtension(pi: ExtensionAPI, deps?: PiPrett
 	// Tool registration
 	// ------------------------------------------------------------------
 
+	const toolPi = claudeStyle ? withClaudeToolStyleApi(pi) : pi;
 	if (isToolEnabled("read") && createReadTool) {
-		registerReadTool(pi, cwd, null, createReadTool(cwd), TextComp);
+		registerReadTool(toolPi, cwd, null, createReadTool(cwd), TextComp);
 	}
 	if (isToolEnabled("bash") && createBashTool) {
-		registerBashTool(pi, cwd, null, createBashTool(cwd), TextComp);
+		registerBashTool(toolPi, cwd, null, createBashTool(cwd), TextComp);
 	}
 	if (isToolEnabled("ls") && createLsTool) {
-		registerLsTool(pi, cwd, null, createLsTool(cwd), TextComp);
+		registerLsTool(toolPi, cwd, null, createLsTool(cwd), TextComp);
 	}
 	if (isToolEnabled("find") && createFindTool) {
-		registerFindTool(pi, cwd, fffService, createFindTool(cwd), TextComp);
+		registerFindTool(toolPi, cwd, fffService, createFindTool(cwd), TextComp);
 	}
 	if (isToolEnabled("grep") && createGrepTool) {
-		registerGrepTool(pi, cwd, fffService, createGrepTool(cwd), TextComp);
+		registerGrepTool(toolPi, cwd, fffService, createGrepTool(cwd), TextComp);
 	}
 }

package/src/prompt-editor.ts

@@ -7,15 +7,20 @@ export type CustomEditorConstructor = new (...args: ConstructorParameters<typeof
 type PromptColor = (text: string) => string;
 
 const PROMPT_ICON = "❯";
-const PROMPT_WIDTH = 3; // one space on either side of the icon
+const BOXED_PROMPT_WIDTH = 3; // one space on either side of the icon
+const UNBOXED_PROMPT_WIDTH = 2; // icon flush left, one space after
 
 /**
  * Build a CustomEditor subclass that reserves room for, and renders, the
  * user-message prompt. The host still owns all editing and app keybindings.
+ * With `boxed: false` the host's plain horizontal rules are kept as-is (no rounded
+ * corners, no side bars) and the prompt sits flush left: `❯ text`, ignoring the
+ * host's horizontal padding.
  */
 export function createPromptEditorClass(
 	Base: CustomEditorConstructor,
 	colorPrompt: PromptColor,
+	boxed = true,
 ): CustomEditorConstructor {
 	const basePrototype = Base.prototype as unknown as {
 		renderTopBorder?: unknown;
@@ -33,13 +38,19 @@ export function createPromptEditorClass(
 			const [tui, theme, keybindings, options] = args;
 			super(tui, theme, keybindings, { ...(options ?? {}), embedWorkingStatus: true });
 			this.userPaddingX = super.getPaddingX();
-			super.setPaddingX(this.userPaddingX + this.promptWidth());
+			super.setPaddingX(this.reservedPadding());
 		}
 
 		private promptWidth(): number {
+			if (!boxed) return UNBOXED_PROMPT_WIDTH;
 			// 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);
+			return BOXED_PROMPT_WIDTH + (supportsBorderHooks && this.userPaddingX === 0 ? 1 : 0);
+		}
+
+		/** Columns the host must reserve left of the input: user padding plus the prompt slot. */
+		private reservedPadding(): number {
+			return (boxed ? this.userPaddingX : 0) + this.promptWidth();
 		}
 
 		override getPaddingX(): number {
@@ -48,16 +59,19 @@ export function createPromptEditorClass(
 
 		override setPaddingX(padding: number): void {
 			this.userPaddingX = Math.max(0, padding);
-			super.setPaddingX(this.userPaddingX + this.promptWidth());
+			super.setPaddingX(this.reservedPadding());
 		}
 
 		protected override renderTopBorder(width: number, hiddenLineCount: number): string {
 			this.isScrolled = hiddenLineCount > 0;
-			return this.roundBorder(super.renderTopBorder(width, hiddenLineCount), width, "╭", "╮");
+			const border = super.renderTopBorder(width, hiddenLineCount);
+			return boxed ? this.roundBorder(border, width, "╭", "╮") : border;
 		}
 
 		protected override renderBottomBorder(width: number, hiddenLineCount: number): string {
-			this.bottomBorderLine = this.roundBorder(super.renderBottomBorder(width, hiddenLineCount), width, "╰", "╯");
+			const border = super.renderBottomBorder(width, hiddenLineCount);
+			if (!boxed) return border;
+			this.bottomBorderLine = this.roundBorder(border, width, "╰", "╯");
 			return this.bottomBorderLine;
 		}
 
@@ -75,16 +89,17 @@ export function createPromptEditorClass(
 				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)} `;
+					const promptPadding = Math.min(this.reservedPadding(), maxPadding);
+					const slot = boxed ? BOXED_PROMPT_WIDTH : UNBOXED_PROMPT_WIDTH;
+					if (promptPadding >= slot && firstContentLine.startsWith(" ".repeat(promptPadding))) {
+						const promptStart = promptPadding - slot;
+						const prompt = boxed ? ` ${colorPrompt(PROMPT_ICON)} ` : `${colorPrompt(PROMPT_ICON)} `;
 						lines[1] = `${firstContentLine.slice(0, promptStart)}${prompt}${firstContentLine.slice(promptPadding)}`;
 					}
 				}
 			}
 
-			if (!supportsBorderHooks || !this.bottomBorderLine) return lines;
+			if (!boxed || !supportsBorderHooks || !this.bottomBorderLine) return lines;
 
 			const bottomBorderIndex = lines.lastIndexOf(this.bottomBorderLine);
 			const contentEnd = bottomBorderIndex > 0 ? bottomBorderIndex : lines.length - 1;

package/src/render.ts

@@ -200,7 +200,16 @@ export function preserveBoxBackground(ansi: string): string {
 	});
 }
 
-export function fillToolBackground(text: string, bg = BG_BASE, width?: number): string {
+/** Left indent for self-rendered rows: host `ctx.outputPad` spaces, falling back to 1 on older/invalid hosts. */
+export function toolIndent(ctx?: Pick<RenderContext, "outputPad">): string {
+	const pad = ctx?.outputPad;
+	// Reject unusable values, including pads wider than the terminal (avoids giant allocations).
+	return typeof pad === "number" && Number.isInteger(pad) && pad >= 0 && pad <= termWidth()
+		? " ".repeat(pad)
+		: TOOL_RESULT_INDENT;
+}
+
+export function fillToolBackground(text: string, bg = BG_BASE, width?: number, indent = TOOL_RESULT_INDENT): string {
 	return text
 		.split("\n")
 		.map((line) => {
@@ -209,7 +218,8 @@ export function fillToolBackground(text: string, bg = BG_BASE, width?: number):
 				return bg ? bg + stripped : stripped;
 			}
 			const plainLead = line.replace(ANSI_CAPTURE_RE, "");
-			const skipPad = line.startsWith(TOOL_RESULT_INDENT) || plainLead.startsWith(TOOL_RESULT_INDENT);
+			// Indented rows keep their natural width; with no indent every row is padded.
+			const skipPad = indent !== "" && (line.startsWith(indent) || plainLead.startsWith(indent));
 			const fitted = truncateToWidth(line, width, "", !skipPad);
 			const stripped = preserveBoxBackground(fitted);
 			return bg ? bg + stripped : stripped;
@@ -218,8 +228,8 @@ export function fillToolBackground(text: string, bg = BG_BASE, width?: number):
 }
 
 /** 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);
+export function fillToolBody(text: string, bg = BG_BASE, width?: number, indent = TOOL_RESULT_INDENT): string {
+	return fillToolBackground(text.endsWith("\n") ? text : `${text}\n`, bg, width, indent);
 }
 
 const TOOL_TITLE_STATE_KEY = "__piPrettyToolTitle";
@@ -250,29 +260,44 @@ function lnum(n: number, w: number): string {
 // Tool metrics line
 // ---------------------------------------------------------------------------
 
-export function renderToolMetrics(result: AgentToolResult<Record<string, unknown>>): string {
+/** Prefer the host's final duration (0 is valid); fall back to wrapper-recorded metadata. */
+function resolveDurationMs(
+	result: AgentToolResult<Record<string, unknown>>,
+	ctx?: Pick<RenderContext, "durationMs">,
+): number | undefined {
+	const host = ctx?.durationMs;
+	if (typeof host === "number" && Number.isFinite(host) && host >= 0) return host;
+	const details = result.details as Record<string, unknown> | undefined;
+	return details?.[ELAPSED_KEY] as number | undefined;
+}
+
+export function renderToolMetrics(
+	result: AgentToolResult<Record<string, unknown>>,
+	ctx?: Pick<RenderContext, "durationMs">,
+): string {
 	const details = result.details as Record<string, unknown> | undefined;
-	if (!details) return "";
-	const elapsed = formatElapsedMs(details[ELAPSED_KEY] as number | undefined);
-	const chars = formatCharCount(details[CHARS_KEY] as number | undefined);
+	const elapsed = formatElapsedMs(resolveDurationMs(result, ctx));
+	const chars = formatCharCount(details?.[CHARS_KEY] as number | undefined);
 	if (!elapsed && !chars) return "";
 	return `${FG_DIM}· ${[elapsed, chars].filter(Boolean).join(" · ")}${RST}`;
 }
 
-export function renderToolDuration(result: AgentToolResult<Record<string, unknown>>): string {
-	const details = result.details as Record<string, unknown> | undefined;
-	return formatElapsedMs(details?.[ELAPSED_KEY] as number | undefined);
+export function renderToolDuration(
+	result: AgentToolResult<Record<string, unknown>>,
+	ctx?: Pick<RenderContext, "durationMs">,
+): string {
+	return formatElapsedMs(resolveDurationMs(result, ctx));
 }
 
 // ---------------------------------------------------------------------------
 // Error renderer
 // ---------------------------------------------------------------------------
 
-export function renderToolError(error: string, theme: ThemeLike): string {
+export function renderToolError(error: string, theme: ThemeLike, indent = TOOL_RESULT_INDENT): string {
 	const body = compactErrorLines(error)
-		.map((line) => `${TOOL_RESULT_INDENT}${line ? theme.fg("error", line) : ""}`)
+		.map((line) => `${indent}${line ? theme.fg("error", line) : ""}`)
 		.join("\n");
-	return fillToolBody(body, BG_ERROR);
+	return fillToolBody(body, BG_ERROR, undefined, indent);
 }
 
 // ---------------------------------------------------------------------------
@@ -305,14 +330,14 @@ export async function renderFileContent(
 // Bash — colored exit status
 // ---------------------------------------------------------------------------
 
-export function renderBashOutput(text: string): string {
+export function renderBashOutput(text: string, indent = TOOL_RESULT_INDENT): string {
 	const lines = text.split("\n");
 	const maxShow = MAX_PREVIEW_LINES;
 	const show = lines.slice(0, maxShow);
 	const remaining = lines.length - maxShow;
 
 	let body = show.join("\n");
-	if (remaining > 0) body += `\n${TOOL_RESULT_INDENT}${FG_DIM}… ${remaining} more lines${RST}`;
+	if (remaining > 0) body += `\n${indent}${FG_DIM}… ${remaining} more lines${RST}`;
 
 	return body;
 }
@@ -351,6 +376,7 @@ export function renderTree(text: string, _basePath: string): string {
 // Find — grouped file list (plain, no tree characters or icons)
 // ---------------------------------------------------------------------------
 
+/** File rows keep the structural one-space indent; the tool applies host outer padding. */
 export function renderFindResults(text: string, theme?: ThemeLike): string {
 	const lines = text.trim().split("\n").filter(Boolean);
 	if (!lines.length) return theme ? theme.fg("dim", "(no matches)") : `${FG_DIM}(no matches)${RST}`;
@@ -392,7 +418,7 @@ export function renderFindResults(text: string, theme?: ThemeLike): string {
 // Grep — highlighted matches with line numbers
 // ---------------------------------------------------------------------------
 
-export async function renderGrepResults(text: string, pattern: string): Promise<string> {
+export async function renderGrepResults(text: string, pattern: string, indent = TOOL_RESULT_INDENT): Promise<string> {
 	const lines = normalizeLineEndings(text).split("\n");
 	if (!lines.length || (lines.length === 1 && !lines[0].trim())) return `${FG_DIM}(no matches)${RST}`;
 
@@ -423,10 +449,10 @@ export async function renderGrepResults(text: string, pattern: string): Promise<
 			const nw = Math.max(3, lineNo.length);
 			let display = content;
 			if (re) display = content.replace(re, `${RST}${FG_YELLOW}\x1b[1m$1${RST}`);
-			out.push(`${TOOL_RESULT_INDENT}${lnum(Number(lineNo), nw)} ${FG_RULE}│${RST} ${display}${RST}`);
+			out.push(`${indent}${lnum(Number(lineNo), nw)} ${FG_RULE}│${RST} ${display}${RST}`);
 			count++;
 		} else if (line.trim() === "--") {
-			out.push(`${TOOL_RESULT_INDENT}${FG_DIM}  ···${RST}`);
+			out.push(`${indent}${FG_DIM}  ···${RST}`);
 		} else if (line.trim()) {
 			out.push(line);
 			count++;
@@ -445,7 +471,7 @@ export function makeRenderCall(toolName: string) {
 		resolveBaseBackground(theme);
 		const text = ctx.lastComponent ?? new TuiText("", 0, 0);
 		const bg = ctx.isError ? BG_ERROR : undefined;
-		text.setText(fillToolBackground(`${theme.fg("toolTitle", theme.bold(toolName))}`, bg));
+		text.setText(fillToolBackground(`${theme.fg("toolTitle", theme.bold(toolName))}`, bg, undefined, toolIndent(ctx)));
 		return text;
 	};
 }
@@ -455,26 +481,30 @@ export function makeRenderResult() {
 		resolveBaseBackground(theme);
 		const text = ctx.lastComponent ?? new TuiText("", 0, 0);
 		if (ctx.isError) {
-			text.setText(renderToolError(getTextContent(result) || "Error", theme));
+			text.setText(renderToolError(getTextContent(result) || "Error", theme, toolIndent(ctx)));
 			return text;
 		}
 		const content = getTextContent(result);
 		if (content) {
 			const renderWidth = termWidth();
+			const indent = toolIndent(ctx);
 			const lines = content.split("\n");
 			const maxShow = ctx.expanded ? lines.length : Math.min(lines.length, MAX_PREVIEW_LINES);
 			const preview = lines.slice(0, maxShow).join("\n");
 			const more = lines.length > maxShow ? `\n${FG_DIM}... ${lines.length - maxShow} more lines${RST}` : "";
-			const metrics = renderToolMetrics(result);
+			const metrics = renderToolMetrics(result, ctx);
 			text.setText(
 				fillToolBody(
-					`${TOOL_RESULT_INDENT}${preview}${more}${metrics ? `\n${TOOL_RESULT_INDENT}${metrics}` : ""}`,
+					`${indent}${preview}${more}${metrics ? `\n${indent}${metrics}` : ""}`,
 					undefined,
 					renderWidth,
+					indent,
 				),
 			);
 		} else {
-			text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", "(no text output)")}`));
+			text.setText(
+				fillToolBody(`${toolIndent(ctx)}${theme.fg("dim", "(no text output)")}`, undefined, undefined, toolIndent(ctx)),
+			);
 		}
 		return text;
 	};

package/src/tools/bash.ts

@@ -1,7 +1,7 @@
 /* pi-pretty: bash tool -- command execution with styled output. */
 
 import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { resolveBaseBackground, TOOL_RESULT_INDENT, termWidth } from "../config.js";
+import { resolveBaseBackground, termWidth } from "../config.js";
 import {
 	CHARS_KEY,
 	compactErrorLines,
@@ -17,6 +17,7 @@ import {
 	renderToolDuration,
 	renderToolError,
 	setCollapsedToolTitle,
+	toolIndent,
 } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { BashDetails, ComponentLike, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
@@ -106,6 +107,7 @@ export function registerBashTool(
 			resolveBaseBackground(theme);
 			const text = ctx.lastComponent ?? new TC("", 0, 0);
 			const t = typeof args.timeout === "number" ? ` ${theme.fg("muted", `(timeout ${args.timeout}s)`)}` : "";
+			const ind = toolIndent(ctx);
 			const tw = termWidth() || 80;
 			const rawCmd = String(args.command ?? "");
 			const headerBudget = ctx.expanded ? tw : Math.max(8, tw - 20);
@@ -117,11 +119,7 @@ export function registerBashTool(
 						: rawCmd;
 			const commandLabel = theme.fg(ctx.isError ? "error" : "toolTitle", theme.bold(`$ ${cmd}`));
 			const renderTitle = (suffix = ""): string =>
-				fillToolBackground(
-					`\n${TOOL_RESULT_INDENT}${commandLabel}${t}${suffix}\n`,
-					undefined,
-					ctx.expanded ? undefined : tw,
-				);
+				fillToolBackground(`\n${ind}${commandLabel}${t}${suffix}\n`, undefined, ctx.expanded ? undefined : tw, ind);
 			rememberToolTitle(ctx, text, renderTitle);
 			text.setText(renderTitle());
 			return text;
@@ -154,26 +152,29 @@ 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(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 buildInfo = (): string =>
+					[
+						`${lineCount} lines`,
+						renderToolDuration(displayResult, ctx),
+						rejectedMetrics ? formatCharCount(rejectedMetrics.chars) : "",
+						!ctx.expanded ? "ctrl+o to expand" : "",
+					]
+						.filter(Boolean)
+						.map((part) => theme.fg("dim", part))
+						.join(theme.fg("dim", " · "));
+				const info = buildInfo();
 				const rw = termWidth();
 
 				if (setCollapsedToolTitle(ctx, text, ` ${info}`)) return text;
 
 				const renderFn = (w: number) => {
-					if (!ctx.expanded) return fillToolBody(header, undefined, w);
-					if (!output.trim()) return fillToolBody(header, undefined, w);
+					const ind = toolIndent(ctx);
+					const header = `${ind}${buildInfo()}`;
+					if (!ctx.expanded) return fillToolBody(header, undefined, w, ind);
+					if (!output.trim()) return fillToolBody(header, undefined, w, ind);
 					const show = output.split("\n");
-					const out = [header, "", ...show.map((line: string) => `${TOOL_RESULT_INDENT}${line}`)];
-					return fillToolBody(out.join("\n"), undefined, w);
+					const out = [header, "", ...show.map((line: string) => `${ind}${line}`)];
+					return fillToolBody(out.join("\n"), undefined, w, ind);
 				};
 
 				text.setText(renderFn(rw));
@@ -184,7 +185,7 @@ export function registerBashTool(
 					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(displayResult)}`;
+						const k = `bash:${ctx.expanded ? "1" : "0"}:${width}:${d.exitCode ?? "killed"}:${output.length}:${renderToolDuration(displayResult, ctx)}:${toolIndent(ctx).length}`;
 						if (key !== k) {
 							text.setText(renderFn(width));
 							key = k;
@@ -196,13 +197,17 @@ export function registerBashTool(
 			}
 
 			if (ctx.isError) {
-				text.setText(renderToolError(tc || "Error", theme));
+				text.setText(renderToolError(tc || "Error", theme, toolIndent(ctx)));
 				return text;
 			}
 			const fc = displayResult.content?.[0];
+			const ind = toolIndent(ctx);
 			text.setText(
 				fillToolBody(
-					`${TOOL_RESULT_INDENT}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+					`${ind}${theme.fg("dim", fc && "text" in fc ? String(fc.text).slice(0, 120) : "done")}`,
+					undefined,
+					undefined,
+					ind,
 				),
 			);
 			return text;

package/src/tools/find.ts

@@ -2,7 +2,7 @@
 
 import { isAbsolute, relative } from "node:path";
 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 { BG_ERROR, FG_DIM, RST, resolveBaseBackground } from "../config.js";
 import { isLikelyGlobPattern, normalizeFindGlobPattern } from "../find-glob.js";
 import { shortPath } from "../helpers.js";
 import { NOTICE_PARTIAL_FILE_INDEX } from "../notices.js";
@@ -14,6 +14,7 @@ import {
 	renderToolDuration,
 	renderToolError,
 	setCollapsedToolTitle,
+	toolIndent,
 } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { FffServiceWithCursor, FindDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
@@ -171,8 +172,9 @@ 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}`;
+			const ind = toolIndent(ctx);
 			const renderTitle = (suffix = ""): string =>
-				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+				fillToolBackground(`\n${ind}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined, undefined, ind);
 			rememberToolTitle(ctx, text, renderTitle);
 			text.setText(renderTitle());
 			return text;
@@ -182,8 +184,9 @@ export function registerFindTool(
 			resolveBaseBackground(theme);
 			const r = result;
 			const text = (ctx as RenderCtxLike).lastComponent ?? new TC("", 0, 0);
+			const ind = toolIndent(ctx);
 			if (ctx.isError) {
-				text.setText(renderToolError(getText(r) || "Error", theme));
+				text.setText(renderToolError(getText(r) || "Error", theme, ind));
 				return text;
 			}
 			const d = r.details as FindDetails | undefined;
@@ -191,36 +194,37 @@ export function registerFindTool(
 				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(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", "0 files")}${noticeStr}`));
+					const noticeStr = d.notices?.length ? `\n${ind}${theme.fg("warning", `[${d.notices.join(". ")}]`)}` : "";
+					text.setText(fillToolBody(`${ind}${theme.fg("dim", "0 files")}${noticeStr}`, undefined, undefined, ind));
 					return text;
 				}
 				if (!ctx.expanded) {
-					const duration = renderToolDuration(r);
+					const duration = renderToolDuration(r, ctx);
 					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}`));
+					text.setText(fillToolBody(`${ind}${summary}`, undefined, undefined, ind));
 					return text;
 				}
 				const rendered = renderFindResults(d.text, theme)
 					.split("\n")
-					.map((l) => `${TOOL_RESULT_INDENT}${l}`)
+					.map((l) => `${ind}${l}`)
 					.join("\n");
-				const noticeStr = d.notices?.length
-					? `\n${TOOL_RESULT_INDENT}${theme.fg("warning", `[${d.notices.join(". ")}]`)}`
-					: "";
-				const duration = renderToolDuration(r);
+				const noticeStr = d.notices?.length ? `\n${ind}${theme.fg("warning", `[${d.notices.join(". ")}]`)}` : "";
+				const duration = renderToolDuration(r, ctx);
 				text.setText(
 					fillToolBody(
-						`${TOOL_RESULT_INDENT}${theme.fg("dim", `${d.matchCount} files`)}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n${rendered}${noticeStr}`,
+						`${ind}${theme.fg("dim", `${d.matchCount} files`)}${duration ? `${FG_DIM}· ${duration}${RST}` : ""}\n${rendered}${noticeStr}`,
+						undefined,
+						undefined,
+						ind,
 					),
 				);
 				return text;
 			}
 			const fc = r.content?.[0] as TextContent | undefined;
-			text.setText(fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", fc?.text?.slice(0, 120) ?? "0 files")}`));
+			text.setText(
+				fillToolBody(`${ind}${theme.fg("dim", fc?.text?.slice(0, 120) ?? "0 files")}`, undefined, undefined, ind),
+			);
 			return text;
 		},
 	} as unknown as ToolDefinition);

package/src/tools/grep.ts

@@ -1,7 +1,7 @@
 /* pi-pretty: grep tool -- FFF-backed text search with SDK fallback. */
 
 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 { BG_ERROR, FG_DIM, RST, resolveBaseBackground } from "../config.js";
 import { fffFormatGrepText } from "../fff-helpers.js";
 import { normalizeLineEndings, shortPath } from "../helpers.js";
 import { NOTICE_PARTIAL_FILE_INDEX } from "../notices.js";
@@ -11,6 +11,7 @@ import {
 	rememberToolTitle,
 	renderToolError,
 	setCollapsedToolTitle,
+	toolIndent,
 } from "../render.js";
 import { resolveTextCtor } from "../tui-text.js";
 import type { FffServiceWithCursor, GrepDetails, RenderCtxLike, SdkToolDef, TextContent, ThemeLike } from "../types.js";
@@ -122,8 +123,9 @@ 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)`);
+			const ind = toolIndent(ctx);
 			const renderTitle = (suffix = ""): string =>
-				fillToolBackground(`\n${TOOL_RESULT_INDENT}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined);
+				fillToolBackground(`\n${ind}${out}${suffix}\n`, ctx.isError ? BG_ERROR : undefined, undefined, ind);
 			rememberToolTitle(ctx, text, renderTitle);
 			text.setText(renderTitle());
 			return text;
@@ -132,6 +134,7 @@ export function registerGrepTool(
 		renderResult(result: Result, _opt: unknown, theme: ThemeLike, ctx: RenderCtxLike) {
 			resolveBaseBackground(theme);
 			const text = ctx.lastComponent ?? new T("", 0, 0);
+			const ind = toolIndent(ctx);
 			if (ctx.isError) {
 				text.setText(
 					renderToolError(
@@ -140,6 +143,7 @@ export function registerGrepTool(
 							.map((c) => c.text)
 							.join("\n") || "Error",
 						theme,
+						ind,
 					),
 				);
 				return text;
@@ -150,7 +154,7 @@ export function registerGrepTool(
 				if (!ctx.expanded) {
 					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));
+					text.setText(fillToolBody(`${ind}${summary}`, ctx.isError ? BG_ERROR : undefined, undefined, ind));
 					return text;
 				}
 				const maxShow = lines.length;
@@ -164,14 +168,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");
-				text.setText(fillToolBody(body, ctx.isError ? BG_ERROR : undefined));
+				const body = out.map((l) => `${ind}${l}`).join("\n");
+				text.setText(fillToolBody(body, ctx.isError ? BG_ERROR : undefined, undefined, ind));
 				return text;
 			}
 			const fc = result.content?.[0];
 			const fallback = fc && "text" in fc ? String(fc.text).slice(0, 120) : "no matches";
 			text.setText(
-				fillToolBody(`${TOOL_RESULT_INDENT}${theme.fg("dim", fallback)}`, ctx.isError ? BG_ERROR : undefined),
+				fillToolBody(`${ind}${theme.fg("dim", fallback)}`, ctx.isError ? BG_ERROR : undefined, undefined, ind),
 			);
 			return text;
 		},