@quandev104/pi-style 0.1.2 → 0.1.4

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

@@ -7,16 +7,40 @@ import { stripAnsi } from "../../../shared/ansi.js";
 import type { BoxTheme } from "../../../shared/box.js";
 import {
 	boxedToolWidthKey,
-	formatBoxedFooter,
+	formatBoxedRunningStatus,
+	formatBoxedWords,
 	formatToolOutputLine,
 	getTextOutput,
 	renderBoxedToolCall,
 	renderBoxedToolResult,
 	replaceTabs,
+	shortenPath,
 } from "../../../shared/box.js";
 import { safeTruncateToWidth, truncateAtCodePointBoundary } from "../../../shared/render-budget.js";
-import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
-import { type BoxedToolContext, type BoxedToolDefinition, noteExecutionStart } from "./shared.js";
+import {
+	type GrepMatch,
+	groupMatchesByFile,
+	parseFindOutput,
+	parseGrepBareOutput,
+	parseGrepOutput,
+	parseLsLongOutput,
+	parseLsOutput,
+	pluralForm,
+	renderGrepTree,
+	renderOutputTree,
+	SEARCH_ICON,
+	TREE_INDENT,
+} from "./output-tree.js";
+import {
+	getStateElapsedMs,
+	getToolsRenderConfig,
+	isResultSeen,
+	markResultSeen,
+	recordExecutionEnded,
+	startElapsedTicker,
+	stopElapsedTicker,
+} from "./session-config.js";
+import { type BoxedToolContext, type BoxedToolDefinition, noteBoxedCallState, noteExecutionStart } from "./shared.js";
 
 const MAX_LINE_CHARS = 2000;
 const ESC = "\x1b";
@@ -167,44 +191,271 @@ function renderBoxedBashCall(
 	if (commandLines.length > maxCommandLines + 1) {
 		detailLines.push(theme.fg("muted", `... ${commandLines.length - maxCommandLines - 1} more lines`));
 	}
-	return renderBoxedToolCall(theme, "Bash", detailLines, {
+	const running = Boolean(context.executionStarted);
+	const resultSeen = isResultSeen(context.state);
+	const base = {
 		widthKey,
 		isError: Boolean(context.isError),
 		isPartial: Boolean(context.isPartial),
 		isPending: Boolean(context.isPartial),
-	});
+		running,
+	};
+	if (running && context.isPartial && !resultSeen) {
+		// Pre-result running card: the call closes the box with a live running
+		// footer and a `No output received yet` line. The first partial result
+		// renders nothing, so this card is never duplicated below.
+		detailLines.push(theme.fg("dim", "No output received yet"));
+		return renderBoxedToolCall(theme, "Bash", detailLines, {
+			...base,
+			pendingLabel: formatBoxedRunningStatus(theme, getStateElapsedMs(context.state)),
+		});
+	}
+	// Streaming (a result renderer already continues this box) and terminal
+	// (settled) passes leave the box open so the result closes it.
+	return renderBoxedToolCall(theme, "Bash", detailLines, { ...base, resultSeen });
+}
+
+// ── Terminal status detection ────────────────────────────────────────────────
+// The bash tool appends a `\n\n<status>` suffix to failed results (nonzero exit,
+// timeout, abort). Parse it off the raw text so the footer can carry the real
+// status instead of displaying the suffix as output.
+
+type BashTerminalStatus =
+	| { kind: "exit"; exitCode: number }
+	| { kind: "timeout"; seconds: number }
+	| { kind: "cancelled" };
+
+const BASH_STATUS_PATTERNS: ReadonlyArray<{
+	re: RegExp;
+	build: (match: RegExpMatchArray) => BashTerminalStatus;
+}> = [
+	{
+		re: /(?:^|\n\n)Command timed out after ([\d.]+) seconds$/i,
+		build: (match) => ({ kind: "timeout", seconds: Number(match[1]) }),
+	},
+	{ re: /(?:^|\n\n)[^\n]*aborted$/i, build: () => ({ kind: "cancelled" }) },
+	{
+		re: /(?:^|\n\n)Command exited with code (\d+)$/i,
+		build: (match) => ({ kind: "exit", exitCode: Number(match[1]) }),
+	},
+];
+
+function parseBashTerminalStatus(text: string): { status: BashTerminalStatus | undefined; body: string } {
+	const clean = String(text ?? "").replace(/\r/g, "");
+	for (const { re, build } of BASH_STATUS_PATTERNS) {
+		const match = clean.match(re);
+		if (match && match.index !== undefined) {
+			return { status: build(match), body: clean.slice(0, match.index).trimEnd() };
+		}
+	}
+	// Pi's message_end error path (agent aborted) sends a bare status text with
+	// no bash output shape; recognize it as a cancelled state.
+	if (/^(?:operation )?aborted(?: after \d+ retry attempts?)?$/i.test(clean.trim())) {
+		return { status: { kind: "cancelled" }, body: "" };
+	}
+	return { status: undefined, body: clean };
+}
+
+function bashErrorLabel(status: BashTerminalStatus | undefined): string | undefined {
+	if (status?.kind === "timeout") return "✗ Timed out";
+	if (status?.kind === "cancelled") return "✗ Cancelled";
+	return undefined;
+}
+
+/** Body text shown when a terminal bash result produced no output. */
+function bashEmptyBodyText(status: BashTerminalStatus | undefined, isError: boolean): string {
+	if (status?.kind === "timeout") return "No output was received before the timeout";
+	if (status?.kind === "cancelled") return "Command was cancelled without producing output";
+	if (isError) return "Command failed without producing output";
+	return "Command completed without producing output";
+}
+
+function bashFooter(
+	theme: BoxTheme,
+	status: BashTerminalStatus | undefined,
+	elapsedMs: number | undefined,
+	bodyText: string,
+	isError: boolean,
+): string {
+	const elapsed = elapsedMs === undefined ? "--" : `${(elapsedMs / 1000).toFixed(2)}s`;
+	const words = bodyText.trim() ? formatBoxedWords(bodyText) : "";
+
+	if (status?.kind === "timeout") {
+		const seconds = Number.isFinite(status.seconds) && status.seconds > 0 ? status.seconds : Number.NaN;
+		return theme.fg(
+			"warning",
+			Number.isFinite(seconds) ? `Terminated after ${seconds.toFixed(1)}s` : "Terminated by timeout",
+		);
+	}
+	if (status?.kind === "cancelled") {
+		return [theme.fg("warning", "Cancelled"), theme.fg("text", elapsed)].join(theme.fg("dim", " · "));
+	}
+
+	const exitLabel = status?.kind === "exit" ? `Exit ${status.exitCode}` : isError ? "Failed" : "Exit 0";
+	const exitColor = status?.kind === "exit" && status.exitCode !== 0 ? "error" : "text";
+	const parts = [theme.fg(exitColor, exitLabel), theme.fg("text", elapsed)];
+	if (words) parts.push(theme.fg("dim", words));
+	return parts.join(theme.fg("dim", " · "));
 }
 
-function formatTimeout(context: BoxedToolContext): string {
-	const timeout = context?.args?.timeout ?? 300;
-	return `${timeout}s`;
+// ── Interactive command heuristics ───────────────────────────────────────────
+// Terminal programs that read stdin or own the screen produce no pipe output;
+// when one runs silently we hint that it may be waiting for terminal input.
+
+const INTERACTIVE_COMMANDS = new Set([
+	"pi",
+	"vim",
+	"vi",
+	"nvim",
+	"nano",
+	"less",
+	"more",
+	"man",
+	"top",
+	"htop",
+	"btop",
+	"ssh",
+	"telnet",
+	"python",
+	"python3",
+	"node",
+	"sqlite3",
+	"mysql",
+	"psql",
+	"redis-cli",
+	"mongosh",
+	"bc",
+	"irssi",
+]);
+
+function isInteractiveCommand(command: unknown): boolean {
+	const base =
+		(
+			String(command ?? "")
+				.trim()
+				.split(/\s+/)[0] ?? ""
+		)
+			.split("/")
+			.pop() ?? "";
+	return INTERACTIVE_COMMANDS.has(base);
 }
 
-function renderBoxedBashResult(
+/** Wrap an output preview so an empty result renders state text instead of `∅`. */
+function bashBodyComponent(preview: Component, emptyLines: string[] | undefined): Component {
+	if (!emptyLines) return preview;
+	return {
+		invalidate: () => preview.invalidate(),
+		render(width: number): string[] {
+			const lines = preview.render(width);
+			return lines.length > 0 ? lines : emptyLines;
+		},
+	};
+}
+
+/** Streaming continuation: streamed output (or `No output received yet`), a
+ *  live running footer, and no `Response` divider until the tool settles. */
+function renderBashStreamingResult(
 	theme: BoxTheme,
-	inner: Component,
-	result: unknown,
+	raw: string,
+	options: { expanded: boolean },
 	context: BoxedToolContext,
-	expandHint?: string,
 ): Component {
+	const body = stripBashToolNoticeLines(stripAnsi(raw));
+	const hasOutput = body.trim().length > 0;
+	const elapsed = getStateElapsedMs(context.state);
+	const emptyLines: string[] = [theme.fg("dim", "No output received yet")];
+	if (!hasOutput && isInteractiveCommand(context?.args?.command) && (elapsed ?? 0) >= 1000) {
+		emptyLines.push(theme.fg("dim", "The process may be waiting for terminal input"));
+	}
+	const preview = createBashResultPreview(theme, body, options, "toolOutput");
 	const rawCommand = String(context?.args?.command ?? "...");
-	const referenceLines = rawCommand.split("\n").map((line, index) => `${index === 0 ? "$ " : "> "}${line}`);
-	return renderBoxedToolResult(theme, inner, {
+	return renderBoxedToolResult(theme, bashBodyComponent(preview, hasOutput ? undefined : emptyLines), {
 		widthKey: bashWidthKey(rawCommand, context?.args?.timeout),
-		referenceLines,
-		footerLines: [
-			formatBoxedFooter(theme, result as never, [`timeout ${formatTimeout(context)}`], getElapsed(context)),
-		],
-		...(expandHint ? { expandHint } : {}),
-		isError: context.isError,
-		isPartial: Boolean(context.isPartial),
+		referenceLines: rawCommand.split("\n").map((line, index) => `${index === 0 ? "$ " : "> "}${line}`),
+		dividerLabel: "Output",
+		showDivider: hasOutput,
+		footerLines: [formatBoxedRunningStatus(theme, elapsed)],
+		isPartial: true,
 	});
 }
 
-function getElapsed(context: BoxedToolContext): number | undefined {
-	return getStateElapsedMs(context.state);
+function renderBashFinalResult(
+	theme: BoxTheme,
+	raw: string,
+	options: { expanded: boolean },
+	context: BoxedToolContext,
+): Component {
+	const isError = Boolean(context.isError);
+	const clean = stripAnsi(raw);
+	const { status, body: statusStripped } = parseBashTerminalStatus(clean);
+	const output = stripBashToolNoticeLines(statusStripped);
+	const elapsed = getStateElapsedMs(context.state);
+	const outputColor = isError ? "error" : "toolOutput";
+	const footer = bashFooter(theme, status, elapsed, output, isError);
+	const errorLabel = isError ? (bashErrorLabel(status) ?? "✗ Error") : undefined;
+
+	const rawCommand = String(context?.args?.command ?? "...");
+	const widthKey = bashWidthKey(rawCommand, context?.args?.timeout);
+	const referenceLines = rawCommand.split("\n").map((line, index) => `${index === 0 ? "$ " : "> "}${line}`);
+
+	if (!options.expanded) {
+		// Collapsed: only process the tail of the output (notices stripped per line).
+		const scanLines = getToolsRenderConfig().maxCollapsedLines + 10;
+		let nlCount = 0;
+		let tailStart = 0;
+		for (let i = statusStripped.length - 1; i >= 0; i--) {
+			if (statusStripped.charCodeAt(i) === 10) {
+				nlCount++;
+				if (nlCount >= scanLines) {
+					tailStart = i + 1;
+					break;
+				}
+			}
+		}
+		const tail = stripBashToolNoticeLines(stripAnsi(statusStripped.slice(tailStart)));
+		const totalLinesBefore = tailStart > 0 ? countNewlines(statusStripped, 0, tailStart) : 0;
+		const preview = createBashResultPreview(theme, tail, options, outputColor);
+		return renderBoxedToolResult(
+			theme,
+			bashBodyComponent(
+				preview,
+				statusStripped.trim() ? undefined : [theme.fg("muted", bashEmptyBodyText(status, isError))],
+			),
+			{
+				widthKey,
+				referenceLines,
+				footerLines: [footer],
+				...(totalLinesBefore > 0 ? { expandHint: "Ctrl+O for more" } : {}),
+				isError,
+				isPartial: false,
+				...(errorLabel ? { errorLabel } : {}),
+			},
+		);
+	}
+
+	const preview = createBashResultPreview(theme, output, options, outputColor);
+	return renderBoxedToolResult(
+		theme,
+		bashBodyComponent(preview, output.trim() ? undefined : [theme.fg("muted", bashEmptyBodyText(status, isError))]),
+		{
+			widthKey,
+			referenceLines,
+			footerLines: [footer],
+			isError,
+			isPartial: false,
+			...(errorLabel ? { errorLabel } : {}),
+		},
+	);
 }
 
+/** First-partial-pass result: the pending/running call card stands alone. */
+const EMPTY_BASH_RESULT: Component = Object.freeze({
+	invalidate() {},
+	render() {
+		return [];
+	},
+});
+
 function createBashResultPreview(
 	theme: BoxTheme,
 	text: string,
@@ -304,36 +555,403 @@ function createBashResultPreview(
 	};
 }
 
+// ── ls/find/grep/rg command detection ───────────────────────────────────────
+// A bash command whose real command is ls/find/grep/rg (after env assignments,
+// sudo/env/time prefixes, and path stripping), with no shell metacharacters
+// (pipes, redirects, `;`, `&&`, command substitution, subshells, newlines), is
+// rendered as the same boxless output tree as the corresponding native tool.
+// Everything else keeps the boxed command/response shell.
+
+type BashTreeKind = "ls" | "find" | "grep";
+
+interface BashTreeClass {
+	readonly kind: BashTreeKind;
+	readonly pattern?: string;
+	readonly pathLabel?: string;
+	/** grep: exactly one path positional — single-file output (`line: content`)
+	 *  is attributed to it. */
+	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([
+	"-e",
+	"--regexp",
+	"-g",
+	"--glob",
+	"--type",
+	"-t",
+	"--include",
+	"--exclude",
+	"-C",
+	"-A",
+	"-B",
+	"--context",
+	"--after-context",
+	"--before-context",
+	"-m",
+	"--max-count",
+	"-M",
+	"--max-columns",
+	"--ignore-file",
+]);
+
+/** find flags that consume a separate value token (`-type f`). */
+const FIND_VALUE_FLAGS = new Set([
+	"-type",
+	"-mtime",
+	"-atime",
+	"-ctime",
+	"-size",
+	"-maxdepth",
+	"-mindepth",
+	"-perm",
+	"-group",
+	"-user",
+	"-newer",
+]);
+
+function classifyByArgs(kind: BashTreeKind, args: string[]): BashTreeClass {
+	const positionals: string[] = [];
+	let pattern: string | undefined;
+	for (let i = 0; i < args.length; i++) {
+		const token = args[i] ?? "";
+		if (
+			(kind === "grep" && (token === "-e" || token === "--regexp")) ||
+			(kind === "find" && (token === "-name" || token === "-iname" || token === "-path" || token === "-ipath"))
+		) {
+			pattern = args[++i];
+			continue;
+		}
+		if (kind === "grep" && GREP_VALUE_FLAGS.has(token)) {
+			i++; // skip the flag and its value
+			continue;
+		}
+		if (kind === "find" && FIND_VALUE_FLAGS.has(token)) {
+			i++; // skip the flag and its value
+			continue;
+		}
+		if (token.startsWith("-")) continue;
+		positionals.push(token);
+	}
+	const rawPath = positionals[0] ?? ".";
+	const pathLabel = rawPath === "." ? "current directory" : shortenPath(rawPath);
+	if (kind === "ls") return { kind, pathLabel };
+	if (kind === "find") return { kind, ...(pattern !== undefined ? { pattern } : {}), pathLabel };
+	const grepPattern = pattern ?? positionals[0];
+	const pathArgs = pattern !== undefined ? positionals : positionals.slice(1);
+	const grepPath = pathArgs.join(" ");
+	const grepPathLabel = !grepPath || grepPath === "." ? "current directory" : shortenPath(grepPath);
+	return {
+		kind,
+		...(grepPattern !== undefined ? { pattern: grepPattern } : {}),
+		pathLabel: grepPathLabel,
+		...(pathArgs.length === 1 ? { singlePath: pathArgs[0] ?? "" } : {}),
+	};
+}
+
+/** `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 base = (rest[0] ?? "").split("/").pop() ?? "";
+	let kind: BashTreeKind | null = null;
+	if (base === "ls") kind = "ls";
+	else if (base === "find") kind = "find";
+	else if (BASH_GREP_COMMANDS.has(base)) kind = "grep";
+	if (!kind) return null;
+
+	const cls = classifyByArgs(kind, rest.slice(1));
+	if (cdDir && cls.pathLabel === "current directory") {
+		return {
+			kind,
+			...(cls.pattern !== undefined ? { pattern: cls.pattern } : {}),
+			pathLabel: shortenPath(cdDir),
+			...(cls.singlePath !== undefined ? { singlePath: cls.singlePath } : {}),
+		};
+	}
+	return cls;
+}
+
+function bashTreeHeader(theme: BoxTheme, cls: BashTreeClass, counts?: { files?: number; matches?: number }): string {
+	const label = cls.kind === "find" ? "Glob" : 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} ` : "";
+	const prefix = icon + (hasDetail ? `${label}:` : label);
+	const patternPart = cls.pattern ? ` ${theme.fg("text", cls.pattern)}` : "";
+	let middle = "";
+	if (counts) {
+		if (cls.kind === "grep") {
+			const matches = counts.matches ?? 0;
+			const files = counts.files ?? 0;
+			middle = ` ${theme.fg("accent", `${matches} ${pluralForm("match", matches)}`)}${theme.fg("dim", ` · ${files} ${pluralForm("file", files)}`)}`;
+		} else {
+			const files = counts.files ?? 0;
+			middle = ` ${theme.fg("accent", `${files} ${pluralForm("file", files)}`)}`;
+		}
+	}
+	const pathPart =
+		cls.pathLabel && cls.pathLabel !== "current directory" ? theme.fg("dim", ` · in ${cls.pathLabel}`) : "";
+	return `${typeof theme?.bold === "function" ? theme.bold(prefix) : prefix}${patternPart}${middle}${pathPart}`;
+}
+
+/** `ls -l` long-format lines (permissions block) can't be parsed into names
+ *  reliably; fall back to the boxed shell for those. A leading `total N`
+ *  summary line is skipped before the check. */
+function isLongFormatLs(text: string): boolean {
+	const first = text
+		.split("\n")
+		.map((line) => line.trim())
+		.find((line) => line.length > 0 && !/^total\s+\d+$/i.test(line));
+	return Boolean(first) && /^[bcdlsp-][rwxtsST-]{9}[\s@]/.test(first as string);
+}
+
+/** Parsed bash tree output, or null to fall back to the boxed shell
+ *  (long-format ls, unparseable grep). */
+type ParsedBashTree = { entries: string[] } | { matches: GrepMatch[] };
+
+function parseBashTreeOutput(cls: BashTreeClass, output: string): ParsedBashTree | null {
+	if (cls.kind === "ls") {
+		// `ls -l`/`ls -la` long format is parsed into names (with `/` for dirs)
+		// so bash listings render like the List tool tree.
+		if (isLongFormatLs(output)) return { entries: parseLsLongOutput(output) };
+		return { entries: parseLsOutput(output) };
+	}
+	if (cls.kind === "find") return { entries: parseFindOutput(output) };
+	const matches = parseGrepOutput(output);
+	if (matches.length === 0 && output.trim().length > 0) {
+		// Single-file `rg`/`grep` output is `line: content` with no filename:
+		// attribute matches to the command's single path argument.
+		if (cls.singlePath) {
+			const bare = parseGrepBareOutput(output, cls.singlePath);
+			if (bare.length > 0) return { matches: bare };
+		}
+		return null;
+	}
+	return { matches };
+}
+
+interface BashTreeState {
+	readonly cls: BashTreeClass;
+	/** 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;
+	fallback?: boolean;
+}
+
+const bashTreeStates = new Map<string, BashTreeState>();
+
+/** Reset all bash tree state (session start/shutdown, new message). */
+export function resetBashTreeRegistry(): void {
+	bashTreeStates.clear();
+}
+
+function renderBashTreeLines(theme: BoxTheme, state: BashTreeState, width: number): string[] {
+	const safeWidth = Math.max(1, width);
+	const cls = state.cls;
+	if (state.parsed && "entries" in state.parsed) {
+		const entries = state.parsed.entries;
+		return renderOutputTree(theme, bashTreeHeader(theme, cls, { files: entries.length }), entries, safeWidth, {
+			moreUnit: "file",
+			indent: TREE_INDENT,
+			withIcons: getToolsRenderConfig().nerdFonts,
+		});
+	}
+	if (state.parsed && "matches" in state.parsed) {
+		const matches = state.parsed.matches;
+		return renderGrepTree(
+			theme,
+			bashTreeHeader(theme, cls, { matches: matches.length, files: groupMatchesByFile(matches).length }),
+			matches,
+			safeWidth,
+			{ indent: TREE_INDENT, withIcons: getToolsRenderConfig().nerdFonts },
+		);
+	}
+	return [safeTruncateToWidth(bashTreeHeader(theme, cls), safeWidth, "…")];
+}
+
+/** Empty result component — the tree lives in the call panel, which re-renders
+ *  with the parsed output once the result arrives. */
+const EMPTY_BASH_TREE_RESULT: Component = {
+	invalidate() {},
+	render() {
+		return [];
+	},
+};
+
+/** 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 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);
+	return {
+		invalidate() {},
+		render(width: number): string[] {
+			if (!state) return [];
+			if (state.fallback) {
+				return renderBoxedBashCall(
+					theme,
+					state.command.split("\n"),
+					context,
+					bashWidthKey(state.command, context?.args?.timeout),
+				).render(width);
+			}
+			return renderBashTreeLines(theme, state, width);
+		},
+	};
+}
+
 export const bashTool: BoxedToolDefinition = {
 	call(args, theme, context) {
 		noteExecutionStart(context);
+		const cls = classifyBashCommand(String(args?.command ?? ""));
+		if (cls) {
+			bashTreeStates.set(context.toolCallId, { cls, command: String(args?.command ?? "") });
+			return renderBashTreePanel(theme, context.toolCallId, context);
+		}
+		noteBoxedCallState(context);
 		const rawCommand = String(args?.command ?? "...");
 		return renderBoxedBashCall(theme, rawCommand.split("\n"), context, bashWidthKey(rawCommand, args?.timeout));
 	},
 	result(result, options, theme, context) {
-		const raw = getTextOutput(result);
-		const outputColor = context.isError ? "error" : "toolOutput";
-
-		if (!options.expanded) {
-			const scanLines = getToolsRenderConfig().maxCollapsedLines + 10;
-			let nlCount = 0;
-			let tailStart = 0;
-			for (let i = raw.length - 1; i >= 0; i--) {
-				if (raw.charCodeAt(i) === 10) {
-					nlCount++;
-					if (nlCount >= scanLines) {
-						tailStart = i + 1;
-						break;
-					}
-				}
+		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.
+			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;
 			}
-			const tail = stripBashToolNoticeLines(stripAnsi(raw.slice(tailStart)));
-			const totalLinesBefore = tailStart > 0 ? countNewlines(raw, 0, tailStart) : 0;
-			const inner = createBashResultPreview(theme, tail, options, outputColor);
-			return renderBoxedBashResult(theme, inner, result, context, totalLinesBefore > 0 ? "Ctrl+O for more" : undefined);
+			// 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 {
+			recordExecutionEnded(context.state);
+			stopElapsedTicker(context.state);
+		}
+		const raw = getTextOutput(result);
+		if (options.isPartial) {
+			// First partial pass: the running call card stands alone. Later passes
+			// stream output into the open continuation without a Response divider.
+			if (firstResultPass) return EMPTY_BASH_RESULT;
+			return renderBashStreamingResult(theme, raw, options, context);
 		}
-		const output = stripBashToolNoticeLines(stripAnsi(raw));
-		const inner = createBashResultPreview(theme, output, options, outputColor);
-		return renderBoxedBashResult(theme, inner, result, context);
+		return renderBashFinalResult(theme, raw, options, context);
 	},
 };