pi-compact-tools 0.16.1 → 0.16.5

package/README.md

@@ -1,8 +1,10 @@
 # pi-compact-tools
 
-Tool rows for Pi in three styles: **Claude**, **Codex**, and **Compact**. Pick the look you know from Claude Code or Codex CLI, or Pi's own compact rows, and switch any time with `/compact-tools`. Includes a silent mode and a GitHub Dark theme, and works with custom tools from other packages.
+Three tool-row styles for Pi: **Claude**, **Codex**, and **Compact**. Switch styles live, hide tool noise with silent mode, and see what codemode scripts actually called.
 
-![One conversation drawn in the Compact style, switched to the Claude style, then the Codex style, then silent mode](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/overview.gif)
+**UI only:** no changes to tool execution, model input, or session records. Includes custom-tool rendering and a GitHub Dark theme.
+
+![The same tool calls in Compact, Claude, Codex, then silent mode](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/overview.gif)
 
 ## Install
 
@@ -10,131 +12,93 @@ Tool rows for Pi in three styles: **Claude**, **Codex**, and **Compact**. Pick t
 pi install npm:pi-compact-tools
 ```
 
-Restart Pi or run `/reload`, then run `/compact-tools` to choose a style. To try it for one session without installing: `pi -e npm:pi-compact-tools`.
+Run `/reload` or restart Pi, then `/compact-tools` to choose a style. Try without installing: `pi -e npm:pi-compact-tools`.
 
-Requires Node.js 22.19+ and Pi 0.85.1+. **Pi 1.2.0 or later is recommended** for native renderer integration and compact HTML exports. It changes only how tool calls are drawn, not what they run or what the model sees.
+Requires Node.js 22.19+ and Pi 0.85.1+. **Pi 1.0.2+ recommended** for native renderer integration and styled HTML exports.
 
 ## Styles
 
-| Style | Looks like | Set with |
+| Style | What you see | Command |
 |---|---|---|
-| **Claude** | Claude Code: reads and searches fold into one line, `⎿` results | `/compact-tools claude` |
-| **Codex** | Codex CLI: `• Explored` groups, `• Ran` with the last output lines | `/compact-tools codex` |
-| **Compact** | one expandable row per call, with its status and time (default) | `/compact-tools compact` |
+| **Claude** | Grouped reads/searches, `⎿` results, edit previews | `/compact-tools claude` |
+| **Codex** | `• Explored` groups, `• Ran` output, highlighted diffs | `/compact-tools codex` |
+| **Compact** (default) | One row per call: status, duration, line count, and diff | `/compact-tools compact` |
+| **Off / Pi native** | Pi's original rows, thinking display, and working indicator | `/compact-tools off` |
 
-Silent mode (`Ctrl+'` or `/silent`) works on top of any style. `/compact-tools off` restores Pi's own rows.
+Every style, including **off**, redraws existing rows immediately, even while tools run. No reload or interruption is needed. Only read-only exploration is grouped; commands that write or execute work keep separate rows.
 
 ### Claude
 
-![Claude style: reads and searches folded into one line, then Bash and Update rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
-
-- Reads, searches, and listings fold into one line: `Searched for 2 patterns, read 3 files`.
-- `Bash`, `Update`, `Write`, and custom tools keep their own rows with `⎿` results and short previews.
-- Matched against Claude Code 2.1.296 in a live terminal.
+![Claude: grouped exploration, tests, writes, edits, and expanded output](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
 
 ### Codex
 
-![Codex style: an Explored group, Ran rows with their last output lines, and an Edited diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/codex-style.gif)
-
-- Reads, searches, and listings fold into `• Explored`: `Read a.ts, b.ts`, `Search TODO in src`.
-- Commands read `Ran` or `Failed (exit 2)` with their last three output lines; opened, `$ cmd`, all its output, and `✓ • 1.23s`.
-- Edits preview their changed lines; custom tools read `• Called name`.
-- Matched against Codex CLI 0.162.1 in a live terminal.
+![Codex: Explored groups, Ran output, Wrote and Edited rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/codex-style.gif)
 
 ### Compact
 
-![Compact style: searches, reads, a test run, and an edit with its diff, each call with its status](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
+![Compact: individual tool rows, completion status, and an edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
+
+## Silent mode
 
-- One row per call: what it ran, its status, duration, and line count.
-- Edits show a highlighted diff with `(+3 -1)`; reads and writes show numbered code.
+Toggle with **`Ctrl+'`** or `/silent`; use `/silent on` and `/silent off` explicitly. Works with any style. It also hides thinking, intermediate assistant turns, and error/status notices; turn it off to inspect them.
 
-A command that writes or runs something, such as `tee`, `xargs`, or `find -delete`, always keeps its own row; only calls that just look around are folded into a group.
+**During work:** hide tool rows while the activity light keeps moving and the answer still arrives. Turn it off to restore every row.
 
-### Silent mode
+![Silent mode toggled during a running command, then disabled to restore its rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
 
-![Silent mode switched on mid-run: the rows fold 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)
+**In a resumed session:** hide pages of completed tool calls to see the conversation at a glance.
+
+![A resumed session with 18 tool calls reduced to its two prompts and answers](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-history.gif)
+
+This changes the display only—not the saved history or the model's context. Set `"mode": "silent"` to start sessions with it on.
+
+## Codemode summaries
 
-Only your prompts and the answers. Toggle with `Ctrl+'` or `/silent`; `"mode": "silent"` starts sessions with it on.
+Codemode is Pi's tool for scripts that call other tools. Enable it for a session with `pi --tools +codemode`; use Pi 1.2+ for the native summaries shown here. This extension only renders it.
 
-## Commands
+Completed scripts show outcomes in all three styles: `read 3 · bash 1 · edit 3 2`. Counts use your theme's success, error, and warning colors—green, red, and yellow in the included theme. Each tool appears once; edits come last.
+
+![Codemode outcomes in all three styles: three reads, one command, three successful and two failed edits](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nested-calls.gif)
+
+The two failed edits are intentional. Reload/resume preserves summaries from nested-call records; older hosts without those records keep normal previews. See [compatibility details](https://github.com/nedleeds/pi-compact-tools/blob/main/docs/development.md#ui-only-integration-and-compatibility).
+
+## Commands and controls
 
 ```text
-/compact-tools                 # choose a style and where to save it
-/compact-tools codex           # switch style, at once, even while tools run
+/compact-tools                 # choose style and save scope
 /compact-tools claude project  # save for this trusted project
-/compact-tools off             # restore Pi's own rows (reloads Pi)
-/compact-tools status          # effective style, mode, and config paths
+/compact-tools codex global    # save globally
+/compact-tools status          # effective settings and paths
+/compact-tools off             # restore Pi's native UI live, even while streaming
 ```
 
-Without a scope, the style is saved where it is decided: in the trusted project if its settings choose a style, otherwise globally. Switching between Claude, Codex, and Compact redraws every row at once, even while tools run. Turning rows `off` or back on reloads Pi, so it waits until the response finishes. Your other settings are kept.
+Without a scope, changes are saved where the style is configured: project or global. A trusted project's own style overrides a global save. `/compact-tools off` immediately restores native tool rows, unmodified thinking, Pi's working indicator and keyboard behavior, with no grouping or silent hiding—even while a response or tool is running. No reload, abort, or restart occurs. Your selected theme, tool execution, and session history are not changed. Use `/compact-tools compact`, `claude`, or `codex` to enable it again, also live. Your silent-mode choice is retained for when you re-enable a style; `/silent` while off only updates that saved choice, without hiding native UI.
+
+- Click a row/group or press `Ctrl+O` to expand/collapse.
+- `Ctrl+T` changes the thinking display, not the model's reasoning effort.
+- Choose `github-dark-pro` in Pi's `/settings` for the included theme.
 
 ## Configuration
 
-Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json` (trusted projects only; they override global settings field by field). Add `"$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json"` for editor validation.
+Optional: `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`. Trusted project settings override global settings field by field.
 
 ```json
 {
+  "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json",
   "style": "compact",
   "mode": "normal",
-  "tools": ["read", "write", "edit", "bash"],
   "previewLines": 10,
   "auto_compact": { "read": true, "write": true, "edit": false, "bash": true },
   "custom_tools": { "enabled": true, "auto_compact": true, "exclude": [] }
 }
 ```
 
-- `style`: `claude`, `codex`, `compact`, or `off`.
-- `tools`: built-ins drawn in the style. Also `grep`, `find`, `ls`, `powershell`.
-- `auto_compact`: `true` starts a Compact row collapsed; `false` shows up to `previewLines` rows. Custom tool names work too.
-- `custom_tools`: rows for tools from other packages. `exclude` keeps a tool's own look.
-
-## Codemode summaries
-
-Completed `codemode` rows in **Compact, Claude, and Codex** list the outcomes of the tools the script actually called, beside the duration and output-line count:
-
-```text
-Done in 1.234s (42 lines) · read 3 · bash 1 · edit 3 2
-```
-
-Each tool appears once with plain colored counts and no count parentheses or pipe: `read 3 · bash 1 · edit 3 2`. Single-outcome calls show one green success count, red failure count, or yellow unfinished-only count. Mixed success/failure calls show the green success count followed by the red failure count, separated only by a space; zero-count placeholders are omitted. Unfinished calls alongside settled calls add a separate yellow note such as `edit 3 2 1 unfinished`. Summary names retain their theme title hue at 75% brightness without bold, while outcome numbers keep their hues at 80% brightness. The main tool title and code preview remain unchanged. `Done in … (N lines)` uses a neutral tone one step brighter than the frame; spaces and `·` separators retain the dim frame chrome. There are no circles, leading bars, underlines, patch totals, or per-call diff lists. Non-edit groups retain first-occurrence order, and edit always appears last. Incomplete records show `(partial)`. Long summaries wrap to the pane width. Previews and author-provided expanded views remain available; expansion does not add patch details. Claude and Codex place the indented completion summary after output and keep disclosure last. Completion rows do not consume Claude’s output-preview limit.
-
-The summary uses the host’s nested-call events and saved records without changing what the model sees. It retains only tool names and statuses, never arguments, results, or edit diff totals. An in-process `/reload`, resumed sessions, and `/tree` navigation preserve or restore call counts and outcomes. Hosts without nested-call data keep the previous row rendering.
-
-## UI-only behavior
-
-This package never registers or activates agent tools and does not add model-facing
-messages, tool schemas, or prompt text. Host execution settings (including shell
-prefixes and image resizing) remain untouched. Renderer-bearing overrides of names
-such as `read` or `bash` follow `custom_tools`, including its exclusions.
-
-On Pi 1.0.2 and newer, the public renderer API also applies compact rendering to HTML
-exports. Older hosts use a terminal-only compatibility patch; HTML exports keep
-Pi's native renderers. On Pi 1.1 and newer, final durations use the host's recorded
-`durationMs`, including restored sessions, and tool rows follow `outputPad` (0 or 1)
-without changing their internal style indentation. Older hosts keep event-based
-timing and the original margins; the minimum supported Pi version is unchanged.
-When custom compact rendering is enabled, it intentionally takes precedence over
-fallback renderers supplied by earlier `next() ?? mine` resolvers for unknown tools.
-Disable `custom_tools` or exclude the tool to preserve those fallback renderers.
-
-## Controls
-
-- Click a row or group, or press `Ctrl+O`, to expand and collapse.
-- `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
+`auto_compact` entries set to `true` start Compact rows collapsed. Add tool names to `custom_tools.exclude` to keep their own rendering. All options are described in the linked schema.
 
 ## Development
 
-```bash
-npm install
-npm run check
-pi -e .
-```
-
-Development dependencies are pinned to Pi 1.2.0; the peer minimum remains Pi 0.85.1. CI checks Pi 0.85.1, 0.99.1, 1.0.0, 1.0.2, 1.1.0, and 1.2.0 on Node 22.19.0 and 24. Schema validation and deterministic test clocks are development-only dependencies, not runtime dependencies. Development scripts and tests are not included in the published package. `npm test` runs the rendering tests first and the resource/packaging checks separately so their subprocesses do not disturb animation tests.
-
-For a local before/after performance comparison, run `npx tsx tests/benchmark.ts <clean-baseline-directory>` with the same host dependencies in both directories. Measurements are informational, not timing-sensitive test assertions.
-
-Renders are pinned in `tests/golden/`. After an intended change to the output, record it with `UPDATE_GOLDEN=1 npm test` and review the diff. The Claude and Codex styles are checked against references captured from the real tools in `tests/fixtures/`. The README's GIFs are recorded with `scripts/record-demos.sh` (needs `vhs` and `ffmpeg`). Before publishing, add the version's notes to `release-notes.json` (`[]` for none).
+See [development, compatibility, and demo recording](https://github.com/nedleeds/pi-compact-tools/blob/main/docs/development.md). Run `npm ci` and `npm run check` before contributing.
 
 ## License
 

package/extensions/compact-tools-activity.ts

@@ -251,7 +251,6 @@ export class SilentActivityAnimator {
 
 	constructor(private readonly pi: ExtensionAPI) {
 		pi.on("agent_start", () => {
-			if (!this.context) return;
 			this.running = true;
 			this.answering = false;
 			this.refresh();
@@ -265,7 +264,6 @@ export class SilentActivityAnimator {
 		});
 		pi.on("tool_execution_start", () => this.setAnswering(false));
 		pi.on("turn_start", () => {
-			if (!this.context) return;
 			this.running = true;
 			this.answering = false;
 			this.refresh();
@@ -274,17 +272,16 @@ export class SilentActivityAnimator {
 		// Keep the shared clock alive until Pi declares final settlement, as the
 		// working-label controller already does.
 		pi.on("agent_settled", () => {
-			if (!this.context) return;
 			this.running = false;
 			this.refresh();
 		});
 	}
 
-	bind(ctx: ExtensionContext): void {
+	bind(ctx: ExtensionContext, resume = false): void {
 		this.hide();
 		this.context = ctx;
 		this.running = ctx.isIdle?.() === false;
-		this.answering = false;
+		if (!resume) this.answering = false;
 	}
 
 	setEnabled(enabled: boolean): void {
@@ -293,10 +290,12 @@ export class SilentActivityAnimator {
 	}
 
 	dispose(): void {
-		this.hide();
-		this.context = undefined;
-		this.running = false;
-		this.enabled = false;
+		try { this.hide(); }
+		finally {
+			this.context = undefined;
+			this.running = false;
+			this.enabled = false;
+		}
 	}
 
 	/** Guarded like the progress label: a host with a partial API keeps the default color. */
@@ -305,7 +304,7 @@ export class SilentActivityAnimator {
 	}
 
 	private setAnswering(answering: boolean): void {
-		if (!this.context || this.answering === answering) return;
+		if (this.answering === answering) return;
 		this.answering = answering;
 		this.refresh();
 	}

package/extensions/compact-tools-clock.ts

@@ -1,29 +1,46 @@
 /**
- * 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.
+ * One clock for tool indicators, the working label, and silent activity. The
+ * fastest subscriber sets its cadence; slower animations share those frames,
+ * keeping their average period with a remainder instead of repainting between
+ * indicator frames. With no indicators it returns to the original 80ms cadence.
  */
 export const TICK_MS = 80;
 
-type Listener = () => void;
-
-const listeners = new Set<Listener>();
+type Subscription = { listener: () => void; period: number; elapsed: number };
+const listeners = new Set<Subscription>();
 let timer: ReturnType<typeof setInterval> | undefined;
+let cadence = 0;
+
+function reschedule(): void {
+	const next = listeners.size ? Math.min(...[...listeners].map(({ period }) => period)) : 0;
+	if (next === cadence) return;
+	if (timer) clearInterval(timer);
+	timer = undefined;
+	cadence = next;
+	if (!next) return;
+	timer = setInterval(() => {
+		// Capture the elapsed step: a subscriber may change the cadence or unsubscribe
+		// another callback while this dispatch is in progress.
+		const step = cadence;
+		for (const entry of [...listeners]) {
+			if (!listeners.has(entry)) continue;
+			entry.elapsed += step;
+			if (entry.elapsed < entry.period) continue;
+			entry.elapsed %= entry.period;
+			entry.listener();
+		}
+	}, next);
+	timer.unref?.();
+}
 
-/** 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?.();
-	}
+/** Subscribe until disposed. No timer survives the last subscriber. */
+export function onTick(listener: () => void, period = TICK_MS): () => void {
+	if (!Number.isFinite(period) || period <= 0) throw new RangeError("Animation period must be positive and finite");
+	const entry: Subscription = { listener, period, elapsed: 0 };
+	listeners.add(entry);
+	reschedule();
 	return () => {
-		listeners.delete(listener);
-		if (listeners.size > 0 || !timer) return;
-		clearInterval(timer);
-		timer = undefined;
+		listeners.delete(entry);
+		reschedule();
 	};
 }

package/extensions/compact-tools-command.ts

@@ -1,19 +1,19 @@
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
-import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { DISPLAY_STYLES, type CompactToolsConfig, type DisplayStyle } from "./compact-tools-types.ts";
 import { loadConfig } from "./compact-tools-config.ts";
 
 type Scope = "global" | "project";
 const SCOPES: readonly Scope[] = ["global", "project"];
-const HELP = "Usage: /compact-tools [compact|claude|codex|off] [global|project]\nWithout a scope the style is saved globally, or to this project when its settings choose the style.\n/compact-tools status · /compact-tools help\nCtrl+O expands rows; /silent toggles quiet mode. Styles switch at once, even while tools run; off reloads Pi.";
+const HELP = "Usage: /compact-tools [compact|claude|codex|off] [global|project]\nWithout a scope the style is saved globally, or to this project when its settings choose the style.\n/compact-tools status · /compact-tools help\nCtrl+O expands rows; /silent toggles quiet mode. All styles, including off, switch at once, even while tools run.";
 const BUSY = "Wait for the current response to finish before changing tool styles.";
 const CHOICES: Record<DisplayStyle, string> = {
 	compact: "Compact — one expandable row per tool call",
 	claude: "Claude — group reads and searches",
 	codex: "Codex — explored groups and output tails, like Codex CLI",
-	off: "Off — restore Pi's default tool rows",
+	off: "Off — restore Pi's native UI",
 };
 
 export function configPath(cwd: string, scope: Scope): string {
@@ -78,15 +78,10 @@ function errorMessage(error: unknown): string {
 
 /**
  * Draw the saved style in place, without a reload, and say whether it could: a switch
- * between the compact, Claude, and Codex styles keeps every tool's registration, so
- * it applies at once, even while a response runs. Turning rows off or back on cannot.
+ * between any style, including native/off, changes only UI routing. It applies
+ * at once while a response runs, with no tool registry or transcript changes.
  */
-export type ApplyStyle = (cwd: string, trusted: boolean) => boolean;
-
-/** Whether a switch needs Pi to reload: only off hands tools to or takes them from Pi's own renderers. */
-function needsReload(from: DisplayStyle, to: DisplayStyle): boolean {
-	return from === "off" || to === "off";
-}
+export type ApplyStyle = (cwd: string, trusted: boolean, ctx: ExtensionContext) => boolean;
 
 export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => CompactToolsConfig, applyStyle?: ApplyStyle): void {
 	pi.registerCommand("compact-tools", {
@@ -122,9 +117,9 @@ export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => C
 				ctx.ui.notify(HELP, "warning");
 				return;
 			}
-			// A switch between drawn styles applies in place, so only one that reloads waits for the response.
+			// Only a host/integration without live UI routing requires an idle reload.
 			const named = parts[0] as DisplayStyle | undefined;
-			if (named && !ctx.isIdle() && (needsReload(getConfig().style, named) || !applyStyle)) {
+			if (named && !ctx.isIdle() && !applyStyle) {
 				ctx.ui.notify(BUSY, "warning");
 				return;
 			}
@@ -155,7 +150,7 @@ export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => C
 				return;
 			}
 			// The agent may have started while the user was choosing in a dialog.
-			const reloads = needsReload(getConfig().style, style) || !applyStyle;
+			const reloads = !applyStyle;
 			if (reloads && !ctx.isIdle()) {
 				ctx.ui.notify(BUSY, "warning");
 				return;
@@ -175,7 +170,7 @@ export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => C
 				ctx.ui.notify(`Saved ${style} to global settings, but this project keeps its own ${effective} style. Run /compact-tools ${style} to switch it here.`, "warning");
 				return;
 			}
-			if (!reloads && applyStyle!(ctx.cwd, ctx.isProjectTrusted())) {
+			if (!reloads && applyStyle!(ctx.cwd, ctx.isProjectTrusted(), ctx)) {
 				ctx.ui.notify(`Switched to ${style} style (saved to ${where}).`, "info");
 				return;
 			}
@@ -183,7 +178,9 @@ export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => C
 				ctx.ui.notify(`Saved ${style} style to ${where}. It applies once the response finishes; run /reload then.`, "warning");
 				return;
 			}
-			ctx.ui.notify(`Switching to ${style} style (saved to ${where}). Reloading…`, "info");
+			ctx.ui.notify(style === "off"
+				? `Restoring Pi's native UI (saved to ${where}). Reloading…`
+				: `Switching to ${style} style (saved to ${where}). Reloading…`, "info");
 			// Reloading makes this ctx stale, so a failure is reported through the UI held from before.
 			const ui = ctx.ui;
 			try {

package/extensions/compact-tools-grouping.ts

@@ -324,8 +324,9 @@ export class ToolGroupController {
 	}
 
 	dispose(): void {
-		this.context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
+		const context = this.context;
 		this.context = undefined;
+		context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
 	}
 
 	private makeGroup(rows: ToolRowLike[], members: unknown[], tui: { requestRender(): void }): Component {

package/extensions/compact-tools-invocation.ts

@@ -3,6 +3,12 @@ import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { normalizeLineEndings } from "./compact-tools-core.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
+/** Historical/transcribed read arguments may contain numeric strings or null. Display only. */
+export function readStartLine(value: unknown): number {
+	if (typeof value === "string" && value.trim() !== "") value = Number(value);
+	return typeof value === "number" && Number.isFinite(value) ? value : 1;
+}
+
 function pathFrom(args: ToolArgs): string {
 	const value = args.path ?? args.file_path;
 	return typeof value === "string" ? normalizeLineEndings(value) : "";

package/extensions/compact-tools-progress.ts

@@ -96,28 +96,24 @@ export class ProgressController {
 	private level: ThinkingLevel = "medium";
 
 	constructor(private readonly pi: ExtensionAPI) {
-		// 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.
+		// Keep only the current phase/active calls while detached. No UI work or
+		// clock runs, but re-enabling mid-stream can resume the correct label.
 		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;
+			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;
+			if (typeof event.toolName !== "string") 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…");
@@ -128,7 +124,6 @@ export class ProgressController {
 		// so releasing the label at agent_end makes a retried turn reappear under Pi's
 		// default label. Release it at the final settlement instead.
 		pi.on("agent_settled", () => {
-			if (!this.context) return;
 			this.activeTools.clear();
 			this.clearMessage();
 		});
@@ -146,30 +141,34 @@ export class ProgressController {
 		if (typeof this.pi.getThinkingLevel === "function") this.level = this.pi.getThinkingLevel();
 	}
 
-	bind(ctx: ExtensionContext): void {
+	bind(ctx: ExtensionContext, resume = false): void {
 		this.stopAnimation();
 		this.context = ctx;
 		this.readLevel();
-		this.activeTools.clear();
+		const message = resume && ctx.isIdle?.() === false ? this.message ?? "Thinking…" : undefined;
+		if (!message) this.activeTools.clear();
 		this.message = undefined;
 		this.frames = [];
 		this.frame = 0;
 		ctx.ui.setWorkingVisible(true);
 		ctx.ui.setWorkingIndicator({ frames: [] });
+		if (message) this.setMessage(message);
 	}
 
-	dispose(): void {
+	dispose(preservePhase = false): void {
+		const context = this.context;
+		this.context = undefined;
 		this.stopAnimation();
-		this.activeTools.clear();
-		this.context?.ui.setWorkingMessage();
-		this.context?.ui.setWorkingIndicator();
-		this.message = undefined;
+		if (!preservePhase) this.activeTools.clear();
+		if (!preservePhase) this.message = undefined;
 		this.frames = [];
-		this.context = undefined;
+		try { context?.ui.setWorkingMessage(); }
+		finally { context?.ui.setWorkingIndicator(); }
 	}
 
 	private setMessage(message: string): void {
-		if (!this.context || (this.message === message && this.stopTicking)) return;
+		if (!this.context) { this.message = message; return; }
+		if (this.message === message && this.stopTicking) return;
 		this.message = message;
 		this.frames = [];
 		this.frame = 0;

package/extensions/compact-tools-rendering.ts

@@ -1,5 +1,7 @@
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import {
-	createBashToolDefinition, createEditToolDefinition, createFindToolDefinition,
+	getPackageDir, createBashToolDefinition, createEditToolDefinition, createFindToolDefinition,
 	createGrepToolDefinition, createLsToolDefinition, createPowerShellToolDefinition,
 	createReadToolDefinition, createWriteToolDefinition,
 	type ToolDefinition,
@@ -22,6 +24,20 @@ for (const [name, factory] of Object.entries(factories)) {
 	}
 }
 
+let nativeTimerLoad: Promise<void> | undefined;
+/** Optional bundled renderer: absent on old hosts, and never executes a tool. */
+export function loadNativeTimerRenderers(): Promise<void> {
+	return nativeTimerLoad ??= (async () => {
+		try {
+			const url = pathToFileURL(join(getPackageDir(), "dist/extensions/codemode/renderer.js"));
+			const { codemodeRenderers } = await import(url.href);
+			if (typeof codemodeRenderers?.renderCall === "function" && typeof codemodeRenderers?.renderResult === "function") {
+				builtinRenderers.set("codemode", { call: String(codemodeRenderers.renderCall), result: String(codemodeRenderers.renderResult) });
+			}
+		} catch { /* Optional host internals must not prevent UI loading. */ }
+	})();
+}
+
 /** Conservative fallback on legacy hosts without source metadata. */
 export function hasAuthorRenderers(name: string, definition: ToolDefinition<any, any, any> | undefined): boolean {
 	if (!definition) return false;
@@ -30,6 +46,25 @@ export function hasAuthorRenderers(name: string, definition: ToolDefinition<any,
 		|| (definition.renderResult && String(definition.renderResult) !== builtin?.result));
 }
 
+/**
+ * Native shell rows own a one-second elapsed timer in their renderer state. Pause
+ * it when leaving native rendering (without fabricating a final result), and seed
+ * its start from the observed execution time when entering native rendering late.
+ * Guard by the exact host renderer fingerprint: third-party state is not ours.
+ */
+export function syncNativeToolTimer(row: object, name: string, base: ToolDefinition<any, any, any> | undefined, native: boolean, timing?: { startedAt: number; endedAt?: number }): void {
+	if (!base || !builtinRenderers.has(name) || !["bash", "powershell", "codemode"].includes(name) || hasAuthorRenderers(name, base)) return;
+	const state = (row as { rendererState?: { startedAt?: number; endedAt?: number; interval?: ReturnType<typeof setInterval> } }).rendererState;
+	if (!state) return;
+	if (native) {
+		if (state.startedAt === undefined && timing) state.startedAt = timing.startedAt;
+		if (state.endedAt === undefined && timing?.endedAt !== undefined) state.endedAt = timing.endedAt;
+	} else if (state.interval !== undefined) {
+		clearInterval(state.interval);
+		state.interval = undefined;
+	}
+}
+
 /** Change only a transcript row's renderer shell, never a tool registry entry. */
 export function refreshRowShell(row: object): void {
 	const target = row as {