@diegopetrucci/pi-extensions 0.1.16 → 0.1.17

package/README.md

@@ -2,13 +2,13 @@
 
 A collection of [pi](https://github.com/earendil-works/pi-mono) agent extensions I made:
 
+- [`quiet-tools`](./extensions/quiet-tools): Renders collapsed built-in tool rows as quiet one-line previews without changing model-visible tool results; toggle temporarily with `/quiet-tools`.
+- [`confirm-destructive`](./extensions/confirm-destructive): Confirms before destructive session actions like clear, switch, and fork.
+- [`context-cap`](./extensions/context-cap): Caps effective model context windows at 200k tokens by default so pi avoids the `dumb zone`; toggle temporarily with `/context-cap`.
 - [`minimal-footer`](./extensions/minimal-footer): Replaces pi's built-in footer with a minimal configurable two-line layout: branch/repo on the first line, context/model on the second, optional `DUMB ZONE`, plus OpenAI Codex 5-hour and 7-day usage when available.
+- [`notify`](./extensions/notify): Sends configurable terminal, desktop, bell, and sound notifications when pi finishes and is ready for input.
 - [`oracle`](./extensions/oracle): Adds an Amp-style read-only oracle tool that auto-selects the strongest reasoning model on the current provider/subscription, covers pi’s built-in providers with hardcoded rankings, sets reasoning to xhigh by default, and shows live status while running.
-- [`context-cap`](./extensions/context-cap): Caps effective model context windows at 200k tokens by default so pi avoids the `dumb zone`; toggle temporarily with `/context-cap`.
-- [`compact-bash`](./extensions/compact-bash): Renders collapsed assistant `bash` tool output as a one-line preview; toggle temporarily with `/compact-bash`.
 - [`permission-gate`](./extensions/permission-gate): Prompts for confirmation before dangerous bash commands like `rm -rf`, `sudo`, and `chmod 777`.
-- [`confirm-destructive`](./extensions/confirm-destructive): Confirms before destructive session actions like clear, switch, and fork.
-- [`notify`](./extensions/notify): Sends configurable terminal, desktop, bell, and sound notifications when pi finishes and is ready for input.
 
 (For the full list of pi extensions I use, [check out my dotfiles](https://github.com/diegopetrucci/dot/blob/main/.pi/agent/settings.json).)
 
@@ -23,13 +23,13 @@ pi install npm:@diegopetrucci/pi-extensions
 Or pin the GitHub package to this release:
 
 ```bash
-pi install git:github.com/diegopetrucci/pi-extensions@v0.1.16
+pi install git:github.com/diegopetrucci/pi-extensions@v0.1.17
 ```
 
 Or a specific extension:
 
 ```bash
-pi install npm:@diegopetrucci/pi-oracle
+pi install npm:@diegopetrucci/pi-quiet-tools
 ```
 
 Then reload pi:

package/extensions/quiet-tools/README.md

@@ -0,0 +1,63 @@
+# quiet-tools
+
+A pi extension that makes collapsed built-in tool rows much quieter in the TUI.
+
+When enabled, collapsed tool output renders as one output line plus an inline hidden-line count and `Ctrl+O` expand hint. Expanding with `Ctrl+O` still shows pi's full rendered output.
+
+`quiet-tools` only changes the visual renderer. It does not truncate, summarize, or rewrite the actual tool results sent to the model.
+
+## Covered tools
+
+- `bash`
+- `read`
+- `grep`
+- `find`
+- `ls`
+- `edit`
+- `write`
+
+For `edit` and `write`, the collapsed call preview is also shortened so large diffs or file contents do not fill the TUI. Expanding restores pi's normal renderer.
+
+## Commands
+
+```text
+/quiet-tools status
+/quiet-tools off
+/quiet-tools on
+/quiet-tools toggle
+```
+
+The extension starts enabled by default. Disabling is temporary for the current extension runtime/session; after `/reload`, `/new`, `/resume`, or `/fork`, it starts enabled again.
+
+## Install
+
+### Standalone npm package
+
+```bash
+pi install npm:@diegopetrucci/pi-quiet-tools
+```
+
+### Collection package
+
+```bash
+pi install npm:@diegopetrucci/pi-extensions
+```
+
+### GitHub package
+
+```bash
+pi install git:github.com/diegopetrucci/pi-extensions
+```
+
+Then reload pi:
+
+```text
+/reload
+```
+
+## Notes
+
+- This extension overrides pi's built-in tool definitions so it can customize only their TUI renderers.
+- It reuses pi's built-in implementations and preserves `shellPath`, `shellCommandPrefix`, and image autoresize settings when they are available from settings files.
+- If another extension also overrides built-in tool execution, pi's extension load order determines which override wins.
+- It affects assistant-invoked tool rows. User `!`/`!!` bash commands are rendered by a separate pi component and keep pi's default preview behavior.

package/extensions/quiet-tools/index.ts

@@ -0,0 +1,384 @@
+import {
+	createBashToolDefinition,
+	createEditToolDefinition,
+	createFindToolDefinition,
+	createGrepToolDefinition,
+	createLsToolDefinition,
+	createReadToolDefinition,
+	createWriteToolDefinition,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+	keyHint,
+	SettingsManager,
+	type ExtensionAPI,
+	type ToolDefinition as PiToolDefinition,
+	type ToolsOptions,
+} from "@earendil-works/pi-coding-agent";
+import { Box, Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+
+const COLLAPSED_PREVIEW_LINES = 1;
+const QUIET_CALL_TOOL_NAMES = new Set(["edit", "write"]);
+
+type ToolDefinition = PiToolDefinition<any, any, any>;
+type ToolRenderCall = NonNullable<ToolDefinition["renderCall"]>;
+type ToolRenderResult = NonNullable<ToolDefinition["renderResult"]>;
+type ToolRenderCallParams = Parameters<ToolRenderCall>;
+type ToolRenderResultParams = Parameters<ToolRenderResult>;
+type RenderTheme = ToolRenderResultParams[2];
+type ToolRenderContext = ToolRenderResultParams[3];
+
+type TimerRenderState = {
+	startedAt?: number;
+	endedAt?: number;
+	interval?: ReturnType<typeof setInterval>;
+};
+
+type TruncationLike = {
+	truncated?: boolean;
+	truncatedBy?: "lines" | "bytes";
+	firstLineExceedsLimit?: boolean;
+	outputLines?: number;
+	totalLines?: number;
+	maxBytes?: number;
+	maxLines?: number;
+};
+
+class QuietResultRenderComponent extends Container {}
+
+function sanitizePreviewText(text: string): string {
+	return text
+		.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "")
+		.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+		.replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "");
+}
+
+function getTextOutput(result: ToolRenderResultParams[0]): string {
+	return sanitizePreviewText(
+		result.content
+			.filter((content) => content.type === "text")
+			.map((content) => content.text ?? "")
+			.join("\n")
+			.trim(),
+	);
+}
+
+function visibleLength(text: string): number {
+	return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").length;
+}
+
+function plural(count: number, singular: string): string {
+	return `${count} ${singular}${count === 1 ? "" : "s"}`;
+}
+
+function formatDuration(ms: number): string {
+	return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function renderCollapsedLine(line: string, hiddenLines: number, theme: RenderTheme, width: number): string {
+	if (width <= 0) return "";
+
+	const styledLine = theme.fg("toolOutput", line);
+	if (hiddenLines <= 0) {
+		return truncateToWidth(styledLine, width, "...");
+	}
+
+	const hint = theme.fg(
+		"muted",
+		`  ... ${plural(hiddenLines, "more line")} (${keyHint("app.tools.expand", "to expand")})`,
+	);
+	const hintWidth = visibleLength(hint);
+	if (hintWidth + 8 > width) {
+		return truncateToWidth(`${styledLine}${hint}`, width, "...");
+	}
+
+	return `${truncateToWidth(styledLine, width - hintWidth, "...")}${hint}`;
+}
+
+function formatLimitWarning(label: string, count: unknown): string | undefined {
+	return typeof count === "number" ? `${count} ${label} limit` : undefined;
+}
+
+function getTruncationWarnings(result: ToolRenderResultParams[0]): string[] {
+	const details = result.details as
+		| {
+				truncation?: TruncationLike;
+				fullOutputPath?: string;
+				matchLimitReached?: number;
+				resultLimitReached?: number;
+				entryLimitReached?: number;
+				linesTruncated?: boolean;
+		  }
+		| undefined;
+	const truncation = details?.truncation;
+	const warnings: string[] = [];
+
+	if (details?.fullOutputPath) {
+		warnings.push(`Full output: ${details.fullOutputPath}`);
+	}
+
+	if (truncation?.truncated) {
+		if (truncation.firstLineExceedsLimit) {
+			warnings.push(`First line exceeds ${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit`);
+		} else if (truncation.truncatedBy === "lines") {
+			warnings.push(
+				`Truncated: showing ${truncation.outputLines ?? "some"} of ${truncation.totalLines ?? "?"} lines (${truncation.maxLines ?? DEFAULT_MAX_LINES} line limit)`,
+			);
+		} else {
+			warnings.push(
+				`Truncated: ${truncation.outputLines ?? "some"} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+			);
+		}
+	}
+
+	const matchLimitWarning = formatLimitWarning("matches", details?.matchLimitReached);
+	if (matchLimitWarning) warnings.push(matchLimitWarning);
+
+	const resultLimitWarning = formatLimitWarning("results", details?.resultLimitReached);
+	if (resultLimitWarning) warnings.push(resultLimitWarning);
+
+	const entryLimitWarning = formatLimitWarning("entries", details?.entryLimitReached);
+	if (entryLimitWarning) warnings.push(entryLimitWarning);
+
+	if (details?.linesTruncated) warnings.push("Some lines truncated");
+
+	return warnings;
+}
+
+function syncElapsedTimer(options: ToolRenderResultParams[1], context: ToolRenderContext): TimerRenderState {
+	const state = context.state as TimerRenderState;
+
+	if (state.startedAt !== undefined && options.isPartial && !state.interval) {
+		state.interval = setInterval(() => context.invalidate(), 1000);
+	}
+
+	if (!options.isPartial || context.isError) {
+		state.endedAt ??= Date.now();
+		if (state.interval) {
+			clearInterval(state.interval);
+			state.interval = undefined;
+		}
+	}
+
+	return state;
+}
+
+function renderQuietCollapsedResult(
+	result: ToolRenderResultParams[0],
+	options: ToolRenderResultParams[1],
+	theme: RenderTheme,
+	context: ToolRenderContext,
+): Container {
+	const state = syncElapsedTimer(options, context);
+	const component = context.lastComponent instanceof QuietResultRenderComponent
+		? context.lastComponent
+		: new QuietResultRenderComponent();
+	component.clear();
+
+	const output = getTextOutput(result);
+	const outputLines = output ? output.split("\n") : [];
+
+	if (outputLines.length > 0) {
+		const firstLine = outputLines[0] ?? "";
+		const hiddenLines = Math.max(0, outputLines.length - COLLAPSED_PREVIEW_LINES);
+		component.addChild({
+			render: (width) => [renderCollapsedLine(firstLine, hiddenLines, theme, width)],
+			invalidate: () => undefined,
+		});
+	} else if (options.isPartial) {
+		component.addChild(new Text(theme.fg("muted", "Running..."), 0, 0));
+	}
+
+	const warnings = getTruncationWarnings(result);
+	if (warnings.length > 0) {
+		component.addChild(new Text(theme.fg("warning", `[${warnings.join(". ")}]`), 0, 0));
+	}
+
+	if (state.startedAt !== undefined && options.isPartial) {
+		component.addChild(new Text(theme.fg("muted", `Elapsed ${formatDuration(Date.now() - state.startedAt)}`), 0, 0));
+	}
+
+	component.invalidate();
+	return component;
+}
+
+function getPathArg(args: unknown): string | undefined {
+	if (!args || typeof args !== "object") return undefined;
+	const values = args as { path?: unknown; file_path?: unknown };
+	return typeof values.file_path === "string"
+		? values.file_path
+		: typeof values.path === "string"
+			? values.path
+			: undefined;
+}
+
+function formatQuietEditCall(args: unknown, theme: ToolRenderCallParams[1]): string {
+	const path = getPathArg(args);
+	const edits = args && typeof args === "object" && Array.isArray((args as { edits?: unknown }).edits)
+		? (args as { edits: unknown[] }).edits.length
+		: undefined;
+	const editSummary = typeof edits === "number" && edits > 0 ? `${plural(edits, "edit block")} hidden` : "preview hidden";
+	return `${theme.fg("toolTitle", theme.bold("edit"))} ${theme.fg("accent", path ?? "...")}${theme.fg(
+		"muted",
+		`  ... ${editSummary} (${keyHint("app.tools.expand", "to expand")})`,
+	)}`;
+}
+
+function formatQuietWriteCall(args: unknown, theme: ToolRenderCallParams[1]): string {
+	const path = getPathArg(args);
+	const content = args && typeof args === "object" ? (args as { content?: unknown }).content : undefined;
+	const contentSummary = typeof content === "string"
+		? `${plural(content.split("\n").length, "line")}, ${formatSize(Buffer.byteLength(content, "utf8"))} hidden`
+		: "content hidden";
+	return `${theme.fg("toolTitle", theme.bold("write"))} ${theme.fg("accent", path ?? "...")}${theme.fg(
+		"muted",
+		`  ... ${contentSummary} (${keyHint("app.tools.expand", "to expand")})`,
+	)}`;
+}
+
+function renderQuietCall(
+	toolName: string,
+	base: ToolDefinition,
+	args: ToolRenderCallParams[0],
+	theme: ToolRenderCallParams[1],
+	context: ToolRenderCallParams[2],
+) {
+	if (context.expanded || !QUIET_CALL_TOOL_NAMES.has(toolName)) {
+		return base.renderCall?.(args, theme, context) ?? new Text(theme.fg("toolTitle", theme.bold(toolName)), 0, 0);
+	}
+
+	if (toolName === "edit") {
+		const component = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1);
+		const bgColor = context.isError
+			? "toolErrorBg"
+			: context.executionStarted && !context.isPartial
+				? "toolSuccessBg"
+				: "toolPendingBg";
+		component.setBgFn((text) => theme.bg(bgColor, text));
+		component.clear();
+		component.addChild(new Text(formatQuietEditCall(args, theme), 0, 0));
+		component.invalidate();
+		return component;
+	}
+
+	const text = context.lastComponent instanceof Text ? context.lastComponent : new Text("", 0, 0);
+	text.setText(formatQuietWriteCall(args, theme));
+	return text;
+}
+
+function createQuietToolDefinition(base: ToolDefinition): ToolDefinition {
+	const baseRenderResult = base.renderResult;
+
+	return {
+		...base,
+		renderCall(args, theme, context) {
+			return renderQuietCall(base.name, base, args, theme, context);
+		},
+		renderResult(result, options, theme, context) {
+			if (options.expanded && baseRenderResult) {
+				const delegateContext = context.lastComponent instanceof QuietResultRenderComponent
+					? { ...context, lastComponent: undefined }
+					: context;
+				return baseRenderResult(result, options, theme, delegateContext);
+			}
+
+			return renderQuietCollapsedResult(result, options, theme, context);
+		},
+	};
+}
+
+function createBaseToolOptions(cwd: string): ToolsOptions | undefined {
+	try {
+		const settings = SettingsManager.create(cwd);
+		return {
+			read: { autoResizeImages: settings.getImageAutoResize() },
+			bash: {
+				commandPrefix: settings.getShellCommandPrefix(),
+				shellPath: settings.getShellPath(),
+			},
+		};
+	} catch {
+		return undefined;
+	}
+}
+
+function createBaseToolDefinitions(cwd: string): ToolDefinition[] {
+	const options = createBaseToolOptions(cwd);
+	return [
+		createReadToolDefinition(cwd, options?.read),
+		createBashToolDefinition(cwd, options?.bash),
+		createEditToolDefinition(cwd, options?.edit),
+		createWriteToolDefinition(cwd, options?.write),
+		createGrepToolDefinition(cwd, options?.grep),
+		createFindToolDefinition(cwd, options?.find),
+		createLsToolDefinition(cwd, options?.ls),
+	] as ToolDefinition[];
+}
+
+function createQuietToolDefinitions(cwd: string, enabled: boolean): ToolDefinition[] {
+	const baseDefinitions = createBaseToolDefinitions(cwd);
+	return enabled ? baseDefinitions.map(createQuietToolDefinition) : baseDefinitions;
+}
+
+export default function quietToolsExtension(pi: ExtensionAPI) {
+	let enabled = true;
+
+	function registerTools(cwd: string): void {
+		for (const tool of createQuietToolDefinitions(cwd, enabled)) {
+			pi.registerTool(tool);
+		}
+	}
+
+	pi.on("session_start", async (_event, ctx) => {
+		registerTools(ctx.cwd);
+	});
+
+	pi.registerCommand("quiet-tools", {
+		description: "Toggle compact collapsed previews for built-in tool rows",
+		getArgumentCompletions: (prefix) => {
+			const commands = ["on", "off", "toggle", "status"];
+			const query = prefix.trim().toLowerCase();
+			const matches = commands.filter((command) => command.startsWith(query));
+			return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
+		},
+		handler: async (args, ctx) => {
+			const action = args.trim().toLowerCase() || "toggle";
+
+			if (action === "on" || action === "enable") {
+				enabled = true;
+				registerTools(ctx.cwd);
+				ctx.ui.notify("Quiet tool previews enabled: collapsed built-in tool rows show one-line output.", "info");
+				return;
+			}
+
+			if (action === "off" || action === "disable") {
+				enabled = false;
+				registerTools(ctx.cwd);
+				ctx.ui.notify("Quiet tool previews disabled: restored pi's standard built-in tool renderers.", "info");
+				return;
+			}
+
+			if (action === "toggle") {
+				enabled = !enabled;
+				registerTools(ctx.cwd);
+				ctx.ui.notify(
+					enabled
+						? "Quiet tool previews enabled: collapsed built-in tool rows show one-line output."
+						: "Quiet tool previews disabled: restored pi's standard built-in tool renderers.",
+					"info",
+				);
+				return;
+			}
+
+			if (action === "status") {
+				ctx.ui.notify(
+					`Quiet tool previews are ${enabled ? "enabled" : "disabled"}. Collapsed preview lines: ${enabled ? COLLAPSED_PREVIEW_LINES : "pi default"}. Model-visible tool results are unchanged.`,
+					"info",
+				);
+				return;
+			}
+
+			ctx.ui.notify("Usage: /quiet-tools on | off | toggle | status", "warning");
+		},
+	});
+}

package/extensions/{compact-bash → quiet-tools}/package.json

@@ -1,13 +1,13 @@
 {
-  "name": "@diegopetrucci/pi-compact-bash",
+  "name": "@diegopetrucci/pi-quiet-tools",
   "version": "0.1.0",
-  "description": "A pi extension that renders collapsed bash tool output as a one-line preview.",
-  "keywords": ["pi-package", "pi", "bash", "terminal"],
+  "description": "A pi extension that visually compacts collapsed built-in tool output in the TUI without changing tool results sent to the model.",
+  "keywords": ["pi-package", "pi", "tools", "terminal", "tui"],
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/diegopetrucci/pi-extensions.git",
-    "directory": "extensions/compact-bash"
+    "directory": "extensions/quiet-tools"
   },
   "files": [
     "index.ts",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.16",
-  "description": "A collection of pi extensions, including a minimal custom footer, an Amp-style oracle, a 200k context cap for auto-compaction, one-line collapsed bash previews, a permission gate for dangerous bash commands, confirm-before-destructive session actions, and terminal notifications when pi is ready for input.",
+  "version": "0.1.17",
+  "description": "A collection of pi extensions, including a minimal custom footer, an Amp-style oracle, a 200k context cap for auto-compaction, quiet one-line collapsed tool previews, a permission gate for dangerous bash commands, confirm-before-destructive session actions, and terminal notifications when pi is ready for input.",
   "keywords": ["pi-package", "pi", "terminal", "agent"],
   "license": "MIT",
   "repository": {
@@ -31,7 +31,7 @@
       "./extensions/minimal-footer/index.ts",
       "./extensions/oracle/index.ts",
       "./extensions/context-cap/index.ts",
-      "./extensions/compact-bash/index.ts",
+      "./extensions/quiet-tools/index.ts",
       "./extensions/permission-gate/index.ts",
       "./extensions/confirm-destructive/index.ts",
       "./extensions/notify/index.ts"

package/extensions/compact-bash/README.md

@@ -1,49 +0,0 @@
-# compact-bash
-
-A pi extension that makes collapsed assistant `bash` tool output much quieter.
-
-When enabled, collapsed bash output renders as one output line plus an inline hidden-line count and `Ctrl+O` expand hint. Expanding with `Ctrl+O` still shows the full rendered output.
-
-## Commands
-
-```text
-/compact-bash status
-/compact-bash off
-/compact-bash on
-/compact-bash toggle
-```
-
-The extension starts enabled by default. Disabling is temporary for the current extension runtime/session; after `/reload`, `/new`, `/resume`, or `/fork`, it starts enabled again.
-
-## Install
-
-### Standalone npm package
-
-```bash
-pi install npm:@diegopetrucci/pi-compact-bash
-```
-
-### Collection package
-
-```bash
-pi install npm:@diegopetrucci/pi-extensions
-```
-
-### GitHub package
-
-```bash
-pi install git:github.com/diegopetrucci/pi-extensions
-```
-
-Then reload pi:
-
-```text
-/reload
-```
-
-## Notes
-
-- This extension overrides pi's built-in `bash` tool so it can customize only the TUI renderer.
-- It reuses pi's built-in bash implementation and preserves `shellPath`/`shellCommandPrefix` settings when they are available from settings files.
-- It does not truncate or rewrite the actual tool result sent to the model.
-- It affects assistant-invoked `bash` tool rows. User `!`/`!!` bash commands are rendered by a separate pi component and keep pi's default preview behavior.

package/extensions/compact-bash/index.ts

@@ -1,241 +0,0 @@
-import {
-	createBashToolDefinition,
-	DEFAULT_MAX_BYTES,
-	formatSize,
-	keyHint,
-	SettingsManager,
-	type ExtensionAPI,
-} from "@earendil-works/pi-coding-agent";
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
-
-const COLLAPSED_PREVIEW_LINES = 1;
-
-type BashToolDefinition = ReturnType<typeof createBashToolDefinition>;
-type BashRenderResult = NonNullable<BashToolDefinition["renderResult"]>;
-type BashRenderResultParams = Parameters<BashRenderResult>;
-type BashRenderState = {
-	endedAt?: number;
-	interval?: ReturnType<typeof setInterval>;
-};
-
-function getTextOutput(result: BashRenderResultParams[0]): string {
-	return result.content
-		.filter((content) => content.type === "text")
-		.map((content) => content.text ?? "")
-		.join("\n")
-		.trim();
-}
-
-function formatDuration(ms: number): string {
-	return `${(ms / 1000).toFixed(1)}s`;
-}
-
-function visibleLength(text: string): number {
-	return text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").length;
-}
-
-function renderCollapsedLine(
-	line: string,
-	hiddenLines: number,
-	theme: BashRenderResultParams[2],
-	width: number,
-): string {
-	if (width <= 0) return "";
-
-	const styledLine = theme.fg("toolOutput", line);
-	if (hiddenLines <= 0) {
-		return truncateToWidth(styledLine, width, "...");
-	}
-
-	const hint = theme.fg(
-		"muted",
-		`  ... ${hiddenLines} more line${hiddenLines === 1 ? "" : "s"} (${keyHint("app.tools.expand", "to expand")})`,
-	);
-	const hintWidth = visibleLength(hint);
-	if (hintWidth + 8 > width) {
-		return truncateToWidth(`${styledLine}${hint}`, width, "...");
-	}
-
-	return `${truncateToWidth(styledLine, width - hintWidth, "...")}${hint}`;
-}
-
-function getTruncationWarnings(result: BashRenderResultParams[0]): string[] {
-	const details = result.details as
-		| {
-				truncation?: {
-					truncated?: boolean;
-					truncatedBy?: "lines" | "bytes";
-					outputLines?: number;
-					totalLines?: number;
-					maxBytes?: number;
-				};
-				fullOutputPath?: string;
-		  }
-		| undefined;
-	const truncation = details?.truncation;
-	const warnings: string[] = [];
-
-	if (details?.fullOutputPath) {
-		warnings.push(`Full output: ${details.fullOutputPath}`);
-	}
-
-	if (truncation?.truncated) {
-		if (truncation.truncatedBy === "lines") {
-			warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
-		} else {
-			warnings.push(
-				`Truncated: ${truncation.outputLines} lines shown (${formatSize(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
-			);
-		}
-	}
-
-	return warnings;
-}
-
-function syncElapsedTimer(options: BashRenderResultParams[1], context: BashRenderResultParams[3]): BashRenderState {
-	const state = context.state as BashRenderState & { startedAt?: number };
-
-	if (state.startedAt !== undefined && options.isPartial && !state.interval) {
-		state.interval = setInterval(() => context.invalidate(), 1000);
-	}
-
-	if (!options.isPartial || context.isError) {
-		state.endedAt ??= Date.now();
-		if (state.interval) {
-			clearInterval(state.interval);
-			state.interval = undefined;
-		}
-	}
-
-	return state;
-}
-
-const renderCompactBashResult: BashRenderResult = (result, options, theme, context) => {
-	const state = syncElapsedTimer(options, context);
-	const component = (context.lastComponent as Container | undefined) ?? new Container();
-	component.clear();
-
-	const output = getTextOutput(result);
-	const outputLines = output ? output.split("\n") : [];
-
-	if (outputLines.length > 0) {
-		if (options.expanded) {
-			const displayText = outputLines.map((line) => theme.fg("toolOutput", line)).join("\n");
-			component.addChild(new Text(displayText, 0, 0));
-		} else {
-			const firstLine = outputLines[0] ?? "";
-			const hiddenLines = Math.max(0, outputLines.length - COLLAPSED_PREVIEW_LINES);
-			component.addChild({
-				render: (width) => [renderCollapsedLine(firstLine, hiddenLines, theme, width)],
-				invalidate: () => undefined,
-			});
-		}
-	} else if (options.isPartial) {
-		component.addChild(new Text(theme.fg("muted", "Running..."), 0, 0));
-	}
-
-	const warnings = getTruncationWarnings(result);
-	if (warnings.length > 0) {
-		component.addChild(new Text(theme.fg("warning", `[${warnings.join(". ")}]`), 0, 0));
-	}
-
-	if (options.expanded) {
-		const statusParts: string[] = [];
-		if (outputLines.length > COLLAPSED_PREVIEW_LINES) {
-			statusParts.push(`(${keyHint("app.tools.expand", "to collapse")})`);
-		}
-		if (state.startedAt !== undefined) {
-			const endTime = state.endedAt ?? Date.now();
-			statusParts.push(theme.fg("muted", `${options.isPartial ? "Elapsed" : "Took"} ${formatDuration(endTime - state.startedAt)}`));
-		}
-		if (statusParts.length > 0) {
-			component.addChild(new Text(statusParts.join("\n"), 0, 0));
-		}
-	}
-
-	component.invalidate();
-	return component;
-};
-
-function createBaseBashToolDefinition(cwd: string): BashToolDefinition {
-	try {
-		const settings = SettingsManager.create(cwd);
-		return createBashToolDefinition(cwd, {
-			commandPrefix: settings.getShellCommandPrefix(),
-			shellPath: settings.getShellPath(),
-		});
-	} catch {
-		return createBashToolDefinition(cwd);
-	}
-}
-
-function createCompactBashToolDefinition(cwd: string, enabled: boolean): BashToolDefinition {
-	const base = createBaseBashToolDefinition(cwd);
-	if (!enabled) return base;
-
-	return {
-		...base,
-		renderResult: renderCompactBashResult,
-	};
-}
-
-export default function compactBashExtension(pi: ExtensionAPI) {
-	let enabled = true;
-
-	function registerBashTool(cwd: string): void {
-		pi.registerTool(createCompactBashToolDefinition(cwd, enabled));
-	}
-
-	pi.on("session_start", async (_event, ctx) => {
-		registerBashTool(ctx.cwd);
-	});
-
-	pi.registerCommand("compact-bash", {
-		description: "Toggle one-line collapsed previews for bash tool output",
-		getArgumentCompletions: (prefix) => {
-			const commands = ["on", "off", "toggle", "status"];
-			const query = prefix.trim().toLowerCase();
-			const matches = commands.filter((command) => command.startsWith(query));
-			return matches.length > 0 ? matches.map((value) => ({ value, label: value })) : null;
-		},
-		handler: async (args, ctx) => {
-			const action = args.trim().toLowerCase() || "toggle";
-
-			if (action === "on" || action === "enable") {
-				enabled = true;
-				registerBashTool(ctx.cwd);
-				ctx.ui.notify("Compact bash previews enabled: collapsed bash output shows one line.", "info");
-				return;
-			}
-
-			if (action === "off" || action === "disable") {
-				enabled = false;
-				registerBashTool(ctx.cwd);
-				ctx.ui.notify("Compact bash previews disabled: restored pi's standard bash renderer.", "info");
-				return;
-			}
-
-			if (action === "toggle") {
-				enabled = !enabled;
-				registerBashTool(ctx.cwd);
-				ctx.ui.notify(
-					enabled
-						? "Compact bash previews enabled: collapsed bash output shows one line."
-						: "Compact bash previews disabled: restored pi's standard bash renderer.",
-					"info",
-				);
-				return;
-			}
-
-			if (action === "status") {
-				ctx.ui.notify(
-					`Compact bash previews are ${enabled ? "enabled" : "disabled"}. Collapsed preview lines: ${enabled ? COLLAPSED_PREVIEW_LINES : "pi default"}.`,
-					"info",
-				);
-				return;
-			}
-
-			ctx.ui.notify("Usage: /compact-bash on | off | toggle | status", "warning");
-		},
-	});
-}