pi-compact-tools 0.14.0 → 0.14.2

package/README.md

@@ -12,7 +12,7 @@ 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`.
 
-Requires Node.js 22.19+ and Pi 0.85.1+. 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 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.
 
 ## Styles
 
@@ -88,6 +88,23 @@ Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.js
 - `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.
 
+## 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.
@@ -101,7 +118,7 @@ npm run check
 pi -e .
 ```
 
-Development dependencies are pinned to Pi 1.0.0; the peer minimum remains Pi 0.85.1. CI checks Pi 0.85.1, 0.99.1, and 1.0.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.
+Development dependencies are pinned to Pi 1.1.0; the peer minimum remains Pi 0.85.1. CI checks Pi 0.85.1, 0.99.1, 1.0.0, 1.0.2, and 1.1.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.
 

package/extensions/compact-tools-codex-rows.ts

@@ -145,6 +145,7 @@ function prefixedRows(lines: readonly Segment[][], first: string, rest: string,
 }
 
 function durationOf(state: RowState): string | undefined {
+	if (state.durationMs !== undefined) return formatCodexDuration(state.durationMs);
 	return state.startedAt !== undefined && state.endedAt !== undefined ? formatCodexDuration(state.endedAt - state.startedAt) : undefined;
 }
 

package/extensions/compact-tools-custom.ts

@@ -1,10 +1,13 @@
 import { ToolExecutionComponent, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { hookMethod } from "./compact-tools-hook.ts";
+import { refreshRowShell } from "./compact-tools-rendering.ts";
 
 // Symbol.for keys are shared by every evaluation of this module. The prototype is
 // Pi's and outlives a /reload, so the patch is installed once and always asks the
 // most recently loaded extension instance, through the shared slot, what to render.
-const RESOLVER_KEY = Symbol.for("pi-compact-tools.custom.resolver");
-const PATCHED_KEY = Symbol.for("pi-compact-tools.custom.patched");
+const RESOLVER_KEY = Symbol.for("pi-compact-tools.custom.resolver.v2");
+const LEGACY_RESOLVER_KEY = Symbol.for("pi-compact-tools.custom.resolver");
+const PATCHED_KEY = Symbol.for("pi-compact-tools.custom.patched.v2");
 const ROUTED_METHODS = ["getCallRenderer", "getResultRenderer", "getRenderShell", "hasRendererDefinition"] as const;
 
 type AnyToolDefinition = ToolDefinition<any, any, any>;
@@ -26,14 +29,12 @@ type RoutedPrototype = Record<(typeof ROUTED_METHODS)[number], (...args: unknown
 type ResolverSlot = typeof globalThis & { [RESOLVER_KEY]?: RowResolver };
 
 export function setRowResolver(resolver: RowResolver | undefined): void {
+	// The v1 patch may survive an npm update plus /reload. Keep its slot empty.
+	(globalThis as unknown as Record<symbol, unknown>)[LEGACY_RESOLVER_KEY] = undefined;
 	(globalThis as ResolverSlot)[RESOLVER_KEY] = resolver;
 }
 
-/**
- * Stop answering for rows, if `resolver` is still the one answering. The patch on
- * Pi's rows outlives the extension, so a /reload that leaves it out must find no
- * resolver, and Pi's own renderers draw every row made afterwards.
- */
+/** Remove this instance's resolver when the UI extension is unloaded. */
 export function clearRowResolver(resolver: RowResolver): void {
 	if ((globalThis as ResolverSlot)[RESOLVER_KEY] === resolver) setRowResolver(undefined);
 }
@@ -48,28 +49,41 @@ export function patchToolRows(prototype: object | undefined): boolean {
 	const routed = prototype as RoutedPrototype;
 	if (!ROUTED_METHODS.every((method) => typeof routed[method] === "function")) return false;
 	if (Object.hasOwn(prototype, PATCHED_KEY)) return true;
-	// Decided once per row: Pi picks the row's container from these answers in its
-	// constructor, so a row must never switch renderers after it is built. /reload
-	// rebuilds the transcript, so config changes still reach every row.
-	const decisions = new WeakMap<object, RowRenderers | null>();
+	hookMethod(prototype, "updateDisplay", "custom.refreshShell", (self, args, original) => {
+		refreshRowShell(self);
+		return original.apply(self, args);
+	});
+	// Cache within a configuration generation. session_start can apply trusted
+	// project settings after rows were constructed; a new resolver invalidates
+	// those provisional decisions, and updateDisplay reconciles the shell.
+	const decisions = new WeakMap<object, { resolver: RowResolver | undefined; renderers: RowRenderers | null }>();
+	const owners = new WeakMap<object, { call?: unknown; result?: unknown }>();
+	const changed = (row: object, kind: "call" | "result", renderer: unknown) => {
+		let owner = owners.get(row);
+		if (!owner) owners.set(row, owner = {});
+		if (owner[kind] !== renderer) {
+			(row as Record<string, unknown>)[kind === "call" ? "callRendererComponent" : "resultRendererComponent"] = undefined;
+			owner[kind] = renderer;
+		}
+		return renderer;
+	};
 	const resolve = (row: ToolRow): RowRenderers | undefined => {
-		let renderers = decisions.get(row);
-		if (renderers === undefined) {
-			try {
-				renderers = (globalThis as ResolverSlot)[RESOLVER_KEY]?.(row) ?? null;
-			} catch {
-				renderers = null;
-			}
-			decisions.set(row, renderers);
+		const resolver = (globalThis as ResolverSlot)[RESOLVER_KEY];
+		let decision = decisions.get(row);
+		if (!decision || decision.resolver !== resolver) {
+			let renderers: RowRenderers | null;
+			try { renderers = resolver?.(row) ?? null; } catch { renderers = null; }
+			decision = { resolver, renderers };
+			decisions.set(row, decision);
 		}
-		return renderers ?? undefined;
+		return decision.renderers ?? undefined;
 	};
 	const original = Object.fromEntries(ROUTED_METHODS.map((method) => [method, routed[method]])) as RoutedPrototype;
 	routed.getCallRenderer = function (this: ToolRow, ...args) {
-		return resolve(this)?.renderCall ?? original.getCallRenderer.apply(this, args);
+		return changed(this, "call", resolve(this)?.renderCall ?? original.getCallRenderer.apply(this, args));
 	};
 	routed.getResultRenderer = function (this: ToolRow, ...args) {
-		return resolve(this)?.renderResult ?? original.getResultRenderer.apply(this, args);
+		return changed(this, "result", resolve(this)?.renderResult ?? original.getResultRenderer.apply(this, args));
 	};
 	routed.getRenderShell = function (this: ToolRow, ...args) {
 		return resolve(this) ? "self" : original.getRenderShell.apply(this, args);

package/extensions/compact-tools-grouping.ts

@@ -26,6 +26,7 @@ import {
 import { formatDurationMs, type RowStatus } from "./compact-tools-core.ts";
 import { hookMethod } from "./compact-tools-hook.ts";
 import { getTextResult } from "./compact-tools-invocation.ts";
+import { outputPadLines } from "./compact-tools-layout.ts";
 import { chromePainter, paintIndicator } from "./compact-tools-palette.ts";
 import type { ToolRuntime } from "./compact-tools-runtime.ts";
 import { findChat, isKind, isSilent } from "./compact-tools-silent.ts";
@@ -52,6 +53,8 @@ export interface ToolRowLike {
 	result?: AgentToolResult<unknown> & { isError?: boolean };
 	isPartial: boolean;
 	expanded: boolean;
+	/** Present on Pi 1.1+ tool components, absent on legacy hosts. */
+	outputPad?: number;
 	render(width: number): string[];
 	handleMouse?(event: unknown): unknown;
 	invalidate(): void;
@@ -333,7 +336,10 @@ export class ToolGroupController {
 			this.states.set(key, state);
 		}
 		const groupState = state;
-		const draw = (group: readonly ToolRowLike[], width: number, expanded: boolean) => this.drawCached(group, width, expanded, groupState);
+		const draw = (group: readonly ToolRowLike[], width: number, expanded: boolean) => {
+			const pad = group[0]?.outputPad;
+			return outputPadLines(this.drawCached(group, width + (pad === 0 ? 1 : 0), expanded, groupState), width, pad);
+		};
 		if (this.runtime.config.style !== "codex") return new ToolGroupComponent(rows, members, state, draw, () => tui.requestRender());
 		// Codex opens a group to the whole of each call, and closes it from one "− Show less" beneath them.
 		const toggle = (expanded: boolean) => {
@@ -342,7 +348,9 @@ export class ToolGroupController {
 		};
 		const footer = (width: number) => {
 			const theme = this.paint?.theme ?? this.context?.ui.theme;
-			return theme ? [truncateToWidth(theme.fg("dim", codexDisclosure(width, true)), Math.max(1, width), "…")] : [];
+			const pad = rows[0]?.outputPad;
+			const available = width + (pad === 0 ? 1 : 0);
+			return theme ? outputPadLines([truncateToWidth(theme.fg("dim", codexDisclosure(available, true)), Math.max(1, available), "…")], width, pad) : [];
 		};
 		const group = new ToolGroupComponent(rows, members, state, draw, toggle, footer);
 		// Read once the group has followed Ctrl+O, which it does as it is made. A call that joins an

package/extensions/compact-tools-layout.ts

@@ -15,6 +15,45 @@ import { highlightMarkdown } from "./compact-tools-markdown.ts";
 import { paintChrome } from "./compact-tools-palette.ts";
 import type { ToolArgs } from "./compact-tools-types.ts";
 
+/**
+ * Styles include one outer margin column in their prefixes. Pi 1.1+ can request
+ * no outer padding; reclaim that column without changing tree/code indentation.
+ * Missing fields and outputPad=1 keep the legacy output byte-for-byte.
+ */
+export function outputPadLines(lines: string[], width: number, outputPad?: number): string[] {
+	if (outputPad !== 0) return lines;
+	return lines.map((line) => stripTerminalSequences(line).startsWith(" ")
+		? sliceByColumn(line, 1, Math.max(0, width), true)
+		: truncateToWidth(line, Math.max(0, width), "…"));
+}
+
+class UnpaddedComponent implements Component {
+	private source?: string[];
+	private width?: number;
+	private lines: string[] = [];
+
+	constructor(private readonly inner: Component) {}
+
+	render(width: number): string[] {
+		const source = this.inner.render(width + 1);
+		if (source !== this.source || width !== this.width) {
+			this.source = source;
+			this.width = width;
+			this.lines = outputPadLines(source, width, 0);
+		}
+		return this.lines;
+	}
+
+	invalidate(): void {
+		this.inner.invalidate();
+		this.source = undefined;
+	}
+}
+
+export function withOutputPad(component: Component, outputPad?: number): Component {
+	return outputPad === 0 ? new UnpaddedComponent(component) : component;
+}
+
 export class CachedComponent implements Component {
 	private cachedWidth?: number;
 	private cachedLines?: string[];

package/extensions/compact-tools-rendering.ts

@@ -0,0 +1,51 @@
+import {
+	createBashToolDefinition, createEditToolDefinition, createFindToolDefinition,
+	createGrepToolDefinition, createLsToolDefinition, createPowerShellToolDefinition,
+	createReadToolDefinition, createWriteToolDefinition,
+	type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+
+// Constructing definitions does not register/activate tools or run their execute
+// functions. Only renderer fingerprints are retained, never model-facing fields.
+const factories = {
+	read: createReadToolDefinition, write: createWriteToolDefinition, edit: createEditToolDefinition,
+	bash: createBashToolDefinition, powershell: createPowerShellToolDefinition,
+	grep: createGrepToolDefinition, find: createFindToolDefinition, ls: createLsToolDefinition,
+};
+const builtinRenderers = new Map<string, { call: string; result: string }>();
+for (const [name, factory] of Object.entries(factories)) {
+	try {
+		const definition = factory(process.cwd());
+		builtinRenderers.set(name, { call: String(definition.renderCall), result: String(definition.renderResult) });
+	} catch {
+		// A missing/unsupported reference renderer 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;
+	const builtin = builtinRenderers.get(name);
+	return Boolean((definition.renderCall && String(definition.renderCall) !== builtin?.call)
+		|| (definition.renderResult && String(definition.renderResult) !== builtin?.result));
+}
+
+/** Change only a transcript row's renderer shell, never a tool registry entry. */
+export function refreshRowShell(row: object): void {
+	const target = row as {
+		children?: unknown[]; selfRenderContainer?: unknown; contentBox?: unknown; contentTextRegion?: unknown;
+		hasRendererDefinition?(): boolean; getRenderShell?(): string;
+		callRendererComponent?: unknown; resultRendererComponent?: unknown;
+	};
+	if (!Array.isArray(target.children) || !target.selfRenderContainer || !target.contentBox || !target.contentTextRegion) return;
+	const wanted = target.hasRendererDefinition?.()
+		? target.getRenderShell?.() === "self" ? target.selfRenderContainer : target.contentBox
+		: target.contentTextRegion;
+	const shells: unknown[] = [target.selfRenderContainer, target.contentBox, target.contentTextRegion];
+	const index = target.children.findIndex((child) => shells.includes(child));
+	if (index >= 0 && target.children[index] !== wanted) {
+		target.children[index] = wanted;
+		target.callRendererComponent = undefined;
+		target.resultRendererComponent = undefined;
+	}
+}

package/extensions/compact-tools-runtime.ts

@@ -20,7 +20,12 @@ const INDICATOR_INTERVAL_MS = 45;
 const UNDRAWN_ROW_MS = 1_500;
 const EXECUTION_TIMINGS_KEY = Symbol.for("pi.compact-tools.execution-timings");
 
-type ExecutionTiming = { startedAt: number; endedAt?: number };
+type ExecutionTiming = { startedAt: number; endedAt?: number; durationMs?: number };
+
+/** Treat missing or malformed host durations like an older host; zero is valid. */
+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 & {
@@ -186,6 +191,7 @@ export class ToolRuntime {
 		// Pi can rebuild the transcript mid-run, making new rows for old calls; a call
 		// keeps the run its first row was made in.
 		this.restoreTiming(state, ctx.toolCallId);
+		if (validDurationMs(ctx.durationMs)) state.durationMs = ctx.durationMs;
 		// A row is timed from when it runs, as Pi times its own: the model writing the
 		// arguments is not the tool's time. A restored row never ran in front of the
 		// reader, so it has no time to measure unless this process timed it before a
@@ -210,9 +216,10 @@ export class ToolRuntime {
 		this.trimTimings();
 	}
 
-	noteExecutionEnd(toolCallId: string): void {
+	noteExecutionEnd(toolCallId: string, durationMs?: number): void {
 		const timing = this.executionTimings.get(toolCallId) ?? { startedAt: Date.now() };
 		timing.endedAt ??= Date.now();
+		if (validDurationMs(durationMs)) timing.durationMs = durationMs;
 		this.executionTimings.set(toolCallId, timing);
 		this.trimTimings();
 	}
@@ -290,6 +297,7 @@ export class ToolRuntime {
 		if (!timing) return;
 		state.startedAt = timing.startedAt;
 		state.endedAt = timing.endedAt;
+		if (validDurationMs(timing.durationMs)) state.durationMs = timing.durationMs;
 	}
 
 	private persistTiming(state: RowState, toolCallId: string): void {
@@ -297,6 +305,7 @@ export class ToolRuntime {
 		const timing = this.executionTimings.get(toolCallId) ?? { startedAt: state.startedAt };
 		timing.startedAt = state.startedAt;
 		if (state.endedAt !== undefined) timing.endedAt = state.endedAt;
+		if (validDurationMs(state.durationMs)) timing.durationMs = state.durationMs;
 		this.executionTimings.set(toolCallId, timing);
 		this.trimTimings();
 	}

package/extensions/compact-tools-types.ts

@@ -41,6 +41,8 @@ export interface RowState {
 	finished?: boolean;
 	startedAt?: number;
 	endedAt?: number;
+	/** Host-recorded final duration, when available (Pi 1.1+). */
+	durationMs?: number;
 	resultLineSummary?: string;
 	resultLineSummaryComputed?: boolean;
 	lastResultContent?: unknown;
@@ -51,6 +53,8 @@ export interface RowState {
 	lastResultError?: boolean;
 	lastResultConfigRevision?: object;
 	lastResultPalette?: object;
+	lastResultDurationMs?: number;
+	lastResultOutputPad?: number;
 	/** What a Codex row's head reads from its result: a command's exit code, an edit's counts. */
 	codex?: {
 		exitCode?: number;
@@ -61,7 +65,10 @@ export interface RowState {
 }
 
 type BaseRenderContext = Parameters<NonNullable<BuiltInDefinition["renderCall"]>>[2];
-export type RenderContext<TArgs = ToolArgs> = Omit<BaseRenderContext, "args" | "state"> & {
+export type RenderContext<TArgs = ToolArgs> = Omit<BaseRenderContext, "args" | "state" | "durationMs" | "outputPad"> & {
 	args: TArgs;
 	state: RowState;
+	/** Optional across hosts: older Pi versions do not provide these fields. */
+	durationMs?: number;
+	outputPad?: number;
 };

package/extensions/compact-tools.ts

@@ -7,21 +7,12 @@ import type {
 	ToolDefinition,
 	ToolRenderResultOptions,
 } from "@earendil-works/pi-coding-agent";
-import {
-	createBashToolDefinition,
-	createEditToolDefinition,
-	createFindToolDefinition,
-	createGrepToolDefinition,
-	createLsToolDefinition,
-	createPowerShellToolDefinition,
-	createReadToolDefinition,
-	createWriteToolDefinition,
-	ToolExecutionComponent,
-} 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 { registerCompactToolsCommand } from "./compact-tools-command.ts";
 import { clearRowResolver, installToolRowPatch, setRowResolver, type RowRenderers, type ToolRow } from "./compact-tools-custom.ts";
 import {
@@ -47,6 +38,7 @@ import {
 	prefixedSentence,
 	prefixedText,
 	railComponent,
+	withOutputPad,
 	renderArguments,
 	renderCodeDiff,
 	renderCodeView,
@@ -68,7 +60,6 @@ import { ThinkingCycleController } from "./compact-tools-thinking.ts";
 import { ViewportKeeper } from "./compact-tools-viewport.ts";
 import {
 	SUPPORTED_TOOL_SET,
-	type BuiltInDefinition,
 	type CompactToolName,
 	type RenderContext,
 	type RowState,
@@ -80,7 +71,6 @@ const PREVIEW_DIFF_CONTEXT_LINES = 1;
 
 const runtime = new ToolRuntime();
 const RENDER_WIDGET_KEY = "compact-tools-render";
-const registeredTools = new Set<CompactToolName>();
 let registeredConfiguration: string | undefined;
 /**
  * Whether the last session found its directory trusted. A /reload rebuilds the
@@ -146,6 +136,7 @@ function liveIndicator(theme: Theme, ctx: RenderContext, state: RowState, glyph?
 }
 
 function formatDuration(state: RowState): string | undefined {
+	if (state.durationMs !== undefined) return formatDurationMs(state.durationMs);
 	if (state.startedAt === undefined) return undefined;
 	return formatDurationMs((state.endedAt ?? Date.now()) - state.startedAt);
 }
@@ -165,7 +156,9 @@ function canReuseResult<TArgs>(
 		&& state.lastResultPreview === state.preview
 		&& state.lastResultError === ctx.isError
 		&& state.lastResultConfigRevision === state.configRevision
-		&& state.lastResultPalette === paletteOf(theme);
+		&& state.lastResultPalette === paletteOf(theme)
+		&& state.lastResultDurationMs === state.durationMs
+		&& state.lastResultOutputPad === ctx.outputPad;
 }
 
 function rememberResult(state: RowState, result: AgentToolResult<unknown>, options: ToolRenderResultOptions, isError: boolean, theme: Theme): void {
@@ -214,6 +207,10 @@ function hasNestedArguments(args: ToolArgs): boolean {
 
 /** The call line: a status dot, the tool, and what it was asked, then any arguments the line leaves out. */
 function renderRowCall(name: string, args: ToolArgs, theme: Theme, ctx: RenderContext): Component {
+	return withOutputPad(renderRowCallContent(name, args, theme, ctx), ctx.outputPad);
+}
+
+function renderRowCallContent(name: string, args: ToolArgs, theme: Theme, ctx: RenderContext): Component {
 	const state = runtime.syncRow(ctx);
 	runtime.syncExpansion(state, ctx.expanded, name);
 	const kind = rowKind(name);
@@ -292,7 +289,7 @@ function renderRowBody(
 	author: AuthorResultRenderer | undefined,
 	rail?: string,
 ): Component | undefined {
-	if (rowKind(name) !== "custom") return renderFileBody(name, args, result, output, expanded, theme, isError, rail);
+	if (!author && rowKind(name) !== "custom") return renderFileBody(name, args, result, output, expanded, theme, isError, rail);
 	if (author) {
 		try {
 			const component = author(expanded);
@@ -333,6 +330,7 @@ function claudeBody(
 	theme: Theme,
 	author: AuthorResultRenderer | undefined,
 ): Component | undefined {
+	if (author && expanded) return renderRowBody(name, args, result, output, true, theme, false, author, CLAUDE_INDENT);
 	const path = pathArgument(args);
 	if (name === "edit") {
 		return renderCodeDiff(getEditPatch(result), getEditDiff(result), path, theme,
@@ -416,13 +414,13 @@ function renderRowResult(
 	runtime.syncExpansion(state, ctx.expanded, name);
 	if (canReuseResult(state, result, options, theme, ctx)) return ctx.lastComponent;
 	const kind = rowKind(name);
-	const output = kind === "file" ? getFileOutput(name, ctx.args, result, ctx.isError) : getTextResult(result);
+	const output = kind === "file" && !author ? getFileOutput(name, ctx.args, result, ctx.isError) : getTextResult(result);
 	const hasEditDiff = name === "edit" && getEditDiff(result).length > 0;
 	runtime.setResultAvailable(state, name, hasEditDiff || output.length > 0 || author !== undefined);
 	let component: Component;
 	if (isCodex()) {
 		component = renderCodexResult({
-			name, kind, args: ctx.args, result, output, theme, state, isError: ctx.isError,
+			name, kind: author ? "custom" : kind, args: ctx.args, result, output, theme, state, isError: ctx.isError,
 			isPartial: options.isPartial, expanded: state.expanded === true, toolCallId: ctx.toolCallId, author,
 		});
 	} else if (isClaude()) {
@@ -446,7 +444,9 @@ function renderRowResult(
 		component = new WithinWidth(container);
 	}
 	rememberResult(state, result, options, ctx.isError, theme);
-	return component;
+	state.lastResultDurationMs = state.durationMs;
+	state.lastResultOutputPad = ctx.outputPad;
+	return withOutputPad(component, ctx.outputPad);
 }
 
 /**
@@ -454,20 +454,30 @@ function renderRowResult(
  * author's result renderer still draws the expanded body; the row chrome, status,
  * and collapse behavior match the built-ins.
  */
+let authorStates = new WeakMap<object, { state: RowState; component?: Component }>();
 function createCustomRenderers(name: string, author: ToolDefinition<any, any, any> | undefined): RowRenderers {
 	// Pi hands both renderers the row's own state object, which belongs to the tool's
 	// author. Compact bookkeeping is kept here so neither side overwrites the other.
-	const state: RowState = {};
-	let authorResult: Component | undefined;
-	const own = (ctx: RenderContext<any>): RenderContext => ({ ...ctx, args: ctx.args ?? {}, state });
+	const slot = (ctx: RenderContext<any>) => {
+		let value = authorStates.get(ctx.state);
+		if (!value) authorStates.set(ctx.state, value = { state: {} });
+		return value;
+	};
+	const own = (ctx: RenderContext<any>): RenderContext => ({ ...ctx, args: ctx.args ?? {}, state: slot(ctx).state });
 	return {
 		renderCall: (args, theme, ctx) => renderRowCall(name, (args ?? {}) as ToolArgs, theme, own(ctx)),
 		renderResult: (result, options, theme, ctx) => {
 			const authorRenderer = author?.renderResult;
 			const renderAuthorResult = authorRenderer
 				? (expanded: boolean) => {
-					authorResult = authorRenderer(result, { ...options, expanded }, theme, { ...ctx, lastComponent: authorResult });
-					return authorResult;
+					const value = slot(ctx);
+					// 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 }),
+					});
+					return value.component;
 				}
 				: undefined;
 			return renderRowResult(name, result, options, theme, own(ctx), renderAuthorResult);
@@ -475,63 +485,90 @@ function createCustomRenderers(name: string, author: ToolDefinition<any, any, an
 	};
 }
 
+// Renderer resolvers may run repeatedly for the same call, notably HTML export.
+let builtinStates = new WeakMap<object, RowState>();
+const compactRendererDefinitions = new WeakSet<object>();
+function builtinContext(ctx: RenderContext): RenderContext {
+	let state = builtinStates.get(ctx.state);
+	if (!state) builtinStates.set(ctx.state, state = {});
+	return { ...ctx, state };
+}
+
+/** UI-only routing: never register, activate, or replace model-facing tools. */
 function resolveCustomRow(row: ToolRow): RowRenderers | undefined {
+	if (runtime.config.style === "off") return undefined;
 	const customTools = runtime.config.custom_tools;
-	// Built-ins are governed by `tools`: ones left out keep Pi's own renderer.
-	if (runtime.config.style === "off" || !customTools.enabled || SUPPORTED_TOOL_SET.has(row.toolName)) return undefined;
-	if (customTools.exclude.includes(row.toolName)) return undefined;
+	if (SUPPORTED_TOOL_SET.has(row.toolName) && (!row.toolDefinition || compactRendererDefinitions.has(row.toolDefinition) || (row.toolDefinition.renderResult && compactRendererDefinitions.has(row.toolDefinition.renderResult)) || !hasAuthorRenderers(row.toolName, row.toolDefinition))) {
+		if (!runtime.config.tools.includes(row.toolName as CompactToolName)) return undefined;
+		const renderers: RowRenderers = {
+			renderCall: (args, theme, ctx) => renderRowCall(row.toolName, (args ?? {}) as ToolArgs, theme, builtinContext(ctx as RenderContext)),
+			renderResult: (result, options, theme, ctx) => renderRowResult(row.toolName, result, options, theme, builtinContext(ctx as RenderContext)),
+		};
+		compactRendererDefinitions.add(renderers);
+		compactRendererDefinitions.add(renderers.renderResult);
+		return renderers;
+	}
+	if (!customTools.enabled || customTools.exclude.includes(row.toolName)) return undefined;
 	return createCustomRenderers(row.toolName, row.toolDefinition);
 }
 
-const toolFactories: Record<CompactToolName, (cwd: string) => BuiltInDefinition> = {
-	read: createReadToolDefinition,
-	write: createWriteToolDefinition,
-	edit: createEditToolDefinition,
-	bash: createBashToolDefinition,
-	powershell: createPowerShellToolDefinition,
-	grep: createGrepToolDefinition,
-	find: createFindToolDefinition,
-	ls: createLsToolDefinition,
+type RendererAPI = ExtensionAPI & {
+	registerToolRenderer?: (resolver: (name: string, next: () => ToolDefinition<any, any, any> | undefined) => ToolDefinition<any, any, any> | undefined) => void;
 };
-
-function registerCompactTool(pi: ExtensionAPI, definition: BuiltInDefinition): void {
-	pi.registerTool({
-		...definition,
-		execute: runtime.createTimedExecute(definition),
-		renderShell: "self",
-		renderCall: (args: ToolArgs, theme: Theme, ctx: RenderContext) => renderRowCall(definition.name, args, theme, ctx),
-		renderResult: (result: AgentToolResult<unknown>, options: ToolRenderResultOptions, theme: Theme, ctx: RenderContext) =>
-			renderRowResult(definition.name, result, options, theme, ctx),
-	} as ToolDefinition<any, any, RowState>);
-}
-
-/** Off leaves every tool with Pi's own renderer. */
-function compactedTools(): CompactToolName[] {
-	return runtime.config.style === "off" ? [] : runtime.config.tools;
-}
-
-function registerTools(pi: ExtensionAPI, cwd: string): void {
-	const enabledTools = new Set(compactedTools());
-	for (const name of registeredTools) {
-		// Pi exposes no unregister API, so restoring a disabled tool means re-registering
-		// the built-in definition to release this extension's renderers.
-		if (!enabledTools.has(name)) pi.registerTool(toolFactories[name](cwd));
-	}
-	registeredTools.clear();
-	for (const name of compactedTools()) {
-		registerCompactTool(pi, toolFactories[name](cwd));
-		registeredTools.add(name);
+let publicRendering = false;
+let sessionReady = false;
+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.
+	let config: unknown;
+	let decision: RowRenderers | undefined;
+	const decide = () => {
+		if (config !== runtime.config) {
+			config = runtime.config;
+			decision = resolveCustomRow({ toolName: name, toolDefinition: base });
+		}
+		return decision;
+	};
+	if (!decide() && (sessionReady || !base)) return base;
+	const context = (ctx: Parameters<RowRenderers["renderCall"]>[2], kind: "call" | "result", render: unknown): typeof ctx => {
+		let owner = publicOwners.get(ctx.state);
+		if (!owner) publicOwners.set(ctx.state, owner = {});
+		const changed = owner[kind] !== render;
+		owner[kind] = render;
+		return changed ? { ...ctx, lastComponent: undefined } : ctx;
+	};
+	const call: RowRenderers["renderCall"] = (args, theme, ctx) => {
+		const render = decide()?.renderCall ?? base?.renderCall;
+		return render!(args, theme, context(ctx, "call", render));
+	};
+	const result: RowRenderers["renderResult"] = (value, options, theme, ctx) => {
+		const render = decide()?.renderResult ?? base?.renderResult;
+		return render!(value, options, theme, context(ctx, "result", render));
+	};
+	return {
+		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>;
+}
+let legacyResolver: ((row: ToolRow) => RowRenderers | undefined) | undefined;
+let refreshTranscriptRows: (() => void) | undefined;
+function invalidateRowDecisions(): void {
+	if (!publicRendering) {
+		legacyResolver = (row) => resolveCustomRow(row);
+		setRowResolver(legacyResolver);
 	}
+	refreshTranscriptRows?.();
 }
 
-function configure(pi: ExtensionAPI, cwd?: string, projectTrusted = false): void {
+function configure(_pi: ExtensionAPI, cwd?: string, projectTrusted = false): void {
 	const resolvedCwd = cwd ?? process.cwd();
 	const config = loadConfig(resolvedCwd, projectTrusted);
 	const signature = JSON.stringify([resolvedCwd, config]);
 	if (signature === registeredConfiguration) return;
 	runtime.configure(config);
-	registerTools(pi, resolvedCwd);
 	registeredConfiguration = signature;
+	invalidateRowDecisions();
 }
 
 /**
@@ -547,12 +584,7 @@ function applyStyle(cwd: string, trusted: boolean): boolean {
 	if (JSON.stringify({ ...config, style: current.style }) !== JSON.stringify(current)) return false;
 	runtime.configure(config);
 	registeredConfiguration = JSON.stringify([cwd, config]);
-	const chat = boundTui ? findChat(boundTui) : undefined;
-	for (const child of chat?.children ?? []) {
-		// Pi asks a row's renderers again whenever it redraws the row; this is that redraw.
-		if (isKind(child, ToolExecutionComponent)) (child as { updateDisplay?(): void }).updateDisplay?.();
-	}
-	boundTui?.requestRender();
+	invalidateRowDecisions();
 	return true;
 }
 
@@ -576,32 +608,41 @@ function madeByTool(event: object): boolean {
 	return typeof (event as { parentToolCallId?: unknown }).parentToolCallId === "string";
 }
 
-/** Pi's TUI while one is bound: where a style switched in place finds the rows to draw again. */
-let boundTui: { requestRender(): void } | undefined;
-
 /** 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) => {
-		boundTui = 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 {
-	boundTui = undefined;
+	refreshTranscriptRows = undefined;
 	runtime.bindRenderer(undefined);
 	ctx?.ui.setWidget(RENDER_WIDGET_KEY, undefined, { placement: "belowEditor" });
 }
 
 export default function compactTools(pi: ExtensionAPI): void {
-	// Pi caches this factory and re-invokes it with a fresh `pi` for every session
-	// replacement (/resume, /new, /fork) as well as /reload, each time starting from
-	// an empty tool registry. The module itself survives those invocations, so the
-	// memo below has to be dropped here or configure() mistakes the previous
-	// instance's registration for this one and never installs the renderers.
+	// The cached factory is invoked again after session replacement and reload.
+	// Reset configuration memoization, but never change the host's tool registry.
 	registeredConfiguration = undefined;
-	registeredTools.clear();
+	sessionReady = false;
+	publicOwners = new WeakMap();
 
 	registerCompactToolsCommand(pi, () => runtime.config, applyStyle);
 	const thinkingCycle = new ThinkingCycleController(pi);
@@ -609,12 +650,22 @@ export default function compactTools(pi: ExtensionAPI): void {
 	const viewport = new ViewportKeeper();
 	const silent = new SilentModeController(pi, showReleaseNotice);
 	const groups = new ToolGroupController(runtime);
-	const customRowsAvailable = installToolRowPatch();
-	setRowResolver(resolveCustomRow);
+	builtinStates = new WeakMap();
+	authorStates = new WeakMap();
+	const rendererAPI = pi as RendererAPI;
+	publicRendering = typeof rendererAPI.registerToolRenderer === "function";
+	const customRowsAvailable = publicRendering || installToolRowPatch();
+	if (publicRendering) {
+		setRowResolver(undefined);
+		rendererAPI.registerToolRenderer!((name, next) => {
+			const base = next();
+			return publicRowDefinition(name, base as ToolDefinition<any, any, any> | undefined);
+		});
+	} else invalidateRowDecisions();
 	let customRowsWarned = false;
 	let renderContext: ExtensionContext | undefined;
-	// Register once while the extension runtime is being built. In particular, this
-	// makes the overrides available before Pi restores the active tool set on /reload.
+	// 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);
@@ -625,11 +676,13 @@ export default function compactTools(pi: ExtensionAPI): void {
 		const trusted = ctx.isProjectTrusted();
 		(globalThis as TrustSlot)[TRUST_KEY] = { cwd: realDirectory(ctx.cwd), trusted };
 		configure(pi, ctx.cwd, trusted);
+		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;
-			bindRenderer(ctx);
 			// First, so its input listener sees relayout keys before the thinking controller consumes them.
 			viewport.bind(ctx);
 			progress.bind(ctx);
@@ -637,11 +690,12 @@ export default function compactTools(pi: ExtensionAPI): void {
 			silent.bind(ctx, runtime.config.mode, event.reason === "reload");
 			groups.bind(ctx);
 			if (!silent.isEnabled()) showReleaseNotice(ctx);
-			if (runtime.config.custom_tools.enabled && !customRowsAvailable && !customRowsWarned) {
+			if ((runtime.config.custom_tools.enabled || runtime.config.tools.length > 0) && !customRowsAvailable && !customRowsWarned) {
 				customRowsWarned = true;
-				ctx.ui.notify("Compact rendering for custom tools is unavailable in this version of Pi", "warning");
+				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();
@@ -661,7 +715,7 @@ export default function compactTools(pi: ExtensionAPI): void {
 	});
 	pi.on("tool_execution_end", (event) => {
 		if (madeByTool(event)) return runtime.noteNestedCall(event.toolCallId, false);
-		runtime.noteExecutionEnd(event.toolCallId);
+		runtime.noteExecutionEnd(event.toolCallId, (event as { durationMs?: number }).durationMs);
 	});
 	pi.on("session_shutdown", (event) => {
 		thinkingCycle.dispose();
@@ -673,6 +727,7 @@ export default function compactTools(pi: ExtensionAPI): void {
 		renderContext = undefined;
 		runtime.reset(event.reason !== "reload");
 		// A reload that keeps the extension sets it again before Pi rebuilds the transcript.
-		clearRowResolver(resolveCustomRow);
+		if (legacyResolver) clearRowResolver(legacyResolver);
+		refreshTranscriptRows = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "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.0.0",
-    "@earendil-works/pi-tui": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.1.0",
+    "@earendil-works/pi-tui": "1.1.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,26 @@
 {
+  "0.14.2": {
+    "New": [
+      "Supports Pi 1.1 recorded execution durations and output padding when those fields are available"
+    ],
+    "Fix": [
+      "Restored Compact and expanded Codex rows retain their recorded execution time, including zero-duration calls",
+      "Final host-recorded durations stay accurate when the system clock changes",
+      "Tool rows and folded groups honor outputPad without changing their internal style indentation",
+      "Embedded third-party renderers do not receive a duplicate outer margin",
+      "Preserves existing timing and margins on older Pi versions; the minimum supported version remains Pi 0.85.1"
+    ],
+    "Deprecated": []
+  },
+  "0.14.1": {
+    "Fix": [
+      "Fixed unintended input-token overhead: compact rendering no longer registers or activates tools that Pi would otherwise leave inactive",
+      "Preserves Pi’s tool execution settings and other extensions’ tool definitions and renderers",
+      "Fixed tool rows not updating correctly after reloads or trusted-project style changes",
+      "Uses Pi’s native renderer API on Pi 1.0.2 and later, including compact HTML exports",
+      "Supports Pi 0.85.1 and later; Pi 1.0.2 or later is recommended. On earlier Pi versions, HTML exports use Pi’s default renderers"
+    ]
+  },
   "0.14.0": {
     "New": [
       "Codex style added.",