pi-compact-tools 0.9.2 → 0.10.0

package/README.md

@@ -1,17 +1,19 @@
 # pi-compact-tools
 
-Compact, expandable rendering for Pi's built-in tools, with a GitHub Dark theme.
+Compact, expandable rendering for Pi's built-in tools and for custom tools from other packages, with a GitHub Dark theme.
 
-![Compact rows for every built-in tool](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
+![Compact rows for built-in and custom tools, including a web search and an edit with its diff and line counts](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-![Syntax-highlighted edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
+![Syntax-highlighted edit diff with lines added and removed](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
 
 ![Numbered read code view](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/code-aware-results.gif)
 
 ## Features
 
 - Compact rows for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`, with status, duration, and line count
+- The same compact rows for custom tools registered by other packages, such as web search or MCP tools, with no setup
 - Syntax-highlighted edit diffs and numbered `read`/`write` code views, including Markdown code fences
+- Edits report what they changed on their status line, lines added and removed in the diff colors: `(+3 -1)`
 - Animated working label above the prompt, lit in the session's own thinking-level color, and a `Ctrl+T` thinking summary/detail cycle
 - Theme-agnostic chrome: rails, the tool indicator, and the working label are derived from the active theme and stay legible on light and dark backgrounds
 - No Nerd Font required
@@ -37,12 +39,55 @@ Optional. Put it in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-t
 ```
 
 - `tools`: tools to render compactly. Also available: `grep`, `find`, `ls`, `powershell`.
-- `auto_compact`: `true` starts hidden, `false` starts with a preview of up to `previewLines` rows (`1`–`100`).
+- `auto_compact`: `true` starts hidden, `false` starts with a preview of up to `previewLines` rows (`1`–`100`). Custom tools can be listed by name too, such as `"web_search": false`.
+- `mode`: `"normal"` (default) or `"silent"`. See [Silent mode](#silent-mode).
+- `custom_tools`: compact rendering for tools from other packages. See [Custom tools](#custom-tools).
+
+## Custom tools
+
+Tools registered by other packages get the same row as the built-ins: a status indicator, the tool name, a one-line summary of the call, then duration and line count once it finishes. It works for any tool, whichever package registered it, with nothing to configure.
+
+Expanding a row shows the call's arguments and then the result as the tool's own package renders it, so a package's custom result view is kept. Tools without a result renderer show their text output.
+
+```json
+{
+  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": ["my_tool"] }
+}
+```
+
+- `enabled`: `false` leaves every custom tool with its own renderer. `"custom_tools": false` is shorthand.
+- `auto_compact`: like the built-in setting, `true` starts rows hidden and `false` starts with a preview. A tool named in the top-level `auto_compact` uses its own setting instead.
+- `exclude`: tool names that keep their own renderer.
+
+Built-in tools follow `tools` above: a built-in left out of that list keeps Pi's default renderer.
+
+Pi has no public API for changing how another package's tool is drawn, so this wraps the renderer lookup of Pi's tool row component. Nothing in Pi's installation is modified, and it only applies while this extension is loaded. If a Pi release changes that component, custom tools fall back to their own renderers and Pi shows a warning once.
+
+## Silent mode
+
+![Silent mode switched on mid-run: the tool rows fold away into a moving light, the answer stays, and every row comes back when it is off](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
+
+Silent mode shows only your prompts and the final answers. Tool calls (including custom tools from other packages), the assistant's in-between turns, thinking, error and abort notices, extension notices such as web-search progress, and Pi's own status lines are hidden while the animated working label shows what is running.
+
+- While the agent works, a light runs back and forth along a short line beneath your latest prompt, above the working label and just as long, leaving a fading afterimage in the thinking level's color. It steps aside once the answer starts.
+- `Ctrl+'` or `/silent` toggles it for the current session; `/silent on` and `/silent off` set it explicitly.
+- `Ctrl+'` needs a terminal that reports it as its own key (the Kitty keyboard protocol: Ghostty, Kitty, WezTerm, and others). Where it only types `'`, use `/silent`.
+- Set `"mode": "silent"` in `compact-tools.json` to start every session silent.
+- Turning it off brings back every hidden row. Nothing is removed from the session or the model's context.
+- Errors are hidden too, so a run that fails ends without an answer. Turn silent mode off to see what went wrong.
+
+Pi has no public API for hiding other extensions' tool rows, so silent mode wraps Pi's transcript components. If a future Pi release changes them, `/silent` reports that it is unavailable and the transcript renders normally.
 
 ## Controls
 
 - Click a row or press `Ctrl+O` to expand or collapse results.
+- In fullscreen mode, expanding or collapsing every row, cycling thinking, and toggling silent mode keep the text you were reading in place instead of jumping.
 - `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
+- `Ctrl+'` or `/silent` toggles silent mode.
+
+## Release notes
+
+After an update, the next new conversation opens with a bordered "What's new" block, the way Pi shows its own changelog: once, listing every release since the last one shown. A resumed session keeps it for the next new one, and so does silent mode. The block lives only in the TUI; it is never saved to the session or sent to the model. When publishing a new version, add its changes to `release-notes.json`; `npm run check` requires an entry matching `package.json`.
 
 ## Development
 

package/extensions/compact-tools-activity.ts

@@ -0,0 +1,351 @@
+import { UserMessageComponent, type ExtensionAPI, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import { onTick } from "./compact-tools-clock.ts";
+import { colorizeRgb, interpolateRgb, type Rgb } from "./compact-tools-color.ts";
+import { hookMethod } from "./compact-tools-hook.ts";
+import { activityGlow, type ColorRamp, type ThinkingLevel } from "./compact-tools-palette.ts";
+
+const WIDGET_KEY = "compact-tools-silent-activity-render";
+const ACTIVITY_STATE = Symbol.for("pi-compact-tools.silent.activity.state");
+// Markers under which earlier versions kept the unwrapped methods; hookMethod
+// replaces those wrappers so a /reload never leaves the old drawing in place.
+const LEGACY_USER_RENDER = Symbol.for("pi-compact-tools.silent.activity.originalUserRender");
+const LEGACY_TRANSCRIPT_RENDER = Symbol.for("pi-compact-tools.silent.activity.originalTranscriptRender");
+const LEGACY_GAP_RENDER = Symbol.for("pi-compact-tools.silent.activity.originalGapRender");
+/**
+ * Pi mounts the same components in regular and fullscreen mode, in this order:
+ * transcript, pending messages, status, widgets above, editor, widgets below, footer.
+ */
+const MOUNTED_CHILDREN = 7;
+const WIDGETS_ABOVE_CHILD = 3;
+/**
+ * Frames per run to the end of the line and back, on the shared 80 ms clock: about
+ * two seconds. The light crosses the middle fast, a cell or more per frame, so
+ * few frames are needed; the tail fills in every cell it swept past between them.
+ */
+const BREATH_FRAMES = 26;
+const DOT_COUNT = 9;
+/**
+ * Pi draws the working label into the editor's top border after a "── " prefix,
+ * so the label's first letter sits in column 3. The line starts there too, lining
+ * up with "Thinking…" just below it.
+ */
+const LABEL_COLUMN = 3;
+/** A heavy line segment: consecutive cells join into one unbroken line, like the editor border below. */
+const DOT = "━";
+/** Brightness a passed cell keeps from one 80 ms frame to the next: the tail fades within about a third of a second. */
+const AFTERGLOW = 0.6;
+/** Frames of history the tail is traced over; beyond this it is fully dark. */
+const AFTERGLOW_FRAMES = 8;
+/** Samples between frames, so a light crossing two cells in one frame still leaves both in its tail. */
+const SUBSTEPS = 8;
+/** Brightness levels: coarse enough that unchanged frames compare equal and skip a repaint. */
+const TONE_LEVELS = 32;
+/** Perceptual easing for color: faint tail steps would otherwise read as bands. */
+const TONE_GAMMA = 0.75;
+
+/**
+ * Where the light is at a (possibly fractional) frame. It runs to the last cell and
+ * back, and each run follows a quintic S-curve (smootherstep): it lingers at each
+ * end, is fastest through the middle, and settles into the far end.
+ */
+function lightPosition(time: number): number {
+	const step = ((time % BREATH_FRAMES) + BREATH_FRAMES) % BREATH_FRAMES;
+	const half = BREATH_FRAMES / 2;
+	const run = step < half ? step / half : (BREATH_FRAMES - step) / half;
+	return run * run * run * (run * (run * 6 - 15) + 10) * (DOT_COUNT - 1);
+}
+
+function cellAt(time: number): number {
+	return Math.round(lightPosition(time));
+}
+
+/**
+ * Brightness of every cell for one frame. The head is the cell the light is on, at
+ * full brightness. A cell it has passed, even between two frames, keeps a fading
+ * afterimage, so the light trails an unbroken tail. Nothing ahead of the head is
+ * ever lit: the direction turns only when the head actually steps off an end cell,
+ * and cells ahead of it in the new direction are dark.
+ */
+function computeFrame(frame: number): number[] {
+	const head = cellAt(frame);
+	let direction: 1 | -1 = 1;
+	for (let sample = 1; sample <= BREATH_FRAMES * SUBSTEPS; sample++) {
+		const previous = cellAt(frame - sample / SUBSTEPS);
+		if (previous !== head) {
+			direction = head > previous ? 1 : -1;
+			break;
+		}
+	}
+	return Array.from({ length: DOT_COUNT }, (_, index) => {
+		if ((index - head) * direction > 0) return 0;
+		for (let sample = 0; sample <= AFTERGLOW_FRAMES * SUBSTEPS; sample++) {
+			if (cellAt(frame - sample / SUBSTEPS) === index) {
+				return Math.round(AFTERGLOW ** (sample / SUBSTEPS) * TONE_LEVELS) / TONE_LEVELS;
+			}
+		}
+		return 0;
+	});
+}
+
+// One run is computed once when the module loads; every frame after is a lookup.
+const FRAMES: readonly (readonly number[])[] = Array.from({ length: BREATH_FRAMES }, (_, frame) => computeFrame(frame));
+const FRAME_CHANGED: readonly boolean[] = FRAMES.map((cells, frame) => {
+	const previous = FRAMES[(frame + BREATH_FRAMES - 1) % BREATH_FRAMES]!;
+	return cells.some((value, index) => value !== previous[index]);
+});
+
+function frameIndex(frame: number): number {
+	return ((Math.floor(frame) % BREATH_FRAMES) + BREATH_FRAMES) % BREATH_FRAMES;
+}
+
+/** Brightness of each cell, 0 to 1, at a frame. */
+export function dotIntensities(frame: number): number[] {
+	return [...FRAMES[frameIndex(frame)]!];
+}
+
+/** Whether a frame looks different from the one before it; an identical frame needs no repaint. */
+export function frameChanges(frame: number): boolean {
+	return FRAME_CHANGED[frameIndex(frame)]!;
+}
+
+// Resolving a ramp walks the theme's colors; it only changes with the theme or the level.
+const glowCache = new WeakMap<Theme, Map<ThinkingLevel, ColorRamp | null>>();
+
+function cachedGlow(theme: Theme, level: ThinkingLevel): ColorRamp | undefined {
+	let byLevel = glowCache.get(theme);
+	if (!byLevel) {
+		byLevel = new Map();
+		glowCache.set(theme, byLevel);
+	}
+	if (!byLevel.has(level)) byLevel.set(level, activityGlow(theme, level) ?? null);
+	return byLevel.get(level) ?? undefined;
+}
+
+function toneColor(glow: ColorRamp, intensity: number): Rgb {
+	return interpolateRgb(glow.from, glow.to, intensity ** TONE_GAMMA);
+}
+
+/** A line the light runs along with a fading afterimage, in the thinking level's color, fitted to the width. */
+export function renderActivityDots(
+	frame: number,
+	width: number,
+	theme: Theme,
+	level: ThinkingLevel = "medium",
+	column = LABEL_COLUMN,
+): string[] {
+	if (width <= 0) return [];
+	const indent = Math.max(0, Math.min(column, width - 1));
+	const fitting = Math.min(DOT_COUNT, width - indent);
+	const glow = cachedGlow(theme, level);
+	const dots = FRAMES[frameIndex(frame)]!.slice(0, fitting).map((intensity) => glow
+		? colorizeRgb(theme, toneColor(glow, intensity), DOT)
+		// Reached only when the theme's colors did not resolve.
+		: theme.fg(intensity > 0.5 ? "text" : "dim", DOT));
+	return [" ".repeat(indent) + dots.join("")];
+}
+
+/** Add the activity row directly beneath the prompt, keeping Pi's padding inside its box. */
+export function attachActivityToUserMessage(lines: string[], activity: string): string[] {
+	return [...lines, activity];
+}
+
+interface ActivityState {
+	active: boolean;
+	frame: number;
+	level?: ThinkingLevel;
+	theme?: Theme;
+	tui?: TUI;
+	target?: UserMessageComponent;
+	candidate?: UserMessageComponent;
+	selectionPending?: boolean;
+}
+
+function sharedActivityState(): ActivityState {
+	const holder = globalThis as typeof globalThis & { [ACTIVITY_STATE]?: ActivityState };
+	holder[ACTIVITY_STATE] ??= { active: false, frame: 0 };
+	return holder[ACTIVITY_STATE];
+}
+
+/** Fill unused transcript rows above the content while silent mode is active. */
+export function bottomAlignTranscript(lines: string[], viewportHeight: number): string[] {
+	const gap = Math.max(0, Math.floor(viewportHeight) - lines.length);
+	return gap > 0 ? [...Array<string>(gap).fill(""), ...lines] : lines;
+}
+
+function patchTranscriptAlignment(tui: TUI): void {
+	const getPrimaryScrollView = (tui as TUI & { getPrimaryScrollView?: () => unknown }).getPrimaryScrollView;
+	const scroll = getPrimaryScrollView?.call(tui) as { child?: { render(width: number): string[] }; viewportHeight?: number } | undefined;
+	const document = scroll?.child;
+	if (!document) return;
+	hookMethod(document, "render", "activity.transcriptRender", (self, args, original) => {
+		const lines: string[] = original.apply(self, args);
+		if (!sharedActivityState().active) return lines;
+		const height = scroll?.viewportHeight;
+		return typeof height === "number" ? bottomAlignTranscript(lines, height) : lines;
+	}, [LEGACY_TRANSCRIPT_RENDER]);
+}
+
+type ContainerLike = { children?: unknown[]; render(width: number): string[] };
+
+function isSpacer(component: unknown): boolean {
+	return typeof component === "object" && component !== null && component.constructor?.name === "Spacer";
+}
+
+/**
+ * Pi keeps one blank row between the transcript and the editor: the widgets-above
+ * area renders a lone spacer when no extension placed a widget there. While the
+ * line animates it already separates the prompt from the editor, so that row
+ * would only push them apart. It is found by its fixed place among the TUI's
+ * children, the same in regular and fullscreen mode, and left
+ * alone whenever the layout differs or a real widget occupies it.
+ */
+function patchEditorGap(tui: TUI): void {
+	const children = (tui as TUI & { children?: unknown[] }).children;
+	if (!Array.isArray(children) || children.length !== MOUNTED_CHILDREN) return;
+	const gap = children[WIDGETS_ABOVE_CHILD] as ContainerLike | undefined;
+	if (!gap || !Array.isArray(gap.children)) return;
+	hookMethod(gap, "render", "activity.editorGap", (self: ContainerLike, args, original) => {
+		if (!sharedActivityState().active) return original.apply(self, args);
+		return (self.children ?? []).every(isSpacer) ? [] : original.apply(self, args);
+	}, [LEGACY_GAP_RENDER]);
+}
+
+/** Draw the activity row as part of the latest submitted user message. */
+function patchUserMessage(): boolean {
+	const prototype = UserMessageComponent?.prototype;
+	if (!prototype) return false;
+	return hookMethod(prototype, "render", "activity.userRender", (self: UserMessageComponent, args, original) => {
+		const state = sharedActivityState();
+		if (!state.active) return original.apply(self, args);
+		const lines: string[] = original.apply(self, args);
+		if (lines.length === 0) return lines;
+		// The transcript renders user messages in order. Commit the last one after
+		// the current render pass, then repaint only if the target changed.
+		state.candidate = self;
+		if (!state.selectionPending) {
+			state.selectionPending = true;
+			queueMicrotask(() => {
+				state.selectionPending = false;
+				if (!state.active || state.target === state.candidate) return;
+				state.target = state.candidate;
+				state.tui?.requestRender();
+			});
+		}
+		if (state.target !== self || !state.theme) return lines;
+		const width = args[0] as number;
+		return attachActivityToUserMessage(lines, renderActivityDots(state.frame, width, state.theme, state.level)[0] ?? "");
+	}, [LEGACY_USER_RENDER]);
+}
+
+/** Animates beneath the latest submitted prompt during a silent turn. */
+export class SilentActivityAnimator {
+	private context: ExtensionContext | undefined;
+	private running = false;
+	/** The final answer is streaming; the dots step aside rather than sit under it. */
+	private answering = false;
+	private enabled = false;
+	private mounted = false;
+	private frame = 0;
+	/** Stops this animation's share of the shared clock. */
+	private stopTicking: (() => void) | undefined;
+
+	constructor(private readonly pi: ExtensionAPI) {
+		pi.on("agent_start", () => {
+			if (!this.context) return;
+			this.running = true;
+			this.answering = false;
+			this.refresh();
+		});
+		// Text means the assistant is answering. Thinking, a tool call, or a new turn
+		// means it went back to work, so the dots return.
+		pi.on("message_update", (event) => {
+			const type = event.assistantMessageEvent?.type;
+			if (type === "text_start" || type === "text_delta") this.setAnswering(true);
+			else if (type === "thinking_start" || type === "toolcall_start") this.setAnswering(false);
+		});
+		pi.on("tool_execution_start", () => this.setAnswering(false));
+		pi.on("turn_start", () => this.setAnswering(false));
+		pi.on("agent_end", () => {
+			if (!this.context) return;
+			this.running = false;
+			this.refresh();
+		});
+	}
+
+	bind(ctx: ExtensionContext): void {
+		this.hide();
+		this.context = ctx;
+		this.running = ctx.isIdle?.() === false;
+		this.answering = false;
+	}
+
+	setEnabled(enabled: boolean): void {
+		this.enabled = enabled;
+		this.refresh();
+	}
+
+	dispose(): void {
+		this.hide();
+		this.context = undefined;
+		this.running = false;
+		this.enabled = false;
+	}
+
+	/** Guarded like the progress label: a host with a partial API keeps the default color. */
+	private readLevel(): ThinkingLevel {
+		return typeof this.pi.getThinkingLevel === "function" ? this.pi.getThinkingLevel() : "medium";
+	}
+
+	private setAnswering(answering: boolean): void {
+		if (!this.context || this.answering === answering) return;
+		this.answering = answering;
+		this.refresh();
+	}
+
+	private refresh(): void {
+		if (this.context && this.enabled && this.running && !this.answering) this.show();
+		else this.hide();
+	}
+
+	private show(): void {
+		if (!this.context || this.mounted || !patchUserMessage()) return;
+		this.frame = 0;
+		this.mounted = true;
+		Object.assign(sharedActivityState(), {
+			active: true, frame: 0, level: this.readLevel(), theme: this.context.ui.theme,
+			target: undefined, candidate: undefined,
+		});
+		// This invisible widget provides Pi's TUI for animation repaints.
+		this.context.ui.setWidget(WIDGET_KEY, (tui) => {
+			sharedActivityState().tui = tui;
+			patchTranscriptAlignment(tui);
+			patchEditorGap(tui);
+			return { render: () => [], invalidate() {} };
+		}, { placement: "belowEditor" });
+		// Ticks with the working label, so the two share one repaint per frame, and
+		// frames that look the same as the last one ask for no repaint at all.
+		this.stopTicking = onTick(() => {
+			this.frame++;
+			const state = sharedActivityState();
+			const level = this.readLevel();
+			const changed = frameChanges(this.frame) || level !== state.level;
+			state.frame = this.frame;
+			state.level = level;
+			if (changed) state.tui?.requestRender();
+		});
+	}
+
+	private hide(): void {
+		const state = sharedActivityState();
+		state.active = false;
+		state.tui = undefined;
+		state.target = undefined;
+		state.candidate = undefined;
+		this.stopTicking?.();
+		this.stopTicking = undefined;
+		if (!this.mounted) return;
+		this.mounted = false;
+		this.context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
+	}
+}

package/extensions/compact-tools-clock.ts

@@ -0,0 +1,29 @@
+/**
+ * One shared animation clock. Every animation tick asks Pi to lay out and repaint
+ * the whole screen, so the working label and the silent-mode line tick together:
+ * both change inside the same callback, and Pi coalesces their requests into one
+ * frame instead of two unsynchronized timers each forcing frames of their own.
+ */
+export const TICK_MS = 80;
+
+type Listener = () => void;
+
+const listeners = new Set<Listener>();
+let timer: ReturnType<typeof setInterval> | undefined;
+
+/** Run `listener` on every tick until the returned function is called. The clock stops when idle. */
+export function onTick(listener: Listener): () => void {
+	listeners.add(listener);
+	if (!timer) {
+		timer = setInterval(() => {
+			for (const tick of [...listeners]) tick();
+		}, TICK_MS);
+		timer.unref?.();
+	}
+	return () => {
+		listeners.delete(listener);
+		if (listeners.size > 0 || !timer) return;
+		clearInterval(timer);
+		timer = undefined;
+	};
+}

package/extensions/compact-tools-config.ts

@@ -2,15 +2,18 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import {
+	DISPLAY_MODES,
 	SUPPORTED_TOOL_SET,
 	type CompactToolName,
 	type CompactToolsConfig,
+	type DisplayMode,
 } from "./compact-tools-types.ts";
 
 const CONFIG_FILE = "compact-tools.json";
 type JsonObject = Record<string, unknown>;
 
 export const DEFAULT_CONFIG: CompactToolsConfig = {
+	mode: "normal",
 	tools: ["read", "write", "edit", "bash"],
 	previewLines: 10,
 	auto_compact: {
@@ -23,6 +26,11 @@ export const DEFAULT_CONFIG: CompactToolsConfig = {
 		find: true,
 		ls: true,
 	},
+	custom_tools: {
+		enabled: true,
+		auto_compact: true,
+		exclude: [],
+	},
 };
 
 function isObject(value: unknown): value is JsonObject {
@@ -37,6 +45,12 @@ function isIntegerInRange(value: unknown, minimum: number, maximum: number): val
 	return typeof value === "number" && Number.isInteger(value) && value >= minimum && value <= maximum;
 }
 
+function parseMode(value: unknown, path: string): DisplayMode | undefined {
+	if ((DISPLAY_MODES as readonly unknown[]).includes(value)) return value as DisplayMode;
+	warn(path, `mode must be one of ${DISPLAY_MODES.join(", ")}; using previous value`);
+	return undefined;
+}
+
 function parseTools(value: unknown, path: string): CompactToolName[] | undefined {
 	if (!Array.isArray(value)) {
 		warn(path, "tools must be an array; using previous values");
@@ -63,13 +77,39 @@ function parseAutoCompact(
 		return base;
 	}
 	const result = { ...base };
+	// Any tool name is accepted: a custom tool's entry overrides custom_tools.auto_compact.
 	for (const [name, enabled] of Object.entries(value)) {
-		if (!SUPPORTED_TOOL_SET.has(name)) {
-			warn(path, `ignoring unsupported auto_compact tool: ${name}`);
-		} else if (typeof enabled !== "boolean") {
+		if (typeof enabled !== "boolean") {
 			warn(path, `auto_compact.${name} must be true or false; using previous value`);
 		} else {
-			result[name as CompactToolName] = enabled;
+			result[name] = enabled;
+		}
+	}
+	return result;
+}
+
+function parseCustomTools(
+	base: CompactToolsConfig["custom_tools"],
+	value: unknown,
+	path: string,
+): CompactToolsConfig["custom_tools"] {
+	if (value === undefined) return base;
+	if (typeof value === "boolean") return { ...base, enabled: value };
+	if (!isObject(value)) {
+		warn(path, "custom_tools must be true, false, or an object; using previous values");
+		return base;
+	}
+	const result = { ...base };
+	for (const key of ["enabled", "auto_compact"] as const) {
+		if (value[key] === undefined) continue;
+		if (typeof value[key] === "boolean") result[key] = value[key];
+		else warn(path, `custom_tools.${key} must be true or false; using previous value`);
+	}
+	if (value.exclude !== undefined) {
+		if (Array.isArray(value.exclude) && value.exclude.every((name) => typeof name === "string")) {
+			result.exclude = [...new Set(value.exclude as string[])];
+		} else {
+			warn(path, "custom_tools.exclude must be an array of tool names; using previous values");
 		}
 	}
 	return result;
@@ -81,14 +121,16 @@ export function mergeConfig(base: CompactToolsConfig, value: unknown, path: stri
 		warn(path, "expected a JSON object; using previous values");
 		return base;
 	}
+	const mode = value.mode === undefined ? base.mode : (parseMode(value.mode, path) ?? base.mode);
 	const tools = value.tools === undefined ? base.tools : (parseTools(value.tools, path) ?? base.tools);
 	const auto_compact = parseAutoCompact(base.auto_compact, value.auto_compact, path);
+	const custom_tools = parseCustomTools(base.custom_tools, value.custom_tools, path);
 	const previewLines = value.previewLines === undefined ? base.previewLines
 		: isIntegerInRange(value.previewLines, 1, 100) ? value.previewLines : base.previewLines;
 	if (value.previewLines !== undefined && !isIntegerInRange(value.previewLines, 1, 100)) {
 		warn(path, "previewLines must be 1–100; using previous value");
 	}
-	return { tools, auto_compact, previewLines };
+	return { mode, tools, auto_compact, custom_tools, previewLines };
 }
 
 function readJson(path: string): unknown {

package/extensions/compact-tools-custom.ts

@@ -0,0 +1,77 @@
+import { ToolExecutionComponent, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+
+// Symbol.for keys are shared by every evaluation of this module. The prototype is
+// Pi's and outlives a /reload, so the patch is installed once and always asks the
+// most recently loaded extension instance, through the shared slot, what to render.
+const RESOLVER_KEY = Symbol.for("pi-compact-tools.custom.resolver");
+const PATCHED_KEY = Symbol.for("pi-compact-tools.custom.patched");
+const ROUTED_METHODS = ["getCallRenderer", "getResultRenderer", "getRenderShell", "hasRendererDefinition"] as const;
+
+type AnyToolDefinition = ToolDefinition<any, any, any>;
+
+/** The fields of Pi's tool row that decide which renderer is used. */
+export interface ToolRow {
+	toolName: string;
+	toolDefinition?: AnyToolDefinition;
+}
+
+export interface RowRenderers {
+	renderCall: NonNullable<AnyToolDefinition["renderCall"]>;
+	renderResult: NonNullable<AnyToolDefinition["renderResult"]>;
+}
+
+export type RowResolver = (row: ToolRow) => RowRenderers | undefined;
+
+type RoutedPrototype = Record<(typeof ROUTED_METHODS)[number], (...args: unknown[]) => unknown>;
+type ResolverSlot = typeof globalThis & { [RESOLVER_KEY]?: RowResolver };
+
+export function setRowResolver(resolver: RowResolver | undefined): void {
+	(globalThis as ResolverSlot)[RESOLVER_KEY] = resolver;
+}
+
+/**
+ * Pi routes every renderer lookup on a tool row through these four methods, so
+ * answering them is enough to give any tool, whichever extension registered it,
+ * compact renderers. Returns false when the host no longer has that shape.
+ */
+export function patchToolRows(prototype: object | undefined): boolean {
+	if (!prototype) return false;
+	const routed = prototype as RoutedPrototype;
+	if (!ROUTED_METHODS.every((method) => typeof routed[method] === "function")) return false;
+	if (Object.hasOwn(prototype, PATCHED_KEY)) return true;
+	// Decided once per row: Pi picks the row's container from these answers in its
+	// constructor, so a row must never switch renderers after it is built. /reload
+	// rebuilds the transcript, so config changes still reach every row.
+	const decisions = new WeakMap<object, RowRenderers | null>();
+	const resolve = (row: ToolRow): RowRenderers | undefined => {
+		let renderers = decisions.get(row);
+		if (renderers === undefined) {
+			try {
+				renderers = (globalThis as ResolverSlot)[RESOLVER_KEY]?.(row) ?? null;
+			} catch {
+				renderers = null;
+			}
+			decisions.set(row, renderers);
+		}
+		return renderers ?? undefined;
+	};
+	const original = Object.fromEntries(ROUTED_METHODS.map((method) => [method, routed[method]])) as RoutedPrototype;
+	routed.getCallRenderer = function (this: ToolRow, ...args) {
+		return resolve(this)?.renderCall ?? original.getCallRenderer.apply(this, args);
+	};
+	routed.getResultRenderer = function (this: ToolRow, ...args) {
+		return resolve(this)?.renderResult ?? original.getResultRenderer.apply(this, args);
+	};
+	routed.getRenderShell = function (this: ToolRow, ...args) {
+		return resolve(this) ? "self" : original.getRenderShell.apply(this, args);
+	};
+	routed.hasRendererDefinition = function (this: ToolRow, ...args) {
+		return resolve(this) ? true : original.hasRendererDefinition.apply(this, args);
+	};
+	Object.defineProperty(prototype, PATCHED_KEY, { value: true });
+	return true;
+}
+
+export function installToolRowPatch(): boolean {
+	return patchToolRows(ToolExecutionComponent?.prototype);
+}