@quandev104/pi-style 0.1.4 → 0.1.6

package/extension-src/pi-style/features/tools/bash-execution.ts

@@ -0,0 +1,112 @@
+// Boxed presentation for Pi's native direct bash execution (`!command` /
+// `!!command` prefix in the input box). The native BashExecutionComponent draws
+// plain full-width top/bottom bars; a fingerprint-certified additive render
+// patch (see pi/compatibility-probe.ts) installs an own `render` on the
+// prototype that re-frames the output into the same rounded box used by the
+// boxed tool presentation: `╭─ ➔ Bash ◌ ─╮`, boxed `$ command` + output body,
+// `╰─ Exit 0 ─╯`.
+//
+// The renderer is a pure delegate: it falls back to the native (inherited
+// Container) rendering whenever the theme cache is empty or the component
+// shape is unsupported. Nothing about the native instance is mutated — the
+// box is computed per render from the live component state.
+
+import type { BoxTheme } from "../../shared/box.js";
+import {
+	boxBlankLine,
+	boxInnerWidth,
+	boxLabeledBorder,
+	boxLine,
+	boxWidth,
+	formatBoxedRunningStatus,
+} from "../../shared/box.js";
+import { getThemeExtra } from "../../shared/theme-extras.js";
+
+let cachedTheme: BoxTheme | undefined;
+
+/** Provide the active theme for the boxed bash execution display (session start / theme change). */
+export function setBashExecutionTheme(theme: BoxTheme | undefined): void {
+	cachedTheme = theme;
+}
+
+/** Structural view of the native BashExecutionComponent as used by the patch. */
+interface BashExecutionInstance {
+	command: string;
+	status: "running" | "cancelled" | "error" | "complete";
+	exitCode?: number | null;
+	contentContainer: { render(width: number): string[] };
+	/** Wall-clock start captured on the first boxed render for the live `◌ Running · Ns` footer. */
+	piStyleStart?: number;
+}
+
+const TOP_LEFT = "╭";
+const TOP_RIGHT = "╮";
+const BOTTOM_LEFT = "╰";
+const BOTTOM_RIGHT = "╯";
+
+function bashTitleColor(theme: BoxTheme): string {
+	// Honors the `bashPromptColor` theme extra, falling back to the bashMode
+	// semantic color (the same source the boxed bash tool title uses).
+	const extra = getThemeExtra(theme, "bashPromptColor");
+	return extra || "bashMode";
+}
+
+function boldOf(theme: BoxTheme): (text: string) => string {
+	return typeof theme?.bold === "function" ? theme.bold : (text: string) => text;
+}
+
+/** `➔ Bash ◌/✓/✗` — the same title language as the boxed bash tool call. */
+function bashBoxTitle(theme: BoxTheme, host: BashExecutionInstance): string {
+	const name = "Bash";
+	const bold = boldOf(theme);
+	const prefix = theme.fg(bashTitleColor(theme), `➔ ${name}`);
+	if (host.status === "running") return bold(`${prefix} ${theme.fg("text", "◌")}`);
+	if (host.status === "cancelled") return bold(theme.fg("warning", `➔ ${name} ✗`));
+	if (host.status === "error") return bold(theme.fg("error", `➔ ${name} ✗`));
+	return bold(`${prefix} ${theme.fg("success", "✓")}`);
+}
+
+/** Bottom-border label: live running status with elapsed, or the terminal state. */
+function bashBoxFooter(theme: BoxTheme, host: BashExecutionInstance): string {
+	if (host.status === "running") {
+		const elapsed = typeof host.piStyleStart === "number" ? (Date.now() - host.piStyleStart) / 1000 : undefined;
+		return formatBoxedRunningStatus(theme, elapsed);
+	}
+	if (host.status === "cancelled") return theme.fg("warning", "Cancelled");
+	if (host.status === "error") return theme.fg("error", `Exit ${host.exitCode ?? "?"}`);
+	return theme.fg("text", "Exit 0");
+}
+
+/**
+ * Render a BashExecutionComponent as the rounded box. Returns undefined so the
+ * caller falls back to the native rendering whenever the theme is unavailable
+ * or the component shape is not the certified layout.
+ */
+export function renderBashExecutionBox(instance: unknown, args: unknown[]): string[] | undefined {
+	const theme = cachedTheme;
+	const width = args[0];
+	if (!theme || typeof width !== "number" || !Number.isFinite(width) || width <= 0) return undefined;
+	const host = instance as BashExecutionInstance;
+	const content = host.contentContainer;
+	if (!content || typeof content.render !== "function") return undefined;
+	try {
+		if (host.piStyleStart === undefined) host.piStyleStart = Date.now();
+		const renderedWidth = boxWidth(width);
+		const inner = boxInnerWidth(renderedWidth);
+		// The native Text children render one leading padding space per line;
+		// drop it so boxLine's own side padding produces symmetric borders.
+		const wrapped = content
+			.render(inner)
+			.map((line) => boxLine(theme, line.startsWith(" ") ? line.slice(1) : line, renderedWidth));
+		return [
+			"",
+			boxLabeledBorder(theme, TOP_LEFT, TOP_RIGHT, bashBoxTitle(theme, host), undefined, renderedWidth),
+			boxBlankLine(theme, renderedWidth),
+			...wrapped,
+			boxBlankLine(theme, renderedWidth),
+			boxLabeledBorder(theme, BOTTOM_LEFT, BOTTOM_RIGHT, bashBoxFooter(theme, host), undefined, renderedWidth),
+		];
+	} catch {
+		return undefined;
+	}
+}

package/extension-src/pi-style/features/tools/boxed/bash.ts

@@ -17,6 +17,25 @@ import {
 	shortenPath,
 } from "../../../shared/box.js";
 import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
+import { parseSimpleBashCommand } from "./command-shape.js";
+import {
+	classifyGhCommand,
+	type GhParsedSemantic,
+	type GhRunJobParsed,
+	type GhSemanticClass,
+	parseGhOutput,
+	renderGhCardLines,
+	renderGhRunJobResult,
+} from "./gh.js";
+import {
+	classifyGitCommand,
+	type GitDiffParsed,
+	type GitParsedSemantic,
+	type GitSemanticClass,
+	parseGitOutput,
+	renderGitCardLines,
+	renderGitDiffResult,
+} from "./git.js";
 import {
 	type GrepMatch,
 	groupMatchesByFile,
@@ -573,59 +592,7 @@ interface BashTreeClass {
 	readonly singlePath?: string;
 }
 
-const BASH_PREFIX_COMMANDS = new Set(["sudo", "env", "time", "nice", "nohup", "command", "stdbuf", "ionice", "watch"]);
 const BASH_GREP_COMMANDS = new Set(["grep", "egrep", "fgrep", "rg"]);
-// Pipes (`|`), `;`, and `&` are excluded here: the classifier validates them
-// explicitly (allowing `cd X && cmd` chains and a trailing `| head/tail`).
-const BASH_SHELL_META_CHARS = new Set(["<", ">", "(", ")", "`"]);
-
-/** Tokenize a single command line, stripping quotes. Returns null on an
- *  unterminated quote. `hasMeta` is true if any shell metacharacter appears
- *  *outside* quotes (so `grep 'a|b' f` stays classifiable). */
-function tokenizeCommandLine(line: string): { tokens: string[]; hasMeta: boolean } | null {
-	const tokens: string[] = [];
-	let current = "";
-	let inToken = false;
-	let quote: string | null = null;
-	let hasMeta = false;
-	for (let i = 0; i < line.length; i++) {
-		const char = line[i] ?? "";
-		if (quote) {
-			if (char === "\\" && quote === '"') {
-				current += line[++i] ?? "";
-				continue;
-			}
-			if (char === quote) {
-				quote = null;
-				continue;
-			}
-			current += char;
-			continue;
-		}
-		if (char === '"' || char === "'") {
-			quote = char;
-			inToken = true;
-			continue;
-		}
-		if (char === " " || char === "\t") {
-			if (inToken) {
-				tokens.push(current);
-				current = "";
-				inToken = false;
-			}
-			continue;
-		}
-		if (BASH_SHELL_META_CHARS.has(char) || (char === "$" && (line[i + 1] ?? "") === "(")) {
-			hasMeta = true;
-			continue;
-		}
-		current += char;
-		inToken = true;
-	}
-	if (quote) return null;
-	if (inToken) tokens.push(current);
-	return { tokens, hasMeta };
-}
 
 /** grep/rg flags that consume a separate value token (`--type ts`). */
 const GREP_VALUE_FLAGS = new Set([
@@ -704,55 +671,11 @@ function classifyByArgs(kind: BashTreeKind, args: string[]): BashTreeClass {
 	};
 }
 
-/** `head [-n N]` / `tail [-n N]` truncation pipe tail (allowed at the end). */
-function isHeadOrTailTail(tokens: readonly string[]): boolean {
-	if (tokens.length === 0 || (tokens[0] !== "head" && tokens[0] !== "tail")) return false;
-	for (let i = 1; i < tokens.length; i++) {
-		const token = tokens[i] ?? "";
-		if (token === "-n") continue;
-		if (/^\d+$/.test(token)) continue;
-		if (/^-\d+$/.test(token)) continue;
-		return false;
-	}
-	return true;
-}
-
 /** Classify a bash command for tree rendering, or null to keep the boxed shell. */
 export function classifyBashCommand(command: string): BashTreeClass | null {
-	const commandText = String(command ?? "").trim();
-	if (!commandText || commandText.includes("\n")) return null;
-	const tokenized = tokenizeCommandLine(commandText);
-	if (!tokenized || tokenized.hasMeta || tokenized.tokens.length === 0) return null;
-	let tokens = tokenized.tokens;
-
-	// Allow a single trailing truncation pipe: `cmd | head [-n] N` / `| tail …`.
-	const pipes = tokens.flatMap((token, i) => (token === "|" ? [i] : []));
-	if (pipes.length > 0) {
-		if (pipes.length > 1) return null;
-		const last = pipes[0] ?? -1;
-		if (!isHeadOrTailTail(tokens.slice(last + 1))) return null;
-		tokens = tokens.slice(0, last);
-	}
-
-	let index = 0;
-	// Skip leading environment assignments (FOO=bar ...) and prefix commands.
-	while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[index] ?? "")) index++;
-	while (index < tokens.length && BASH_PREFIX_COMMANDS.has(tokens[index] ?? "")) index++;
-	// `cd <dir> &&` / `cd <dir>;` chains: the last directory becomes the default
-	// path when the command itself carries none.
-	let cdDir: string | undefined;
-	while (
-		tokens[index] === "cd" &&
-		index + 2 < tokens.length &&
-		tokens[index + 1] !== undefined &&
-		(tokens[index + 2] === "&&" || tokens[index + 2] === ";")
-	) {
-		cdDir = tokens[index + 1];
-		index += 3;
-	}
-	const rest = tokens.slice(index);
-	if (rest.length === 0 || rest.some((token) => token === "&&" || token === ";" || token === "&")) return null;
-
+	const shape = parseSimpleBashCommand(command, { allowTrailingTruncationPipe: true });
+	if (!shape) return null;
+	const rest = shape.tokens;
 	const base = (rest[0] ?? "").split("/").pop() ?? "";
 	let kind: BashTreeKind | null = null;
 	if (base === "ls") kind = "ls";
@@ -761,11 +684,11 @@ export function classifyBashCommand(command: string): BashTreeClass | null {
 	if (!kind) return null;
 
 	const cls = classifyByArgs(kind, rest.slice(1));
-	if (cdDir && cls.pathLabel === "current directory") {
+	if (shape.cdDir && cls.pathLabel === "current directory") {
 		return {
 			kind,
 			...(cls.pattern !== undefined ? { pattern: cls.pattern } : {}),
-			pathLabel: shortenPath(cdDir),
+			pathLabel: shortenPath(shape.cdDir),
 			...(cls.singlePath !== undefined ? { singlePath: cls.singlePath } : {}),
 		};
 	}
@@ -773,7 +696,7 @@ export function classifyBashCommand(command: string): BashTreeClass | null {
 }
 
 function bashTreeHeader(theme: BoxTheme, cls: BashTreeClass, counts?: { files?: number; matches?: number }): string {
-	const label = cls.kind === "find" ? "Glob" : cls.kind === "ls" ? "List" : "Grep";
+	const label = cls.kind === "find" ? "Find" : cls.kind === "ls" ? "List" : "Grep";
 	const hasDetail = Boolean(cls.pattern) || Boolean(counts);
 	// ls/find/grep headers carry the magnifying-glass icon in Nerd Font mode.
 	const icon = getToolsRenderConfig().nerdFonts ? `${SEARCH_ICON} ` : "";
@@ -832,22 +755,86 @@ function parseBashTreeOutput(cls: BashTreeClass, output: string): ParsedBashTree
 }
 
 interface BashTreeState {
-	readonly cls: BashTreeClass;
+	readonly cls: BashSemanticClass;
 	/** Raw command, so the call panel can render the boxed bash call on fallback. */
 	readonly command: string;
 	/** `parsed` once the result arrives; `fallback` when the boxed shell takes over. */
-	parsed?: ParsedBashTree;
+	parsed?: ParsedSemantic;
 	fallback?: boolean;
 }
 
-const bashTreeStates = new Map<string, BashTreeState>();
+/** Classified semantic command: a bash tree (ls/find/grep), a git card, or a
+ *  gh card (pr/issue/run). */
+export type BashSemanticClass = BashTreeClass | GitSemanticClass | GhSemanticClass;
+type ParsedSemantic = ParsedBashTree | GitParsedSemantic | GhParsedSemantic;
+
+/** Classify a bash command for semantic rendering (tree, git card, or gh
+ *  card), or null to keep the boxed command/response shell. */
+export function classifyBashSemantic(command: string): BashSemanticClass | null {
+	return classifyBashCommand(command) ?? classifyGitCommand(command) ?? classifyGhCommand(command);
+}
+
+function isBashTreeClass(cls: BashSemanticClass): cls is BashTreeClass {
+	return cls.kind === "ls" || cls.kind === "find" || cls.kind === "grep";
+}
+
+/** Type guard for the gh semantic classes (pr/issue/run list/view/checks/
+ *  create/job). */
+function isGhClass(cls: BashSemanticClass): cls is GhSemanticClass {
+	switch (cls.kind) {
+		case "pr-list":
+		case "pr-view":
+		case "pr-checks":
+		case "pr-create":
+		case "issue-list":
+		case "issue-view":
+		case "run-list":
+		case "run-view":
+		case "run-job":
+			return true;
+		default:
+			return false;
+	}
+}
+
+/** `gh run view --job=<id>` renders a boxed log result (Phase 8D); the other gh
+ *  classes render their whole panel in the call card. */
+function isGhRunJobClass(cls: BashSemanticClass): boolean {
+	return cls.kind === "run-job";
+}
+
+/** `git diff` / `git show` render a boxed adaptive-diff result (Phase 8B); the
+ *  other semantic classes render their whole panel in the call card. */
+function isGitDiffClass(cls: BashSemanticClass): boolean {
+	return !isBashTreeClass(cls) && (cls as GitSemanticClass).kind === "diff";
+}
+
+/** `git commit`/`push`/`pull`/`fetch` may produce informational exit-1 output
+ *  (e.g. `git commit` with nothing staged) that still parses to a card. Their
+ *  parsers are fail-closed, so genuine errors (push rejected, hook failure)
+ *  return null and fall back to the raw boxed shell (ADR 0005). */
+function isGitActionClass(cls: BashSemanticClass): boolean {
+	return !isBashTreeClass(cls) && (cls as GitSemanticClass).kind === "action";
+}
+
+function parseSemanticOutput(cls: BashSemanticClass, output: string): ParsedSemantic | null {
+	if (isBashTreeClass(cls)) return parseBashTreeOutput(cls, output);
+	if (isGhClass(cls)) return parseGhOutput(cls, output);
+	return parseGitOutput(cls, output);
+}
+
+const semanticStates = new Map<string, BashTreeState>();
 
-/** Reset all bash tree state (session start/shutdown, new message). */
+/** Reset all semantic bash state (session start/shutdown, new message). */
 export function resetBashTreeRegistry(): void {
-	bashTreeStates.clear();
+	semanticStates.clear();
 }
 
-function renderBashTreeLines(theme: BoxTheme, state: BashTreeState, width: number): string[] {
+function renderBashTreeLines(
+	theme: BoxTheme,
+	state: { cls: BashTreeClass; parsed?: ParsedBashTree },
+	width: number,
+): string[] {
 	const safeWidth = Math.max(1, width);
 	const cls = state.cls;
 	if (state.parsed && "entries" in state.parsed) {
@@ -881,13 +868,13 @@ const EMPTY_BASH_TREE_RESULT: Component = {
 };
 
 /** Live panel component for a classified bash command: pending header until the
- *  result arrives, then the parsed output tree. When the result falls back to
- *  the boxed shell, the call renders the boxed bash call instead, so call and
+ *  result arrives, then the parsed output tree/card. When the result falls back
+ *  to the boxed shell, the call renders the boxed bash call instead, so call and
  *  result form one complete box and never duplicate. The state reference is
  *  captured at creation so a registry clear on session reset/resume does not
  *  blank already-rendered panels. */
-function renderBashTreePanel(theme: BoxTheme, toolCallId: string, context: BoxedToolContext): Component {
-	const state = bashTreeStates.get(toolCallId);
+function renderSemanticPanel(theme: BoxTheme, toolCallId: string, context: BoxedToolContext): Component {
+	const state = semanticStates.get(toolCallId);
 	return {
 		invalidate() {},
 		render(width: number): string[] {
@@ -900,7 +887,21 @@ function renderBashTreePanel(theme: BoxTheme, toolCallId: string, context: Boxed
 					bashWidthKey(state.command, context?.args?.timeout),
 				).render(width);
 			}
-			return renderBashTreeLines(theme, state, width);
+			if (isBashTreeClass(state.cls)) {
+				const treeState: { cls: BashTreeClass; parsed?: ParsedBashTree } = { cls: state.cls };
+				if (state.parsed !== undefined) treeState.parsed = state.parsed as ParsedBashTree;
+				return renderBashTreeLines(theme, treeState, width);
+			}
+			// Git classes only ever carry git parsed values (parseSemanticOutput
+			// dispatches on the class), so the narrowed cast is exact.
+			if (isGhClass(state.cls)) {
+				const ghState: { cls: GhSemanticClass; parsed?: GhParsedSemantic } = { cls: state.cls };
+				if (state.parsed !== undefined) ghState.parsed = state.parsed as GhParsedSemantic;
+				return renderGhCardLines(theme, ghState, width);
+			}
+			const gitState: { cls: GitSemanticClass; parsed?: GitParsedSemantic } = { cls: state.cls };
+			if (state.parsed !== undefined) gitState.parsed = state.parsed as GitParsedSemantic;
+			return renderGitCardLines(theme, gitState, width);
 		},
 	};
 }
@@ -908,10 +909,10 @@ function renderBashTreePanel(theme: BoxTheme, toolCallId: string, context: Boxed
 export const bashTool: BoxedToolDefinition = {
 	call(args, theme, context) {
 		noteExecutionStart(context);
-		const cls = classifyBashCommand(String(args?.command ?? ""));
+		const cls = classifyBashSemantic(String(args?.command ?? ""));
 		if (cls) {
-			bashTreeStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
-			return renderBashTreePanel(theme, context.toolCallId, context);
+			semanticStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
+			return renderSemanticPanel(theme, context.toolCallId, context);
 		}
 		noteBoxedCallState(context);
 		const rawCommand = String(args?.command ?? "...");
@@ -920,25 +921,48 @@ export const bashTool: BoxedToolDefinition = {
 	result(result, options, theme, context) {
 		const firstResultPass = !isResultSeen(context.state);
 		markResultSeen(context.state);
-		const cls = classifyBashCommand(String(context?.args?.command ?? ""));
-		if (cls && !context.isError) {
-			// Tree-classified commands render in the call panel; the result adds
-			// nothing. Keep terminal state in sync without an elapsed ticker.
+		const cls = classifyBashSemantic(String(context?.args?.command ?? ""));
+		// Action classes (commit/push/pull/fetch) also attempt parsing on exit-1
+		// results so informational states like `git commit` with nothing staged
+		// render as a card; the fail-closed parser keeps genuine errors raw.
+		if (cls && (!context.isError || isGitActionClass(cls))) {
+			// Semantic-classified commands render in the call panel; the result adds
+			// nothing. Keep terminal state in sync without an elapsed ticker. Git
+			// parsers only run on the terminal result: streaming partial output may
+			// hold a truncated line that would fail parsing and wrongly fall back.
 			if (!options.isPartial) {
 				recordExecutionEnded(context.state);
 				stopElapsedTicker(context.state);
 			}
-			const output = stripBashToolNoticeLines(stripAnsi(getTextOutput(result)));
-			const parsed = parseBashTreeOutput(cls, output);
-			const state = bashTreeStates.get(context.toolCallId);
-			if (parsed) {
-				if (state) state.parsed = parsed;
-				else bashTreeStates.set(context.toolCallId, { cls, command: String(context?.args?.command ?? ""), parsed });
-				return EMPTY_BASH_TREE_RESULT;
+			if (!options.isPartial || isBashTreeClass(cls)) {
+				const output = stripBashToolNoticeLines(stripAnsi(getTextOutput(result)));
+				const parsed = parseSemanticOutput(cls, output);
+				const state = semanticStates.get(context.toolCallId);
+				if (parsed) {
+					if (state) state.parsed = parsed;
+					else
+						semanticStates.set(context.toolCallId, {
+							cls,
+							command: String(context?.args?.command ?? ""),
+							parsed,
+						});
+					// `git diff` / `git show` render a boxed adaptive-diff result (one frame
+					// per file); `gh run view --job=<id>` renders a boxed log result. Every
+					// other semantic class renders its whole panel in the call card, so the
+					// result adds nothing.
+					if (isGitDiffClass(cls)) {
+						return renderGitDiffResult(theme, parsed as GitDiffParsed, options, context);
+					}
+					if (isGhRunJobClass(cls)) {
+						return renderGhRunJobResult(theme, parsed as GhRunJobParsed, options, context);
+					}
+					return EMPTY_BASH_TREE_RESULT;
+				}
+				// Unparseable output (ls -l, raw rg summary, non-git output): the boxed
+				// shell owns the result; flag the call panel to render nothing so the
+				// two don't duplicate.
+				if (state) state.fallback = true;
 			}
-			// Unparseable output (ls -l, raw rg summary): the boxed shell owns the
-			// result; flag the call panel to render nothing so the two don't duplicate.
-			if (state) state.fallback = true;
 		} else if (options.isPartial) {
 			startElapsedTicker(context.state, context.invalidate);
 		} else {

package/extension-src/pi-style/features/tools/boxed/batch.ts

@@ -15,20 +15,23 @@
 // - Batch boundaries: a new batch starts when the active batch is closed. The
 //   active batch closes when a non-batchable tool call is dispatched
 //   (boxed/index.ts), when a new message starts (pi/index.ts), and on session
-//   reset (session-coordinator.ts). Lone calls render the same boxless tree
-//   (a batch of one) — there is no boxed single-call special case.
+//   reset (session-coordinator.ts). A lone `read` call renders as a single
+//   inline line (`➔ Read <path>`); lone ls/find calls render a flat output
+//   tree (a batch of one).
 // - No surrounding box: indentation and tree glyphs (├─/└─) carry the
-//   hierarchy; the header line is the summary (` Read (N) · 0.08s`).
+//   hierarchy; the header line of a batched panel is the summary
+//   (` Read (N) · 0.08s`).
 // - Errors stay visible: failed members are always rendered inline (even in the
 //   collapsed state), with their error text indented beneath the path.
-// - read members render a single path row. ls/find members render their parsed
-//   output as a file subtree (flat for a lone call, nested per member when
-//   batched) — see renderOutputBatchPanel. Pending/failed members without output
-//   fall back to the path row.
+// - read members render a single path row (a lone read collapses to one inline
+//   line). ls/find members render their parsed output as a file subtree (flat
+//   for a lone call, nested per member when batched) — see
+//   renderOutputBatchPanel. Pending/failed members without output fall back to
+//   the path row.
 
 import type { Component } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../../shared/ansi.js";
-import { type BoxTheme, formatToolTitlePrefix } from "../../../shared/box.js";
+import { type BoxTheme, dimLine, formatToolTitlePrefix } from "../../../shared/box.js";
 import { safeTruncateToWidth } from "../../../shared/render-budget.js";
 import {
 	fileIcon,
@@ -53,7 +56,7 @@ export interface BatchToolMeta {
 	readonly toolName: string;
 	/** Human label shown in the batch header (e.g. "Read", "List", "Find"). */
 	readonly label: string;
-	/** Header label for output-tree panels: "Glob" for find, "List" for ls. */
+	/** Header label for output-tree panels: "Find" for find, "List" for ls. */
 	readonly headerLabel?: string;
 }
 
@@ -283,7 +286,7 @@ function renderErrorLines(theme: BoxTheme, errorText: string, width: number): st
 		.map((line) => line.trim())
 		.filter((line) => line.length > 0);
 	if (raw.length === 0) return [];
-	const prefix = `${theme.fg("borderMuted", "  │  ")}`;
+	const prefix = `${dimLine("  │  ")}`;
 	const out = raw
 		.slice(0, BATCH_ERROR_LINES)
 		.map((line) => safeTruncateToWidth(`${prefix}${theme.fg("error", line)}`, Math.max(1, width), "…"));
@@ -305,14 +308,14 @@ function renderBatchTree(theme: BoxTheme, batch: BatchState, status: BatchStatus
 		const glyph = memberGlyph(theme, member, showGlyphs);
 		// Primary color for files read successfully, error red for failures.
 		const pathColor = member.isError ? "error" : member.status === "done" ? "accent" : "text";
-		const line = `${BATCH_TREE_INDENT}${theme.fg("borderMuted", branch)}${glyph ? ` ${glyph}` : ""} ${theme.fg(pathColor, member.detail)}`;
+		const line = `${BATCH_TREE_INDENT}${dimLine(branch)}${glyph ? ` ${glyph}` : ""} ${theme.fg(pathColor, member.detail)}`;
 		out.push(safeTruncateToWidth(line, Math.max(1, width), "…"));
 		if (member.isError && member.errorText) out.push(...renderErrorLines(theme, member.errorText, width));
 	}
 	if (more > 0) {
 		out.push(
 			safeTruncateToWidth(
-				`${BATCH_TREE_INDENT}${theme.fg("borderMuted", "└─")} ${theme.fg("dim", `${more} more`)}`,
+				`${BATCH_TREE_INDENT}${dimLine("└─")} ${theme.fg("dim", `${more} more`)}`,
 				Math.max(1, width),
 				"…",
 			),
@@ -321,7 +324,7 @@ function renderBatchTree(theme: BoxTheme, batch: BatchState, status: BatchStatus
 	return out;
 }
 
-/** Header for a lone (batch-of-one) ls/find output panel: `Glob: <pattern> <N> files · in <path>`. */
+/** Header for a lone (batch-of-one) ls/find output panel: `Find: <pattern> <N> files · in <path>`. */
 function formatLoneOutputHeader(theme: BoxTheme, meta: BatchToolMeta, member: BatchMember): string {
 	const label = meta.headerLabel ?? meta.label;
 	const count = member.outputEntries?.length ?? 0;
@@ -337,26 +340,26 @@ function formatLoneOutputHeader(theme: BoxTheme, meta: BatchToolMeta, member: Ba
 /** Nested file subtree for one member inside a batched (2+) output panel. */
 function renderMemberSubtree(theme: BoxTheme, member: BatchMember, isLastMember: boolean, width: number): string[] {
 	const safeWidth = Math.max(1, width);
-	const trunk = isLastMember ? " " : theme.fg("borderMuted", "│");
+	const trunk = isLastMember ? " " : dimLine("│");
 	const out: string[] = [];
 
 	// Member header row: path + file count (or status glyph when not done).
 	const entries = member.outputEntries ?? [];
 	if (member.isError) {
-		const line = `${BATCH_TREE_INDENT}${theme.fg("borderMuted", isLastMember ? "└─" : "├─")} ${theme.fg("error", "✗")} ${theme.fg("error", member.pathLabel ?? member.detail)}`;
+		const line = `${BATCH_TREE_INDENT}${dimLine(isLastMember ? "└─" : "├─")} ${theme.fg("error", "✗")} ${theme.fg("error", member.pathLabel ?? member.detail)}`;
 		out.push(safeTruncateToWidth(line, safeWidth, "…"));
 		if (member.errorText) out.push(...renderErrorLines(theme, member.errorText, width));
 		return out;
 	}
 	if (member.status !== "done" || member.outputEntries === undefined) {
 		const glyph = member.status === "done" ? theme.fg("success", "✓") : theme.fg("text", "◌");
-		const line = `${BATCH_TREE_INDENT}${theme.fg("borderMuted", isLastMember ? "└─" : "├─")} ${glyph} ${theme.fg("text", member.pathLabel ?? member.detail)}`;
+		const line = `${BATCH_TREE_INDENT}${dimLine(isLastMember ? "└─" : "├─")} ${glyph} ${theme.fg("text", member.pathLabel ?? member.detail)}`;
 		out.push(safeTruncateToWidth(line, safeWidth, "…"));
 		return out;
 	}
 
 	const countLabel = theme.fg("dim", ` · ${entries.length} ${pluralForm("file", entries.length)}`);
-	const headerLine = `${BATCH_TREE_INDENT}${theme.fg("borderMuted", isLastMember ? "└─" : "├─")} ${theme.fg("accent", member.pathLabel ?? member.detail)}${countLabel}`;
+	const headerLine = `${BATCH_TREE_INDENT}${dimLine(isLastMember ? "└─" : "├─")} ${theme.fg("accent", member.pathLabel ?? member.detail)}${countLabel}`;
 	out.push(safeTruncateToWidth(headerLine, safeWidth, "…"));
 
 	const visible = entries.slice(0, BATCH_MEMBER_FILE_HEAD_LIMIT);
@@ -367,11 +370,11 @@ function renderMemberSubtree(theme: BoxTheme, member: BatchMember, isLastMember:
 		const entry = visible[i] ?? "";
 		const label = icons && entry ? `${fileIcon(entry)} ${entry}` : entry;
 		const branch = i < lastIndex || more > 0 ? "├─" : "└─";
-		const line = `${BATCH_TREE_INDENT}${trunk}${TREE_CHILD_INDENT}${theme.fg("borderMuted", branch)} ${theme.fg("toolOutput", label)}`;
+		const line = `${BATCH_TREE_INDENT}${trunk}${TREE_CHILD_INDENT}${dimLine(branch)} ${theme.fg("toolOutput", label)}`;
 		out.push(safeTruncateToWidth(line, safeWidth, "…"));
 	}
 	if (more > 0) {
-		const line = `${BATCH_TREE_INDENT}${trunk}${TREE_CHILD_INDENT}${theme.fg("borderMuted", "└─")} ${theme.fg("dim", `… ${more} more ${pluralForm("file", more)}`)}`;
+		const line = `${BATCH_TREE_INDENT}${trunk}${TREE_CHILD_INDENT}${dimLine("└─")} ${theme.fg("dim", `… ${more} more ${pluralForm("file", more)}`)}`;
 		out.push(safeTruncateToWidth(line, safeWidth, "…"));
 	}
 	return out;
@@ -381,7 +384,7 @@ function renderMemberSubtree(theme: BoxTheme, member: BatchMember, isLastMember:
 function renderOutputBatchPanel(theme: BoxTheme, batch: BatchState, status: BatchStatus, width: number): string[] {
 	const safeWidth = Math.max(1, width);
 
-	// Lone successful call with output: flat tree under a `Glob:/List:` header.
+	// Lone successful call with output: flat tree under a `Find:/List:` header.
 	if (batch.members.length === 1) {
 		const member = batch.members[0];
 		if (member && member.outputEntries !== undefined && !member.isError) {
@@ -408,19 +411,39 @@ function renderOutputBatchPanel(theme: BoxTheme, batch: BatchState, status: Batc
 	});
 	if (more > 0) {
 		out.push(
-			safeTruncateToWidth(
-				`${BATCH_TREE_INDENT}${theme.fg("borderMuted", "└─")} ${theme.fg("dim", `${more} more`)}`,
-				safeWidth,
-				"…",
-			),
+			safeTruncateToWidth(`${BATCH_TREE_INDENT}${dimLine("└─")} ${theme.fg("dim", `${more} more`)}`, safeWidth, "…"),
 		);
 	}
 	return out;
 }
 
+/** Lone `read` call: single inline line `➔ Read <path>` — no count, no tree. */
+function isLoneRead(batch: BatchState): boolean {
+	return batch.meta.toolName === "read" && batch.members.length === 1;
+}
+
+/** Lone read renders `➔ Read <path>` on one line; errors keep their error text. */
+function renderLoneReadPanel(theme: BoxTheme, batch: BatchState, status: BatchStatus, width: number): string[] {
+	const member = batch.members[0];
+	if (!member) return [];
+	const prefix = bold(theme, formatToolTitlePrefix(theme, batch.meta.label));
+	const glyph = memberGlyph(theme, member, !status.allDone || status.failed > 0);
+	const pathColor = member.isError ? "error" : member.status === "done" ? "accent" : "text";
+	const out = [
+		safeTruncateToWidth(
+			`${prefix}${glyph ? ` ${glyph}` : ""} ${theme.fg(pathColor, member.detail)}`,
+			Math.max(1, width),
+			"…",
+		),
+	];
+	if (member.isError && member.errorText) out.push(...renderErrorLines(theme, member.errorText, width));
+	return out;
+}
+
 function renderBatchPanelLines(theme: BoxTheme, batch: BatchState, status: BatchStatus, width: number): string[] {
-	// The tree stays open in every state, including for a lone call: no boxed
-	// single-call special case, no collapsed single-line summary.
+	// Lone read collapses to a single inline line; batched reads and lone
+	// ls/find calls keep their tree panels.
+	if (isLoneRead(batch)) return renderLoneReadPanel(theme, batch, status, width);
 	if (isOutputTool(batch.meta) && batch.members.some((member) => member.outputEntries !== undefined)) {
 		return renderOutputBatchPanel(theme, batch, status, width);
 	}