pi-compact-tools 0.14.1 → 0.15.0

package/README.md

@@ -30,7 +30,7 @@ Silent mode (`Ctrl+'` or `/silent`) works on top of any style. `/compact-tools o
 
 - Reads, searches, and listings fold into one line: `Searched for 2 patterns, read 3 files`.
 - `Bash`, `Update`, `Write`, and custom tools keep their own rows with `⎿` results and short previews.
-- Matched against Claude Code 2.1.288 in a live terminal.
+- Matched against Claude Code 2.1.296 in a live terminal.
 
 ### Codex
 
@@ -39,7 +39,7 @@ Silent mode (`Ctrl+'` or `/silent`) works on top of any style. `/compact-tools o
 - Reads, searches, and listings fold into `• Explored`: `Read a.ts, b.ts`, `Search TODO in src`.
 - Commands read `Ran` or `Failed (exit 2)` with their last three output lines; opened, `$ cmd`, all its output, and `✓ • 1.23s`.
 - Edits preview their changed lines; custom tools read `• Called name`.
-- Matched against Codex CLI 0.160.0 in a live terminal.
+- Matched against Codex CLI 0.162.1 in a live terminal.
 
 ### Compact
 
@@ -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-codex.ts

@@ -20,8 +20,15 @@ export const CODEX_MARGIN = " ";
 export const CODEX_BULLET = "•";
 /** Codex draws a tab as four columns. */
 export const CODEX_TAB = "    ";
-/** Codex's key is ctrl+t; in Pi the key that opens a row is ctrl+o. */
-export const CODEX_EXPAND_KEY = "ctrl+o";
+/**
+ * Codex's key is ctrl+t; in Pi the key that opens a row is ctrl+o. Codex 0.161 spells
+ * a modifier by platform (`⌃t` on macOS, `^t` on Linux, `ctrl+t` elsewhere) and so does
+ * this. PI_COMPACT_TOOLS_PLATFORM stands in for the platform, so the suite draws the
+ * same rows wherever it runs.
+ */
+export function codexExpandKey(platform: string = process.env.PI_COMPACT_TOOLS_PLATFORM ?? process.platform): string {
+	return platform === "darwin" ? "⌃o" : platform === "linux" ? "^o" : "ctrl+o";
+}
 
 /** How Codex prints how long a call took: `250ms`, `1.50s`, `1m 15s`. */
 export function formatCodexDuration(milliseconds: number): string {
@@ -41,7 +48,7 @@ export function codexDisclosure(width: number, expanded: boolean, hiddenLines?:
 	if (expanded) return `${indent}− Show less`;
 	if (hiddenLines === undefined) return `${indent}+ Show details`;
 	const label = `+ ${hiddenLines} ${hiddenLines === 1 ? "line" : "lines"}`;
-	const hint = ` (${CODEX_EXPAND_KEY} to expand)`;
+	const hint = ` (${codexExpandKey()} to expand)`;
 	return visibleWidth(indent + label + hint) <= width ? indent + label + hint : indent + label;
 }
 

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

@@ -8,13 +8,52 @@ import {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
-import { diffTintRgb, fillRgb } from "./compact-tools-color.ts";
+import { diffTintRgb, fillRgb, type Rgb } from "./compact-tools-color.ts";
 import { normalizeLineEndings } from "./compact-tools-core.ts";
 import { resolveLanguage } from "./compact-tools-language.ts";
 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[];
@@ -408,10 +447,123 @@ function codeGutter(
 	theme: Theme,
 ): string {
 	const number = (lineNumber === undefined ? "" : String(lineNumber)).padStart(numberWidth);
-	if (!signs) return theme.fg("toolDiffContext", `${number}  `);
+	if (!signs) return theme.fg("toolDiffContext", ` ${number} `);
 	const sign = kind === "add" ? "+" : kind === "remove" ? "-" : " ";
 	const color = kind === "add" ? "toolDiffAdded" : kind === "remove" ? "toolDiffRemoved" : "toolDiffContext";
-	return theme.fg(color, `${number} ${sign} `);
+	return theme.fg(color, ` ${number} ${sign}`);
+}
+
+type CharRange = [start: number, end: number];
+
+/** Most token pairs a word diff compares; a longer pair of lines is left untinted instead of taking quadratic time. */
+const WORD_DIFF_MAX_CELLS = 40_000;
+/** How alike two lines must be, by shared characters, before their changed words are marked. */
+const WORD_DIFF_MIN_SIMILARITY = 0.6;
+/** How much of the theme color a changed word is tinted with, against the row's own tint. */
+const WORD_TINT = 0.32;
+
+/**
+ * The changed words of a removed row and the added row that replaces it, as Claude
+ * Code marks them: a brighter tint behind each word the pair does not share. Two
+ * rows with little in common are rewrites rather than edits and mark nothing.
+ */
+function wordDiffRanges(removed: string, added: string): { removed: CharRange[]; added: CharRange[] } | undefined {
+	const split = (text: string) => text.match(/[\p{L}\p{N}_]+|\s+|[^\s\p{L}\p{N}_]/gu) ?? [];
+	const before = split(removed);
+	const after = split(added);
+	if (before.length * after.length > WORD_DIFF_MAX_CELLS) return undefined;
+	const width = after.length + 1;
+	const lengths = new Uint16Array((before.length + 1) * width);
+	for (let i = before.length - 1; i >= 0; i--) {
+		for (let j = after.length - 1; j >= 0; j--) {
+			lengths[i * width + j] = before[i] === after[j]
+				? lengths[(i + 1) * width + j + 1]! + 1
+				: Math.max(lengths[(i + 1) * width + j]!, lengths[i * width + j + 1]!);
+		}
+	}
+	const removedChanged = new Array<boolean>(before.length).fill(true);
+	const addedChanged = new Array<boolean>(after.length).fill(true);
+	let shared = 0;
+	for (let i = 0, j = 0; i < before.length && j < after.length;) {
+		if (before[i] === after[j]) {
+			removedChanged[i] = addedChanged[j] = false;
+			shared += before[i]!.length;
+			i++;
+			j++;
+		} else if (lengths[(i + 1) * width + j]! >= lengths[i * width + j + 1]!) i++;
+		else j++;
+	}
+	if (shared === 0 || (2 * shared) / (removed.length + added.length) < WORD_DIFF_MIN_SIMILARITY) return undefined;
+	const ranges = (text: string, tokens: string[], changed: boolean[]): CharRange[] => {
+		const output: CharRange[] = [];
+		let offset = 0;
+		tokens.forEach((token, index) => {
+			const last = output.at(-1);
+			if (changed[index]) {
+				if (last && last[1] === offset) last[1] = offset + token.length;
+				else output.push([offset, offset + token.length]);
+			}
+			offset += token.length;
+		});
+		// A range starts and ends on a word, not on the blanks beside it.
+		return output
+			.map(([start, end]): CharRange => [
+				end - text.slice(start, end).trimStart().length,
+				start + text.slice(start, end).trimEnd().length,
+			])
+			.filter(([start, end]) => end > start);
+	};
+	const markedRemoved = ranges(removed, before, removedChanged);
+	const markedAdded = ranges(added, after, addedChanged);
+	return markedRemoved.length || markedAdded.length ? { removed: markedRemoved, added: markedAdded } : undefined;
+}
+
+/** Changed-word ranges for every removed row paired, in order, with the added row beside it. */
+function pairWordRanges(lines: readonly CodeDiffLine[]): Map<number, CharRange[]> {
+	const marked = new Map<number, CharRange[]>();
+	let index = 0;
+	while (index < lines.length) {
+		if (lines[index]!.kind !== "remove") {
+			index++;
+			continue;
+		}
+		const removedStart = index;
+		while (index < lines.length && lines[index]!.kind === "remove") index++;
+		const addedStart = index;
+		while (index < lines.length && lines[index]!.kind === "add") index++;
+		for (let offset = 0; offset < Math.min(addedStart - removedStart, index - addedStart); offset++) {
+			const pair = wordDiffRanges(lines[removedStart + offset]!.content, lines[addedStart + offset]!.content);
+			if (!pair) continue;
+			if (pair.removed.length) marked.set(removedStart + offset, pair.removed);
+			if (pair.added.length) marked.set(addedStart + offset, pair.added);
+		}
+	}
+	return marked;
+}
+
+/** A row's text with a brighter fill behind the given character ranges and `base` behind the rest. */
+function fillWithWords(
+	theme: Theme,
+	base: Rgb,
+	word: Rgb,
+	content: string,
+	ranges: readonly CharRange[],
+	chunk: string,
+	chunkStart: number,
+	padding: number,
+): string {
+	const chunkWidth = visibleWidth(chunk);
+	let output = "";
+	let cursor = 0;
+	for (const [start, end] of ranges) {
+		const from = Math.max(cursor, visibleWidth(content.slice(0, start)) - chunkStart);
+		const to = Math.min(chunkWidth, visibleWidth(content.slice(0, end)) - chunkStart);
+		if (to <= from) continue;
+		if (from > cursor) output += fillRgb(theme, base, sliceByColumn(chunk, cursor, from - cursor, true));
+		output += fillRgb(theme, word, sliceByColumn(chunk, from, to - from, true));
+		cursor = to;
+	}
+	return output + fillRgb(theme, base, sliceByColumn(chunk, cursor, chunkWidth - cursor, true) + " ".repeat(padding));
 }
 
 type CodeRowsOptions = {
@@ -439,8 +591,12 @@ function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, optio
 	const gutterWidth = numberWidth + (options.signs ? 3 : 2);
 	const addedTint = options.signs ? diffTintRgb(theme, "toolDiffAdded") : undefined;
 	const removedTint = options.signs ? diffTintRgb(theme, "toolDiffRemoved") : undefined;
+	const addedWordTint = options.signs ? diffTintRgb(theme, "toolDiffAdded", WORD_TINT) : undefined;
+	const removedWordTint = options.signs ? diffTintRgb(theme, "toolDiffRemoved", WORD_TINT) : undefined;
+	let words: Map<number, CharRange[]> | undefined;
 	return new CachedComponent((width) => {
 		highlighted ??= highlightCodeLines(lines, resolveLanguage(path, shebangLine), theme);
+		if (options.signs) words ??= pairWordRanges(lines);
 		const bodyWidth = Math.max(1, width - prefixWidth);
 		const codeWidth = Math.max(1, bodyWidth - gutterWidth);
 		const output: string[] = [];
@@ -450,6 +606,8 @@ function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, optio
 				return;
 			}
 			const tint = line.kind === "add" ? addedTint : line.kind === "remove" ? removedTint : undefined;
+			const wordRanges = words?.get(index);
+			const wordTint = line.kind === "add" ? addedWordTint : removedWordTint;
 			for (const [chunkIndex, chunk] of hardSliceAnsi(highlighted![index] ?? line.content, codeWidth).entries()) {
 				const gutter = codeGutter(
 					line.kind,
@@ -463,8 +621,15 @@ function renderCodeRows(lines: CodeDiffLine[], path: string, theme: Theme, optio
 					output.push(prefix + body);
 					continue;
 				}
-				const padded = body + " ".repeat(Math.max(0, bodyWidth - visibleWidth(body)));
-				output.push(prefix + fillRgb(theme, tint, padded));
+				const padding = Math.max(0, bodyWidth - visibleWidth(body));
+				if (wordRanges && wordTint) {
+					output.push(
+						prefix + fillRgb(theme, tint, gutter)
+							+ fillWithWords(theme, tint, wordTint, line.content, wordRanges, chunk, chunkIndex * codeWidth, padding),
+					);
+					continue;
+				}
+				output.push(prefix + fillRgb(theme, tint, body + " ".repeat(padding)));
 			}
 		});
 		if (options.footer) {

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.15.0",
   "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.15.0": {
+    "New": [
+      "Claude style now marks the changed words in an edit diff, like Claude Code 2.1.296: a removed line and the added line that replaces it get a brighter tint on the words that differ. Lines that are mostly rewritten are left alone",
+      "Codex style spells the expand key the way Codex 0.162 does: `⌃o` on macOS, `^o` on Linux, `ctrl+o` elsewhere"
+    ],
+    "Fix": [
+      "Line numbers in edit diffs and Write previews moved one column right and lost one trailing space, matching Claude Code 2.1.296. Code stays in the same column"
+    ]
+  },
+  "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",