@quandev104/pi-style 0.1.3 → 0.1.5

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);
 	}

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

@@ -0,0 +1,136 @@
+// Simple bash command shape detection, shared by the bash tool renderer and
+// the git/gh semantic classifiers.
+//
+// A command is "simple" when pi-style can reason about it purely from its
+// token list: single line, no shell metacharacters (pipes, redirects,
+// substitutions), and no `&&`/`;`/`&` outside a leading `cd X &&` chain.
+// Anything ambiguous returns null so the boxed command/response shell stays
+// the fallback (ADR 0005 — no approximate rendering).
+
+/** Tokens of a classifiable command after env/prefix/cd-chain stripping. */
+export interface SimpleBashCommandShape {
+	/** Tokens after leading env assignments, prefix commands, and `cd X &&` chains. */
+	readonly tokens: string[];
+	/** Last directory from a leading `cd <dir> &&` / `cd <dir>;` chain. */
+	readonly cdDir?: string;
+}
+
+const BASH_PREFIX_COMMANDS = new Set(["sudo", "env", "time", "nice", "nohup", "command", "stdbuf", "ionice", "watch"]);
+// 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 };
+}
+
+/** `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;
+}
+
+/**
+ * Tokenize a single-line bash command and verify it is simple enough to
+ * classify: no shell metacharacters (`<`, `>`, `(`, `)`, backtick, `$(`), no
+ * `&&`/`;`/`&` outside a leading `cd X &&` chain, and — unless
+ * `allowTrailingTruncationPipe` — no pipes at all. Returns null for anything
+ * ambiguous so callers fall back to the boxed shell. Newlines and unterminated
+ * quotes are rejected.
+ */
+export function parseSimpleBashCommand(
+	command: string,
+	options: { allowTrailingTruncationPipe?: boolean } = {},
+): SimpleBashCommandShape | 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;
+
+	if (options.allowTrailingTruncationPipe) {
+		// 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);
+		}
+	} else if (tokens.includes("|")) {
+		// git/gh classification keeps the pipe rule strict (ADR 0005): any pipe
+		// falls back to the raw boxed shell.
+		return null;
+	}
+
+	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;
+	return { tokens: rest, ...(cdDir !== undefined ? { cdDir } : {}) };
+}

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

@@ -2,8 +2,15 @@
 // (renderCall/renderResult only; no edit-core re-registration).
 
 import { getLanguageFromPath } from "@earendil-works/pi-coding-agent";
+import type { Component } from "@earendil-works/pi-tui";
 import { stripAnsi } from "../../../shared/ansi.js";
-import { type BoxTheme, getTextOutput, renderBoxedToolCall, renderBoxedToolResult } from "../../../shared/box.js";
+import {
+	type BoxTheme,
+	formatBoxedRunningStatus,
+	getTextOutput,
+	renderBoxedToolCall,
+	renderBoxedToolResult,
+} from "../../../shared/box.js";
 import { formatElapsedMs, getElapsedMs } from "../../../shared/elapsed.js";
 import {
 	AdaptiveDiffComponent,
@@ -12,10 +19,13 @@ import {
 	extractEditedPath,
 	firstText,
 } from "../../../shared/split-diff.js";
+import { isResultSeen } from "./session-config.js";
 import {
 	type BoxedToolContext,
 	type BoxedToolDefinition,
 	displayPath,
+	noteBoxedCallState,
+	noteBoxedResultPhase,
 	noteExecutionStart,
 	resultFooterLines,
 	stateElapsedMs,
@@ -24,6 +34,14 @@ import {
 const MAX_HIGHLIGHT_DIFF_CHARS = 12000;
 const MAX_HIGHLIGHT_DIFF_ROWS = 120;
 
+/** First-partial-pass result: the pending/running call card stands alone. */
+const EMPTY_EDIT_RESULT: Component = Object.freeze({
+	invalidate() {},
+	render() {
+		return [];
+	},
+});
+
 type EditResultDetails = { diff?: string; path?: string } | undefined;
 
 /** `Diff · +3 -0` divider label. */
@@ -52,18 +70,26 @@ function editDiffFooter(
 export const editTool: BoxedToolDefinition = {
 	call(args, theme, context) {
 		noteExecutionStart(context);
+		noteBoxedCallState(context);
 		const detail = displayPath(String(args?.path ?? args?.file_path ?? ""), context);
 		return renderBoxedToolCall(theme, "Edit", [], {
 			headerDetail: detail,
 			isError: Boolean(context.isError),
 			isPartial: Boolean(context.isPartial),
 			isPending: Boolean(context.isPartial),
+			running: Boolean(context.executionStarted),
+			resultSeen: isResultSeen(context.state),
 		});
 	},
 	result(result, options, theme, context) {
-		// Handle partial/streaming state
+		// Handle partial/streaming state: continue the open call box with the
+		// applying hint (no Response divider until the tool settles).
 		if (options.isPartial) {
+			const firstResultPass = noteBoxedResultPhase(context, options.isPartial);
+			if (firstResultPass) return EMPTY_EDIT_RESULT;
 			return renderBoxedToolResult(theme, () => [`${theme.fg("dim", "↳")} ${theme.fg("muted", "Applying edit...")}`], {
+				showDivider: false,
+				footerLines: [formatBoxedRunningStatus(theme, stateElapsedMs(context))],
 				isPartial: true,
 			});
 		}

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

@@ -4,7 +4,8 @@
 import type { Component } from "@earendil-works/pi-tui";
 import type { BoxTheme, MetricResultLike } from "../../../shared/box.js";
 import {
-	formatBoxedFooter,
+	formatBoxedRunningStatus,
+	formatBoxedWords,
 	formatToolName,
 	formatToolOutputLine,
 	formatToolParamLines,
@@ -13,8 +14,8 @@ import {
 	renderBoxedToolResult,
 	selectRenderLines,
 } from "../../../shared/box.js";
-import { getStateElapsedMs, getToolsRenderConfig } from "./session-config.js";
-import { type BoxedToolContext, noteExecutionStart } from "./shared.js";
+import { getStateElapsedMs, getToolsRenderConfig, isResultSeen } from "./session-config.js";
+import { type BoxedToolContext, noteBoxedCallState, noteBoxedResultPhase, noteExecutionStart } from "./shared.js";
 
 const MAX_FALLBACK_PREVIEW_LINES = 10;
 
@@ -25,10 +26,13 @@ export function renderFallbackCall(
 	context: BoxedToolContext,
 ): Component {
 	noteExecutionStart(context);
+	noteBoxedCallState(context);
 	return renderBoxedToolCall(theme, formatToolName(String(toolName ?? "Tool")), formatToolParamLines(args, theme), {
 		isError: Boolean(context.isError),
 		isPartial: Boolean(context.isPartial),
 		isPending: Boolean(context.isPartial),
+		running: Boolean(context.executionStarted),
+		resultSeen: isResultSeen(context.state),
 	});
 }
 
@@ -39,6 +43,7 @@ export function renderFallbackResult(
 	theme: BoxTheme,
 	context: BoxedToolContext,
 ): Component {
+	const firstResultPass = noteBoxedResultPhase(context, options.isPartial);
 	const isError = Boolean(context.isError);
 	const expanded = Boolean(options.expanded);
 	const maxLines = expanded ? getToolsRenderConfig().maxExpandedLines : MAX_FALLBACK_PREVIEW_LINES;
@@ -46,6 +51,28 @@ export function renderFallbackResult(
 	const elapsedMs = getStateElapsedMs(context.state);
 	const { lines, omitted } = selectRenderLines(output, maxLines);
 
+	if (options.isPartial) {
+		// Streaming continuation into the open call box: no Response divider and
+		// no metrics footer until the tool settles. The first partial pass renders
+		// nothing so the pending/running call card stands alone.
+		if (firstResultPass) return EMPTY_FALLBACK_RESULT;
+		const hasOutput = output.trim().length > 0;
+		return renderBoxedToolResult(
+			theme,
+			() => {
+				const body = lines.map((line) => formatToolOutputLine(theme, line, "toolOutput"));
+				if (!hasOutput) body.push(theme.fg("dim", "No output received yet"));
+				return body;
+			},
+			{
+				dividerLabel: "Output",
+				showDivider: hasOutput,
+				footerLines: [formatBoxedRunningStatus(theme, elapsedMs)],
+				isPartial: true,
+			},
+		);
+	}
+
 	return renderBoxedToolResult(
 		theme,
 		() => {
@@ -56,7 +83,7 @@ export function renderFallbackResult(
 			return body;
 		},
 		{
-			footerLines: [formatBoxedFooter(theme, result, [], elapsedMs)],
+			footerLines: [formatBoxedFooterWithElapsed(theme, elapsedMs, output)],
 			renderLineBudget: maxLines,
 			...(expanded || omitted <= 0 ? {} : { expandHint: "Ctrl+O for more" }),
 			isError,
@@ -65,5 +92,21 @@ export function renderFallbackResult(
 	);
 }
 
+/** First-partial-pass result: the pending/running call card stands alone. */
+const EMPTY_FALLBACK_RESULT: Component = Object.freeze({
+	invalidate() {},
+	render() {
+		return [];
+	},
+});
+
+function formatBoxedFooterWithElapsed(theme: BoxTheme, elapsedMs: number | undefined, output: string): string {
+	const elapsed = elapsedMs === undefined ? "--" : `${(elapsedMs / 1000).toFixed(2)}s`;
+	const words = output.trim() ? formatBoxedWords(output) : "";
+	const parts = [theme.fg("text", elapsed)];
+	if (words) parts.push(theme.fg("dim", words));
+	return parts.join(theme.fg("dim", " · "));
+}
+
 // Re-exported for callers that need the tool-name label normalization.
 export { formatToolName };

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

@@ -1,7 +1,7 @@
 // Boxed find tool renderer.
 //
 // find calls render as a boxless tree panel — a lone find shows its parsed
-// output as a flat `Glob: <pattern> <N> files · in <path>` tree; consecutive
+// output as a flat `Find: <pattern> <N> files · in <path>` tree; consecutive
 // find calls group into one panel with per-member nested subtrees (see
 // batch.ts). Pending/failed calls without output fall back to a path row.
 
@@ -21,7 +21,7 @@ import { type BoxedToolDefinition, noteExecutionStart } from "./shared.js";
 const FIND_META: BatchToolMeta = Object.freeze({
 	toolName: "find",
 	label: "Find",
-	headerLabel: "Glob",
+	headerLabel: "Find",
 });
 
 function pathLabel(rawPath: string): string {