pi-compact-tools 0.15.0 → 0.16.1

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+. **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.
+Requires Node.js 22.19+ and Pi 0.85.1+. **Pi 1.2.0 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,18 @@ 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.
 
+## Codemode summaries
+
+Completed `codemode` rows in **Compact, Claude, and Codex** list the outcomes of the tools the script actually called, beside the duration and output-line count:
+
+```text
+Done in 1.234s (42 lines) · read 3 · bash 1 · edit 3 2
+```
+
+Each tool appears once with plain colored counts and no count parentheses or pipe: `read 3 · bash 1 · edit 3 2`. Single-outcome calls show one green success count, red failure count, or yellow unfinished-only count. Mixed success/failure calls show the green success count followed by the red failure count, separated only by a space; zero-count placeholders are omitted. Unfinished calls alongside settled calls add a separate yellow note such as `edit 3 2 1 unfinished`. Summary names retain their theme title hue at 75% brightness without bold, while outcome numbers keep their hues at 80% brightness. The main tool title and code preview remain unchanged. `Done in … (N lines)` uses a neutral tone one step brighter than the frame; spaces and `·` separators retain the dim frame chrome. There are no circles, leading bars, underlines, patch totals, or per-call diff lists. Non-edit groups retain first-occurrence order, and edit always appears last. Incomplete records show `(partial)`. Long summaries wrap to the pane width. Previews and author-provided expanded views remain available; expansion does not add patch details. Claude and Codex place the indented completion summary after output and keep disclosure last. Completion rows do not consume Claude’s output-preview limit.
+
+The summary uses the host’s nested-call events and saved records without changing what the model sees. It retains only tool names and statuses, never arguments, results, or edit diff totals. An in-process `/reload`, resumed sessions, and `/tree` navigation preserve or restore call counts and outcomes. Hosts without nested-call data keep the previous row rendering.
+
 ## UI-only behavior
 
 This package never registers or activates agent tools and does not add model-facing
@@ -118,7 +130,7 @@ npm run check
 pi -e .
 ```
 
-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.
+Development dependencies are pinned to Pi 1.2.0; the peer minimum remains Pi 0.85.1. CI checks Pi 0.85.1, 0.99.1, 1.0.0, 1.0.2, 1.1.0, and 1.2.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

@@ -272,6 +272,8 @@ type ResultInput = {
 	expanded: boolean;
 	toolCallId: string;
 	author?: (expanded: boolean) => Component | undefined;
+	/** A codemode completion summary, in this style's native indentation. */
+	completion?: Component;
 };
 
 /**
@@ -425,11 +427,11 @@ function customResult(input: ResultInput, width: number): string[] {
 			const start = lines.findIndex((line) => stripTerminalSequences(line).trim() !== "");
 			rows = (start < 0 ? [] : lines.slice(start)).map((line, index) => (index === 0 ? first : CODEX_INDENT) + line);
 		} else if (text || isError) rows = prefixedRows(textLines(outputLines(isError ? `Error: ${text}` : text).join("\n"), "dim"), first, CODEX_INDENT, width, theme);
-		return [...rows, dimDisclosure(theme, width, true)];
+		return [...rows, ...(input.completion?.render(width) ?? []), dimDisclosure(theme, width, true)];
 	}
 	let lines = text ? tailLines(text) : [];
 	if (isError && outputLines(text).length <= CODEX_PREVIEW_ROWS) lines = lines.length ? [`Error: ${lines[0]}`, ...lines.slice(1)] : ["Error: "];
-	return [...previewRows(lines, theme, width), dimDisclosure(theme, width, false)];
+	return [...previewRows(lines, theme, width), ...(input.completion?.render(width) ?? []), dimDisclosure(theme, width, false)];
 }
 
 /** Everything a Codex row draws beneath its head. */

package/extensions/compact-tools-color.ts

@@ -141,7 +141,7 @@ export function paletteOf(theme: Theme): object {
 
 /** Every token the derived colors are made from. */
 const PALETTE_TOKENS: readonly ThemeColor[] = [
-	"text", "dim", "muted", "toolDiffAdded", "toolDiffRemoved",
+	"text", "dim", "muted", "toolTitle", "success", "error", "warning", "toolDiffAdded", "toolDiffRemoved",
 	"thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh",
 ];
 /** One object per palette seen; a session switches among a handful of themes at most. */

package/extensions/compact-tools-layout.ts

@@ -203,12 +203,18 @@ export function prefixedLines(text: string, firstPrefix: string, continuationPre
  * A sentence under a tree prefix, wrapped at words as a terminal UI wraps prose:
  * a word moves to the next row whole, and only a word longer than a row is split.
  */
-export function prefixedSentence(text: string, firstPrefix: string, continuationPrefix: string): Component {
+export function prefixedSentence(text: string, firstPrefix: string, continuationPrefix: string, trimWrappedIndent = false): Component {
 	const prefixWidth = Math.max(visibleWidth(firstPrefix), visibleWidth(continuationPrefix));
 	const lines = text.replace(/\t/g, "   ").split("\n");
 	return new CachedComponent((width) => {
 		const available = Math.max(1, width - prefixWidth);
-		return lines.flatMap((line) => wrapTextWithAnsi(line, available).map((row) => truncateToWidth(row, available, "")))
+		return lines.flatMap((line) => wrapTextWithAnsi(line, available).map((row, index) => {
+			if (trimWrappedIndent && index > 0) {
+				const spaces = stripTerminalSequences(row).match(/^ +/u)?.[0].length ?? 0;
+				if (spaces) row = sliceByColumn(row, spaces, visibleWidth(row) - spaces, true);
+			}
+			return truncateToWidth(row, available, "");
+		}))
 			.map((row, index) => `${index === 0 ? firstPrefix : continuationPrefix}${row}`);
 	});
 }
@@ -216,8 +222,9 @@ export function prefixedSentence(text: string, firstPrefix: string, continuation
 /**
  * Output as Claude Code previews it. Each line is wrapped to the width, and rows
  * rather than lines are counted: collapsed, `maxRows` show, all of them when only
- * one more would be hidden, and then `more(hidden)`. Claude Code wraps ten
- * columns short of the terminal, so previews break where its own do.
+ * one more would be hidden, then an optional completion and `more(hidden)`.
+ * Claude Code wraps ten columns short of the terminal, so previews break where
+ * its own do. Completion rows never count toward the output-preview limit.
  */
 export function claudeRows(
 	lines: readonly string[],
@@ -225,17 +232,20 @@ export function claudeRows(
 	continuationPrefix: string,
 	maxRows: number | undefined,
 	more: (hidden: number) => string,
+	completion?: Component,
 ): Component {
 	const prefixWidth = Math.max(visibleWidth(firstPrefix), visibleWidth(continuationPrefix));
 	return new CachedComponent((width) => {
 		const available = Math.max(1, width - prefixWidth);
 		const wrapWidth = maxRows === undefined ? available : Math.min(available, Math.max(width - 10, 10));
 		let rows = lines.flatMap((line) => hardWrapTextWithAnsi(line, wrapWidth).map((row) => row.trimEnd()));
-		if (maxRows !== undefined && rows.length > maxRows + 1) {
-			rows = [...rows.slice(0, maxRows), truncateToWidth(more(rows.length - maxRows), available, "…")];
-		}
-		return rows.map((row, index) => `${index === 0 ? firstPrefix : continuationPrefix}${row}`);
-	});
+		const hidden = maxRows !== undefined && rows.length > maxRows + 1 ? rows.length - maxRows : 0;
+		if (hidden) rows = rows.slice(0, maxRows);
+		const rendered = rows.map((row, index) => `${index === 0 ? firstPrefix : continuationPrefix}${row}`);
+		if (completion) rendered.push(...completion.render(width));
+		if (hidden) rendered.push((rendered.length ? continuationPrefix : firstPrefix) + truncateToWidth(more(hidden), available, "…"));
+		return rendered;
+	}, () => completion?.invalidate());
 }
 
 export function hardWrapTextWithAnsi(text: string, width: number): string[] {

package/extensions/compact-tools-nested.ts

@@ -0,0 +1,169 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { chromePainter, nestedCountPainter, nestedTitlePainter } from "./compact-tools-palette.ts";
+
+const SUMMARY_KEY = Symbol.for("pi-compact-tools.nested-summaries.v1");
+const MAX_PARENTS = 2_000;
+const MAX_CALLS = 256;
+const MAX_NAME_LENGTH = 256;
+const MAX_ID_LENGTH = 1_024;
+type Status = "ok" | "error" | "unfinished";
+type Call = { name: string; status: Status };
+type Summary = { calls: Map<string, Call>; partial: boolean; finished: boolean; live: boolean; revision: object };
+type Shared = typeof globalThis & { [SUMMARY_KEY]?: Map<string, Summary> };
+type NestedEvent = { toolCallId: string; toolName: string; parentToolCallId?: string; isError?: boolean; result?: unknown };
+
+/** UI-only, bounded bookkeeping. Never retain arguments, results, or full diffs. */
+export class NestedCallSummaries {
+	private readonly summaries: Map<string, Summary>;
+
+	constructor() {
+		const shared = globalThis as Shared;
+		this.summaries = shared[SUMMARY_KEY] ??= new Map();
+	}
+
+	clear(): void {
+		this.summaries.clear();
+	}
+
+	begin(id: string, name: string): void {
+		if (name !== "codemode" || id.length > MAX_ID_LENGTH) return;
+		this.summaries.delete(id);
+		this.summaries.set(id, { calls: new Map(), partial: false, finished: false, live: true, revision: {} });
+		this.trim();
+	}
+
+	finish(id: string): void {
+		const summary = this.summaries.get(id);
+		if (summary) {
+			summary.finished = true;
+			summary.revision = {};
+		}
+	}
+
+	/** A revision is also read at draw time, so even a late child end cannot freeze a footer. */
+	revision(id: string): object | undefined {
+		return this.summaries.get(id)?.revision;
+	}
+
+	/** Host-assigned descendant ids are `<caller id>/<n>`; retain the whole provider root id. */
+	private root(parent: string): string | undefined {
+		let id = parent;
+		while (id) {
+			if (this.summaries.has(id)) return id;
+			const slash = id.lastIndexOf("/");
+			if (slash < 0) return undefined;
+			id = id.slice(0, slash);
+		}
+		return undefined;
+	}
+
+	/** Returns true only when a finished parent needs a fresh terminal frame. */
+	note(event: NestedEvent, ended: boolean): boolean {
+		if (typeof event.parentToolCallId !== "string" || event.parentToolCallId.length > MAX_ID_LENGTH) return false;
+		const root = this.root(event.parentToolCallId);
+		const summary = root === undefined ? undefined : this.summaries.get(root);
+		if (!summary) return false;
+		if (typeof event.toolCallId !== "string" || typeof event.toolName !== "string"
+			|| event.toolCallId.length > MAX_ID_LENGTH || event.toolName.length > MAX_NAME_LENGTH) {
+			if (!summary.partial) { summary.partial = true; summary.revision = {}; }
+			return summary.finished;
+		}
+		const previous = summary.calls.get(event.toolCallId);
+		// A duplicate start must not turn an already settled call back into a running one.
+		if (!ended && previous) return false;
+		if (!previous && summary.calls.size >= MAX_CALLS) {
+			if (!summary.partial) { summary.partial = true; summary.revision = {}; }
+			return summary.finished;
+		}
+		const status = ended ? event.isError ? "error" : "ok" : "unfinished";
+		if (previous?.name === event.toolName && previous.status === status) return false;
+		summary.calls.set(event.toolCallId, { name: event.toolName, status });
+		summary.live = true;
+		summary.revision = {};
+		return summary.finished;
+	}
+
+	/** Pi persists `{calls: [{id, name, status}], complete}`, deliberately without results. */
+	restore(message: unknown): boolean {
+		if (!message || typeof message !== "object") return false;
+		const value = message as { role?: string; toolName?: string; toolCallId?: string; nestedCalls?: { calls?: unknown; complete?: unknown } };
+		if (value.role !== "toolResult" || value.toolName !== "codemode" || typeof value.toolCallId !== "string"
+			|| value.toolCallId.length > MAX_ID_LENGTH || !Array.isArray(value.nestedCalls?.calls)) return false;
+		// A bounded persisted snapshot must not drop observed live calls.
+		const existing = this.summaries.get(value.toolCallId);
+		if (existing?.live && existing.calls.size > 0) return false;
+		const summary: Summary = { calls: new Map(), partial: value.nestedCalls.complete !== true, finished: true, live: false, revision: {} };
+		let inspected = 0;
+		for (const item of value.nestedCalls.calls) {
+			if (inspected++ >= MAX_CALLS) { summary.partial = true; break; }
+			if (!item || typeof item !== "object") { summary.partial = true; continue; }
+			const call = item as { id?: unknown; name?: unknown; status?: unknown };
+			if (typeof call.id !== "string" || typeof call.name !== "string"
+				|| call.id.length > MAX_ID_LENGTH || call.name.length > MAX_NAME_LENGTH
+				|| (call.status !== "ok" && call.status !== "error" && call.status !== "unfinished")) { summary.partial = true; continue; }
+			if (!summary.calls.has(call.id) && summary.calls.size >= MAX_CALLS) { summary.partial = true; break; }
+			summary.calls.set(call.id, { name: call.name, status: call.status as Status });
+		}
+		this.summaries.set(value.toolCallId, summary);
+		this.trim();
+		return true;
+	}
+
+	/** The live branch only, never abandoned entries; callers clear on non-reload session changes. */
+	restoreBranch(entries: readonly unknown[]): void {
+		for (const entry of entries) {
+			if (entry && typeof entry === "object") this.restore((entry as { message?: unknown }).message);
+		}
+	}
+
+	/** Other tool groups keep first-occurrence order; edit counts always come last. */
+	format(id: string, theme: Theme, _expanded = false): string | undefined {
+		const summary = this.summaries.get(id);
+		if (!summary || (summary.calls.size === 0 && !summary.partial)) return undefined;
+		type Group = { name: string; calls: Call[] };
+		const groups: Group[] = [];
+		const byTool = new Map<string, Group>();
+		for (const call of summary.calls.values()) {
+			const key = call.name;
+			let group = byTool.get(key);
+			if (!group) {
+				group = { name: call.name, calls: [] };
+				byTool.set(key, group);
+				groups.push(group);
+			}
+			group.calls.push(call);
+		}
+		const editIndex = groups.findIndex((group) => group.name === "edit");
+		if (editIndex >= 0) groups.push(...groups.splice(editIndex, 1));
+		const title = nestedTitlePainter(theme);
+		const chrome = chromePainter(theme);
+		const success = nestedCountPainter(theme, "success");
+		const error = nestedCountPainter(theme, "error");
+		const warning = nestedCountPainter(theme, "warning");
+		const parts = groups.map((group) => {
+			const name = stripTerminalSequences(group.name).replace(/[\x00-\x20\x7f-\x9f]/gu, " ").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/gu, "").trim() || "tool";
+
+			const successes = group.calls.filter((call) => call.status === "ok").length;
+			const failures = group.calls.filter((call) => call.status === "error").length;
+			const unfinished = group.calls.filter((call) => call.status === "unfinished").length;
+			const counts = [successes ? success(String(successes)) : "",
+				failures ? error(String(failures)) : ""].filter(Boolean);
+			const settled = counts.length > 0;
+			if (!settled) counts.push(warning(String(unfinished)));
+			return title(name) + chrome(" ") + counts.join(chrome(" "))
+				+ (settled && unfinished ? chrome(" ") + warning(`${unfinished} unfinished`) : "");
+		});
+		const partial = summary.partial || [...summary.calls.values()].some((call) => call.status === "unfinished");
+		return parts.join(chrome(" · ")) + (partial ? (parts.length ? " " : "") + warning("(partial)") : "");
+	}
+
+	private trim(): void {
+		if (this.summaries.size <= MAX_PARENTS) return;
+		for (const [id, summary] of this.summaries) {
+			if (summary.finished) { this.summaries.delete(id); return; }
+		}
+		const oldest = this.summaries.keys().next().value;
+		if (oldest !== undefined) this.summaries.delete(oldest);
+	}
+}

package/extensions/compact-tools-palette.ts

@@ -38,10 +38,11 @@ type ContrastBand = { color: ThemeColor; keepHue: number; minimum: number; maxim
 type ContrastRange = { minimum: number; maximum: number };
 
 /**
- * One tone for the whole frame — rails, the result connector, and the status line it leads
- * to — so the frame reads as a single quiet object rather than competing with the output.
+ * A quiet frame tone for rails, connectors, and separators. Completion metadata
+ * sits one small brightness step above it so duration and line counts remain legible.
  */
 const CHROME: ContrastBand = { color: "dim", keepHue: 0.35, minimum: 0.22, maximum: 0.28 };
+const COMPLETION: ContrastBand = { ...CHROME, minimum: 0.26, maximum: 0.32 };
 /** The indicator breathes either side of the chrome tone, dipping below it and peaking above. */
 const PULSE_LOW: ContrastBand = { color: "dim", keepHue: 0.4, minimum: 0.18, maximum: 0.3 };
 const PULSE_HIGH: ContrastBand = { color: "muted", keepHue: 0.4, minimum: 0.4, maximum: 0.6 };
@@ -105,7 +106,34 @@ export function chromePainter(theme: Theme): (text: string) => string {
 	});
 }
 
-/** Paint one rail, connector, or status line in the chrome tone. */
+/** Duration and line-count metadata is slightly brighter than rails and separators. */
+export function completionPainter(theme: Theme): (text: string) => string {
+	return perPalette(theme, "completion-metadata", () => {
+		const color = bandedRgb(theme, COMPLETION);
+		return color ? rgbPainter(theme, color) : (text: string) => theme.fg("dim", text);
+	});
+}
+
+/** Nested names keep the title hue, slightly darker than ordinary titles, without bold. */
+export function nestedTitlePainter(theme: Theme): (text: string) => string {
+	return perPalette(theme, "nested-title", () => {
+		const title = themeColorRgb(theme, "toolTitle");
+		const paint = title ? rgbPainter(theme, interpolateRgb(title, { r: 0, g: 0, b: 0 }, 0.25))
+			: (text: string) => theme.fg("toolTitle", text);
+		return paint;
+	});
+}
+
+/** Quiet summary numbers retain outcome hues at 80% brightness. */
+export function nestedCountPainter(theme: Theme, color: "success" | "error" | "warning"): (text: string) => string {
+	return perPalette(theme, `nested-count:${color}`, () => {
+		const rgb = themeColorRgb(theme, color);
+		return rgb ? rgbPainter(theme, interpolateRgb(rgb, { r: 0, g: 0, b: 0 }, 0.20))
+			: (text: string) => theme.fg(color, text);
+	});
+}
+
+/** Paint frame rails, connectors, separators, or running status in the quiet chrome tone. */
 export function paintChrome(theme: Theme, text: string): string {
 	return chromePainter(theme)(text);
 }

package/extensions/compact-tools-runtime.ts

@@ -51,7 +51,8 @@ export class ToolRuntime {
 	private readonly currentCalls = new Set<string>();
 	/**
 	 * Calls a tool is making through `ctx.executeTool()`, as codemode scripts do. They
-	 * never get a row of their own, so nothing is timed or remembered for them.
+	 * never get a row of their own, so no execution timing is kept for them.
+	 * The independent nested-summary observer keeps only their outcome counts.
 	 */
 	private readonly nestedCalls = new Set<string>();
 
@@ -98,6 +99,11 @@ export class ToolRuntime {
 		this.requestRender = requestRender;
 	}
 
+	/** A late summary changes only a draw-time footer, not every row's layout. */
+	repaint(): void {
+		if (!isSilent()) this.requestRender?.();
+	}
+
 	/**
 	 * The agent started or stopped working. Once it stops nothing can still be
 	 * running, so a row that never got its result stops pulsing and waits instead.

package/extensions/compact-tools.ts

@@ -48,10 +48,11 @@ import {
 	WithinWidth,
 } from "./compact-tools-layout.ts";
 import { CLAUDE_DIFF_CONTEXT_LINES, CLAUDE_INDENT, CLAUDE_OUTPUT_ROWS, CLAUDE_RESULT_PREFIX, CLAUDE_TITLE_INDENT, CLAUDE_WRITE_ROWS, claudeFailure, claudeOutcome, claudeTitle } from "./compact-tools-claude.ts";
-import { CODEX_BULLET } from "./compact-tools-codex.ts";
+import { CODEX_BULLET, CODEX_INDENT } from "./compact-tools-codex.ts";
+import { NestedCallSummaries } from "./compact-tools-nested.ts";
 import { renderCodexCall, renderCodexResult } from "./compact-tools-codex-rows.ts";
 import { ToolGroupController } from "./compact-tools-grouping.ts";
-import { chromePainter, paintIndicator } from "./compact-tools-palette.ts";
+import { chromePainter, completionPainter, paintIndicator } from "./compact-tools-palette.ts";
 import { ProgressController } from "./compact-tools-progress.ts";
 import { showReleaseNotice } from "./compact-tools-release.ts";
 import { ToolRuntime } from "./compact-tools-runtime.ts";
@@ -70,6 +71,7 @@ import {
 const PREVIEW_DIFF_CONTEXT_LINES = 1;
 
 const runtime = new ToolRuntime();
+const nestedSummaries = new NestedCallSummaries();
 const RENDER_WIDGET_KEY = "compact-tools-render";
 let registeredConfiguration: string | undefined;
 /**
@@ -179,15 +181,19 @@ function renderControls(
 	isError: boolean,
 	failureReason?: string,
 	changes?: { added: number; removed: number },
+	nestedSummary?: string,
+	prefix = " └ ",
+	indent = "   ",
 ): Component {
 	const duration = running ? undefined : formatDuration(state);
 	const status = running
 		? (duration ?? "Running")
 		: `${isError ? "Failed" : "Done"}${duration ? ` in ${duration}` : ""}`;
 	// A failed row already reads as an error through its output color and Pi's row
-	// background, so the status word stays chrome rather than repeating that signal.
+	// background, so completion metadata stays neutral rather than repeating that signal.
 	const chrome = chromePainter(theme);
-	let details = chrome(status);
+	const metadata = running ? chrome : completionPainter(theme);
+	let details = metadata(status);
 	if (failureReason && isError && !running) details += chrome(" · ") + theme.fg("error", failureReason);
 	// An edit reports what it changed the way a diff does: lines added and removed.
 	else if (changes && !running && !isError) {
@@ -195,8 +201,9 @@ function renderControls(
 			+ theme.fg("toolDiffRemoved", `-${changes.removed}`) + chrome(")");
 	}
 	// A failed call produced no result worth counting; "(0 lines)" would only mislead.
-	else if (state.resultLineSummary && !running && !isError) details += chrome(` (${state.resultLineSummary})`);
-	return prefixedText(details, chrome(" └ "), "   ");
+	else if (state.resultLineSummary && !running && !isError) details += metadata(` (${state.resultLineSummary})`);
+	if (nestedSummary && !running) details += chrome(" · ") + nestedSummary;
+	return nestedSummary ? prefixedSentence(details, chrome(prefix), indent, true) : prefixedText(details, chrome(prefix), indent);
 }
 
 /** Arguments a one-line summary cannot show: objects, or lists of them. */
@@ -306,14 +313,14 @@ function claudeMoreLines(theme: Theme, hidden: number): string {
 }
 
 /** Output previewed in rows the way Claude Code previews it, all of it once opened. */
-function claudeOutput(output: string, expanded: boolean, theme: Theme, isError: boolean, empty: string, firstPrefix: string): Component {
+function claudeOutput(output: string, expanded: boolean, theme: Theme, isError: boolean, empty: string, firstPrefix: string, completion?: Component): Component {
 	const normalized = normalizeLineEndings(output).trimEnd();
 	// Pi's bash reports an empty run as "(no output)"; Claude Code dims its own words for it.
 	const lines = !normalized || normalized === "(no output)"
 		? [chromePainter(theme)(empty)]
 		: normalized.split("\n").map((line) => theme.fg(isError ? "error" : "toolOutput", line));
 	return claudeRows(lines, firstPrefix, CLAUDE_INDENT, expanded ? undefined : CLAUDE_OUTPUT_ROWS,
-		(hidden) => claudeMoreLines(theme, hidden));
+		(hidden) => claudeMoreLines(theme, hidden), completion);
 }
 
 /**
@@ -363,6 +370,7 @@ function renderClaudeResult(
 	expanded: boolean,
 	output: string,
 	author: AuthorResultRenderer | undefined,
+	completion?: Component,
 ): Component {
 	const chrome = chromePainter(theme);
 	const container = new CachedContainer();
@@ -378,11 +386,12 @@ function renderClaudeResult(
 		// shortened to one line, and a click shows it whole in its place.
 		if (failure.detail) {
 			container.addChild(line(theme.fg("error", failure.headline)));
-			container.addChild(claudeOutput(failure.detail, expanded, theme, true, "", CLAUDE_INDENT));
+			container.addChild(claudeOutput(failure.detail, expanded, theme, true, "", CLAUDE_INDENT, completion));
 		} else if (expanded && output.trim()) {
-			container.addChild(claudeOutput(`Error: ${output.trim()}`, true, theme, true, "", chrome(CLAUDE_RESULT_PREFIX)));
+			container.addChild(claudeOutput(`Error: ${output.trim()}`, true, theme, true, "", chrome(CLAUDE_RESULT_PREFIX), completion));
 		} else {
 			container.addChild(line(theme.fg("error", failure.headline)));
+			if (completion) container.addChild(completion);
 		}
 		return container;
 	}
@@ -392,8 +401,9 @@ function renderClaudeResult(
 		? formatResultLineSummary(name, args, result, output) ?? "Done"
 		: claudeOutcome(name, args, result, output, (value) => theme.bold(value));
 	if (outcome !== undefined) container.addChild(line(theme.fg("toolOutput", outcome)));
-	else container.addChild(claudeOutput(output, expanded, theme, false, rowKind(name) === "shell" ? "(No output)" : "(No content)", chrome(CLAUDE_RESULT_PREFIX)));
+	else container.addChild(claudeOutput(output, expanded, theme, false, rowKind(name) === "shell" ? "(No output)" : "(No content)", chrome(CLAUDE_RESULT_PREFIX), completion));
 	if (body) container.addChild(body);
+	if (completion && outcome !== undefined) container.addChild(completion);
 	return container;
 }
 
@@ -409,6 +419,7 @@ function renderRowResult(
 	theme: Theme,
 	ctx: RenderContext,
 	author?: AuthorResultRenderer,
+	watchNested = true,
 ): Component {
 	const state = runtime.syncRow(ctx, !options.isPartial);
 	runtime.syncExpansion(state, ctx.expanded, name);
@@ -417,14 +428,23 @@ function renderRowResult(
 	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);
+	const nestedSummary = name === "codemode" && !options.isPartial ? nestedSummaries.format(ctx.toolCallId, theme, state.expanded === true) : undefined;
+	if (nestedSummary && !state.resultLineSummaryComputed) {
+		state.resultLineSummary = output ? formatResultLineSummary(name, ctx.args, result, output) : undefined;
+		state.resultLineSummaryComputed = true;
+	}
 	let component: Component;
 	if (isCodex()) {
 		component = renderCodexResult({
 			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,
+			completion: nestedSummary ? renderControls(theme, state, false, ctx.isError, undefined, undefined, nestedSummary, CODEX_INDENT, CODEX_INDENT) : undefined,
 		});
 	} else if (isClaude()) {
-		component = new WithinWidth(renderClaudeResult(name, ctx.args, result, options, theme, ctx.isError, state.expanded === true, output, author));
+		const container = new CachedContainer();
+		const completion = nestedSummary ? renderControls(theme, state, false, ctx.isError, undefined, undefined, nestedSummary, CLAUDE_INDENT, CLAUDE_INDENT) : undefined;
+		container.addChild(renderClaudeResult(name, ctx.args, result, options, theme, ctx.isError, state.expanded === true, output, author, completion));
+		component = new WithinWidth(container);
 	} else {
 		if (!options.isPartial && !state.resultLineSummaryComputed) {
 			// A custom tool with no text has nothing to count.
@@ -440,13 +460,28 @@ function renderRowResult(
 		// the output shows, it already says why, and repeating it only doubles the error.
 		const failureReason = ctx.isError && !state.expanded && !state.preview ? summarizeFailure(name, output) : undefined;
 		container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, failureReason,
-			name === "edit" ? countEditChanges(result) : undefined));
+			name === "edit" ? countEditChanges(result) : undefined, nestedSummary));
 		component = new WithinWidth(container);
 	}
 	rememberResult(state, result, options, ctx.isError, theme);
 	state.lastResultDurationMs = state.durationMs;
 	state.lastResultOutputPad = ctx.outputPad;
-	return withOutputPad(component, ctx.outputPad);
+	let drawn = withOutputPad(component, ctx.outputPad);
+	if (name !== "codemode" || options.isPartial || !watchNested) return drawn;
+	// The host can deliver a final nested snapshot (or a cancelled child's end)
+	// after the parent's result. Read through at draw time, not only on updateResult.
+	let revision = nestedSummaries.revision(ctx.toolCallId);
+	return {
+		render(width) {
+			const next = nestedSummaries.revision(ctx.toolCallId);
+			if (next !== revision) {
+				revision = next;
+				drawn = renderRowResult(name, result, options, theme, { ...ctx, lastComponent: undefined }, author, false);
+			}
+			return drawn.render(width);
+		},
+		invalidate() { drawn.invalidate(); },
+	};
 }
 
 /**
@@ -670,7 +705,12 @@ export default function compactTools(pi: ExtensionAPI): void {
 	const lastTrust = (globalThis as TrustSlot)[TRUST_KEY];
 	configure(pi, cwd, lastTrust?.cwd === realDirectory(cwd) && lastTrust.trusted);
 	pi.on("session_start", (event, ctx) => {
-		if (event.reason !== "reload") runtime.clearTimings();
+		if (event.reason !== "reload") {
+			runtime.clearTimings();
+			nestedSummaries.clear();
+		}
+		const branch = ctx.sessionManager?.getBranch?.();
+		if (Array.isArray(branch)) nestedSummaries.restoreBranch(branch);
 		// Rows restored from the session are drawn next; while idle none of them is running.
 		if (typeof ctx.isIdle === "function") runtime.setBusy(!ctx.isIdle());
 		const trusted = ctx.isProjectTrusted();
@@ -703,18 +743,39 @@ export default function compactTools(pi: ExtensionAPI): void {
 			groups.dispose();
 		}
 	});
+	// /tree changes the branch without session_start. Fill sibling-branch records
+	// before Pi rebuilds its transcript, while retaining richer same-process deltas.
+	pi.on("session_tree", (_event, ctx) => {
+		const branch = ctx.sessionManager?.getBranch?.();
+		if (Array.isArray(branch)) nestedSummaries.restoreBranch(branch);
+		runtime.repaint();
+	});
 	pi.on("agent_start", () => runtime.setBusy(true));
 	pi.on("agent_end", () => runtime.setBusy(false));
 	// The calls of the run going on, read from each update as Pi reads them to make
 	// their rows, and told to extensions before Pi makes them.
 	pi.on("message_update", (event) => noteCalls(event.message));
+	// Notification-only: read the host's nested record without changing any message.
+	pi.on("message_end", (event) => {
+		if (nestedSummaries.restore(event.message)) runtime.repaint();
+	});
 	pi.on("tool_execution_start", (event) => {
-		if (madeByTool(event)) return runtime.noteNestedCall(event.toolCallId, true);
+		if (madeByTool(event)) {
+			runtime.noteNestedCall(event.toolCallId, true);
+			nestedSummaries.note(event, false);
+			return;
+		}
+		nestedSummaries.begin(event.toolCallId, event.toolName);
 		runtime.noteCall(event.toolCallId);
 		runtime.noteExecutionStart(event.toolCallId);
 	});
 	pi.on("tool_execution_end", (event) => {
-		if (madeByTool(event)) return runtime.noteNestedCall(event.toolCallId, false);
+		if (madeByTool(event)) {
+			runtime.noteNestedCall(event.toolCallId, false);
+			if (nestedSummaries.note(event, true)) runtime.repaint();
+			return;
+		}
+		nestedSummaries.finish(event.toolCallId);
 		runtime.noteExecutionEnd(event.toolCallId, (event as { durationMs?: number }).durationMs);
 	});
 	pi.on("session_shutdown", (event) => {
@@ -726,6 +787,7 @@ export default function compactTools(pi: ExtensionAPI): void {
 		unbindRenderer(renderContext);
 		renderContext = undefined;
 		runtime.reset(event.reason !== "reload");
+		if (event.reason !== "reload") nestedSummaries.clear();
 		// A reload that keeps the extension sets it again before Pi rebuilds the transcript.
 		if (legacyResolver) clearRowResolver(legacyResolver);
 		refreshTranscriptRows = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "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.1.0",
-    "@earendil-works/pi-tui": "1.1.0",
+    "@earendil-works/pi-coding-agent": "1.2.0",
+    "@earendil-works/pi-tui": "1.2.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,36 @@
 {
+  "0.16.1": {
+    "New": [
+      "Minimal codemode summaries show each tool once: read 3 · bash 1 · edit 3 2; non-edit tools keep first-call order and edit always comes last",
+      "Plain counts use green for success, red for failure, and yellow for unfinished calls, without zero placeholders, count parentheses, status icons, pipes, or edit diff lists",
+      "Summary names retain their theme title hue at 75% brightness without bold; outcome counts retain their hues at 80% brightness",
+      "Completion duration and output-line metadata is one step brighter; rails, connectors, separators, main tool titles, and code previews are unchanged"
+    ],
+    "Fix": [
+      "Interleaved nested calls aggregate into one group per tool, with success counts before failure counts",
+      "Reloads, resumed sessions, and /tree navigation preserve or restore nested counts and outcomes without retaining tool arguments, results, or edit diff bookkeeping",
+      "Unfinished calls and incomplete records remain visible, including when mixed with settled outcomes"
+    ],
+    "Deprecated": []
+  },
+  "0.16.0": {
+    "New": [
+      "Completed codemode rows summarize nested tool successes and failures beside their duration and output-line count without changing model input",
+      "Reloads retain exact live edit diffs; resumed sessions and /tree branches restore saved per-call outcomes without guessing changes",
+      "Codemode summaries show every edit attempt in order: edit(3) [+10 -3|✗|+5 -7], with no checkmark on successful changes",
+      "Compact, Claude, and Codex show the first three edit attempts when collapsed and every recorded attempt when expanded",
+      "Diff separators are dim and have no surrounding whitespace; additions and removals retain their diff colors"
+    ],
+    "Fix": [
+      "Updated the GitHub Dark theme and theme fixtures to Pi 1.2's published schema; validated both startup and reload resource loading",
+      "Verified on Pi 1.2.0 while preserving the Pi 0.85.1 minimum and the existing 0.15.0 word-diff and platform key-label features",
+      "Per-call edit diffs keep first-call order even when nested calls finish out of order",
+      "Claude and Codex keep codemode output, an indented completion summary without a separate branch marker, and the disclosure in that order",
+      "Failed and unfinished edit attempts remain visible in previews, including omitted-attempt status counts",
+      "A missing successful edit diff shows ok for that call without hiding other calls’ known changes or guessing totals"
+    ],
+    "Deprecated": []
+  },
   "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",

package/themes/github-dark-pro.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "$schema": "https://pi.dev/schemas/theme.schema.json",
   "name": "github-dark-pro",
   "vars": {
     "surfaceMuted": "#21262D",