pi-compact-tools 0.15.0 → 0.16.0

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) [+10 -3|✗|+5 -7]
+```
+
+Most calls are grouped by tool and outcome, in first-call order. A script that catches a failed call can finish successfully while still showing `✗ bash(1)`. Edits instead use one ordered list with the total attempt count: each successful call shows its actual diff without a checkmark, each failed call shows `✗`, and an unfinished call shows `?`. A successful edit without a saved diff shows `ok`; it does not hide other calls’ known changes. Diff entries use a dim `|` separator with no surrounding whitespace; added and removed counts keep their diff colors. Collapsed rows show the first three edit attempts and `… +N more`; omitted failures or unfinished calls are counted beside that marker so the preview cannot hide them. Expanded rows show every recorded edit attempt. Incomplete records show `(partial)`. Long summaries wrap to the pane width. Previews and author-provided expanded views remain available. Claude and Codex place the `Done` / `Failed` summary after the output, without another branch marker and aligned with the output continuation rows. The disclosure stays last: Claude’s `… +N lines (ctrl+o to expand)` or Codex’s `+ Show details` / `− Show less`. Completion rows do not consume Claude’s output-preview limit.
+
+The summary uses the host’s nested-call events and saved records when available, without changing what the model sees. Exact per-call edit diffs survive an in-process `/reload`. After restarting or resuming, Pi’s saved nested records restore call counts, but do not contain edit result diffs, so edits show per-call statuses such as `edit(3) [ok|✗|ok]` rather than invented changes. `/tree` navigation restores the selected branch’s records. 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-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,177 @@
+import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { countEditChanges } from "./compact-tools-invocation.ts";
+
+const SUMMARY_KEY = Symbol.for("pi-compact-tools.nested-summaries.v1");
+const MAX_PARENTS = 2_000;
+const MAX_CALLS = 256;
+const EDIT_PREVIEW_CALLS = 3;
+const MAX_NAME_LENGTH = 256;
+const MAX_ID_LENGTH = 1_024;
+type Status = "ok" | "error" | "unfinished";
+type Call = { name: string; status: Status; changes?: { added: number; removed: number } };
+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";
+		const result = event.result;
+		const changes = status === "ok" && event.toolName === "edit" && result && typeof result === "object"
+			? countEditChanges(result as AgentToolResult<unknown>) : undefined;
+		if (previous?.name === event.toolName && previous.status === status
+			&& previous.changes?.added === changes?.added && previous.changes?.removed === changes?.removed) return false;
+		summary.calls.set(event.toolCallId, { name: event.toolName, status, ...(changes ? { changes } : {}) });
+		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 overwrite exact live edit totals or drop observed 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);
+		}
+	}
+
+	/** Most tools group by outcome; edits keep every call's status and diff in start order. */
+	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;
+		const groups = new Map<string, { name: string; status: Status; calls: Call[] }>();
+		for (const call of summary.calls.values()) {
+			const key = JSON.stringify([call.name, call.name === "edit" ? "all" : call.status]);
+			let group = groups.get(key);
+			if (!group) groups.set(key, group = { name: call.name, status: call.status, calls: [] });
+			group.calls.push(call);
+		}
+		const parts: string[] = [];
+		for (const group of groups.values()) {
+			const color = group.status === "ok" ? "success" : group.status === "error" ? "error" : "warning";
+			const glyph = group.status === "ok" ? "✓" : group.status === "error" ? "✗" : "?";
+			const name = stripTerminalSequences(group.name).replace(/[\x00-\x20\x7f-\x9f]/gu, " ").replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff]/gu, "").trim() || "tool";
+			if (group.name === "edit") {
+				// Include failures and unfinished calls in the same ordered list. A
+				// missing successful diff loses only its numbers, not other calls' diffs.
+				const shown = expanded ? group.calls : group.calls.slice(0, EDIT_PREVIEW_CALLS);
+				const entries = shown.map((call) => {
+					if (call.status === "error") return theme.fg("error", "✗");
+					if (call.status === "unfinished") return theme.fg("warning", "?");
+					return call.changes
+						? theme.fg("toolDiffAdded", `+${call.changes.added}`) + " " + theme.fg("toolDiffRemoved", `-${call.changes.removed}`)
+						: theme.fg("dim", "ok");
+				});
+				const hidden = group.calls.slice(shown.length);
+				if (hidden.length > 0) {
+					// The preview must not hide that an omitted edit failed or is unfinished.
+					const failed = hidden.filter((call) => call.status === "error").length;
+					const unfinished = hidden.filter((call) => call.status === "unfinished").length;
+					let more = theme.fg("dim", `… +${hidden.length} more`);
+					const statuses = [failed ? theme.fg("error", `${failed} failed`) : "", unfinished ? theme.fg("warning", `${unfinished} unfinished`) : ""].filter(Boolean);
+					if (statuses.length > 0) more += " (" + statuses.join(", ") + ")";
+					entries.push(more);
+				}
+				parts.push(`${name}(${group.calls.length}) [` + entries.join(theme.fg("dim", "|")) + "]");
+			} else parts.push(theme.fg(color, glyph) + ` ${name}(${group.calls.length})`);
+		}
+		if (summary.partial || [...summary.calls.values()].some((call) => call.status === "unfinished")) parts.push(theme.fg("warning", "(partial)"));
+		return parts.join(" ");
+	}
+
+	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-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,7 +48,8 @@ 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";
@@ -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,6 +181,9 @@ 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
@@ -196,7 +201,8 @@ function renderControls(
 	}
 	// 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(" └ "), "   ");
+	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 +312,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 +369,7 @@ function renderClaudeResult(
 	expanded: boolean,
 	output: string,
 	author: AuthorResultRenderer | undefined,
+	completion?: Component,
 ): Component {
 	const chrome = chromePainter(theme);
 	const container = new CachedContainer();
@@ -378,11 +385,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 +400,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 +418,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 +427,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 +459,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 +704,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 +742,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 +786,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.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.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,22 @@
 {
+  "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",