pi-compact-tools 0.16.0 → 0.16.1

package/README.md

@@ -93,12 +93,12 @@ Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.js
 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]
+Done in 1.234s (42 lines) · read 3 · bash 1 · edit 3 2
 ```
 
-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.
+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 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.
+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
 

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-nested.ts

@@ -1,15 +1,14 @@
-import type { AgentToolResult, Theme } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
 import { stripTerminalSequences } from "@earendil-works/pi-tui";
-import { countEditChanges } from "./compact-tools-invocation.ts";
+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 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 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 };
@@ -78,12 +77,8 @@ export class NestedCallSummaries {
 			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 } : {}) });
+		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;
@@ -95,7 +90,7 @@ export class NestedCallSummaries {
 		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.
+		// 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: {} };
@@ -122,48 +117,45 @@ export class NestedCallSummaries {
 		}
 	}
 
-	/** 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 {
+	/** 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;
-		const groups = new Map<string, { name: string; status: Status; calls: Call[] }>();
+		type Group = { name: string; calls: Call[] };
+		const groups: Group[] = [];
+		const byTool = new Map<string, Group>();
 		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: [] });
+			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 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 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";
-			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(" ");
+
+			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 {

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.ts

@@ -52,7 +52,7 @@ 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";
@@ -190,9 +190,10 @@ function renderControls(
 		? (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) {
@@ -200,7 +201,7 @@ 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})`);
+	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);
 }

package/package.json

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

package/release-notes.json

@@ -1,4 +1,18 @@
 {
+  "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",