pi-compact-transcript 0.2.1 → 0.5.0

package/README.md

@@ -1,11 +1,23 @@
 # pi-compact-transcript
 
-A compact transcript extension for [pi](https://pi.dev):
-
-- Collapses hidden thinking blocks into `Thinking...` and consecutive thinking blocks into `Thinking... (Nx)`.
-- Adds a short, visible next-step summary to collapsed thinking rows without exposing raw chain-of-thought.
-- Collapses built-in tool calls/results into one-line previews.
-- Consecutive tool uses in the same agent run are summarized as `Used N tools <latest tool preview>`.
+A compact transcript extension for [pi](https://pi.dev).
+
+| Without the extension | With the extension |
+|---|---|
+| ![pi transcript without the extension](docs/plugin_disabled.png) | ![pi transcript with the extension](docs/plugin_enabled.png) |
+
+What it does:
+
+- Collapses every tool call/result into a one-line preview, including custom/external tools added by other extensions.
+- Each tool row carries a status diamond: blinking gray `◆` while the tool runs, solid green `◆` on success, solid red `◆` on failure.
+- Consecutive uses of the same tool coalesce into a single row, e.g. `◆ 4× read src/foo.ts {12 lines · 8s}`; a different tool starts a new row with its own diamond.
+- Tool rows show durations when they take a second or longer; grouped rows show the total.
+- Failed tools always get their own visible row (red diamond) and end the current burst.
+- Tool rows render dimmed so assistant text stands out.
+- Hidden thinking blocks are suppressed entirely — no `Thinking...` markers.
+- Each agent run ends with a one-line summary, e.g. `Read 6 files, edited 2, ran 3 commands, 1 failed · 42s`.
+- Unknown tools preview their most meaningful string argument (command, code, query, path, url, ...) instead of dumping raw JSON args.
+- Expanded tool output still falls back to pi's original renderer, so you can use pi's normal tool expansion when details matter.
 - Minimizes vertical space so long agent runs do not scroll away as quickly.
 
 ## Install from GitHub
@@ -47,8 +59,20 @@ The extension works best with hidden thinking and no output padding:
 
 Set these in `~/.pi/agent/settings.json`, or use `/settings` in pi.
 
+Thinking suppression only applies when `hideThinkingBlock` is on; with it off, pi renders thinking traces normally.
+
+## Commands
+
+```text
+/compact-transcript          # toggle on/off
+/compact-transcript on|off   # set explicitly
+/compact-transcript status   # show current state
+```
+
+Toggling applies to the visible transcript immediately — existing rows re-render, no reload needed. The pre-0.5 mode names (`balanced`, `aggressive`, `debug`, `disabled`) are accepted as legacy aliases for `on`/`off`.
+
 ## Notes
 
-This extension overrides the built-in tool renderers for `bash`, `read`, `write`, `edit`, `grep`, `find`, and `ls`. It delegates execution to pi's original built-in tools; only display is changed.
+This extension changes display only. Tool execution is still handled by pi and any other extensions that registered or override tools.
 
-The consecutive-thinking collapse and compact self-rendered tool rows use pi's current internal TUI components. If pi changes those internal paths in a future release, the extension falls back to the normal hidden-thinking/tool rendering behavior.
+For built-in and extension tools, compact rendering uses pi's public exported TUI components where available. The cross-tool burst compaction and thinking suppression still rely on pi's current TUI component internals, so if pi changes those internals in a future release, the extension falls back to pi's normal rendering behavior for the affected rows.

package/extensions/compact-transcript.ts

@@ -1,57 +1,134 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-	createBashTool,
-	createEditTool,
-	createFindTool,
-	createGrepTool,
-	createLsTool,
-	createReadTool,
-	createWriteTool,
-} from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { AssistantMessageComponent, ToolExecutionComponent } from "@earendil-works/pi-coding-agent";
 import { Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { createRequire } from "node:module";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { pathToFileURL } from "node:url";
 
-type BuiltInName = "bash" | "read" | "write" | "edit" | "grep" | "find" | "ls";
+// Older versions of this extension wrote a footer status under this key; it is
+// kept only to clear that status once per session for users upgrading in place.
+const STATUS_KEY = "compact-transcript";
+const CONFIG_ENTRY_TYPE = "compact-transcript-config";
+const SUMMARY_ENTRY_TYPE = "compact-transcript-summary";
+
+const MIN_PREVIEW_WIDTH = 20;
+const MAX_PREVIEW_WIDTH = 104;
+// Leave room for pi's row gutter/padding so compact lines never wrap.
+const PREVIEW_MARGIN = 6;
+const BLINK_INTERVAL_MS = 400;
+// Status marker is two cells wide ("◆ ").
+const MARKER_WIDTH = 2;
+
+type CompactTranscriptConfig = {
+	enabled: boolean;
+};
 
 type ToolInfo = {
 	id: string;
 	name: string;
 	args: any;
 	preview: string;
+	hidden?: boolean;
+	running?: boolean;
+	burstCount?: number;
+	startedAt?: number;
+	durationMs?: number;
+	burstDurationMs?: number;
 	result?: string;
+	isError?: boolean;
 	invalidate?: () => void;
 };
 
-const BUILT_INS: BuiltInName[] = ["bash", "read", "write", "edit", "grep", "find", "ls"];
-const LABEL = "Thinking...";
+type RunStats = {
+	startedAt: number;
+	toolCount: number;
+	readFiles: Set<string>;
+	editFiles: Set<string>;
+	commandCount: number;
+	otherCount: number;
+	failedCount: number;
+};
 
-let currentTools: ToolInfo[] = [];
-let toolsById = new Map<string, ToolInfo>();
+type SummaryData = {
+	reads: number;
+	edits: number;
+	commands: number;
+	others: number;
+	failed: number;
+	durationMs: number;
+};
 
-const toolCache = new Map<string, ReturnType<typeof createBuiltInTools>>();
+type RuntimeState = {
+	config: CompactTranscriptConfig;
+	toolsById: Map<string, ToolInfo>;
+	currentBurst: ToolInfo[];
+	hiddenToolIds: Set<string>;
+	runningToolIds: Set<string>;
+	agentActive: boolean;
+	blinkOn: boolean;
+	blinkTimer?: ReturnType<typeof setInterval>;
+	runStats: RunStats;
+	// Live transcript components, so toggling can re-render existing rows.
+	toolComponents: Set<any>;
+	assistantComponents: Set<any>;
+	currentTheme?: Theme;
+};
 
-function createBuiltInTools(cwd: string) {
+const DEFAULT_CONFIG: CompactTranscriptConfig = {
+	enabled: true,
+};
+
+const STATE_KEY = Symbol.for("pi-compact-transcript.state");
+const TOOL_PATCH_KEY = Symbol.for("pi-compact-transcript.tool-patch");
+const ASSISTANT_PATCH_KEY = Symbol.for("pi-compact-transcript.assistant-patch");
+
+function newRunStats(): RunStats {
 	return {
-		bash: createBashTool(cwd),
-		read: createReadTool(cwd),
-		write: createWriteTool(cwd),
-		edit: createEditTool(cwd),
-		grep: createGrepTool(cwd),
-		find: createFindTool(cwd),
-		ls: createLsTool(cwd),
+		startedAt: Date.now(),
+		toolCount: 0,
+		readFiles: new Set(),
+		editFiles: new Set(),
+		commandCount: 0,
+		otherCount: 0,
+		failedCount: 0,
 	};
 }
 
-function getBuiltInTools(cwd: string) {
-	let tools = toolCache.get(cwd);
-	if (!tools) {
-		tools = createBuiltInTools(cwd);
-		toolCache.set(cwd, tools);
+function normalizeConfig(input: unknown): CompactTranscriptConfig {
+	const source = (input && typeof input === "object" ? input : {}) as Record<string, unknown>;
+	let enabled = DEFAULT_CONFIG.enabled;
+	if (typeof source.enabled === "boolean") {
+		enabled = source.enabled;
+	} else if (typeof source.mode === "string") {
+		// Pre-0.5 config persisted a mode string instead of an enabled flag.
+		enabled = source.mode !== "disabled" && source.mode !== "off";
 	}
-	return tools;
+	return { enabled };
+}
+
+function getState(): RuntimeState {
+	const globalWithState = globalThis as typeof globalThis & { [STATE_KEY]?: RuntimeState };
+	globalWithState[STATE_KEY] ??= {
+		config: { ...DEFAULT_CONFIG },
+		toolsById: new Map(),
+		currentBurst: [],
+		hiddenToolIds: new Set(),
+		runningToolIds: new Set(),
+		agentActive: false,
+		blinkOn: true,
+		runStats: newRunStats(),
+		toolComponents: new Set(),
+		assistantComponents: new Set(),
+	};
+	return globalWithState[STATE_KEY]!;
+}
+
+const state = getState();
+
+function isEnabled(): boolean {
+	return state.config.enabled;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+	return typeof value === "string" && value.trim().length > 0;
 }
 
 function shortenPath(path: unknown): string {
@@ -66,7 +143,11 @@ function oneLine(value: unknown): string {
 		.trim();
 }
 
-function limitPlain(text: string, max = Math.max(20, (process.stdout.columns || 100) - 6)): string {
+function previewWidth(base = process.stdout.columns || 100): number {
+	return Math.max(MIN_PREVIEW_WIDTH, Math.min(MAX_PREVIEW_WIDTH, base - PREVIEW_MARGIN));
+}
+
+function limitPlain(text: string, max = previewWidth()): string {
 	const clean = oneLine(text);
 	if (clean.length <= max) return clean;
 	return `${clean.slice(0, Math.max(0, max - 1))}…`;
@@ -76,6 +157,43 @@ function quote(s: string): string {
 	return JSON.stringify(s);
 }
 
+function safeJson(value: unknown): string {
+	try {
+		return JSON.stringify(value ?? {});
+	} catch {
+		return String(value);
+	}
+}
+
+// Sub-second durations render as "" so fast tools stay clutter-free.
+function formatDuration(ms: number): string {
+	if (!Number.isFinite(ms) || ms < 1000) return "";
+	const totalSeconds = Math.round(ms / 1000);
+	if (totalSeconds < 60) return `${totalSeconds}s`;
+	const minutes = Math.floor(totalSeconds / 60);
+	const seconds = totalSeconds % 60;
+	return seconds ? `${minutes}m${seconds}s` : `${minutes}m`;
+}
+
+// Checked in order; earlier keys are more likely to be the argument a human
+// would recognize the call by.
+const PREFERRED_ARG_KEYS = [
+	"command",
+	"code",
+	"query",
+	"pattern",
+	"path",
+	"file_path",
+	"filePath",
+	"file",
+	"url",
+	"prompt",
+	"text",
+	"description",
+	"name",
+];
+const PATH_ARG_KEYS = new Set(["path", "file_path", "filePath", "file"]);
+
 function previewFor(name: string, args: any): string {
 	switch (name) {
 		case "bash":
@@ -106,41 +224,97 @@ function previewFor(name: string, args: any): string {
 			return `find ${args?.pattern ? quote(String(args.pattern)) : "..."} ${shortenPath(args?.path) || "."}`;
 		case "ls":
 			return `ls ${shortenPath(args?.path) || "."}`;
-		default:
-			return `${name} ${oneLine(JSON.stringify(args ?? {}))}`;
+		default: {
+			// Unknown tools: show the most meaningful string argument instead of
+			// dumping the whole args object as JSON.
+			if (args && typeof args === "object") {
+				for (const key of PREFERRED_ARG_KEYS) {
+					const value = (args as Record<string, unknown>)[key];
+					if (isNonEmptyString(value)) {
+						const rendered = PATH_ARG_KEYS.has(key) ? shortenPath(value) : oneLine(value);
+						return `${name} ${rendered}`;
+					}
+				}
+				const firstString = Object.values(args).find(isNonEmptyString);
+				if (firstString) return `${name} ${oneLine(firstString)}`;
+			}
+			return `${name} ${safeJson(args ?? {})}`;
+		}
 	}
 }
 
-function resultPreview(result: any): string {
+function resultPreview(result: any, isPartial = false): string {
 	const text = Array.isArray(result?.content)
 		? result.content.find((c: any) => c?.type === "text" && typeof c.text === "string")?.text
 		: undefined;
-	if (!text) return "";
+	if (!text) return isPartial ? "running" : "";
 	const lines = String(text).trim().split("\n").filter(Boolean);
-	if (lines.length === 0) return "";
+	if (lines.length === 0) return isPartial ? "running" : "";
 	if (lines.length === 1) return lines[0];
 	return `${lines.length} lines`;
 }
 
-function toolCallName(block: any): string {
-	return block?.name ?? block?.toolName ?? block?.tool_name ?? block?.tool?.name ?? "tool";
+function resetToolRun() {
+	state.toolsById = new Map();
+	state.currentBurst = [];
+	state.hiddenToolIds = new Set();
+	state.runningToolIds = new Set();
+	stopBlinkTimer();
+}
+
+function captureTheme(ctx: ExtensionContext) {
+	state.currentTheme = ctx.ui.theme;
 }
 
-function toolCallArgs(block: any): any {
-	return block?.args ?? block?.input ?? block?.arguments ?? block?.tool?.args ?? {};
+function setToolHidden(info: ToolInfo, hidden: boolean) {
+	info.hidden = hidden;
+	if (hidden) state.hiddenToolIds.add(info.id);
+	else state.hiddenToolIds.delete(info.id);
 }
 
-function resetToolRun() {
-	currentTools = [];
-	toolsById = new Map();
+function applyResult(info: ToolInfo, result: any, isError: boolean, isPartial: boolean) {
+	const suffix = resultPreview(result, isPartial);
+	if (suffix) info.result = suffix;
+	if (isError) {
+		info.isError = true;
+		// A failed tool always gets its own visible row, even if a burst had
+		// hidden it; render it as itself rather than as a burst summary.
+		info.burstCount = 1;
+		setToolHidden(info, false);
+	}
+}
+
+function ensureBlinkTimer() {
+	if (state.blinkTimer || state.runningToolIds.size === 0) return;
+	state.blinkTimer = setInterval(() => {
+		if (state.runningToolIds.size === 0) {
+			stopBlinkTimer();
+			return;
+		}
+		state.blinkOn = !state.blinkOn;
+		for (const id of state.runningToolIds) state.toolsById.get(id)?.invalidate?.();
+	}, BLINK_INTERVAL_MS);
+	state.blinkTimer.unref?.();
+}
+
+function stopBlinkTimer() {
+	if (state.blinkTimer) clearInterval(state.blinkTimer);
+	state.blinkTimer = undefined;
+	state.blinkOn = true;
+}
+
+function statusMarker(theme: Theme, opts: { running?: boolean; isError?: boolean; hasResult?: boolean }): string {
+	if (opts.isError) return theme.fg("error", "◆ ");
+	if (opts.running) return theme.fg("dim", state.blinkOn ? "◆ " : "◇ ");
+	if (opts.hasResult) return theme.fg("success", "◆ ");
+	return theme.fg("dim", "◆ ");
 }
 
 function upsertToolInfo(id: string, name: string, args: any, invalidate?: () => void): ToolInfo {
-	let info = toolsById.get(id);
+	let info = state.toolsById.get(id);
 	if (!info) {
 		info = { id, name, args, preview: previewFor(name, args) };
-		toolsById.set(id, info);
-		if (!currentTools.some((tool) => tool.id === id)) currentTools.push(info);
+		state.toolsById.set(id, info);
 	}
 	info.name = name;
 	info.args = args;
@@ -149,212 +323,446 @@ function upsertToolInfo(id: string, name: string, args: any, invalidate?: () =>
 	return info;
 }
 
-function compactToolLine(toolCallId: string, name: string, args: any, theme: any, invalidate?: () => void, result?: any): string {
-	const info = upsertToolInfo(toolCallId, name, args, invalidate);
-	const suffix = resultPreview(result);
-	if (suffix) info.result = suffix;
+function recordToolStart(name: string, args: any) {
+	const base = name.split(".").pop() ?? name;
+	state.runStats.toolCount++;
+	if (base === "read") {
+		if (isNonEmptyString(args?.path)) state.runStats.readFiles.add(args.path);
+	} else if (base === "edit" || base === "write") {
+		if (isNonEmptyString(args?.path)) state.runStats.editFiles.add(args.path);
+	} else if (base === "bash") {
+		state.runStats.commandCount++;
+	} else {
+		state.runStats.otherCount++;
+	}
+}
 
-	if (currentTools[currentTools.length - 1]?.id !== toolCallId) return "";
+function joinBurst(info: ToolInfo) {
+	const previous = state.currentBurst[state.currentBurst.length - 1];
+
+	if (!isEnabled()) {
+		state.currentBurst = [];
+		return;
+	}
+
+	// Bursts only group repeats of the same tool; a different tool starts a
+	// fresh row (and leaves the previous row visible with its count).
+	if (state.currentBurst.length && state.currentBurst[state.currentBurst.length - 1].name !== info.name) {
+		state.currentBurst = [];
+	}
 
-	const details = info.result ? `${info.preview} {${oneLine(info.result)}}` : info.preview;
-	if (currentTools.length === 1) return theme.fg("muted", limitPlain(details));
-	const prefix = `Used ${currentTools.length} tools `;
-	return theme.fg("toolTitle", prefix) + theme.fg("muted", limitPlain(details, Math.max(20, (process.stdout.columns || 100) - prefix.length - 6)));
+	if (!state.currentBurst.some((tool) => tool.id === info.id)) state.currentBurst.push(info);
+	for (const tool of state.currentBurst.slice(0, -1)) setToolHidden(tool, true);
+	info.burstCount = state.currentBurst.length;
+	previous?.invalidate?.();
 }
 
-function nextStepSummary(content: any[], fromIndex: number): string {
-	const tools = content.slice(fromIndex + 1).filter((c: any) => c?.type === "toolCall");
-	if (tools.length === 0) return " Next, I’ll continue from this reasoning and respond with the result. I’ll keep the visible output brief.";
+function beginTool(id: string, name: string, args: any) {
+	const info = upsertToolInfo(id, name, args);
+	setToolHidden(info, false);
+	info.burstCount = 1;
+	info.running = true;
+	info.isError = false;
+	info.startedAt = Date.now();
+	state.runningToolIds.add(id);
+	ensureBlinkTimer();
+	recordToolStart(name, args);
+	joinBurst(info);
+	// The component may already be on screen from argument streaming; repaint
+	// now so the running marker and burst count appear immediately instead of
+	// waiting for the next result event or blink tick.
+	info.invalidate?.();
+}
 
-	const first = tools[0];
-	const preview = limitPlain(previewFor(toolCallName(first), toolCallArgs(first)), 90);
-	if (tools.length === 1) {
-		return ` Next, I’ll use ${preview}. I’ll inspect the result and decide the next visible step from there.`;
+// A tool row rendered without a live tool_execution_start event — pi is
+// rebuilding chat history after resume/reload. Reconstruct burst grouping so
+// scrollback coalesces the same way the live view did, but skip timers,
+// stats, and running state.
+function hydrateTool(id: string, name: string, args: any, isError: boolean): ToolInfo {
+	const info = upsertToolInfo(id, name, args);
+	setToolHidden(info, false);
+	info.burstCount = 1;
+	if (isError) {
+		info.isError = true;
+		state.currentBurst = [];
+		return info;
 	}
-	const last = tools[tools.length - 1];
-	const lastPreview = limitPlain(previewFor(toolCallName(last), toolCallArgs(last)), 70);
-	return ` Next, I’ll run ${tools.length} tool calls, starting with ${preview}. I’ll use the latest result to continue, ending this batch around ${lastPreview}.`;
+	joinBurst(info);
+	return info;
 }
 
-async function patchInternalRenderers() {
-	try {
-		const require = createRequire(import.meta.url);
-		const piMain = require.resolve("@earendil-works/pi-coding-agent");
-		const distDir = dirname(piMain);
-		const assistantModule = await import(
-			pathToFileURL(join(distDir, "modes/interactive/components/assistant-message.js")).href
-		);
-		const toolExecutionModule = await import(
-			pathToFileURL(join(distDir, "modes/interactive/components/tool-execution.js")).href
+function updateToolResult(toolCallId: string, result: any, isError = false, isPartial = false) {
+	if (!isPartial) {
+		state.runningToolIds.delete(toolCallId);
+		if (state.runningToolIds.size === 0) stopBlinkTimer();
+	}
+	const info = state.toolsById.get(toolCallId);
+	if (!info) return;
+	if (!isPartial) {
+		info.running = false;
+		if (info.startedAt) info.durationMs = Date.now() - info.startedAt;
+		if (state.currentBurst.includes(info) && state.currentBurst.length > 1) {
+			info.burstDurationMs = state.currentBurst.reduce((total, tool) => total + (tool.durationMs ?? 0), 0);
+		}
+		if (isError) state.runStats.failedCount++;
+	}
+	applyResult(info, result, isError, isPartial);
+	// A failure ends the current burst so the red row stays visible and the
+	// next tool starts a fresh count.
+	if (isError) state.currentBurst = [];
+	info.invalidate?.();
+}
+
+function compactToolLine(
+	toolCallId: string,
+	name: string,
+	args: any,
+	theme: Theme,
+	invalidate?: () => void,
+	result?: any,
+	isError = false,
+	isPartial = false,
+): string {
+	if (!state.toolsById.has(toolCallId)) hydrateTool(toolCallId, name, args, isError);
+	const info = upsertToolInfo(toolCallId, name, args, invalidate);
+	applyResult(info, result, isError, isPartial);
+	if (info.hidden) return "";
+
+	const isBurst = (info.burstCount ?? 1) > 1;
+	const durationText = formatDuration((isBurst ? (info.burstDurationMs ?? info.durationMs) : info.durationMs) ?? 0);
+	const inner = [info.result ? oneLine(info.result) : "", durationText].filter(Boolean).join(" · ");
+	const status = inner ? ` {${inner}}` : info.running ? " {running}" : "";
+	const details = `${info.preview}${status}`;
+	const marker = statusMarker(theme, {
+		running: info.running,
+		isError: info.isError,
+		hasResult: result != null || !!info.result,
+	});
+	if (!isBurst) {
+		return marker + theme.fg("muted", limitPlain(details));
+	}
+
+	const prefix = `${info.burstCount}× `;
+	const budget = previewWidth((process.stdout.columns || 100) - prefix.length - MARKER_WIDTH);
+	return marker + theme.fg("muted", prefix + limitPlain(details, budget));
+}
+
+function patchToolExecutionComponent() {
+	const proto = ToolExecutionComponent.prototype as any;
+	if (typeof proto.updateDisplay !== "function" || typeof proto.render !== "function") return;
+	const existing = proto[TOOL_PATCH_KEY] as
+		| { originalUpdateDisplay: (...args: any[]) => any; originalRender: (...args: any[]) => any }
+		| undefined;
+	const originalUpdateDisplay = existing?.originalUpdateDisplay ?? proto.updateDisplay;
+	const originalRender = existing?.originalRender ?? proto.render;
+
+	proto.updateDisplay = function patchedUpdateDisplay() {
+		if (!this.toolCallId || !this.toolName || !this.selfRenderContainer || typeof this.selfRenderContainer.clear !== "function") {
+			this.__compactTranscriptForceSelf = false;
+			this.__compactTranscriptHidden = false;
+			return originalUpdateDisplay.call(this);
+		}
+		state.toolComponents.add(this);
+
+		const invalidate = () => {
+			this.invalidate();
+			this.ui?.requestRender?.();
+		};
+		// Must run before upsertToolInfo, which would make the row look
+		// already-known and skip burst reconstruction for rehydrated history.
+		if (!state.toolsById.has(this.toolCallId)) {
+			hydrateTool(this.toolCallId, this.toolName, this.args, this.result?.isError ?? false);
+		}
+		const info = upsertToolInfo(this.toolCallId, this.toolName, this.args, invalidate);
+		applyResult(info, this.result, this.result?.isError ?? false, this.isPartial);
+
+		if (!isEnabled() || this.expanded) {
+			setToolHidden(info, false);
+			this.__compactTranscriptForceSelf = false;
+			this.__compactTranscriptHidden = false;
+			return originalUpdateDisplay.call(this);
+		}
+
+		this.__compactTranscriptForceSelf = true;
+		this.__compactTranscriptHidden = false;
+		this.selfRenderContainer.clear();
+		for (const image of this.imageComponents ?? []) this.removeChild?.(image);
+		for (const spacer of this.imageSpacers ?? []) this.removeChild?.(spacer);
+		this.imageComponents = [];
+		this.imageSpacers = [];
+
+		const theme = state.currentTheme;
+		if (!theme) {
+			this.__compactTranscriptForceSelf = false;
+			this.__compactTranscriptHidden = false;
+			return originalUpdateDisplay.call(this);
+		}
+
+		const line = compactToolLine(
+			this.toolCallId,
+			this.toolName,
+			this.args,
+			theme,
+			invalidate,
+			this.result,
+			this.result?.isError ?? false,
+			this.isPartial,
 		);
-		const themeModule = await import(pathToFileURL(join(distDir, "modes/interactive/theme/theme.js")).href);
-
-		const ToolExecutionComponent = toolExecutionModule.ToolExecutionComponent;
-		if (ToolExecutionComponent?.prototype && !ToolExecutionComponent.prototype.__compactTranscriptPatched) {
-			const originalRender = ToolExecutionComponent.prototype.render;
-			ToolExecutionComponent.prototype.updateDisplay = function () {
-				this.__compactTranscriptForceSelf = true;
-				this.hideComponent = false;
-				this.selfRenderContainer.clear();
-				this.imageComponents = [];
-				this.imageSpacers = [];
-
-				const line = compactToolLine(
-					this.toolCallId,
-					this.toolName,
-					this.args,
-					themeModule.theme,
-					() => {
-						this.invalidate();
-						this.ui?.requestRender?.();
-					},
-					this.result,
-				);
-
-				if (!line) {
-					this.hideComponent = true;
-					return;
-				}
 
-				this.selfRenderContainer.addChild(new Text(line, 0, 0));
-			};
-			ToolExecutionComponent.prototype.render = function (width: number) {
-				if (this.hideComponent) return [];
-				if (this.__compactTranscriptForceSelf) return this.selfRenderContainer.render(width);
-				return originalRender.call(this, width);
-			};
-			ToolExecutionComponent.prototype.__compactTranscriptPatched = true;
+		if (!line) {
+			this.__compactTranscriptHidden = true;
+			return;
 		}
 
-		const Component = assistantModule.AssistantMessageComponent;
-		if (!Component?.prototype || Component.prototype.__compactTranscriptPatched) return;
-		const original = Component.prototype.updateContent;
+		this.selfRenderContainer.addChild(new Text(line, 0, 0));
+	};
 
-		Component.prototype.updateContent = function (message: any) {
-			if (!this.hideThinkingBlock) return original.call(this, message);
+	proto.render = function patchedRender(width: number) {
+		if (this.hideComponent || this.__compactTranscriptHidden) return [];
+		if (this.__compactTranscriptForceSelf) return this.selfRenderContainer.render(width);
+		return originalRender.call(this, width);
+	};
 
-			this.lastMessage = message;
-			this.contentContainer.clear();
+	proto[TOOL_PATCH_KEY] = { originalUpdateDisplay, originalRender };
+}
 
-			const visible = message.content.filter(
-				(c: any) => (c.type === "text" && c.text?.trim()) || (c.type === "thinking" && c.thinking?.trim()),
-			);
-			if (visible.length) this.contentContainer.addChild(new Spacer(1));
+function patchAssistantMessageComponent() {
+	const proto = AssistantMessageComponent.prototype as any;
+	if (typeof proto.updateContent !== "function") return;
+	const existing = proto[ASSISTANT_PATCH_KEY] as { originalUpdateContent: (...args: any[]) => any } | undefined;
+	const originalUpdateContent = existing?.originalUpdateContent ?? proto.updateContent;
 
-			for (let i = 0; i < message.content.length; i++) {
-				const content = message.content[i];
-				if (content.type === "text" && content.text?.trim()) {
-					this.contentContainer.addChild(new Markdown(content.text.trim(), this.outputPad, 0, this.markdownTheme));
-					continue;
-				}
-				if (content.type !== "thinking" || !content.thinking?.trim()) continue;
-
-				let count = 1;
-				while (
-					message.content[i + count]?.type === "thinking" &&
-					message.content[i + count]?.thinking?.trim()
-				) {
-					count++;
-				}
-				i += count - 1;
-
-				const label = count > 1 ? `${LABEL} (${count}x)` : LABEL;
-				const summary = nextStepSummary(message.content, i);
-				this.contentContainer.addChild(
-					new Text(themeModule.theme.italic(themeModule.theme.fg("thinkingText", limitPlain(`${label}${summary}`))), this.outputPad, 0),
-				);
-
-				const hasVisibleAfter = message.content
-					.slice(i + 1)
-					.some((c: any) => (c.type === "text" && c.text?.trim()) || (c.type === "thinking" && c.thinking?.trim()));
-				if (hasVisibleAfter) this.contentContainer.addChild(new Spacer(1));
-			}
+	proto.updateContent = function patchedUpdateContent(message: any) {
+		state.assistantComponents.add(this);
+		if (!isEnabled() || !this.hideThinkingBlock || !Array.isArray(message?.content)) {
+			return originalUpdateContent.call(this, message);
+		}
+		if (!this.contentContainer || typeof this.contentContainer.clear !== "function") {
+			return originalUpdateContent.call(this, message);
+		}
 
-			this.hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
-		};
-		Component.prototype.__compactTranscriptPatched = true;
-	} catch {
-		// Best-effort: older/bundled pi builds may not expose internal component modules.
-	}
+		this.lastMessage = message;
+		this.contentContainer.clear();
+		this.hasToolCalls = message.content.some((c: any) => c.type === "toolCall");
+
+		// Thinking blocks are suppressed entirely; only real text is rendered.
+		const texts = message.content.filter((c: any) => c.type === "text" && c.text?.trim());
+		if (texts.length === 0) return;
+
+		// Assistant text ends a tool burst. The live path also does this via
+		// message_update events; doing it here too keeps hydrated history from
+		// grouping tool rows across turn boundaries.
+		state.currentBurst = [];
+
+		this.contentContainer.addChild(new Spacer(1));
+		for (const content of texts) {
+			this.contentContainer.addChild(new Markdown(content.text.trim(), this.outputPad, 0, this.markdownTheme));
+		}
+	};
+
+	proto[ASSISTANT_PATCH_KEY] = { originalUpdateContent };
 }
 
-export default async function (pi: ExtensionAPI) {
-	await patchInternalRenderers();
-	let consecutiveThinking = 0;
+function patchRenderers() {
+	patchToolExecutionComponent();
+	patchAssistantMessageComponent();
+}
 
-	function thinkingLabel() {
-		return consecutiveThinking > 1 ? `${LABEL} (${consecutiveThinking}x)` : LABEL;
+// Re-render every transcript row we have touched so toggling applies to the
+// visible transcript immediately instead of only to future rows.
+function refreshTranscript() {
+	let ui: any;
+	for (const component of state.toolComponents) {
+		try {
+			// ToolExecutionComponent.invalidate() re-runs updateDisplay.
+			component.invalidate?.();
+			ui ??= component.ui;
+		} catch {
+			state.toolComponents.delete(component);
+		}
 	}
-
-	function resetTools() {
-		resetToolRun();
+	for (const component of state.assistantComponents) {
+		try {
+			if (component.lastMessage) component.updateContent?.(component.lastMessage);
+			component.invalidate?.();
+		} catch {
+			state.assistantComponents.delete(component);
+		}
 	}
+	ui?.requestRender?.();
+}
+
+function summaryLine(data: SummaryData): string {
+	const plural = (count: number) => (count === 1 ? "" : "s");
+	const parts: string[] = [];
+	if (data.reads) parts.push(`read ${data.reads} file${plural(data.reads)}`);
+	if (data.edits) parts.push(`edited ${data.edits} file${plural(data.edits)}`);
+	if (data.commands) parts.push(`ran ${data.commands} command${plural(data.commands)}`);
+	if (data.others) parts.push(`${data.others} other tool${plural(data.others)}`);
+	if (data.failed) parts.push(`${data.failed} failed`);
+	if (parts.length === 0) return "";
+	const text = parts.join(", ");
+	const capitalized = text[0].toUpperCase() + text.slice(1);
+	const duration = formatDuration(data.durationMs);
+	return duration ? `${capitalized} · ${duration}` : capitalized;
+}
+
+function normalizeSummary(input: unknown): SummaryData {
+	const source = (input && typeof input === "object" ? input : {}) as Record<string, unknown>;
+	const num = (value: unknown) => (typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0);
+	return {
+		reads: num(source.reads),
+		edits: num(source.edits),
+		commands: num(source.commands),
+		others: num(source.others),
+		failed: num(source.failed),
+		durationMs: num(source.durationMs),
+	};
+}
 
-	function applyThinkingLabel(ctx: ExtensionContext) {
-		ctx.ui.setHiddenThinkingLabel(thinkingLabel());
+function appendRunSummary(pi: ExtensionAPI) {
+	const stats = state.runStats;
+	// Single-tool runs are self-evident from the transcript; a summary line
+	// would just repeat the row above it.
+	if (!isEnabled() || stats.toolCount < 2) return;
+	const data: SummaryData = {
+		reads: stats.readFiles.size,
+		edits: stats.editFiles.size,
+		commands: stats.commandCount,
+		others: stats.otherCount,
+		failed: stats.failedCount,
+		durationMs: Date.now() - stats.startedAt,
+	};
+	pi.appendEntry(SUMMARY_ENTRY_TYPE, data);
+}
+
+function restoreConfigFromBranch(ctx: ExtensionContext) {
+	let nextConfig = { ...DEFAULT_CONFIG };
+	for (const entry of ctx.sessionManager.getBranch()) {
+		if (entry.type === "custom" && entry.customType === CONFIG_ENTRY_TYPE) {
+			nextConfig = normalizeConfig(entry.data);
+		}
 	}
+	state.config = nextConfig;
+}
+
+function setEnabled(enabled: boolean, pi: ExtensionAPI, ctx: ExtensionContext) {
+	state.config.enabled = enabled;
+	pi.appendEntry(CONFIG_ENTRY_TYPE, { ...state.config });
+	refreshTranscript();
+	ctx.ui.notify(`Compact transcript: ${enabled ? "on" : "off"}`, "info");
+}
+
+function parseBoolean(value: string | undefined): boolean | undefined {
+	if (!value) return undefined;
+	const normalized = value.trim().toLowerCase();
+	if (["on", "true", "yes", "1", "enabled"].includes(normalized)) return true;
+	if (["off", "false", "no", "0", "disabled"].includes(normalized)) return false;
+	return undefined;
+}
+
+function registerCommand(pi: ExtensionAPI) {
+	pi.registerCommand("compact-transcript", {
+		description: "Toggle compact transcript rendering (on/off).",
+		getArgumentCompletions(prefix: string) {
+			return ["on", "off", "status"]
+				.filter((value) => value.startsWith(prefix.trimStart()))
+				.map((value) => ({ value, label: value }));
+		},
+		handler: async (args, ctx) => {
+			captureTheme(ctx);
+			const trimmed = args.trim().toLowerCase();
+			if (trimmed === "status") {
+				ctx.ui.notify(`Compact transcript: ${isEnabled() ? "on" : "off"}`, "info");
+				return;
+			}
+			if (!trimmed) {
+				setEnabled(!isEnabled(), pi, ctx);
+				return;
+			}
+			// on/off, plus pre-0.5 mode names as legacy aliases.
+			const legacyOn = ["balanced", "aggressive", "debug"].includes(trimmed);
+			const parsed = legacyOn ? true : parseBoolean(trimmed);
+			if (parsed !== undefined) {
+				setEnabled(parsed, pi, ctx);
+				return;
+			}
+			ctx.ui.notify(`Unknown option "${trimmed}". Usage: /compact-transcript [on|off|status]`, "error");
+		},
+	});
+}
+
+export default function compactTranscript(pi: ExtensionAPI) {
+	patchRenderers();
+	registerCommand(pi);
+
+	pi.registerEntryRenderer<SummaryData>(SUMMARY_ENTRY_TYPE, (entry, _options, theme) => {
+		const line = summaryLine(normalizeSummary(entry.data));
+		if (!line) return undefined;
+		return new Text(theme.fg("muted", line), 0, 0);
+	});
 
 	pi.on("session_start", async (_event, ctx) => {
-		applyThinkingLabel(ctx);
-		ctx.ui.setWorkingMessage(LABEL);
+		restoreConfigFromBranch(ctx);
+		captureTheme(ctx);
+		// Drop all per-tool state and component registries from the previous
+		// session; stale burst counts otherwise corrupt the rebuilt transcript
+		// after resume or /reload.
+		resetToolRun();
+		state.runStats = newRunStats();
+		state.toolComponents = new Set();
+		state.assistantComponents = new Set();
+		ctx.ui.setWorkingMessage();
+		// Clear any footer status left behind by pre-0.4 versions of this extension.
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		stopBlinkTimer();
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+		ctx.ui.setWorkingMessage();
+	});
+
+	pi.on("agent_start", (_event, ctx) => {
+		state.agentActive = true;
+		captureTheme(ctx);
+		resetToolRun();
+		state.runStats = newRunStats();
 	});
 
-	pi.on("agent_start", () => {
-		resetTools();
+	pi.on("agent_end", (_event, _ctx) => {
+		state.agentActive = false;
+		state.currentBurst = [];
+		state.runningToolIds.clear();
+		stopBlinkTimer();
+		appendRunSummary(pi);
 	});
 
 	pi.on("turn_start", (_event, ctx) => {
-		consecutiveThinking = 0;
-		applyThinkingLabel(ctx);
+		captureTheme(ctx);
 	});
 
-	pi.on("message_update", (event: any, ctx) => {
+	pi.on("message_update", (event, ctx) => {
+		captureTheme(ctx);
 		const type = event.assistantMessageEvent?.type;
-		if (type === "thinking_start") {
-			consecutiveThinking++;
-			applyThinkingLabel(ctx);
-			return;
-		}
-		if (type && !type.startsWith("thinking_")) {
-			consecutiveThinking = 0;
-			applyThinkingLabel(ctx);
-			if (type === "text_delta" || type === "text_start") resetTools();
+		if (type === "text_delta" || type === "text_start") {
+			// Visible assistant text ends the current tool burst.
+			state.currentBurst = [];
 		}
 	});
 
-	pi.on("tool_execution_start", (event: any) => {
-		const previous = currentTools[currentTools.length - 1];
-		upsertToolInfo(event.toolCallId, event.toolName, event.args);
-		previous?.invalidate?.();
+	pi.on("tool_execution_start", (event, ctx) => {
+		captureTheme(ctx);
+		beginTool(event.toolCallId, event.toolName, event.args);
 	});
 
-	pi.on("tool_execution_end", (event: any) => {
-		const info = toolsById.get(event.toolCallId);
-		if (!info) return;
-		const suffix = resultPreview(event.result);
-		if (suffix) info.result = suffix;
-		info.invalidate?.();
+	pi.on("tool_execution_update", (event, ctx) => {
+		captureTheme(ctx);
+		updateToolResult(event.toolCallId, event.partialResult, false, true);
 	});
 
-	for (const name of BUILT_INS) {
-		const base = getBuiltInTools(process.cwd())[name] as any;
-		pi.registerTool({
-			...base,
-			name,
-			label: name,
-			renderShell: "self",
-			async execute(toolCallId: string, params: any, signal: AbortSignal | undefined, onUpdate: any, ctx: ExtensionContext) {
-				const tool = (getBuiltInTools(ctx.cwd) as any)[name];
-				return tool.execute(toolCallId, params, signal, onUpdate, ctx);
-			},
-			renderCall(args: any, theme: any, context: any) {
-				const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
-				text.setText(compactToolLine(context.toolCallId, name, args, theme, context.invalidate));
-				return text;
-			},
-			renderResult(_result: any, _options: any, _theme: any, _context: any) {
-				return new Text("", 0, 0);
-			},
-		});
-	}
+	pi.on("tool_execution_end", (event, ctx) => {
+		captureTheme(ctx);
+		updateToolResult(event.toolCallId, event.result, event.isError, false);
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-transcript",
-  "version": "0.2.1",
+  "version": "0.5.0",
   "description": "A compact transcript extension for pi: collapsed thinking summaries and one-line tool previews.",
   "type": "module",
   "license": "MIT",