pi-compact-tools 0.8.0 → 0.8.3

package/README.md

@@ -1,61 +1,19 @@
 # pi-compact-tools
 
-Compact, expandable rendering for Pi's built-in tools, with a polished GitHub Dark theme.
+Compact, expandable rendering for Pi's built-in tools, with a GitHub Dark theme.
 
-> Formerly `@nedleeds/pi-compact-ui`. New installations should use `pi-compact-tools`.
+![Compact rows for every built-in tool](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-## Demo
+![Syntax-highlighted edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
 
-The UI uses portable Unicode symbols and does not require a Nerd Font.
-
-### Compact tool workflow
-
-Active, successful, and failed tool calls stay compact while preserving useful status and timing information.
-
-![Compact tool workflow with Nerd Font](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nerd-font-workflow-optimized.gif)
-
-### Progress and duration display
-
-The working label above the prompt uses the Thinking summary color with a soft white light sweep. Every tool state uses the same `⦁` glyph; running tools use a fourteen-frame cosine-eased RGB pulse between dim and bright gray, then settle to green on success or red on failure. Elapsed time remains visible in the neutral control color.
-
-![Spinner and elapsed-time display](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/spinner-duration-optimized.gif)
-
-### Code-aware results
-
-Completed `edit` rows render a syntax-highlighted diff: a line-number and `+`/`-` gutter beside the code, tinted rows for additions and deletions, and `⋮` where context is skipped. Collapsed rows keep one line of context around each change so the edit itself stays visible; expanding with a click or `Ctrl+O` restores the full context the patch carries.
-
-```text
-⦁ edit src/load.ts
- │ 3   export async function load(path: string): Promise<string> {
- │ 4 -    const raw = await readFile(path, "utf8");
- │ 4 +    const raw = await readFile(path, "utf-8");
- │ 5      return raw.trim();
- └─ Done in 0.012s (2 lines)
-```
-
-`read` and `write` results use the same numbered, syntax-highlighted layout without the diff signs. `read` line numbers start at the requested `offset`, and Pi's continuation notice (`[Showing lines …]`) is shown as a dim note below the code. Markdown files keep their exact source but style headings, lists, quotes, links, emphasis, and inline code, while fenced blocks are highlighted in their declared language. Files without a recognized language keep the plain output color instead of a guessed highlight.
-
-![Edit diff](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 rendering for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`
-- One continuously glowing working label above the input prompt across thinking and tool execution
-- Semantic built-in progress labels and automatically cleaned custom/MCP tool names; collapsed text-search rows include the searched pattern
-- Four-step `Ctrl+T` thinking cycle when provider detail is available: summary, detail, summary, then hidden
-- Millisecond-precision duration and completed output line counts with neutral status text
-- Per-tool hidden or persistent bounded-preview collapsed state with `auto_compact: true` or `false`
-- Primary invocation targets such as paths and patterns stay visible, including common collapsed shell file operations
-- Click and `Ctrl+O` follow Pi's built-in expansion state while preview rows collapse back to their preview
-- Edit results render as syntax-highlighted diffs with a line-number gutter, tinted change rows, and `⋮` context breaks
-- `read` and `write` contents use the same numbered, syntax-highlighted layout, with `read` line numbers following `offset`
-- Markdown files keep their exact source but style headings, lists, quotes, links, and inline code, and highlight fenced code blocks in their declared language
-- Configurable `previewLines` prevents large diffs, HTML, and shell output from flooding the transcript
-- Width-cached expanded results, edit-diff processing, and unchanged result reuse during status animation
-- Dark `│` and `└─` visual grouping
-- Distinct cool-blue thinking text
-- Truecolor and 256-color terminal support, plus Windows, Unix, and classic Mac line endings
-- No Nerd Font requirement
+- 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 and a `Ctrl+T` thinking summary/detail cycle
+- No Nerd Font required
 
 ## Install
 
@@ -63,93 +21,27 @@ Completed `edit` rows render a syntax-highlighted diff: a line-number and `+`/`-
 pi install npm:pi-compact-tools
 ```
 
-Or install from GitHub:
-
-```bash
-pi install git:github.com/nedleeds/pi-compact-tools
-```
-
-Restart Pi or run `/reload`.
-
-Migrating from the previous package name:
-
-```bash
-pi remove npm:@nedleeds/pi-compact-ui
-pi install npm:pi-compact-tools
-```
-
-## Theme
-
-Select `github-dark-pro` in Pi's settings, or add it to `~/.pi/agent/settings.json`:
-
-```json
-{
-  "theme": "github-dark-pro"
-}
-```
+Then restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
 
 ## Configuration
 
-Configuration is optional. Create `~/.pi/agent/compact-tools.json` for global settings or `<project>/.pi/compact-tools.json` for a trusted project.
-
-Default configuration:
+Optional. Put it in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
 
 ```json
 {
-  "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.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 }
 }
 ```
 
-Every tool call title uses `⦁`. Pending calls use dark gray; active calls smoothly pulse through fourteen cosine-eased RGB frames at a 45 ms interval without disappearing. Animation starts while arguments stream, so `write` and `edit` remain visibly active before their filesystem operation begins. Successful titles use green, and failed titles use red. `Done`, `Failed`, elapsed time, and line counts use the same neutral control color without printing inline click or keyboard hints. A single Pi working label animates independently of token arrival and reports `Thinking…`, `Responding…`, semantic built-in states such as `Reading file…`, or cleaned custom states such as `Using jira search…`. Invocation arguments remain in the tool row instead of being duplicated above the prompt. No separate spinner glyph is shown above the prompt.
-
-`auto_compact` controls each tool's initial result state:
-
-- `true` starts with the result hidden.
-- `false` starts with at most `previewLines` rendered rows visible.
-- Clicking or pressing `Ctrl+O` expands the complete result through Pi's built-in expansion state.
-
-`previewLines` accepts `1`–`100` and defaults to `10`. It limits the collapsed preview; the complete result remains available. Unspecified entries inherit the previous configuration layer. By default, `read`, `write`, and `bash` start hidden, while `edit` starts with a short diff preview centered on the changed lines.
-
-To enable all Unix-compatible tools:
-
-```json
-{
-  "tools": ["read", "write", "edit", "bash", "grep", "find", "ls"]
-}
-```
-
-Add `"powershell"` on Windows if desired.
+- `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`).
 
 ## Controls
 
-`Ctrl+T` cycles every thinking block through:
-
-```text
-one-line summary → summary + │-indented detail → one-line summary → Thinking...
-```
-
-Standalone bold lines and Markdown headings split one provider thinking run into logical sections. Each section gets its own summary and optional `│`-indented detail. Summary-only views stay uncluttered with no control hint; the control row appears only while provider-supplied detail is visible. When no thinking detail exists, `Ctrl+T` falls back to Pi's normal visible/hidden toggle instead of showing a duplicate detail phase. While thinking streams, a slightly faster highlight sweeps from the Thinking summary color to white across Pi's working label at a steady interval rather than depending on token updates. The transcript summary remains visually stable. The transformation is display-only; complete thinking remains unchanged in the session and model context.
-
-Primary file and search targets stay visible. Collapsed `bash` and `powershell` rows describe intent—such as `Run tests` or `Check repository status`. Text searches retain their primary pattern (for example, `Search text "TODO|FIXME"`), and common file commands retain their operands (for example, `Run rm "build"` or `Find files "*.test.ts" in "src"`). Expanding the row reveals the exact command. After every supported tool completes, the status reports the expanded result size as `Done in …s (N lines)` instead of repeating options such as context and limit. Counts use the returned text for reads, searches, listings, and shell commands, written content for `write`, and only the changed `-`/`+` lines for `edit`. The count is computed once after completion and cached with the row, so streaming and repeated expansion do not add ongoing work. Large payloads represented as results follow the result toggle.
-
-A mouse click toggles one row using Pi's native result state. `Ctrl+O` remains owned by Pi and expands or collapses all tool rows consistently, including tools not rendered by this extension. A row with `auto_compact: false` cycles predictably between its bounded preview and the complete result, so repeated clicks never remove the row and fall through to a neighboring Thinking block. The extension does not intercept the global keybinding.
-
-## Notes
-
-- Pi `0.85.1+` and Node.js `22.19.0+` are recommended.
-- The working indicator and mouse interaction are provided by Pi's TUI; `Ctrl+O` also works in regular mode.
-- Duration covers the full rendered tool-call lifecycle, including streamed `write` and `edit` arguments.
-- Syntax highlighting is skipped, keeping line numbers, for content over 512 KB, 10,000 lines, or a single 4 KB line. Pi already truncates `read` output to 2,000 lines or 50 KB.
-- Highlighting runs per diff hunk or `read` range, so a hunk or `offset` that starts inside a block comment or Markdown code fence may color its first lines as surrounding text.
-- Selected tools override definitions with the same names so their compact renderers are restored reliably after `/reload`; other extensions overriding those tools may conflict by load order.
+- Click a row or press `Ctrl+O` to expand or collapse results.
+- `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
 
 ## Development
 
@@ -159,8 +51,6 @@ npm run check
 pi -e .
 ```
 
-Pi extensions execute with full system access. Review third-party extension source before installation.
-
 ## License
 
 MIT

package/extensions/compact-tools-color.ts

@@ -25,16 +25,29 @@ function ansi256ToRgb(index: number): Rgb {
 	return { r: gray, g: gray, b: gray };
 }
 
+const ANSI_256_RGB: readonly Rgb[] = Array.from({ length: 256 }, (_, index) => ansi256ToRgb(index));
+
+/**
+ * The nearest-color search runs per character on 256-color terminals, so both the
+ * palette and the answers are kept. Callers interpolate between a handful of theme
+ * colors, so the memo holds tens of entries rather than growing with output size.
+ */
+const ansi256ByRgb = new Map<number, number>();
+
 function rgbToAnsi256(rgb: Rgb): number {
+	const key = (rgb.r << 16) | (rgb.g << 8) | rgb.b;
+	const memoized = ansi256ByRgb.get(key);
+	if (memoized !== undefined) return memoized;
 	let bestIndex = 0;
 	let bestDistance = Number.POSITIVE_INFINITY;
 	for (let index = 0; index < 256; index++) {
-		const candidate = ansi256ToRgb(index);
+		const candidate = ANSI_256_RGB[index]!;
 		const distance = (rgb.r - candidate.r) ** 2 + (rgb.g - candidate.g) ** 2 + (rgb.b - candidate.b) ** 2;
 		if (distance >= bestDistance) continue;
 		bestIndex = index;
 		bestDistance = distance;
 	}
+	ansi256ByRgb.set(key, bestIndex);
 	return bestIndex;
 }
 
@@ -57,11 +70,17 @@ export function interpolateRgb(from: Rgb, to: Rgb, amount: number): Rgb {
 	};
 }
 
-export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+/** Shared by the foreground (38/39) and background (48/49) SGR pairs. */
+function paintRgb(theme: Theme, color: Rgb, text: string, set: 38 | 48): string {
+	const reset = set === 38 ? 39 : 49;
 	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
-		return `\x1b[38;5;${rgbToAnsi256(color)}m${text}\x1b[39m`;
+		return `\x1b[${set};5;${rgbToAnsi256(color)}m${text}\x1b[${reset}m`;
 	}
-	return `\x1b[38;2;${color.r};${color.g};${color.b}m${text}\x1b[39m`;
+	return `\x1b[${set};2;${color.r};${color.g};${color.b}m${text}\x1b[${reset}m`;
+}
+
+export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+	return paintRgb(theme, color, text, 38);
 }
 
 function isDarkTheme(theme: Theme): boolean {
@@ -82,8 +101,5 @@ export function diffTintRgb(theme: Theme, color: ThemeForeground, amount = 0.16)
 }
 
 export function fillRgb(theme: Theme, color: Rgb, text: string): string {
-	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
-		return `\x1b[48;5;${rgbToAnsi256(color)}m${text}\x1b[49m`;
-	}
-	return `\x1b[48;2;${color.r};${color.g};${color.b}m${text}\x1b[49m`;
+	return paintRgb(theme, color, text, 48);
 }

package/extensions/compact-tools-core.ts

@@ -38,6 +38,16 @@ export function classifyCallStatus(isError: boolean, executionStarted: boolean,
 	return executionStarted ? "running" : "pending";
 }
 
+/**
+ * Sub-minute durations keep millisecond precision; longer runs switch to the
+ * minute and hour grouping Pi's own bash and powershell renderers use.
+ */
 export function formatDurationMs(elapsedMs: number): string {
-	return `${(elapsedMs / 1000).toFixed(3)}s`;
+	const seconds = elapsedMs / 1000;
+	if (seconds < 60) return `${seconds.toFixed(3)}s`;
+	const totalSeconds = Math.floor(seconds);
+	const minutes = Math.floor(totalSeconds / 60);
+	const remainderSeconds = totalSeconds % 60;
+	if (minutes < 60) return `${minutes}m ${remainderSeconds}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${remainderSeconds}s`;
 }

package/extensions/compact-tools-language.ts

@@ -0,0 +1,146 @@
+import { getLanguageFromPath } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Pi resolves a language from the file extension and deliberately never falls back to
+ * content auto-detection, because highlight.js guesses confidently and wrongly on the
+ * things people read most: prose scores as AppleScript or LiveCode, logs and `git log`
+ * output as Apache, a one-line TypeScript statement as AutoIt. Relevance scores do not
+ * separate those from real matches, and the library is not reachable from this package
+ * anyway — Pi keeps it nested.
+ *
+ * So this module only widens the deterministic signals: names that identify a file
+ * without an extension, extensions Pi's table omits, and an interpreter the file
+ * declares itself. Anything still unknown stays unhighlighted rather than guessed.
+ */
+
+/** Files whose name, not extension, states the language. Keyed by lowercased basename. */
+const FILENAME_LANGUAGES: Readonly<Record<string, string>> = {
+	dockerfile: "dockerfile",
+	containerfile: "dockerfile",
+	makefile: "makefile",
+	gnumakefile: "makefile",
+	"cmakelists.txt": "cmake",
+	rakefile: "ruby",
+	gemfile: "ruby",
+	guardfile: "ruby",
+	podfile: "ruby",
+	brewfile: "ruby",
+	vagrantfile: "ruby",
+	jenkinsfile: "groovy",
+	".bashrc": "bash",
+	".bash_profile": "bash",
+	".bash_aliases": "bash",
+	".zshrc": "bash",
+	".zprofile": "bash",
+	".profile": "bash",
+	".editorconfig": "ini",
+	".npmrc": "ini",
+	".yarnrc": "ini",
+};
+
+/** Extensions Pi's own table does not cover. Unsupported names degrade to plain text. */
+const EXTENSION_LANGUAGES: Readonly<Record<string, string>> = {
+	mts: "typescript",
+	cts: "typescript",
+	jsonc: "json",
+	json5: "json",
+	bat: "dos",
+	cmd: "dos",
+	psm1: "powershell",
+	psd1: "powershell",
+	ini: "ini",
+	cfg: "ini",
+	conf: "ini",
+	properties: "properties",
+	diff: "diff",
+	patch: "diff",
+	svg: "xml",
+	gradle: "groovy",
+	groovy: "groovy",
+	dart: "dart",
+	nix: "nix",
+	zig: "zig",
+	mm: "objectivec",
+	pl: "perl",
+	pm: "perl",
+	rake: "ruby",
+	kts: "kotlin",
+	sc: "scala",
+	vb: "vbnet",
+	jl: "julia",
+	cr: "crystal",
+	awk: "awk",
+	tcl: "tcl",
+	f90: "fortran",
+	f95: "fortran",
+};
+
+/** Interpreters seen after `#!`, with any version suffix already stripped. */
+const INTERPRETER_LANGUAGES: Readonly<Record<string, string>> = {
+	bash: "bash",
+	sh: "bash",
+	zsh: "bash",
+	dash: "bash",
+	ksh: "bash",
+	fish: "fish",
+	python: "python",
+	node: "javascript",
+	deno: "typescript",
+	bun: "typescript",
+	ruby: "ruby",
+	perl: "perl",
+	php: "php",
+	lua: "lua",
+	awk: "awk",
+	gawk: "awk",
+	rscript: "r",
+	pwsh: "powershell",
+	powershell: "powershell",
+	tclsh: "tcl",
+};
+
+function basename(path: string): string {
+	const separator = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	return separator === -1 ? path : path.slice(separator + 1);
+}
+
+/** `python3.12` and `ruby2.7` name the same languages as `python` and `ruby`. */
+function stripVersion(interpreter: string): string {
+	return interpreter.replace(/[\d.]+$/u, "");
+}
+
+/** Read the language a `#!` line declares, e.g. `#!/usr/bin/env -S python3 -u`. */
+export function languageFromShebang(line: string): string | undefined {
+	const shebang = line.match(/^#!\s*(\S+)((?:\s+\S+)*)$/u);
+	if (!shebang) return undefined;
+	const command = basename(shebang[1]!).toLowerCase();
+	if (command !== "env") return INTERPRETER_LANGUAGES[stripVersion(command)];
+	// `env` forwards to the first argument that is not one of its own flags.
+	for (const argument of shebang[2]!.trim().split(/\s+/u)) {
+		if (!argument || argument.startsWith("-") || argument.includes("=")) continue;
+		return INTERPRETER_LANGUAGES[stripVersion(basename(argument).toLowerCase())];
+	}
+	return undefined;
+}
+
+/** Resolve a language from the path alone, without looking at file contents. */
+export function languageFromPath(path: string): string | undefined {
+	const fromPi = getLanguageFromPath(path);
+	if (fromPi) return fromPi;
+	const name = basename(path).toLowerCase();
+	const byName = FILENAME_LANGUAGES[name];
+	if (byName) return byName;
+	// `.env`, `.env.local`, and `.env.production` all hold the same KEY=value shape.
+	if (name === ".env" || name.startsWith(".env.")) return "ini";
+	const extension = name.includes(".") ? name.slice(name.lastIndexOf(".") + 1) : undefined;
+	return extension ? EXTENSION_LANGUAGES[extension] : undefined;
+}
+
+/**
+ * Resolve a language for a file view. `firstLine` is only consulted when it is genuinely
+ * the file's first line, so a `read` starting at an offset never mistakes a comment for
+ * a shebang.
+ */
+export function resolveLanguage(path: string, firstLine?: string): string | undefined {
+	return languageFromPath(path) ?? (firstLine === undefined ? undefined : languageFromShebang(firstLine));
+}

package/extensions/compact-tools-layout.ts

@@ -1,4 +1,4 @@
-import { getLanguageFromPath, highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import {
 	Container,
@@ -9,6 +9,7 @@ import {
 } from "@earendil-works/pi-tui";
 import { diffTintRgb, fillRgb } from "./compact-tools-color.ts";
 import { normalizeLineEndings } from "./compact-tools-core.ts";
+import { resolveLanguage } from "./compact-tools-language.ts";
 import { highlightMarkdown } from "./compact-tools-markdown.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
@@ -304,7 +305,11 @@ type CodeRowsOptions = {
 
 /** Render numbered, syntax-highlighted code rows shared by edit diffs and read/write file views. */
 function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, options: CodeRowsOptions): Component {
-	const highlighted = highlightCodeLines(lines, getLanguageFromPath(path), theme);
+	// A shebang only speaks for the file when the first row really is line 1, so a
+	// read at an offset or a diff hunk never reads one out of a comment.
+	const first = lines[0];
+	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 = theme.fg("border", " \u2502 ");
 	const prefixWidth = visibleWidth(prefix);

package/extensions/compact-tools-markdown.ts

@@ -1,4 +1,5 @@
-import { getLanguageFromPath, highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { languageFromPath } from "./compact-tools-language.ts";
 
 type Fence = { char: string; length: number; language: string | undefined; start: number };
 
@@ -14,7 +15,7 @@ const INLINE = /(`+)(.+?)\1|\[([^\]\n]+)\]\(([^)\s]+)\)|\*\*(?=\S)(.+?)\*\*|__(?
 function fenceLanguage(info: string): string | undefined {
 	const name = info.toLowerCase();
 	if (!name) return undefined;
-	return getLanguageFromPath(`fence.${name}`) ?? name;
+	return languageFromPath(`fence.${name}`) ?? name;
 }
 
 function highlightInline(text: string, theme: Theme): string {

package/extensions/compact-tools-progress.ts

@@ -80,24 +80,34 @@ export class ProgressController {
 	private timer: ReturnType<typeof setInterval> | undefined;
 
 	constructor(pi: ExtensionAPI) {
-		pi.on("agent_start", () => this.setMessage("Thinking…"));
+		// Every handler leaves early while unbound. Pi keeps dispatching to this
+		// extension in non-TUI modes, and guarding at the top keeps that work — and
+		// any future handler added here — out of the detached path.
+		pi.on("agent_start", () => {
+			if (!this.context) return;
+			this.setMessage("Thinking…");
+		});
 		pi.on("message_update", (event) => {
+			if (!this.context) return;
 			const type = event.assistantMessageEvent.type;
 			if (type === "thinking_start" || type === "thinking_delta") this.setMessage("Thinking…");
 			else if (type === "text_start" || type === "text_delta") this.setMessage("Responding…");
 			else if (type === "toolcall_start" || type === "toolcall_delta") this.setMessage("Preparing tools…");
 		});
 		pi.on("tool_execution_start", (event) => {
+			if (!this.context) return;
 			const message = formatToolProgress(event.toolName, event.args ?? {});
 			this.activeTools.set(event.toolCallId, message);
 			this.setMessage(message);
 		});
 		pi.on("tool_execution_end", (event) => {
+			if (!this.context) return;
 			this.activeTools.delete(event.toolCallId);
 			const remaining = [...this.activeTools.values()].at(-1);
 			this.setMessage(remaining ?? "Processing results…");
 		});
 		pi.on("agent_end", () => {
+			if (!this.context) return;
 			this.activeTools.clear();
 			this.clearMessage();
 		});

package/extensions/compact-tools.ts

@@ -356,6 +356,14 @@ function configure(pi: ExtensionAPI, cwd?: string, projectTrusted = false): void
 }
 
 export default function compactTools(pi: ExtensionAPI): void {
+	// Pi caches this factory and re-invokes it with a fresh `pi` for every session
+	// replacement (/resume, /new, /fork) as well as /reload, each time starting from
+	// an empty tool registry. The module itself survives those invocations, so the
+	// memo below has to be dropped here or configure() mistakes the previous
+	// instance's registration for this one and never installs the renderers.
+	registeredConfiguration = undefined;
+	registeredTools.clear();
+
 	const thinkingCycle = new ThinkingCycleController(pi);
 	const progress = new ProgressController(pi);
 	// Register once while the extension runtime is being built. In particular, this
@@ -376,8 +384,5 @@ export default function compactTools(pi: ExtensionAPI): void {
 		thinkingCycle.dispose();
 		progress.dispose();
 		runtime.reset(event.reason !== "reload");
-		// Some Pi hosts rebuild the active tool registry during reload while keeping
-		// this module instance. Force the next session to restore our renderers.
-		if (event.reason === "reload") registeredConfiguration = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.8.0",
+  "version": "0.8.3",
   "description": "Compact, expandable UI for pi's built-in tools, bundled with a polished GitHub Dark theme.",
   "type": "module",
   "license": "MIT",
@@ -42,15 +42,15 @@
     "themes": [
       "./themes/github-dark-pro.json"
     ],
-    "image": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nerd-font-workflow-optimized.gif"
+    "image": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*"
+    "@earendil-works/pi-coding-agent": ">=0.85.1",
+    "@earendil-works/pi-tui": ">=0.85.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.85.1",
-    "@earendil-works/pi-tui": "0.85.1",
+    "@earendil-works/pi-coding-agent": "0.86.0",
+    "@earendil-works/pi-tui": "0.86.0",
     "@types/node": "^24.0.0",
     "tsx": "^4.23.13",
     "typescript": "^5.9.0"