@quandev104/pi-style 0.1.3 → 0.1.5

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

@@ -7,7 +7,8 @@ import { stripAnsi } from "../../../shared/ansi.js";
 import type { BoxTheme } from "../../../shared/box.js";
 import {
 	boxedToolWidthKey,
-	formatBoxedFooter,
+	formatBoxedRunningStatus,
+	formatBoxedWords,
 	formatToolOutputLine,
 	getTextOutput,
 	renderBoxedToolCall,
@@ -16,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,
@@ -30,8 +50,16 @@ import {
 	SEARCH_ICON,
 	TREE_INDENT,
 } from "./output-tree.js";
-import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
-import { type BoxedToolContext, type BoxedToolDefinition, noteExecutionStart } from "./shared.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";
@@ -182,44 +210,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", " · "));
+}
+
+// ── 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 formatTimeout(context: BoxedToolContext): string {
-	const timeout = context?.args?.timeout ?? 300;
-	return `${timeout}s`;
+/** 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;
+		},
+	};
 }
 
-function renderBoxedBashResult(
+/** 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,
@@ -337,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([
@@ -468,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";
@@ -525,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 } : {}),
 		};
 	}
@@ -537,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} ` : "";
@@ -596,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);
+}
 
-/** Reset all bash tree state (session start/shutdown, new message). */
+const semanticStates = new Map<string, BashTreeState>();
+
+/** 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) {
@@ -645,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[] {
@@ -664,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);
 		},
 	};
 }
@@ -672,52 +909,73 @@ 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 ?? "...");
 		return renderBoxedBashCall(theme, rawCommand.split("\n"), context, bashWidthKey(rawCommand, args?.timeout));
 	},
 	result(result, options, theme, context) {
-		const cls = classifyBashCommand(String(context?.args?.command ?? ""));
-		if (cls && !context.isError) {
-			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 firstResultPass = !isResultSeen(context.state);
+		markResultSeen(context.state);
+		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);
 			}
-			// 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;
-		}
-		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;
+			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;
 			}
-			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);
+		} 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);
 	},
 };