pi-compact-tools 0.10.0 → 0.11.0

package/extensions/compact-tools-grouping.ts

@@ -0,0 +1,282 @@
+import {
+	AssistantMessageComponent,
+	ToolExecutionComponent,
+	type AgentToolResult,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text, truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { claudeFailure, lookHint, lookKind, pathOf, type LookKind } from "./compact-tools-claude.ts";
+import { formatDurationMs, type RowStatus } from "./compact-tools-core.ts";
+import { hookMethod } from "./compact-tools-hook.ts";
+import { getTextResult } from "./compact-tools-invocation.ts";
+import { chromePainter, paintIndicator } from "./compact-tools-palette.ts";
+import type { ToolRuntime } from "./compact-tools-runtime.ts";
+import { findChat, isKind, isSilent } from "./compact-tools-silent.ts";
+import { captureViewport } from "./compact-tools-viewport.ts";
+import type { ToolArgs } from "./compact-tools-types.ts";
+
+const WIDGET_KEY = "compact-tools-groups";
+
+/** Claude Code's words for each way of looking around, in the order it lists them. */
+const PHRASES: ReadonlyArray<{ kind: LookKind; running: string; done: string; singular: string; plural: string }> = [
+	{ kind: "search", running: "searching for", done: "searched for", singular: "pattern", plural: "patterns" },
+	{ kind: "read", running: "reading", done: "read", singular: "file", plural: "files" },
+	{ kind: "list", running: "listing", done: "listed", singular: "directory", plural: "directories" },
+];
+
+export const EXPAND_HINT = "(ctrl+o to expand)";
+
+/** The fields of Pi's tool row a group summary reads. */
+export interface ToolRowLike {
+	toolName: string;
+	toolCallId: string;
+	args: unknown;
+	result?: AgentToolResult<unknown> & { isError?: boolean };
+	isPartial: boolean;
+	expanded: boolean;
+	render(width: number): string[];
+	handleMouse?(event: unknown): unknown;
+	invalidate(): void;
+}
+
+export function memberStatus(row: ToolRowLike): RowStatus {
+	if (!row.result || row.isPartial) return "running";
+	return row.result.isError ? "error" : "success";
+}
+
+function argsOf(row: ToolRowLike): ToolArgs {
+	return typeof row.args === "object" && row.args !== null ? row.args as ToolArgs : {};
+}
+
+// Keyed by the row and checked against its arguments, which stream in: a command is
+// parsed once rather than on every frame the whole transcript repaints.
+const kinds = new WeakMap<object, { args: unknown; kind: LookKind | undefined }>();
+
+function kindOf(row: ToolRowLike): LookKind | undefined {
+	const cached = kinds.get(row);
+	if (cached && cached.args === row.args) return cached.kind;
+	const kind = lookKind(row.toolName, argsOf(row));
+	kinds.set(row, { args: row.args, kind });
+	return kind;
+}
+
+function lastRunning(rows: readonly ToolRowLike[]): ToolRowLike | undefined {
+	for (let index = rows.length - 1; index >= 0; index--) {
+		if (memberStatus(rows[index]!) === "running") return rows[index];
+	}
+	return undefined;
+}
+
+/**
+ * How many patterns, files, and directories a group covers, counted as Claude Code
+ * counts them: files by distinct path, and reads by command only when no file was read.
+ */
+export function countGroup(rows: readonly ToolRowLike[]): Record<LookKind, number> {
+	const counts: Record<LookKind, number> = { search: 0, read: 0, list: 0 };
+	const paths = new Set<string>();
+	let readCommands = 0;
+	for (const row of rows) {
+		const kind = kindOf(row);
+		if (kind === "read" && row.toolName === "read") paths.add(pathOf(argsOf(row)));
+		else if (kind === "read") readCommands++;
+		else if (kind) counts[kind]++;
+	}
+	counts.read = paths.size > 0 ? paths.size : readCommands;
+	return counts;
+}
+
+/**
+ * "Searched for 2 patterns, read 3 files". While any call in the group still runs,
+ * every verb reads in progress. `bold` marks the counts, as Claude Code does.
+ */
+export function summarizeGroup(rows: readonly ToolRowLike[], bold: (text: string) => string = (text) => text): string {
+	const counts = countGroup(rows);
+	const running = lastRunning(rows) !== undefined;
+	const text = PHRASES.filter((phrase) => counts[phrase.kind] > 0)
+		.map((phrase) => {
+			const count = counts[phrase.kind];
+			return `${running ? phrase.running : phrase.done} ${bold(String(count))} ${count === 1 ? phrase.singular : phrase.plural}`;
+		})
+		.join(", ");
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+/** While a call runs, the line under its group names what it looks at. */
+export function groupHint(rows: readonly ToolRowLike[]): string | undefined {
+	const running = lastRunning(rows);
+	if (!running) return undefined;
+	return lookHint(running.toolName, argsOf(running)) || undefined;
+}
+
+/** Claude Code keeps a failure in view beneath the folded group. */
+export function groupFailures(rows: readonly ToolRowLike[]): string[] {
+	return rows.filter((row) => memberStatus(row) === "error")
+		.map((row) => claudeFailure(row.toolName, getTextResult(row.result!)).headline);
+}
+
+type GroupState = { expanded: boolean; lastHostExpanded: boolean };
+
+/** A run of tool rows drawn as one summary line, which a click or Ctrl+O opens into the rows themselves. */
+export class ToolGroupComponent extends Container {
+	constructor(
+		readonly rows: readonly ToolRowLike[],
+		/** Every child the group folded, in order: its tool rows and the thinking between them. */
+		members: readonly unknown[],
+		private readonly state: GroupState,
+		private readonly draw: (rows: readonly ToolRowLike[], width: number, expanded: boolean) => string[],
+		private readonly onToggle: () => void,
+	) {
+		super();
+		// Ctrl+O expands every tool row in Pi; the group follows it both ways.
+		const hostExpanded = rows[0]!.expanded;
+		if (state.lastHostExpanded !== hostExpanded) {
+			state.lastHostExpanded = hostExpanded;
+			state.expanded = hostExpanded;
+		}
+		const header: Component = {
+			render: (width) => this.draw(this.rows, width, this.state.expanded),
+			invalidate() {},
+			handleMouse: (event: { type?: string; button?: string }) => {
+				if (event.type !== "click" || event.button !== "left") return undefined;
+				captureViewport();
+				this.state.expanded = !this.state.expanded;
+				this.onToggle();
+				return { handled: true };
+			},
+		} as Component;
+		this.addChild(header);
+		if (state.expanded) for (const member of members) this.addChild(member as Component);
+	}
+}
+
+function isGroupable(child: unknown): child is ToolRowLike {
+	return isKind(child, ToolExecutionComponent) && kindOf(child as ToolRowLike) !== undefined;
+}
+
+type AssistantLike = { lastMessage?: { content?: Array<{ type: string; text?: string }> } };
+
+/** A turn with no text for the reader: it only thought, then handed off to tools. */
+function isThinkingOnly(child: unknown): boolean {
+	if (!isKind(child, AssistantMessageComponent)) return false;
+	const content = (child as AssistantLike).lastMessage?.content ?? [];
+	return !content.some((block) => block.type === "text" && block.text?.trim());
+}
+
+/**
+ * What may sit between two calls of one group: a turn that only thought, and the
+ * status lines Pi writes into the chat itself, such as "Tool output: collapsed".
+ */
+function isFoldable(child: unknown): boolean {
+	return isThinkingOnly(child) || isKind(child, Text) || isKind(child, Spacer);
+}
+
+/**
+ * Replace each run of reads, searches, and listings with one group. What sits
+ * between two of them folds into the group, as Claude Code keeps thinking out
+ * of the way; anything else, text, a command, an edit, ends the run.
+ */
+export function groupChildren(
+	children: readonly unknown[],
+	makeGroup: (rows: ToolRowLike[], members: unknown[]) => Component,
+): unknown[] {
+	const grouped: unknown[] = [];
+	let rows: ToolRowLike[] = [];
+	let members: unknown[] = [];
+	let pending: unknown[] = [];
+	const flush = () => {
+		if (rows.length > 0) grouped.push(makeGroup(rows, members));
+		rows = [];
+		members = [];
+	};
+	for (const child of children) {
+		if (isGroupable(child)) {
+			rows.push(child);
+			members.push(...pending, child);
+			pending = [];
+			continue;
+		}
+		if (rows.length > 0 && isFoldable(child)) {
+			pending.push(child);
+			continue;
+		}
+		flush();
+		grouped.push(...pending, child);
+		pending = [];
+	}
+	flush();
+	grouped.push(...pending);
+	return grouped;
+}
+
+/** Claude style: runs of reads, searches, and listings fold into one line each. */
+export class ToolGroupController {
+	private context: ExtensionContext | undefined;
+	private readonly states = new WeakMap<object, GroupState>();
+
+	constructor(private readonly runtime: ToolRuntime) {}
+
+	bind(ctx: ExtensionContext): void {
+		this.dispose();
+		this.context = ctx;
+		// An invisible widget is the extension API's way to reach Pi's TUI and its chat.
+		ctx.ui.setWidget(WIDGET_KEY, (tui) => {
+			const chat = findChat(tui);
+			if (chat) {
+				hookMethod(chat, "render", "claude.groups", (self, args, original) => {
+					if (!this.context || isSilent() || this.runtime.config.style !== "claude") return original.apply(self, args);
+					const children = self.children as unknown[];
+					self.children = groupChildren(children, (rows, members) => this.makeGroup(rows, members, tui));
+					try {
+						return original.apply(self, args);
+					} finally {
+						self.children = children;
+					}
+				});
+			}
+			return { render: () => [], invalidate() {} };
+		}, { placement: "belowEditor" });
+	}
+
+	dispose(): void {
+		this.context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
+		this.context = undefined;
+	}
+
+	private makeGroup(rows: ToolRowLike[], members: unknown[], tui: { requestRender(): void }): Component {
+		const key = rows[0]!;
+		let state = this.states.get(key);
+		if (!state) {
+			state = { expanded: key.expanded, lastHostExpanded: key.expanded };
+			this.states.set(key, state);
+		}
+		return new ToolGroupComponent(rows, members, state, (group, width, expanded) => this.draw(group, width, expanded),
+			() => tui.requestRender());
+	}
+
+	/**
+	 * A group's line reads like any other row: its status dot, then what it did in
+	 * the title style. While it runs the dot pulses and the line below names what it
+	 * looks at.
+	 */
+	private draw(rows: readonly ToolRowLike[], width: number, expanded: boolean): string[] {
+		const theme = this.context?.ui.theme;
+		if (!theme) return [];
+		const chrome = chromePainter(theme);
+		const fit = (line: string) => truncateToWidth(line, Math.max(1, width), "…");
+		const running = lastRunning(rows);
+		const failed = rows.some((row) => memberStatus(row) === "error");
+		const status: RowStatus = running ? "running" : failed ? "error" : "success";
+		let title = `${paintIndicator(theme, status, this.runtime.frame)} ${theme.fg("toolTitle", theme.bold(summarizeGroup(rows)))}`;
+		if (running) {
+			const started = this.runtime.timing(running.toolCallId)?.startedAt;
+			const elapsed = started === undefined ? 0 : Date.now() - started;
+			title += `${elapsed >= 2000 ? chrome(` · ${formatDurationMs(elapsed)}`) : ""}…`;
+		}
+		if (!expanded) title += chrome(` ${EXPAND_HINT}`);
+		const lines = ["", fit(` ${title}`)];
+		const hintText = groupHint(rows);
+		if (hintText) lines.push(fit(chrome(` └ ${hintText}`)));
+		if (!expanded) for (const failure of groupFailures(rows)) lines.push(fit(chrome(" └ ") + theme.fg("error", failure)));
+		return lines;
+	}
+}

package/extensions/compact-tools-invocation.ts

@@ -72,7 +72,7 @@ export function getArgumentDetails(name: string, args: ToolArgs): ToolArgs {
 	return collectArgumentDetails(name, args);
 }
 
-function shellSegments(command: string): string[] {
+export function shellSegments(command: string): string[] {
 	const segments: string[] = [];
 	let current = "";
 	let quote: "'" | '"' | "`" | undefined;

package/extensions/compact-tools-layout.ts

@@ -4,6 +4,7 @@ import {
 	Container,
 	sliceByColumn,
 	stripTerminalSequences,
+	truncateToWidth,
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
@@ -86,6 +87,48 @@ export function prefixedText(text: string, firstPrefix: string, continuationPref
 	});
 }
 
+/**
+ * Lines under a tree prefix. With `truncate`, each keeps to one row and ends in an
+ * ellipsis, the way Claude Code previews; otherwise each wraps in full. Lines are
+ * handled one by one, so the indentation that output starts with survives.
+ */
+export function prefixedLines(text: string, firstPrefix: string, continuationPrefix: string, truncate: boolean): Component {
+	const prefixWidth = Math.max(visibleWidth(firstPrefix), visibleWidth(continuationPrefix));
+	const lines = text.replace(/\t/g, "   ").split("\n");
+	return new CachedComponent((width) => {
+		const available = Math.max(1, width - prefixWidth);
+		const rows = truncate
+			? lines.map((line) => truncateToWidth(line, available, "…"))
+			: lines.flatMap((line) => hardWrapTextWithAnsi(line, available));
+		return rows.map((row, index) => `${index === 0 ? firstPrefix : continuationPrefix}${row}`);
+	});
+}
+
+/**
+ * Output as Claude Code previews it. Each line is wrapped to the width, and rows
+ * rather than lines are counted: collapsed, `maxRows` show, all of them when only
+ * one more would be hidden, and then `more(hidden)`. Claude Code wraps ten
+ * columns short of the terminal, so previews break where its own do.
+ */
+export function claudeRows(
+	lines: readonly string[],
+	firstPrefix: string,
+	continuationPrefix: string,
+	maxRows: number | undefined,
+	more: (hidden: number) => string,
+): Component {
+	const prefixWidth = Math.max(visibleWidth(firstPrefix), visibleWidth(continuationPrefix));
+	return new CachedComponent((width) => {
+		const available = Math.max(1, width - prefixWidth);
+		const wrapWidth = maxRows === undefined ? available : Math.min(available, Math.max(width - 10, 10));
+		let rows = lines.flatMap((line) => hardWrapTextWithAnsi(line, wrapWidth).map((row) => row.trimEnd()));
+		if (maxRows !== undefined && rows.length > maxRows + 1) {
+			rows = [...rows.slice(0, maxRows), more(rows.length - maxRows)];
+		}
+		return rows.map((row, index) => `${index === 0 ? firstPrefix : continuationPrefix}${row}`);
+	});
+}
+
 export function hardWrapTextWithAnsi(text: string, width: number): string[] {
 	const safeWidth = Math.max(1, width);
 	const wrapped: string[] = [];
@@ -145,6 +188,7 @@ export type CodeDiffLine = {
 export type CodeDiffOptions = {
 	/** Context lines kept around each change; omit to keep every context line the diff carries. */
 	contextLines?: number;
+	rail?: string;
 };
 
 const DIFF_SEPARATOR = "\u22ee";
@@ -216,13 +260,12 @@ export function trimDiffContext(lines: CodeDiffLine[], contextLines: number): Co
 	});
 	const result: CodeDiffLine[] = [];
 	lines.forEach((line, index) => {
-		if (kept[index]) {
-			result.push(line);
-			return;
-		}
-		if (result.length > 0 && result[result.length - 1]!.kind !== "separator") {
-			result.push({ kind: "separator", content: DIFF_SEPARATOR, hunk: line.hunk });
-		}
+		const previous = result[result.length - 1];
+		// One mark per gap: context dropped next to a hunk break the diff already marks
+		// would otherwise draw two.
+		if (previous?.kind === "separator" && (!kept[index] || line.kind === "separator")) return;
+		if (kept[index]) result.push(line);
+		else if (previous) result.push({ kind: "separator", content: DIFF_SEPARATOR, hunk: line.hunk });
 	});
 	while (result.length > 0 && result[result.length - 1]!.kind === "separator") result.pop();
 	return result;
@@ -302,6 +345,8 @@ type CodeRowsOptions = {
 	signs: boolean;
 	/** Dim note rendered below the code, such as a read truncation notice. */
 	footer?: string;
+	/** What each row starts with; the result rail unless a mode draws its own. */
+	rail?: string;
 };
 
 /** Render numbered, syntax-highlighted code rows shared by edit diffs and read/write file views. */
@@ -312,7 +357,7 @@ function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, optio
 	const shebangLine = first?.lineNumber === 1 && first.kind !== "separator" ? first.content : undefined;
 	const highlighted = highlightCodeLines(lines, resolveLanguage(path, shebangLine), theme);
 	const numberWidth = Math.max(1, ...lines.map((line) => String(line.lineNumber ?? "").length));
-	const prefix = paintChrome(theme, " \u2502 ");
+	const prefix = options.rail ?? paintChrome(theme, " \u2502 ");
 	const prefixWidth = visibleWidth(prefix);
 	const gutterWidth = numberWidth + (options.signs ? 3 : 2);
 	const addedTint = options.signs ? diffTintRgb(theme, "toolDiffAdded") : undefined;
@@ -362,13 +407,14 @@ export function renderCodeDiff(
 	const diff = parseCodeDiff(patch, displayDiff);
 	const lines = options.contextLines === undefined ? diff : trimDiffContext(diff, options.contextLines);
 	if (lines.length === 0) return undefined;
-	return renderCodeRows(lines, path, theme, { signs: true });
+	return renderCodeRows(lines, path, theme, { signs: true, rail: options.rail });
 }
 
 export type CodeViewOptions = {
 	/** File line number of the first code line, e.g. a read's `offset`. */
 	startLine?: number;
 	footer?: string;
+	rail?: string;
 };
 
 /** Render file contents with line numbers and syntax highlighting, matching the edit diff layout. */
@@ -382,20 +428,21 @@ export function renderCodeView(code: string, path: string, theme: Theme, options
 		content: content.replace(/\t/gu, "   "),
 		hunk: 0,
 	}));
-	return renderCodeRows(lines, path, theme, { signs: false, footer: options.footer });
+	return renderCodeRows(lines, path, theme, { signs: false, footer: options.footer, rail: options.rail });
 }
 
 /** Limit a result preview by rendered rows while preserving the full source component for expansion. */
-export function limitComponentLines(component: Component, maximumLines: number, theme: Theme): Component {
+export function limitComponentLines(
+	component: Component,
+	maximumLines: number,
+	theme: Theme,
+	footer: (omitted: number) => string = (omitted) => paintChrome(theme, " │ ")
+		+ theme.fg("toolOutput", `… ${omitted} more ${omitted === 1 ? "line" : "lines"}`),
+): Component {
 	return new CachedComponent((width) => {
 		const lines = component.render(width);
 		if (lines.length <= maximumLines) return lines;
-		const omitted = lines.length - maximumLines;
-		return [
-			...lines.slice(0, maximumLines),
-			paintChrome(theme, " │ ")
-				+ theme.fg("toolOutput", `… ${omitted} more ${omitted === 1 ? "line" : "lines"}`),
-		];
+		return [...lines.slice(0, maximumLines), footer(lines.length - maximumLines)];
 	}, () => component.invalidate?.());
 }
 

package/extensions/compact-tools-palette.ts

@@ -1,4 +1,5 @@
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { indicatorGlyph, indicatorStrength, indicatorTone, type RowStatus } from "./compact-tools-core.ts";
 import {
 	colorizeRgb,
 	interpolateRgb,
@@ -108,6 +109,15 @@ export function indicatorPulse(theme: Theme): ColorRamp | undefined {
 	return ramp(theme, PULSE_LOW, PULSE_HIGH);
 }
 
+/** A row's status dot; a running one pulses between the theme's endpoints as frames advance. */
+export function paintIndicator(theme: Theme, status: RowStatus, frame: number): string {
+	const glyph = indicatorGlyph(status, frame);
+	const pulse = status === "running" ? indicatorPulse(theme) : undefined;
+	return pulse
+		? colorizeRgb(theme, interpolateRgb(pulse.from, pulse.to, indicatorStrength(status, frame)), glyph)
+		: theme.fg(indicatorTone(status, frame), glyph);
+}
+
 /** How far the brightest activity dot moves from the level's color toward the label's crest. */
 const ACTIVITY_CREST_MIX = 0.3;
 /** Contrast against the background of an unlit dot: the level's hue, barely there. */

package/extensions/compact-tools-release.ts

@@ -39,25 +39,27 @@ export function compareVersions(left: string, right: string): number {
 
 /**
  * The notes to show, newest first: every version with notes after the last one
- * shown, up to the installed one. With nothing shown before, only the installed
- * version's notes appear: that is either a new install or an update from a
- * version that predates these notices, and there is no telling which.
+ * shown, up to the installed one. An empty list marks a quiet release, such as a
+ * documentation update, that shows nothing. With nothing shown before, only the
+ * newest notes up to the installed version appear: that is either a new install
+ * or an update from a version that predates these notices, and there is no
+ * telling which.
  */
 export function releasesToShow(
 	installed: string,
 	notes: ReleaseNotes,
 	lastShown: string | undefined,
 ): Array<{ version: string; notes: readonly string[] }> {
-	const versions = lastShown === undefined
-		? (notes[installed]?.length ? [installed] : [])
-		: Object.keys(notes).filter((version) =>
+	const withNotes = Object.keys(notes)
+		.filter((version) =>
 			VERSION.test(version)
-			&& compareVersions(version, lastShown) > 0
 			&& compareVersions(version, installed) <= 0
-			&& notes[version]!.length > 0);
-	return versions
-		.sort((left, right) => compareVersions(right, left))
-		.map((version) => ({ version, notes: notes[version]! }));
+			&& notes[version]!.length > 0)
+		.sort((left, right) => compareVersions(right, left));
+	const versions = lastShown === undefined
+		? withNotes.slice(0, 1)
+		: withNotes.filter((version) => compareVersions(version, lastShown) > 0);
+	return versions.map((version) => ({ version, notes: notes[version]! }));
 }
 
 function lastShownVersion(directory: string): string | undefined {

package/extensions/compact-tools-runtime.ts

@@ -38,6 +38,16 @@ export class ToolRuntime {
 		return this.configValue;
 	}
 
+	/** The shared animation frame of running indicators, for rows drawn outside a tool renderer. */
+	get frame(): number {
+		return this.indicatorFrame;
+	}
+
+	/** When a tool call started and, once it has, ended. */
+	timing(toolCallId: string): Readonly<ExecutionTiming> | undefined {
+		return this.executionTimings.get(toolCallId);
+	}
+
 	configure(config: CompactToolsConfig): void {
 		this.configValue = config;
 		this.configRevision = {};

package/extensions/compact-tools-silent.ts

@@ -59,7 +59,7 @@ function sharedState(): SilentState {
  * an install with a second copy (a development checkout, for one) still builds
  * the same classes, so a matching name identifies them there.
  */
-function isKind(child: unknown, kind: abstract new (...args: any[]) => unknown): boolean {
+export function isKind(child: unknown, kind: abstract new (...args: any[]) => unknown): boolean {
 	return child instanceof kind
 		|| (typeof child === "object" && child !== null && child.constructor?.name === kind.name);
 }
@@ -159,10 +159,16 @@ type TuiLike = { children?: Array<{ children?: unknown[] }> };
  * Pi mounts the transcript document first in both regular and fullscreen mode, and
  * its chat is the document's last child, after the header and resource list.
  */
-function hookChatNotices(tui: unknown): void {
+export function findChat(tui: unknown): { children: unknown[] } | undefined {
 	const documentChildren = (tui as TuiLike).children?.[0]?.children;
 	const chat = Array.isArray(documentChildren) ? documentChildren.at(-1) : undefined;
-	if (typeof chat !== "object" || chat === null || !Array.isArray((chat as { children?: unknown }).children)) return;
+	if (typeof chat !== "object" || chat === null || !Array.isArray((chat as { children?: unknown }).children)) return undefined;
+	return chat as { children: unknown[] };
+}
+
+function hookChatNotices(tui: unknown): void {
+	const chat = findChat(tui);
+	if (!chat) return;
 	hookMethod(chat, "render", "silent.chatNotices", (self, args, original) => {
 		const state = sharedState();
 		if (!state.active || !state.enabled) return original.apply(self, args);

package/extensions/compact-tools-types.ts

@@ -10,6 +10,9 @@ export type BuiltInDefinition = ToolDefinition<any, any, any>;
 
 export const DISPLAY_MODES = ["normal", "silent"] as const;
 export type DisplayMode = (typeof DISPLAY_MODES)[number];
+/** How tool rows are drawn: compactly, the way Claude Code draws them, or by Pi itself. */
+export const DISPLAY_STYLES = ["compact", "claude", "off"] as const;
+export type DisplayStyle = (typeof DISPLAY_STYLES)[number];
 
 export interface CustomToolsConfig {
 	/** Render tools registered by other extensions compactly as well. */
@@ -20,6 +23,7 @@ export interface CustomToolsConfig {
 
 export interface CompactToolsConfig {
 	mode: DisplayMode;
+	style: DisplayStyle;
 	tools: CompactToolName[];
 	/** Built-ins always have an entry; custom tools may, and otherwise use custom_tools.auto_compact. */
 	auto_compact: Record<CompactToolName, boolean> & { [tool: string]: boolean | undefined };