pi-compact-tools 0.16.2 → 0.16.6

package/README.md

@@ -23,8 +23,9 @@ Requires Node.js 22.19+ and Pi 0.85.1+. **Pi 1.0.2+ recommended** for native ren
 | **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` |
 
-Switching redraws existing rows, even while tools run. Only read-only exploration is grouped; commands that write or execute work keep separate 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
 
@@ -69,10 +70,10 @@ The two failed edits are intentional. Reload/resume preserves summaries from nes
 /compact-tools claude project  # save for this trusted project
 /compact-tools codex global    # save globally
 /compact-tools status          # effective settings and paths
-/compact-tools off             # restore Pi's native rows (reloads Pi)
+/compact-tools off             # restore Pi's native UI live, even while streaming
 ```
 
-Without a scope, changes are saved where the style is configured: project or global. A trusted project's own style overrides a global save. Turning rows off or back on waits for the current response to finish and reloads Pi.
+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.

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 {

package/extensions/compact-tools-runtime.ts

@@ -1,9 +1,8 @@
-import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
 import { DEFAULT_CONFIG } from "./compact-tools-config.ts";
+import { onTick } from "./compact-tools-clock.ts";
 import { isSilent } from "./compact-tools-silent.ts";
 import {
 	SUPPORTED_TOOL_SET,
-	type BuiltInDefinition,
 	type CompactToolName,
 	type CompactToolsConfig,
 	type RenderContext,
@@ -27,7 +26,6 @@ export function validDurationMs(value: unknown): value is number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 type Indicator = { invalidate: () => void; drawnAt: number };
-type TimedExecute = (...args: any[]) => Promise<AgentToolResult<unknown>>;
 type SharedState = typeof globalThis & {
 	[EXECUTION_TIMINGS_KEY]?: Map<string, ExecutionTiming>;
 };
@@ -38,7 +36,7 @@ export class ToolRuntime {
 	private readonly executionTimings: Map<string, ExecutionTiming>;
 	private readonly indicators = new Map<string, Indicator>();
 	private indicatorFrame = 0;
-	private indicatorTimer: ReturnType<typeof setInterval> | undefined;
+	private stopIndicatorTicks: (() => void) | undefined;
 	/** Pi's frame request, once bound to its terminal; rows then repaint without being rebuilt. */
 	private requestRender: (() => void) | undefined;
 	/** Whether the agent is working; undefined until the host says, which counts as working. */
@@ -49,12 +47,6 @@ export class ToolRuntime {
 	 * more than one run's calls.
 	 */
 	private readonly currentCalls = new Set<string>();
-	/**
-	 * Calls a tool is making through `ctx.executeTool()`, as codemode scripts do. They
-	 * never get a row of their own, so no execution timing is kept for them.
-	 * The independent nested-summary observer keeps only their outcome counts.
-	 */
-	private readonly nestedCalls = new Set<string>();
 
 	constructor(private readonly clock: () => number = () => performance.now()) {
 		const shared = globalThis as SharedState;
@@ -111,7 +103,6 @@ export class ToolRuntime {
 	setBusy(busy: boolean): void {
 		if (busy && this.busy !== true) {
 			this.currentCalls.clear();
-			this.nestedCalls.clear();
 		}
 		this.busy = busy;
 		if (busy) return;
@@ -129,12 +120,6 @@ export class ToolRuntime {
 		this.currentCalls.add(toolCallId);
 	}
 
-	/** A call another tool made began (`running`) or finished; Pi says so with `parentToolCallId`. */
-	noteNestedCall(toolCallId: string, running: boolean): void {
-		if (running) this.nestedCalls.add(toolCallId);
-		else this.nestedCalls.delete(toolCallId);
-	}
-
 	/**
 	 * Whether a call can be running: only one Pi announced in the run going on. A
 	 * row restored from the session, one left without a result when its run ended,
@@ -158,10 +143,7 @@ export class ToolRuntime {
 		} else {
 			this.indicators.set(toolCallId, { invalidate, drawnAt: this.clock() });
 		}
-		if (!this.indicatorTimer) {
-			this.indicatorTimer = setInterval(() => this.tick(), INDICATOR_INTERVAL_MS);
-			this.indicatorTimer.unref?.();
-		}
+		this.stopIndicatorTicks ??= onTick(() => this.tick(), INDICATOR_INTERVAL_MS);
 		return this.indicatorFrame;
 	}
 
@@ -211,12 +193,7 @@ export class ToolRuntime {
 		return state;
 	}
 
-	/**
-	 * Record when a tool this extension does not wrap starts and ends. Pi reports
-	 * both to extensions before it redraws the row, and the row draws its status
-	 * dot before its result, so without this a finished custom tool kept the
-	 * running dot. Wrapped built-ins already have timings, which are kept.
-	 */
+	/** Record top-level execution events without wrapping model-facing tools. */
 	noteExecutionStart(toolCallId: string): void {
 		if (!this.executionTimings.has(toolCallId)) this.executionTimings.set(toolCallId, { startedAt: Date.now() });
 		this.trimTimings();
@@ -230,24 +207,6 @@ export class ToolRuntime {
 		this.trimTimings();
 	}
 
-	createTimedExecute(definition: BuiltInDefinition): TimedExecute {
-		const execute = definition.execute as TimedExecute;
-		return async (...args: any[]) => {
-			const toolCallId = typeof args[0] === "string" && !this.nestedCalls.has(args[0]) ? args[0] : undefined;
-			const startedAt = (toolCallId ? this.executionTimings.get(toolCallId)?.startedAt : undefined) ?? Date.now();
-			if (toolCallId && !this.executionTimings.has(toolCallId)) {
-				this.executionTimings.set(toolCallId, { startedAt });
-				this.trimTimings();
-			}
-			try {
-				return await execute.apply(definition, args);
-			} finally {
-				const timing = toolCallId ? this.executionTimings.get(toolCallId) : undefined;
-				if (timing) timing.endedAt = Date.now();
-			}
-		};
-	}
-
 	private tick(): void {
 		this.indicatorFrame++;
 		const requestRender = this.requestRender;
@@ -269,15 +228,15 @@ export class ToolRuntime {
 
 	private removeIndicator(toolCallId: string): void {
 		this.indicators.delete(toolCallId);
-		if (this.indicators.size > 0 || !this.indicatorTimer) return;
-		clearInterval(this.indicatorTimer);
-		this.indicatorTimer = undefined;
+		if (this.indicators.size > 0) return;
+		this.stopIndicatorTicks?.();
+		this.stopIndicatorTicks = undefined;
 		this.indicatorFrame = 0;
 	}
 
 	private stopIndicators(): void {
-		if (this.indicatorTimer) clearInterval(this.indicatorTimer);
-		this.indicatorTimer = undefined;
+		this.stopIndicatorTicks?.();
+		this.stopIndicatorTicks = undefined;
 		this.indicators.clear();
 		this.indicatorFrame = 0;
 	}

package/extensions/compact-tools-silent.ts

@@ -311,9 +311,9 @@ export class SilentModeController {
 		return sharedState().enabled;
 	}
 
-	bind(ctx: ExtensionContext, mode: DisplayMode, reload: boolean): void {
+	bind(ctx: ExtensionContext, mode: DisplayMode, reload: boolean, resume = false): void {
 		this.context = ctx;
-		this.activity.bind(ctx);
+		this.activity.bind(ctx, resume);
 		// An invisible widget is the extension API's way to reach Pi's TUI, and
 		// through it the chat container whose notices silent mode hides.
 		ctx.ui.setWidget(WIDGET_KEY, (tui) => {
@@ -326,13 +326,16 @@ export class SilentModeController {
 	}
 
 	dispose(): void {
-		this.activity.dispose();
-		// A patched Pi prototype outlives this extension instance. Disable hiding
-		// while no instance is bound, but keep the choice for a subsequent /reload.
-		sharedState().active = false;
-		this.context?.ui.setStatus(STATUS_KEY, undefined);
-		this.context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
+		const context = this.context;
 		this.context = undefined;
+		// Detach state before calling host UI: an exception must not reactivate
+		// silent hiding or its animation while the extension is off.
+		sharedState().active = false;
+		try { this.activity.dispose(); }
+		finally {
+			try { context?.ui.setStatus(STATUS_KEY, undefined); }
+			finally { context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" }); }
+		}
 	}
 
 	private apply(enabled: boolean): boolean {

package/extensions/compact-tools-thinking.ts

@@ -201,15 +201,18 @@ function getInitialThinkingPhase(): ThinkingPhase {
 }
 
 export class ThinkingCycleController {
+	private context: ExtensionContext | undefined;
 	private phase: ThinkingPhase = "summary";
 	private unsubscribe: (() => void) | undefined;
 	private theme: Theme | undefined;
 	private hasToggleableThinking = false;
 	private refreshThinking: (() => void) | undefined;
 
-	constructor(pi: ExtensionAPI) {
+	constructor(pi: ExtensionAPI, enabled: () => boolean = () => true) {
 		pi.registerMarkdownTransformer((markdown, context) => {
-			if (context.messageType !== "assistant-thinking") return markdown;
+			// Off also applies before session_start, during transcript reconstruction
+			// and HTML exports. Do not summarize or restyle native thinking there.
+			if (!enabled() || context.messageType !== "assistant-thinking") return markdown;
 			const sections = splitThinkingSections(markdown);
 			this.hasToggleableThinking ||= sectionsHaveDetail(sections);
 			const theme = this.theme;
@@ -241,6 +244,7 @@ export class ThinkingCycleController {
 
 	bind(ctx: ExtensionContext): void {
 		this.unsubscribe?.();
+		this.context = ctx;
 		this.theme = ctx.ui.theme;
 		this.hasToggleableThinking = false;
 		// Match Pi's persisted host visibility after startup or /reload. When the
@@ -277,11 +281,15 @@ export class ThinkingCycleController {
 		});
 	}
 
-	dispose(): void {
-		this.unsubscribe?.();
+	dispose(restoreNative = false): void {
+		const context = this.context;
+		const unsubscribe = this.unsubscribe;
+		this.context = undefined;
 		this.unsubscribe = undefined;
 		this.refreshThinking = undefined;
 		this.hasToggleableThinking = false;
 		this.theme = undefined;
+		try { unsubscribe?.(); }
+		finally { if (restoreNative) context?.ui.setHiddenThinkingLabel(); }
 	}
 }

package/extensions/compact-tools-transcript.ts

@@ -0,0 +1,93 @@
+import { ToolExecutionComponent, type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import type { RowRenderers, ToolRow } from "./compact-tools-custom.ts";
+import { refreshRowShell, syncNativeToolTimer } from "./compact-tools-rendering.ts";
+import type { ToolRuntime } from "./compact-tools-runtime.ts";
+import { findChat, isKind } from "./compact-tools-silent.ts";
+
+type Definition = ToolDefinition<any, any, any> | undefined;
+export interface UIFailure { operation: string; error: unknown }
+
+/** Attempt every independent cleanup/row action; the caller reports failures once. */
+export function attemptUI(failures: UIFailure[], operation: string, action: () => void): void {
+	try { action(); } catch (error) { failures.push({ operation, error }); }
+}
+
+interface TranscriptOptions {
+	runtime: ToolRuntime;
+	publicRendering: boolean;
+	resolve(row: ToolRow): RowRenderers | undefined;
+	definition(name: string, base: Definition): Definition;
+	unwrap(definition: Definition): Definition;
+}
+
+const WIDGET_KEY = "compact-tools-render";
+const emptyWidget = () => ({ render: () => [], invalidate() {} });
+
+/** Own the TUI probe and the private host-row reconciliation boundary together. */
+export function createTranscriptRenderer(options: TranscriptOptions) {
+	let context: ExtensionContext | undefined;
+	let refresh: ((failures: UIFailure[]) => void) | undefined;
+
+	const reconcile = (tui: TUI, failures: UIFailure[]) => {
+		const visit = (parent: { children?: unknown[] }) => {
+			for (const child of parent.children ?? []) {
+				if (!child || typeof child !== "object") continue;
+				attemptUI(failures, "tool row", () => {
+					if (!isKind(child, ToolExecutionComponent)) { visit(child); return; }
+					const row = child as ToolRow & { toolCallId: string; updateDisplay?(): void; callRendererComponent?: unknown; resultRendererComponent?: unknown };
+					const base = options.unwrap(row.toolDefinition);
+					syncNativeToolTimer(row, row.toolName, base, !options.resolve({ toolName: row.toolName, toolDefinition: base }), options.runtime.timing(row.toolCallId));
+					if (options.publicRendering) {
+						row.toolDefinition = options.definition(row.toolName, base);
+						// Components must not cross native/compact renderer ownership,
+						// even when both definitions request the same shell.
+						row.callRendererComponent = undefined;
+						row.resultRendererComponent = undefined;
+					}
+					refreshRowShell(row);
+					row.updateDisplay?.();
+				});
+			}
+		};
+		attemptUI(failures, "transcript", () => {
+			const chat = findChat(tui);
+			if (chat && chat.children.length > 0) {
+				visit(chat);
+				attemptUI(failures, "repaint", () => tui.requestRender());
+			}
+		});
+	};
+
+	return {
+		bind(ctx: ExtensionContext, failures: UIFailure[]): void {
+			context = ctx;
+			attemptUI(failures, "renderer probe", () => ctx.ui.setWidget(WIDGET_KEY, (tui) => {
+				options.runtime.bindRenderer(() => tui.requestRender());
+				refresh = (errors) => reconcile(tui, errors);
+				return emptyWidget();
+			}, { placement: "belowEditor" }));
+			refresh?.(failures);
+		},
+		refresh(failures: UIFailure[]): void { refresh?.(failures); },
+		detach(): void {
+			const previous = context;
+			context = undefined;
+			refresh = undefined;
+			options.runtime.bindRenderer(undefined);
+			previous?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
+		},
+		/** Reconcile provisional startup rows without binding runtime animation. */
+		reconcileOnce(ctx: ExtensionContext, failures: UIFailure[]): void {
+			if (refresh) { refresh(failures); return; }
+			try {
+				attemptUI(failures, "startup renderer probe", () => ctx.ui.setWidget(WIDGET_KEY, (tui) => {
+					reconcile(tui, failures);
+					return emptyWidget();
+				}, { placement: "belowEditor" }));
+			} finally {
+				attemptUI(failures, "startup renderer cleanup", () => ctx.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" }));
+			}
+		},
+	};
+}

package/extensions/compact-tools-viewport.ts

@@ -221,12 +221,14 @@ export class ViewportKeeper {
 	}
 
 	dispose(): void {
-		this.unsubscribe?.();
+		const context = this.context;
+		const unsubscribe = this.unsubscribe;
+		this.context = undefined;
 		this.unsubscribe = undefined;
 		const state = sharedState();
 		state.pending = undefined;
 		state.tui = undefined;
-		this.context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
-		this.context = undefined;
+		try { unsubscribe?.(); }
+		finally { context?.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" }); }
 	}
 }

package/extensions/compact-tools.ts

@@ -7,12 +7,11 @@ import type {
 	ToolDefinition,
 	ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
-import { ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
 import { classifyCallStatus, formatDurationMs, normalizeLineEndings, type RowStatus } from "./compact-tools-core.ts";
 import { loadConfig } from "./compact-tools-config.ts";
 import { paletteOf } from "./compact-tools-color.ts";
-import { hasAuthorRenderers, refreshRowShell } from "./compact-tools-rendering.ts";
+import { hasAuthorRenderers, loadNativeTimerRenderers, syncNativeToolTimer } from "./compact-tools-rendering.ts";
 import { registerCompactToolsCommand } from "./compact-tools-command.ts";
 import { clearRowResolver, installToolRowPatch, setRowResolver, type RowRenderers, type ToolRow } from "./compact-tools-custom.ts";
 import {
@@ -23,6 +22,7 @@ import {
 	getEditDiff,
 	getEditPatch,
 	getFileOutput,
+	readStartLine,
 	getTextResult,
 	isReadTextResult,
 	splitReadFooter,
@@ -56,7 +56,8 @@ import { chromePainter, completionPainter, paintIndicator } from "./compact-tool
 import { ProgressController } from "./compact-tools-progress.ts";
 import { showReleaseNotice } from "./compact-tools-release.ts";
 import { ToolRuntime } from "./compact-tools-runtime.ts";
-import { findChat, isKind, SilentModeController } from "./compact-tools-silent.ts";
+import { SilentModeController } from "./compact-tools-silent.ts";
+import { attemptUI, createTranscriptRenderer, type UIFailure } from "./compact-tools-transcript.ts";
 import { ThinkingCycleController } from "./compact-tools-thinking.ts";
 import { ViewportKeeper } from "./compact-tools-viewport.ts";
 import {
@@ -72,7 +73,6 @@ const PREVIEW_DIFF_CONTEXT_LINES = 1;
 
 const runtime = new ToolRuntime();
 const nestedSummaries = new NestedCallSummaries();
-const RENDER_WIDGET_KEY = "compact-tools-render";
 let registeredConfiguration: string | undefined;
 /**
  * Whether the last session found its directory trusted. A /reload rebuilds the
@@ -278,7 +278,7 @@ function renderFileBody(
 	}
 	if (name === "read" && isReadTextResult(result)) {
 		const { body, footer } = splitReadFooter(output);
-		const startLine = typeof args.offset === "number" ? args.offset : 1;
+		const startLine = readStartLine(args.offset);
 		return renderCodeView(body, path, theme, { startLine, footer, rail }) ?? fallback();
 	}
 	if (name === "write") return renderCodeView(output, path, theme, { rail }) ?? fallback();
@@ -509,9 +509,15 @@ function createCustomRenderers(name: string, author: ToolDefinition<any, any, an
 					// Compact owns the outer margin and the result rail. An author
 					// renderer is embedded content, not another host-padded shell.
 					// Leave the field absent on legacy hosts.
-					value.component = authorRenderer(result, { ...options, expanded }, theme, {
-						...ctx, lastComponent: value.component, ...((ctx as { outputPad?: number }).outputPad === undefined ? {} : { outputPad: 0 }),
-					});
+					try {
+						value.component = authorRenderer(result, { ...options, expanded }, theme, {
+							...ctx, lastComponent: value.component, ...((ctx as { outputPad?: number }).outputPad === undefined ? {} : { outputPad: 0 }),
+						});
+					} finally {
+						// Compact owns animation; a delegated native codemode preview
+						// must not leave a second clock when later collapsed.
+						syncNativeToolTimer({ rendererState: ctx.state }, name, author, false);
+					}
 					return value.component;
 				}
 				: undefined;
@@ -552,6 +558,7 @@ type RendererAPI = ExtensionAPI & {
 };
 let publicRendering = false;
 let sessionReady = false;
+let publicBases = new WeakMap<object, ToolDefinition<any, any, any> | undefined>();
 let publicOwners = new WeakMap<object, { call?: unknown; result?: unknown }>();
 function publicRowDefinition(name: string, base: ToolDefinition<any, any, any> | undefined): ToolDefinition<any, any, any> | undefined {
 	// Preserve next()'s result exactly once the session's configuration is known.
@@ -580,46 +587,47 @@ function publicRowDefinition(name: string, base: ToolDefinition<any, any, any> |
 		const render = decide()?.renderResult ?? base?.renderResult;
 		return render!(value, options, theme, context(ctx, "result", render));
 	};
-	return {
+	const definition = {
 		get renderShell() { return decide() ? "self" : base?.renderShell ?? "default"; },
 		get renderCall() { return decide()?.renderCall || base?.renderCall ? call : undefined; },
 		get renderResult() { return decide()?.renderResult || base?.renderResult ? result : undefined; },
 	} as ToolDefinition<any, any, any>;
+	publicBases.set(definition, base);
+	return definition;
 }
 let legacyResolver: ((row: ToolRow) => RowRenderers | undefined) | undefined;
-let refreshTranscriptRows: (() => void) | undefined;
-function invalidateRowDecisions(): void {
+let refreshTranscriptRows: ((failures: UIFailure[]) => void) | undefined;
+function invalidateRowDecisions(failures: UIFailure[]): void {
 	if (!publicRendering) {
 		legacyResolver = (row) => resolveCustomRow(row);
 		setRowResolver(legacyResolver);
 	}
-	refreshTranscriptRows?.();
+	refreshTranscriptRows?.(failures);
 }
 
-function configure(_pi: ExtensionAPI, cwd?: string, projectTrusted = false): void {
+function configure(_pi: ExtensionAPI, cwd?: string, projectTrusted = false, failures: UIFailure[] = []): void {
 	const resolvedCwd = cwd ?? process.cwd();
 	const config = loadConfig(resolvedCwd, projectTrusted);
 	const signature = JSON.stringify([resolvedCwd, config]);
 	if (signature === registeredConfiguration) return;
 	runtime.configure(config);
 	registeredConfiguration = signature;
-	invalidateRowDecisions();
+	invalidateRowDecisions(failures);
 }
 
 /**
  * Apply a style saved by /compact-tools without reloading Pi. The compact, Claude, and
  * Codex styles share every tool registration and read the style as they draw, so the
  * configuration is swapped and each tool row on screen is drawn again, a running one
- * included. Anything else that changed, or a switch to or from off, needs a reload.
+ * included. Only non-style configuration changes require a reload.
  */
-function applyStyle(cwd: string, trusted: boolean): boolean {
+function applyStyle(cwd: string, trusted: boolean, failures: UIFailure[]): boolean {
 	const config = loadConfig(cwd, trusted);
 	const current = runtime.config;
-	if (config.style === "off" || current.style === "off") return false;
 	if (JSON.stringify({ ...config, style: current.style }) !== JSON.stringify(current)) return false;
 	runtime.configure(config);
 	registeredConfiguration = JSON.stringify([cwd, config]);
-	invalidateRowDecisions();
+	invalidateRowDecisions(failures);
 	return true;
 }
 
@@ -643,44 +651,15 @@ function madeByTool(event: object): boolean {
 	return typeof (event as { parentToolCallId?: unknown }).parentToolCallId === "string";
 }
 
-/** Hand the animation Pi's frame request, reached through an invisible widget as the extension API allows. */
-function bindRenderer(ctx: ExtensionContext): void {
-	ctx.ui.setWidget(RENDER_WIDGET_KEY, (tui) => {
-		runtime.bindRenderer(() => tui.requestRender());
-		refreshTranscriptRows = () => {
-			const visit = (parent: { children?: unknown[] }) => {
-				for (const child of parent.children ?? []) {
-					if (!child || typeof child !== "object") continue;
-					if (isKind(child, ToolExecutionComponent)) {
-						const row = child as ToolRow & { updateDisplay?(): void };
-						refreshRowShell(row);
-						row.updateDisplay?.();
-					} else visit(child as { children?: unknown[] });
-				}
-			};
-			const chat = findChat(tui);
-			if (chat && chat.children.length > 0) { visit(chat); tui.requestRender(); }
-		};
-		return { render: () => [], invalidate() {} };
-	}, { placement: "belowEditor" });
-	refreshTranscriptRows?.();
-}
-
-function unbindRenderer(ctx: ExtensionContext | undefined): void {
-	refreshTranscriptRows = undefined;
-	runtime.bindRenderer(undefined);
-	ctx?.ui.setWidget(RENDER_WIDGET_KEY, undefined, { placement: "belowEditor" });
-}
-
 export default function compactTools(pi: ExtensionAPI): void {
 	// The cached factory is invoked again after session replacement and reload.
 	// Reset configuration memoization, but never change the host's tool registry.
 	registeredConfiguration = undefined;
+	refreshTranscriptRows = undefined;
 	sessionReady = false;
 	publicOwners = new WeakMap();
-
-	registerCompactToolsCommand(pi, () => runtime.config, applyStyle);
-	const thinkingCycle = new ThinkingCycleController(pi);
+	publicBases = new WeakMap();
+	const thinkingCycle = new ThinkingCycleController(pi, () => runtime.config.style !== "off");
 	const progress = new ProgressController(pi);
 	const viewport = new ViewportKeeper();
 	const silent = new SilentModeController(pi, showReleaseNotice);
@@ -696,15 +675,66 @@ export default function compactTools(pi: ExtensionAPI): void {
 			const base = next();
 			return publicRowDefinition(name, base as ToolDefinition<any, any, any> | undefined);
 		});
-	} else invalidateRowDecisions();
+	} else invalidateRowDecisions([]);
+	const transcript = createTranscriptRenderer({
+		runtime, publicRendering, resolve: resolveCustomRow, definition: publicRowDefinition,
+		unwrap: (current) => current && publicBases.has(current) ? publicBases.get(current) : current,
+	});
+	refreshTranscriptRows = transcript.refresh;
 	let customRowsWarned = false;
-	let renderContext: ExtensionContext | undefined;
+	let sessionContext: ExtensionContext | undefined;
+	const reportFailures = (ctx: ExtensionContext | undefined, failures: UIFailure[]) => {
+		if (ctx && failures.length > 0) {
+			const operations = [...new Set(failures.map(failure => failure.operation))].join(", ");
+			const message = `Compact tools: UI refresh/cleanup failed (${operations}). The selected style is saved; affected UI may need /reload.`;
+			try { ctx.ui.notify(message, "warning"); }
+			catch (error) { console.warn(message, "UI notification also failed:", error); }
+		}
+	};
+	const enableUI = (ctx: ExtensionContext, reload: boolean, resume: boolean, failures: UIFailure[]) => {
+		// Observe relayout keys before the thinking controller consumes them.
+		attemptUI(failures, "viewport bind", () => viewport.bind(ctx));
+		attemptUI(failures, "progress bind", () => progress.bind(ctx, resume));
+		attemptUI(failures, "thinking bind", () => thinkingCycle.bind(ctx));
+		attemptUI(failures, "silent bind", () => silent.bind(ctx, runtime.config.mode, reload, resume));
+		attemptUI(failures, "groups bind", () => groups.bind(ctx));
+		transcript.bind(ctx, failures);
+	};
+	// One ownership/cleanup inventory for live off, session replacement and shutdown.
+	// Each action is independent: a host failure must not skip later cleanup steps.
+	const detachUI = (options: { preservePhase?: boolean; restoreNative?: boolean; clearTimings?: boolean }, failures: UIFailure[]) => {
+		attemptUI(failures, "thinking cleanup", () => thinkingCycle.dispose(options.restoreNative));
+		attemptUI(failures, "progress cleanup", () => progress.dispose(options.preservePhase));
+		attemptUI(failures, "silent cleanup", () => silent.dispose());
+		attemptUI(failures, "groups cleanup", () => groups.dispose());
+		attemptUI(failures, "viewport cleanup", () => viewport.dispose());
+		attemptUI(failures, "animation cleanup", () => runtime.reset(options.clearTimings === true));
+		attemptUI(failures, "renderer cleanup", () => transcript.detach());
+	};
+	registerCompactToolsCommand(pi, () => runtime.config, (cwd, trusted, ctx) => {
+		const failures: UIFailure[] = [];
+		const wasOff = runtime.config.style === "off";
+		if (!applyStyle(cwd, trusted, failures)) return false;
+		const uiContext = sessionContext ?? ctx;
+		if (uiContext.mode === "tui") {
+			if (runtime.config.style === "off") detachUI({ preservePhase: true, restoreNative: true }, failures);
+			else if (wasOff) enableUI(uiContext, true, true, failures);
+			// Off->off has no attached thinking context to restore the native label.
+			if (wasOff && runtime.config.style === "off") attemptUI(failures, "native thinking", () => uiContext.ui.setHiddenThinkingLabel());
+		}
+		reportFailures(uiContext, failures);
+		return true;
+	});
 	// Configure UI routing before Pi rebuilds transcript rows. Tool declarations
 	// and the active loadout must remain exactly as the host selected them.
 	const cwd = process.cwd();
 	const lastTrust = (globalThis as TrustSlot)[TRUST_KEY];
 	configure(pi, cwd, lastTrust?.cwd === realDirectory(cwd) && lastTrust.trusted);
+	pi.on("session_start", () => loadNativeTimerRenderers());
 	pi.on("session_start", (event, ctx) => {
+		const failures: UIFailure[] = [];
+		detachUI({ restoreNative: true }, failures);
+		sessionContext = ctx;
 		if (event.reason !== "reload") {
 			runtime.clearTimings();
 			nestedSummaries.clear();
@@ -715,33 +745,21 @@ export default function compactTools(pi: ExtensionAPI): void {
 		if (typeof ctx.isIdle === "function") runtime.setBusy(!ctx.isIdle());
 		const trusted = ctx.isProjectTrusted();
 		(globalThis as TrustSlot)[TRUST_KEY] = { cwd: realDirectory(ctx.cwd), trusted };
-		configure(pi, ctx.cwd, trusted);
+		configure(pi, ctx.cwd, trusted, failures);
 		sessionReady = true;
-		unbindRenderer(renderContext);
-		renderContext = undefined;
-		// Even off must reconcile rows built before trusted config was available.
-		if (ctx.mode === "tui") bindRenderer(ctx);
 		if (ctx.mode === "tui" && runtime.config.style !== "off") {
-			renderContext = ctx;
-			// First, so its input listener sees relayout keys before the thinking controller consumes them.
-			viewport.bind(ctx);
-			progress.bind(ctx);
-			thinkingCycle.bind(ctx);
-			silent.bind(ctx, runtime.config.mode, event.reason === "reload");
-			groups.bind(ctx);
+			enableUI(ctx, event.reason === "reload", false, failures);
 			if (!silent.isEnabled()) showReleaseNotice(ctx);
 			if ((runtime.config.custom_tools.enabled || runtime.config.tools.length > 0) && !customRowsAvailable && !customRowsWarned) {
 				customRowsWarned = true;
 				ctx.ui.notify("Compact tool rendering is unavailable in this version of Pi", "warning");
 			}
-		} else {
-			if (ctx.mode === "tui") unbindRenderer(ctx);
-			viewport.dispose();
-			progress.dispose();
-			thinkingCycle.dispose();
-			silent.dispose();
-			groups.dispose();
+		} else if (ctx.mode === "tui") {
+			// Startup-off also reconciles rows built using provisional/trusted config,
+			// but never attaches animation or the compact controllers.
+			transcript.reconcileOnce(ctx, failures);
 		}
+		reportFailures(ctx, failures);
 	});
 	// /tree changes the branch without session_start. Fill sibling-branch records
 	// before Pi rebuilds its transcript, while retaining richer same-process deltas.
@@ -761,7 +779,6 @@ export default function compactTools(pi: ExtensionAPI): void {
 	});
 	pi.on("tool_execution_start", (event) => {
 		if (madeByTool(event)) {
-			runtime.noteNestedCall(event.toolCallId, true);
 			nestedSummaries.note(event, false);
 			return;
 		}
@@ -771,7 +788,6 @@ export default function compactTools(pi: ExtensionAPI): void {
 	});
 	pi.on("tool_execution_end", (event) => {
 		if (madeByTool(event)) {
-			runtime.noteNestedCall(event.toolCallId, false);
 			if (nestedSummaries.note(event, true)) runtime.repaint();
 			return;
 		}
@@ -779,14 +795,10 @@ export default function compactTools(pi: ExtensionAPI): void {
 		runtime.noteExecutionEnd(event.toolCallId, (event as { durationMs?: number }).durationMs);
 	});
 	pi.on("session_shutdown", (event) => {
-		thinkingCycle.dispose();
-		progress.dispose();
-		silent.dispose();
-		groups.dispose();
-		viewport.dispose();
-		unbindRenderer(renderContext);
-		renderContext = undefined;
-		runtime.reset(event.reason !== "reload");
+		const failures: UIFailure[] = [];
+		detachUI({ clearTimings: event.reason !== "reload" }, failures);
+		reportFailures(sessionContext, failures);
+		sessionContext = undefined;
 		if (event.reason !== "reload") nestedSummaries.clear();
 		// A reload that keeps the extension sets it again before Pi rebuilds the transcript.
 		if (legacyResolver) clearRowResolver(legacyResolver);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.16.2",
+  "version": "0.16.6",
   "description": "Tool rows for Pi in three styles: Claude, Codex, and Compact. Switch with /compact-tools; includes silent mode and a GitHub Dark theme.",
   "type": "module",
   "license": "MIT",
@@ -51,8 +51,8 @@
     "@earendil-works/pi-tui": ">=0.85.1"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.2.0",
-    "@earendil-works/pi-tui": "1.2.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-tui": "1.3.0",
     "@sinonjs/fake-timers": "15.0.0",
     "@types/node": "^24.0.0",
     "@types/sinonjs__fake-timers": "15.0.1",

package/release-notes.json

@@ -1,4 +1,46 @@
 {
+  "0.16.6": {
+    "New": [],
+    "Fix": [
+      "Correct the SDK smoke test on Pi 0.99–1.1 by checking native codemode timer behavior only on hosts that provide it while retaining live off/on coverage on every supported version.",
+      "Require the complete supported Pi and Node compatibility matrix to pass before npm publication."
+    ],
+    "Deprecated": []
+  },
+  "0.16.5": {
+    "New": [],
+    "Fix": [
+      "Remove duplicate transcript updates so each tool row refreshes once during session UI binding.",
+      "Reduce median UI rebind time from 8.89 ms to 4.87 ms in a 200-row component benchmark, without implying full reload or general rendering speedups.",
+      "Isolate row refresh failures so other rows and controller cleanup continue, with fallback diagnostics if warning delivery fails.",
+      "Detach controller state despite host cleanup errors to prevent compact animation from restarting while off.",
+      "Centralize UI cleanup and separate transcript reconciliation from extension setup.",
+      "Remove unused execution wrappers and state while preserving timing, codemode summaries, and live off/on switching."
+    ],
+    "Deprecated": []
+  },
+  "0.16.4": {
+    "New": [
+      "The off command restores native Pi UI immediately, including during streaming or tool execution, without reload, abort, or restart",
+      "Re-enable Compact, Claude, or Codex live from off; existing rows and calls created while off follow the selected style"
+    ],
+    "Fix": [
+      "Native and custom renderer shells and component caches reconcile across repeated off/on transitions without replacing author state",
+      "Working labels and silent activity resume the current streaming phase; native shell elapsed timers pause when returning to compact rendering"
+    ],
+    "Deprecated": []
+  },
+  "0.16.3": {
+    "New": [
+      "Verified on Pi 1.3.0 with its version added to CI; the Pi 0.85.1 minimum is unchanged",
+      "Tool indicators, the working label, and silent activity share one animation timer, reducing redundant paint boundaries without changing their average animation rates"
+    ],
+    "Fix": [
+      "Replayed read calls with numeric-string offsets retain their correct code line numbers",
+      "The off command restores Pi's native thinking display as well as tool rows, working indicator, keyboard behavior, and visibility; active themes and session history are unchanged"
+    ],
+    "Deprecated": []
+  },
   "0.16.2": {
     "New": [
       "A concise README and a separate development guide",