pi-compact-tools 0.9.3 → 0.10.1

package/README.md

@@ -1,20 +1,19 @@
 # pi-compact-tools
 
-Compact, expandable rendering for Pi's built-in tools, with a GitHub Dark theme.
+Compact, expandable tool rows for Pi, including 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)
-
-![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
-- Syntax-highlighted edit diffs and numbered `read`/`write` code views, including Markdown code fences
-- 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
+- The same rows for custom tools from other packages, with no setup
+- Syntax-highlighted edit diffs, with lines added and removed: `(+3 -1)`
+- Numbered code views for `read` and `write`
+- Silent mode: only prompts and final answers
+- Works with any theme; no Nerd Font required
 
 ## Install
 
@@ -22,27 +21,64 @@ Compact, expandable rendering for Pi's built-in tools, with a GitHub Dark theme.
 pi install npm:pi-compact-tools
 ```
 
-Then restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
+Restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
 
 ## Configuration
 
-Optional. Put it in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
+All settings go in one optional file: `~/.pi/agent/compact-tools.json`, or `<project>/.pi/compact-tools.json` for one project. Every key is optional.
 
 ```json
 {
   "tools": ["read", "write", "edit", "bash"],
   "previewLines": 10,
-  "auto_compact": { "read": true, "write": true, "edit": false, "bash": true }
+  "auto_compact": { "read": true, "write": true, "edit": false, "bash": true },
+  "mode": "normal",
+  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": [] }
 }
 ```
 
-- `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`).
+- `tools`: built-in tools to compact. Also available: `grep`, `find`, `ls`, `powershell`.
+- `auto_compact`: `true` starts a row hidden, `false` shows a preview of up to `previewLines` rows. Custom tool names work too.
+- `mode`: `"normal"` or `"silent"`. See [Silent mode](#silent-mode).
+- `custom_tools`: see [Custom tools](#custom-tools).
+
+## Custom tools
+
+![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)
+
+Tools from other packages get compact rows automatically. Expanding a row shows the tool's own result view.
+
+Set them with the `custom_tools` key in the same `compact-tools.json`:
+
+```json
+{
+  "auto_compact": { "web_search": false },
+  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": ["my_tool"] }
+}
+```
+
+- `enabled`: `false` turns this off for every custom tool.
+- `auto_compact`: the default for every custom tool. Override one tool in the top-level `auto_compact`, like `web_search` above.
+- `exclude`: tools that keep their original look.
+
+## 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)
+
+Shows only your prompts and the final answers. Tool calls, thinking, and notices are hidden while a light under the prompt shows the agent is working.
+
+- Toggle with `Ctrl+'` or `/silent` (`/silent on`, `/silent off`). `Ctrl+'` needs a terminal with the Kitty keyboard protocol, such as Ghostty, Kitty, or WezTerm.
+- Start every session silent with `"mode": "silent"`.
+- Turning it off brings every hidden row back.
+- Errors are hidden too. If a run ends without an answer, turn silent mode off to see why.
 
 ## Controls
 
+![Ctrl+O expands every tool row, then collapses them again](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/expand-collapse.gif)
+
 - Click a row or press `Ctrl+O` to expand or collapse results.
 - `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
+- `Ctrl+'` or `/silent` toggles silent mode.
 
 ## Development
 
@@ -52,6 +88,8 @@ npm run check
 pi -e .
 ```
 
+Before publishing, add the new version's notes to `release-notes.json`. Pi shows them once after users update. Use `[]` for a release with nothing to announce.
+
 ## License
 
 MIT

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