pi-compact-tools 0.14.1 → 0.14.2

package/README.md

@@ -97,7 +97,10 @@ 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. Durations use the host's tool-execution event boundaries.
+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.
@@ -115,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-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-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

@@ -38,6 +38,7 @@ import {
 	prefixedSentence,
 	prefixedText,
 	railComponent,
+	withOutputPad,
 	renderArguments,
 	renderCodeDiff,
 	renderCodeView,
@@ -135,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);
 }
@@ -154,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 {
@@ -203,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);
@@ -436,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);
 }
 
 /**
@@ -461,7 +471,12 @@ function createCustomRenderers(name: string, author: ToolDefinition<any, any, an
 			const renderAuthorResult = authorRenderer
 				? (expanded: boolean) => {
 					const value = slot(ctx);
-					value.component = authorRenderer(result, { ...options, expanded }, theme, { ...ctx, lastComponent: value.component });
+					// 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;
@@ -515,7 +530,7 @@ function publicRowDefinition(name: string, base: ToolDefinition<any, any, any> |
 		return decision;
 	};
 	if (!decide() && (sessionReady || !base)) return base;
-	const context = (ctx: RenderContext, kind: "call" | "result", render: unknown): RenderContext => {
+	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;
@@ -524,11 +539,11 @@ function publicRowDefinition(name: string, base: ToolDefinition<any, any, any> |
 	};
 	const call: RowRenderers["renderCall"] = (args, theme, ctx) => {
 		const render = decide()?.renderCall ?? base?.renderCall;
-		return render!(args, theme, context(ctx as RenderContext, "call", render));
+		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 as RenderContext, "result", render));
+		return render!(value, options, theme, context(ctx, "result", render));
 	};
 	return {
 		get renderShell() { return decide() ? "self" : base?.renderShell ?? "default"; },
@@ -700,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.14.1",
+  "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,17 @@
 {
+  "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",