pi-compact-tools 0.6.1 → 0.7.7

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Dong Hyeong Lee
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Dong Hyeong Lee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -6,7 +6,7 @@ Compact, expandable rendering for Pi's built-in tools, with a polished GitHub Da
 
 ## Demo
 
-The recordings below use the optional [Nerd Font](#nerd-font-spinner-preset) spinner preset. **The default configuration does not require a Nerd Font**.
+The UI uses portable Unicode symbols and does not require a Nerd Font.
 
 ### Compact tool workflow
 
@@ -14,32 +14,34 @@ Active, successful, and failed tool calls stay compact while preserving useful s
 
 ![Compact tool workflow with Nerd Font](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/nerd-font-workflow-optimized.gif)
 
-### Spinner and duration display
+### Progress and duration display
 
-The spinner animates during execution, then returns to a green success circle or red failure circle. Elapsed time remains visible in the neutral control color.
+The working label above the prompt uses the Thinking summary color with a soft white light sweep. Every tool state uses the same `⦁` glyph; running tools use a fourteen-frame cosine-eased RGB pulse between dim and bright gray, then settle to green on success or red on failure. Elapsed time remains visible in the neutral control color.
 
 ![Spinner and elapsed-time display](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/spinner-duration-optimized.gif)
 
-### Initially visible edit diffs
+### Bounded result previews
 
-Completed `edit` rows show their full diff initially by default. The per-tool `auto_compact` setting controls which tools start with their result hidden without disabling click or `Ctrl+O` interaction.
+Completed `edit` rows show only the lines actually removed (`-`) or added (`+`), without unchanged context, hunk metadata, or success prose. The per-tool `auto_compact` setting chooses between hidden results and a bounded preview; click or `Ctrl+O` uses Pi's normal expansion flow to reveal all changed lines.
 
 ![Edit diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
 
 ## Features
 
 - Compact rendering for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`
-- Animated configurable spinner in fullscreen TUI mode
-- Four-step `Ctrl+T` thinking cycle: summary, detail, summary, then hidden
-- Millisecond-precision duration with neutral status text
-- Per-tool initial compaction and global-toggle participation with `auto_compact: true` or `false`
-- Tool invocation details are always fully visible
-- Click toggles one result between hidden and fully visible; `Ctrl+O` toggles all participating rows
-- Full output on expansion and initially visible edit diffs by default
-- Width-cached expanded results and edit-diff processing for responsive fullscreen scrolling
+- One continuously glowing working label above the input prompt across thinking and tool execution
+- Semantic built-in progress labels and automatically cleaned custom/MCP tool names without exposing invocation arguments
+- Four-step `Ctrl+T` thinking cycle when provider detail is available: summary, detail, summary, then hidden
+- Millisecond-precision duration and completed output line counts with neutral status text
+- Per-tool hidden or persistent bounded-preview collapsed state with `auto_compact: true` or `false`
+- Primary invocation targets such as paths and patterns stay visible; collapsed shell calls show concise intent summaries
+- Click and `Ctrl+O` follow Pi's built-in expansion state while preview rows collapse back to their preview
+- Edit patches display only removed (`-`) and added (`+`) lines, omitting unchanged context
+- Configurable `previewLines` prevents large diffs, HTML, and shell output from flooding the transcript
+- Width-cached expanded results, edit-diff processing, and unchanged result reuse during status animation
 - Dark `│` and `└─` visual grouping
 - Distinct cool-blue thinking text
-- Windows, Unix, and classic Mac line-ending support
+- Truecolor and 256-color terminal support, plus Windows, Unix, and classic Mac line endings
 - No Nerd Font requirement
 
 ## Install
@@ -83,30 +85,25 @@ Default configuration:
 {
   "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json",
   "tools": ["read", "write", "edit", "bash"],
+  "previewLines": 10,
   "auto_compact": {
     "read": true,
     "write": true,
     "edit": false,
     "bash": true
-  },
-  "spinner": {
-    "frames": ["◐", "◓", "◑", "◒"],
-    "intervalMs": 120
   }
 }
 ```
 
-Successful call titles use a green `●`, while failed call titles use a red `●`. `Done`, `Failed`, and elapsed time use the same neutral control color. Fast tools finish immediately; no artificial spinner delay is added.
+Every tool call title uses `⦁`. Pending calls use dark gray; active calls smoothly pulse through fourteen cosine-eased RGB frames at a 45 ms interval without disappearing. Animation starts while arguments stream, so `write` and `edit` remain visibly active before their filesystem operation begins. Successful titles use green, and failed titles use red. `Done`, `Failed`, elapsed time, and line counts use the same neutral control color without printing inline click or keyboard hints. A single Pi working label animates independently of token arrival and reports `Thinking…`, `Responding…`, semantic built-in states such as `Reading file…`, or cleaned custom states such as `Using jira search…`. Invocation arguments remain in the tool row instead of being duplicated above the prompt. No separate spinner glyph is shown above the prompt.
 
-For a minimal blinking spinner, copy [`examples/compact-tools-2.json`](examples/compact-tools-2.json). Its frames use `● ● (blank) ● ●` at 120 ms intervals. The renderer's built-in frame dimming turns this into a fade-out/fade-in animation. Rename it to `compact-tools.json` or copy its contents to the active configuration path.
+`auto_compact` controls each tool's initial result state:
 
-`auto_compact` controls each tool's initial state and whether it participates in the global `Ctrl+O` toggle:
+- `true` starts with the result hidden.
+- `false` starts with at most `previewLines` rendered rows visible.
+- Clicking or pressing `Ctrl+O` expands the complete result through Pi's built-in expansion state.
 
-- `true` starts with the result hidden and participates in `Ctrl+O`.
-- `false` starts with the full result visible and is unaffected by `Ctrl+O`.
-- Clicking any compact-rendered row still toggles that row's result.
-
-Unspecified entries inherit the previous configuration layer. By default, `read`, `write`, and `bash` start compact and participate in the global toggle, while `edit` starts expanded and remains unaffected so code diffs stay visible.
+`previewLines` accepts `1`–`100` and defaults to `10`. It limits the collapsed preview; the complete result remains available. Unspecified entries inherit the previous configuration layer. By default, `read`, `write`, and `bash` start hidden, while `edit` starts with a short changed-lines preview.
 
 To enable all Unix-compatible tools:
 
@@ -118,23 +115,6 @@ To enable all Unix-compatible tools:
 
 Add `"powershell"` on Windows if desired.
 
-## Nerd Font spinner preset
-
-If your terminal uses a [Nerd Font](https://www.nerdfonts.com/), this preset enables all eight tools and the spinner shown in the demos:
-
-```json
-{
-  "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json",
-  "tools": ["read", "write", "edit", "bash", "powershell", "grep", "find", "ls"],
-  "spinner": {
-    "frames": ["✽", "✻", "✲", "✢", "✲", "✻"],
-    "intervalMs": 80
-  }
-}
-```
-
-Remove `"powershell"` on systems where it is unavailable.
-
 ## Controls
 
 `Ctrl+T` cycles every thinking block through:
@@ -143,30 +123,18 @@ Remove `"powershell"` on systems where it is unavailable.
 one-line summary → summary + │-indented detail → one-line summary → Thinking...
 ```
 
-Standalone bold lines and Markdown headings split one provider thinking run into logical sections. Each section gets its own summary, optional `│`-indented detail, and control row; `Ctrl+T` cycles all sections together. While thinking streams, a text-color highlight sweeps across summaries using streaming updates; no spinner glyph or title circle is shown. The transformation is display-only; complete thinking remains unchanged in the session and model context.
-
-Relevant invocation details stay visible, including paths, patterns, shell commands, and auxiliary arguments. After `grep`, `find`, or `ls` completes, auxiliary arguments appear in parentheses beside the `Done in …s` status instead of in the invocation line or a JSON block. Read calls omit offset and limit noise, then report the number of lines read after completion. Large payloads represented as results, such as write content and edit diffs, follow the result toggle.
-
-A mouse click toggles one row's result:
-
-```text
-result hidden ↔ full result
-```
-
-`Ctrl+O` operates on all rows whose tool has `auto_compact: true`:
+Standalone bold lines and Markdown headings split one provider thinking run into logical sections. Each section gets its own summary and optional `│`-indented detail. Summary-only views stay uncluttered with no control hint; the control row appears only while provider-supplied detail is visible. When no thinking detail exists, `Ctrl+T` falls back to Pi's normal visible/hidden toggle instead of showing a duplicate detail phase. While thinking streams, a slightly faster highlight sweeps from the Thinking summary color to white across Pi's working label at a steady interval rather than depending on token updates. The transcript summary remains visually stable. The transformation is display-only; complete thinking remains unchanged in the session and model context.
 
-- If any participating row is not fully expanded, it expands all participating rows.
-- If every participating row is fully expanded, it collapses all participating rows.
-- Rows whose tool has `auto_compact: false` are left unchanged.
+Primary file and search targets stay visible. Collapsed `bash` and `powershell` rows describe intent—such as `Run tests`, `Check repository status`, or `Search text`—without printing arguments; expanding the row reveals the exact command. After every supported tool completes, the status reports the expanded result size as `Done in …s (N lines)` instead of repeating options such as context and limit. Counts use the returned text for reads, searches, listings, and shell commands, written content for `write`, and only the displayed `-`/`+` lines for `edit`. The count is computed once after completion and cached with the row, so streaming and repeated expansion do not add ongoing work. Large payloads represented as results follow the result toggle.
 
-The extension handles and consumes `Ctrl+O` directly, so no Pi keybinding changes are required. With the default `edit: false`, edit diffs start visible and are excluded from the global toggle, while clicking an edit row still collapses or expands it.
+A mouse click toggles one row using Pi's native result state. `Ctrl+O` remains owned by Pi and expands or collapses all tool rows consistently, including tools not rendered by this extension. A row with `auto_compact: false` cycles predictably between its bounded preview and the complete result, so repeated clicks never remove the row and fall through to a neighboring Thinking block. The extension does not intercept the global keybinding.
 
 ## Notes
 
-- Pi `0.85.1+` and Node.js 20+ are recommended.
-- Fullscreen TUI mode is required for spinner animation and mouse interaction; `Ctrl+O` also works in regular mode.
+- Pi `0.85.1+` and Node.js `22.19.0+` are recommended.
+- The working indicator and mouse interaction are provided by Pi's TUI; `Ctrl+O` also works in regular mode.
 - Duration covers the full rendered tool-call lifecycle, including streamed `write` and `edit` arguments.
-- Selected tools override Pi's built-in definitions; other extensions overriding the same names may conflict by load order.
+- Selected tools override definitions with the same names so their compact renderers are restored reliably after `/reload`; other extensions overriding those tools may conflict by load order.
 
 ## Development
 

package/examples/compact-tools-2.json

@@ -1,14 +1,11 @@
 {
   "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json",
   "tools": ["read", "write", "edit", "bash"],
+  "previewLines": 10,
   "auto_compact": {
     "read": true,
     "write": true,
     "edit": false,
     "bash": true
-  },
-  "spinner": {
-    "frames": ["●", "●", " ", "●", "●"],
-    "intervalMs": 120
   }
 }

package/examples/compact-tools.json

@@ -1,14 +1,11 @@
 {
   "$schema": "https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/schemas/compact-tools.schema.json",
   "tools": ["read", "write", "edit", "bash", "grep", "find", "ls"],
+  "previewLines": 10,
   "auto_compact": {
     "read": true,
     "write": true,
     "edit": false,
     "bash": true
-  },
-  "spinner": {
-    "frames": ["◐", "◓", "◑", "◒"],
-    "intervalMs": 120
   }
 }

package/extensions/compact-tools-color.ts

@@ -0,0 +1,65 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+
+export type Rgb = { r: number; g: number; b: number };
+type ThemeForeground = Parameters<Theme["getFgAnsi"]>[0];
+
+const ANSI_BASIC_RGB: readonly Rgb[] = [
+	{ r: 0, g: 0, b: 0 }, { r: 128, g: 0, b: 0 }, { r: 0, g: 128, b: 0 }, { r: 128, g: 128, b: 0 },
+	{ r: 0, g: 0, b: 128 }, { r: 128, g: 0, b: 128 }, { r: 0, g: 128, b: 128 }, { r: 192, g: 192, b: 192 },
+	{ r: 128, g: 128, b: 128 }, { r: 255, g: 0, b: 0 }, { r: 0, g: 255, b: 0 }, { r: 255, g: 255, b: 0 },
+	{ r: 0, g: 0, b: 255 }, { r: 255, g: 0, b: 255 }, { r: 0, g: 255, b: 255 }, { r: 255, g: 255, b: 255 },
+];
+
+function ansi256ToRgb(index: number): Rgb {
+	if (index < 16) return ANSI_BASIC_RGB[index] ?? { r: 192, g: 192, b: 192 };
+	if (index < 232) {
+		const value = index - 16;
+		const channel = (part: number) => part === 0 ? 0 : 55 + part * 40;
+		return {
+			r: channel(Math.floor(value / 36)),
+			g: channel(Math.floor((value % 36) / 6)),
+			b: channel(value % 6),
+		};
+	}
+	const gray = 8 + Math.min(23, index - 232) * 10;
+	return { r: gray, g: gray, b: gray };
+}
+
+function rgbToAnsi256(rgb: Rgb): number {
+	let bestIndex = 0;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (let index = 0; index < 256; index++) {
+		const candidate = ansi256ToRgb(index);
+		const distance = (rgb.r - candidate.r) ** 2 + (rgb.g - candidate.g) ** 2 + (rgb.b - candidate.b) ** 2;
+		if (distance >= bestDistance) continue;
+		bestIndex = index;
+		bestDistance = distance;
+	}
+	return bestIndex;
+}
+
+export function themeColorRgb(theme: Theme, color: ThemeForeground): Rgb | undefined {
+	if (typeof theme.getFgAnsi !== "function") return undefined;
+	const ansi = theme.getFgAnsi(color);
+	const trueColor = ansi.match(/\[38;2;(\d+);(\d+);(\d+)m/u);
+	if (trueColor) return { r: Number(trueColor[1]), g: Number(trueColor[2]), b: Number(trueColor[3]) };
+	const indexed = ansi.match(/\[38;5;(\d+)m/u);
+	return indexed ? ansi256ToRgb(Number(indexed[1])) : undefined;
+}
+
+export function interpolateRgb(from: Rgb, to: Rgb, amount: number): Rgb {
+	const bounded = Math.max(0, Math.min(1, amount));
+	const channel = (start: number, end: number) => Math.round(start + (end - start) * bounded);
+	return {
+		r: channel(from.r, to.r),
+		g: channel(from.g, to.g),
+		b: channel(from.b, to.b),
+	};
+}
+
+export function colorizeRgb(theme: Theme, color: Rgb, text: string): string {
+	if (typeof theme.getColorMode === "function" && theme.getColorMode() === "256color") {
+		return `\x1b[38;5;${rgbToAnsi256(color)}m${text}\x1b[39m`;
+	}
+	return `\x1b[38;2;${color.r};${color.g};${color.b}m${text}\x1b[39m`;
+}

package/extensions/compact-tools-config.ts

@@ -12,6 +12,7 @@ type JsonObject = Record<string, unknown>;
 
 export const DEFAULT_CONFIG: CompactToolsConfig = {
 	tools: ["read", "write", "edit", "bash"],
+	previewLines: 10,
 	auto_compact: {
 		read: true,
 		write: true,
@@ -22,10 +23,6 @@ export const DEFAULT_CONFIG: CompactToolsConfig = {
 		find: true,
 		ls: true,
 	},
-	spinner: {
-		frames: ["◐", "◓", "◑", "◒"],
-		intervalMs: 120,
-	},
 };
 
 function isObject(value: unknown): value is JsonObject {
@@ -40,10 +37,6 @@ function isIntegerInRange(value: unknown, minimum: number, maximum: number): val
 	return typeof value === "number" && Number.isInteger(value) && value >= minimum && value <= maximum;
 }
 
-function isNonEmptyStringArray(value: unknown): value is string[] {
-	return Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0);
-}
-
 function parseTools(value: unknown, path: string): CompactToolName[] | undefined {
 	if (!Array.isArray(value)) {
 		warn(path, "tools must be an array; using previous values");
@@ -82,28 +75,6 @@ function parseAutoCompact(
 	return result;
 }
 
-function parseSpinner(
-	base: CompactToolsConfig["spinner"],
-	value: unknown,
-	path: string,
-): CompactToolsConfig["spinner"] {
-	if (value === undefined) return base;
-	if (!isObject(value)) {
-		warn(path, "spinner must be an object; using previous values");
-		return base;
-	}
-	const frames = value.frames;
-	const intervalMs = value.intervalMs;
-	const validFrames = isNonEmptyStringArray(frames);
-	const validInterval = isIntegerInRange(intervalMs, 40, 5_000);
-	if (frames !== undefined && !validFrames) warn(path, "spinner.frames must be a non-empty string array");
-	if (intervalMs !== undefined && !validInterval) warn(path, "spinner.intervalMs must be 40–5000");
-	return {
-		frames: validFrames ? frames : base.frames,
-		intervalMs: validInterval ? intervalMs : base.intervalMs,
-	};
-}
-
 export function mergeConfig(base: CompactToolsConfig, value: unknown, path: string): CompactToolsConfig {
 	if (value === undefined) return base;
 	if (!isObject(value)) {
@@ -112,8 +83,12 @@ export function mergeConfig(base: CompactToolsConfig, value: unknown, path: stri
 	}
 	const tools = value.tools === undefined ? base.tools : (parseTools(value.tools, path) ?? base.tools);
 	const auto_compact = parseAutoCompact(base.auto_compact, value.auto_compact, path);
-	const spinner = parseSpinner(base.spinner, value.spinner, path);
-	return { tools, auto_compact, spinner };
+	const previewLines = value.previewLines === undefined ? base.previewLines
+		: isIntegerInRange(value.previewLines, 1, 100) ? value.previewLines : base.previewLines;
+	if (value.previewLines !== undefined && !isIntegerInRange(value.previewLines, 1, 100)) {
+		warn(path, "previewLines must be 1–100; using previous value");
+	}
+	return { tools, auto_compact, previewLines };
 }
 
 function readJson(path: string): unknown {
@@ -133,13 +108,3 @@ export function loadConfig(cwd?: string, projectTrusted = false): CompactToolsCo
 	const projectPath = join(cwd, CONFIG_DIR_NAME, CONFIG_FILE);
 	return mergeConfig(globalConfig, readJson(projectPath), projectPath);
 }
-
-export function isFullscreenMode(argv = process.argv): boolean {
-	for (let index = 0; index < argv.length; index++) {
-		const argument = argv[index];
-		if (argument === "--tui-mode") return argv[index + 1] === "fullscreen";
-		if (argument?.startsWith("--tui-mode=")) return argument.slice("--tui-mode=".length) === "fullscreen";
-	}
-	const settings = readJson(join(getAgentDir(), "settings.json"));
-	return isObject(settings) && settings.tuiMode === "fullscreen";
-}

package/extensions/compact-tools-core.ts

@@ -2,6 +2,32 @@
 
 export type RowStatus = "pending" | "running" | "success" | "error";
 
+export type IndicatorTone = "borderAccent" | "border" | "borderMuted" | "success" | "error";
+
+export const RUNNING_INDICATOR_FRAME_COUNT = 14;
+const RUNNING_INDICATOR_MIN_STRENGTH = 0.08;
+
+export function indicatorStrength(status: RowStatus, frame = 0): number {
+	if (status !== "running") return 1;
+	const normalizedFrame = ((frame % RUNNING_INDICATOR_FRAME_COUNT) + RUNNING_INDICATOR_FRAME_COUNT)
+		% RUNNING_INDICATOR_FRAME_COUNT;
+	const wave = (Math.cos((normalizedFrame / RUNNING_INDICATOR_FRAME_COUNT) * Math.PI * 2) + 1) / 2;
+	return RUNNING_INDICATOR_MIN_STRENGTH + (1 - RUNNING_INDICATOR_MIN_STRENGTH) * wave;
+}
+
+/** Semantic fallback for themes whose foreground RGB values cannot be resolved. */
+export function indicatorTone(status: RowStatus, frame = 0): IndicatorTone {
+	if (status === "success") return "success";
+	if (status === "error") return "error";
+	if (status === "pending") return "borderAccent";
+	const strength = indicatorStrength(status, frame);
+	return strength >= 0.7 ? "borderAccent" : strength >= 0.35 ? "border" : "borderMuted";
+}
+
+export function indicatorGlyph(_status: RowStatus, _frame = 0): string {
+	return "⦁";
+}
+
 export function normalizeLineEndings(value: string): string {
 	return value.replace(/\r\n?|\n/g, "\n");
 }

package/extensions/compact-tools-invocation.ts

@@ -24,24 +24,6 @@ function collectArgumentDetails(name: string, args: ToolArgs): ToolArgs {
 	return details;
 }
 
-function formatInlineValue(value: unknown): string {
-	if (typeof value === "string") {
-		const compact = normalizeLineEndings(value).replace(/\s+/gu, " ").trim();
-		return compact || '""';
-	}
-	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-		return String(value);
-	}
-	return JSON.stringify(value) ?? String(value);
-}
-
-export function formatArgumentSummary(name: string, args: ToolArgs): string | undefined {
-	if (!INLINE_ARGUMENT_TOOLS.has(name)) return undefined;
-	const arguments_ = Object.entries(collectArgumentDetails(name, args));
-	if (arguments_.length === 0) return undefined;
-	return arguments_.map(([key, value]) => `${key} ${formatInlineValue(value)}`).join(" · ");
-}
-
 export function getCallDetails(name: string, args: ToolArgs): string {
 	const path = pathFrom(args) || (INLINE_ARGUMENT_TOOLS.has(name) ? "." : "");
 	if (name === "read") return path;
@@ -55,6 +37,106 @@ export function getArgumentDetails(name: string, args: ToolArgs): ToolArgs {
 	return collectArgumentDetails(name, args);
 }
 
+function shellSegments(command: string): string[] {
+	const segments: string[] = [];
+	let current = "";
+	let quote: "'" | '"' | "`" | undefined;
+	let escaped = false;
+	for (let index = 0; index < command.length; index++) {
+		const character = command[index]!;
+		if (escaped) {
+			current += character;
+			escaped = false;
+			continue;
+		}
+		if (character === "\\" && quote !== "'") {
+			current += character;
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			current += character;
+			if (character === quote) quote = undefined;
+			continue;
+		}
+		if (character === "'" || character === '"' || character === "`") {
+			quote = character;
+			current += character;
+			continue;
+		}
+		const pair = command.slice(index, index + 2);
+		if (character === "\n" || character === ";" || pair === "&&" || pair === "||") {
+			if (current.trim()) segments.push(current.trim());
+			current = "";
+			if (pair === "&&" || pair === "||") index++;
+			continue;
+		}
+		current += character;
+	}
+	if (current.trim()) segments.push(current.trim());
+	return segments;
+}
+
+function unquote(value: string): string {
+	return value.replace(/^["']|["']$/gu, "");
+}
+
+/** A calm collapsed label that describes intent without exposing command arguments. */
+export function summarizeShellCommand(name: string, command: string): string {
+	const allSegments = shellSegments(normalizeLineEndings(command));
+	const segments = allSegments.filter((segment) => !/^\s*(?:cd|pushd|popd)\b/iu.test(segment));
+	const primary = segments[0] ?? allSegments[0] ?? "";
+	if (!primary) return name === "powershell" ? "Prepare PowerShell command" : "Prepare shell command";
+
+	const words = primary.trim().split(/\s+/u).map(unquote);
+	while (words.length > 0) {
+		if (/^[A-Za-z_][A-Za-z\d_]*=.*/u.test(words[0] ?? "")
+			|| ["command", "env", "sudo", "time"].includes((words[0] ?? "").toLowerCase())) {
+			words.shift();
+			continue;
+		}
+		break;
+	}
+	const executable = (words[0] ?? "").replace(/^.*[\\/]/u, "").replace(/\.(?:cmd|exe|ps1)$/iu, "").toLowerCase();
+	const action = (words[1] ?? "").toLowerCase();
+	const subject = words[2] ?? "";
+
+	let summary: string;
+	if (["npm", "pnpm", "yarn", "bun"].includes(executable) && action === "run" && subject) {
+		summary = `Run ${subject} task`;
+	} else if (["npm", "pnpm", "yarn", "bun"].includes(executable) && ["test", "check"].includes(action)) {
+		summary = action === "test" ? "Run tests" : "Run project checks";
+	} else if (["npm", "pnpm", "yarn", "bun"].includes(executable) && ["install", "i", "ci"].includes(action)) {
+		summary = "Install dependencies";
+	} else if (executable === "git" && action === "status") {
+		summary = "Check repository status";
+	} else if (executable === "git" && action === "diff") {
+		summary = "Review repository changes";
+	} else if (executable === "git" && action === "log") {
+		summary = "Review commit history";
+	} else if (executable === "git" && ["fetch", "pull", "push", "clone"].includes(action)) {
+		summary = `${action[0]!.toUpperCase()}${action.slice(1)} repository`;
+	} else if (["rg", "grep", "select-string"].includes(executable)) {
+		summary = "Search text";
+	} else if (["find", "fd", "get-childitem", "ls", "dir"].includes(executable)) {
+		summary = executable === "ls" || executable === "dir" || executable === "get-childitem" ? "List files" : "Find files";
+	} else if (["cat", "type", "get-content"].includes(executable)) {
+		summary = "Read file content";
+	} else if (["tsc", "mypy", "pyright"].includes(executable)) {
+		summary = "Check types";
+	} else if (["jest", "vitest", "pytest", "invoke-pester"].includes(executable)) {
+		summary = "Run tests";
+	} else if (executable) {
+		const display = executable.replace(/[-_]+/gu, " ");
+		summary = `Run ${display}`;
+	} else {
+		summary = name === "powershell" ? "Run PowerShell command" : "Run shell command";
+	}
+
+	const remainingSteps = Math.max(0, segments.length - 1);
+	return remainingSteps > 0 ? `${summary} + ${remainingSteps} more ${remainingSteps === 1 ? "step" : "steps"}` : summary;
+}
+
 export function getTextResult(result: AgentToolResult<unknown>): string {
 	const parts: string[] = [];
 	for (const item of result.content) {
@@ -63,20 +145,73 @@ export function getTextResult(result: AgentToolResult<unknown>): string {
 	return normalizeLineEndings(parts.join("\n")).trimEnd();
 }
 
-export function formatReadResultSummary(result: AgentToolResult<unknown>): string | undefined {
-	if (!result.content.some((item) => item.type === "text")) return undefined;
-	const truncation = (result.details as {
-		truncation?: { firstLineExceedsLimit?: boolean; outputLines?: number };
-	} | undefined)?.truncation;
-	if (truncation?.firstLineExceedsLimit) return undefined;
-	let lineCount = truncation?.outputLines;
-	if (!Number.isInteger(lineCount) || lineCount === undefined || lineCount < 0) {
-		const content = getTextResult(result).replace(
-			/\n\n\[(?:Showing lines |\d+ more lines in file\.)[^\n]*\]$/u,
-			"",
-		);
-		lineCount = content.length === 0 ? 0 : content.split("\n").length;
+type ResultDetails = {
+	diff?: unknown;
+	truncation?: {
+		firstLineExceedsLimit?: boolean;
+		outputLines?: number;
+	};
+	matchLimitReached?: unknown;
+	resultLimitReached?: unknown;
+	entryLimitReached?: unknown;
+	linesTruncated?: unknown;
+};
+
+function countTextLines(text: string): number {
+	const normalized = normalizeLineEndings(text).trimEnd();
+	if (!normalized) return 0;
+	let count = 1;
+	for (let index = 0; index < normalized.length; index++) {
+		if (normalized.charCodeAt(index) === 10) count++;
+	}
+	return count;
+}
+
+/** Keep only the lines that the edit actually removed or added; discard context and ellipses. */
+export function getEditChanges(result: AgentToolResult<unknown>): string {
+	const diff = (result.details as ResultDetails | undefined)?.diff;
+	if (typeof diff !== "string") return "";
+	return normalizeLineEndings(diff)
+		.split("\n")
+		.filter((line) => line.startsWith("-") || line.startsWith("+"))
+		.join("\n")
+		.trimEnd();
+}
+
+function stripGeneratedFooter(name: string, text: string, details: ResultDetails | undefined): string {
+	if (name === "read") {
+		return text.replace(/\n\n\[(?:Showing lines |\d+ more lines in file\.)[^\n]*\]$/u, "");
 	}
+	const hasGeneratedFooter = details?.truncation?.outputLines !== undefined
+		|| details?.matchLimitReached !== undefined
+		|| details?.resultLimitReached !== undefined
+		|| details?.entryLimitReached !== undefined
+		|| details?.linesTruncated !== undefined;
+	return hasGeneratedFooter ? text.replace(/\n\n\[[^\n]*\]$/u, "") : text;
+}
+
+export function formatResultLineSummary(
+	name: string,
+	args: ToolArgs,
+	result: AgentToolResult<unknown>,
+	output?: string,
+): string | undefined {
+	const details = result.details as ResultDetails | undefined;
+	const text = name === "edit"
+		? getEditChanges(result)
+		: output ?? (name === "write"
+			? String(args.content ?? "")
+			: result.content.some((item) => item.type === "text")
+				? getTextResult(result)
+				: undefined);
+	if (text === undefined) return undefined;
+	const truncationLines = details?.truncation?.outputLines;
+	const lineCount = !details?.truncation?.firstLineExceedsLimit
+		&& typeof truncationLines === "number"
+		&& Number.isInteger(truncationLines)
+		&& truncationLines >= 0
+		? truncationLines
+		: countTextLines(stripGeneratedFooter(name, text, details));
 	return `${lineCount} ${lineCount === 1 ? "line" : "lines"}`;
 }