@oh-my-pi/pi-coding-agent 16.1.23 → 16.2.0

package/src/task/render.ts

@@ -18,6 +18,7 @@ import {
 	formatExpandHint,
 	formatMoreItems,
 	formatStatusIcon,
+	previewLine,
 	replaceTabs,
 	type ToolUIStatus,
 	truncateToWidth,
@@ -541,7 +542,7 @@ function renderTaskCallLines(args: Partial<TaskParams> | undefined, theme: Theme
 	if (idLabel || desc) {
 		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel || "agent"))}`;
 		if (desc) {
-			line += `: ${theme.fg("muted", truncateToWidth(replaceTabs(desc), 64))}`;
+			line += `: ${theme.fg("muted", previewLine(desc, 64))}`;
 		}
 		lines.push(line);
 	}
@@ -574,7 +575,7 @@ function renderTaskItemLines(tasks: TaskItem[] | undefined, theme: Theme): strin
 		let line = `${bullet} ${theme.fg("accent", theme.bold(idLabel))}`;
 		const desc = typeof task?.description === "string" ? task.description.trim() : "";
 		if (desc) {
-			line += `: ${theme.fg("muted", truncateToWidth(replaceTabs(desc), 64))}`;
+			line += `: ${theme.fg("muted", previewLine(desc, 64))}`;
 		}
 		if (task?.isolated === true) {
 			line += theme.fg("dim", " [isolated]");
@@ -707,7 +708,8 @@ function renderAgentProgress(
 				: "accent";
 
 	// Main status line: id: description [status] · stats · ⟨agent⟩
-	const description = progress.description?.trim();
+	const trimmedDescription = progress.description?.trim();
+	const description = trimmedDescription ? previewLine(trimmedDescription, 64) : undefined;
 	const displayId = formatTaskId(progress.id);
 	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	const indent = prefix ? `${prefix} ` : "";
@@ -748,7 +750,7 @@ function renderAgentProgress(
 	const showBadge = settings.get("task.showResolvedModelBadge");
 	if (progress.status === "running") {
 		if (!description) {
-			const taskPreview = truncateToWidth(progress.assignment ?? progress.task, 40);
+			const taskPreview = previewLine(progress.assignment ?? progress.task, 40);
 			statusLine += ` ${theme.fg("muted", taskPreview)}`;
 		}
 		statusLine = appendAgentStats(statusLine, { ...progress, showResolvedModelBadge: showBadge }, theme);
@@ -766,7 +768,7 @@ function renderAgentProgress(
 			let toolLine = `${continuePrefix}${theme.tree.hook} ${theme.fg("muted", progress.currentTool)}`;
 			const toolDetail = progress.lastIntent ?? progress.currentToolArgs;
 			if (toolDetail) {
-				toolLine += `: ${theme.fg("dim", truncateToWidth(replaceTabs(toolDetail), 40))}`;
+				toolLine += `: ${theme.fg("dim", previewLine(toolDetail, 40))}`;
 			}
 			if (progress.currentToolStartMs) {
 				const elapsed = Date.now() - progress.currentToolStartMs;
@@ -781,7 +783,7 @@ function renderAgentProgress(
 			let toolLine = `${continuePrefix}${theme.tree.hook} ${theme.fg("dim", recent.tool)}`;
 			const toolDetail = progress.lastIntent ?? recent.args;
 			if (toolDetail) {
-				toolLine += `: ${theme.fg("dim", truncateToWidth(replaceTabs(toolDetail), 40))}`;
+				toolLine += `: ${theme.fg("dim", previewLine(toolDetail, 40))}`;
 			}
 			lines.push(toolLine);
 		}
@@ -795,12 +797,12 @@ function renderAgentProgress(
 		const waitLabel = remainingMs > 0 ? `in ${formatDuration(remainingMs)}` : "now";
 		const summary =
 			`retrying ${progress.retryState.attempt}/${progress.retryState.maxAttempts} ${waitLabel}: ` +
-			truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60);
+			previewLine(progress.retryState.errorMessage, 60);
 		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("warning", summary)}`);
 	} else if (progress.retryFailure && progress.status !== "running") {
 		const summary = `auto-retry gave up after ${progress.retryFailure.attempt} attempt${
 			progress.retryFailure.attempt === 1 ? "" : "s"
-		}: ${truncateToWidth(replaceTabs(progress.retryFailure.errorMessage), 80)}`;
+		}: ${previewLine(progress.retryFailure.errorMessage, 80)}`;
 		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("error", summary)}`);
 	}
 
@@ -1029,7 +1031,8 @@ function renderAgentResult(
 					: "failed";
 
 	// Main status line: id: description [status] · stats · ⟨agent⟩
-	const description = result.description?.trim();
+	const trimmedDescription = result.description?.trim();
+	const description = trimmedDescription ? previewLine(trimmedDescription, 64) : undefined;
 	const displayId = formatTaskId(result.id);
 	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	let statusLine = `${prefix ? `${prefix} ` : ""}${theme.fg(iconColor, icon)} ${theme.fg(
@@ -1062,7 +1065,7 @@ function renderAgentResult(
 
 	if (aborted && result.abortReason) {
 		lines.push(
-			`${continuePrefix}${theme.fg("error", theme.status.aborted)} ${theme.fg("dim", truncateToWidth(replaceTabs(result.abortReason), 80))}`,
+			`${continuePrefix}${theme.fg("error", theme.status.aborted)} ${theme.fg("dim", previewLine(result.abortReason, 80))}`,
 		);
 	}
 	// Check for review result (yield with review schema + report_finding)
@@ -1174,9 +1177,7 @@ function renderAgentResult(
 
 	// Error message
 	if (result.error && (!success || mergeFailed) && (!aborted || result.error !== result.abortReason)) {
-		lines.push(
-			`${continuePrefix}${theme.fg(mergeFailed ? "warning" : "error", truncateToWidth(replaceTabs(result.error), 70))}`,
-		);
+		lines.push(`${continuePrefix}${theme.fg(mergeFailed ? "warning" : "error", previewLine(result.error, 70))}`);
 	}
 
 	return lines;

package/src/task/worktree.ts

@@ -169,6 +169,39 @@ export interface NestedRepoPatch {
 	patch: string;
 }
 
+function unquoteGitDiffPath(rawPath: string): string {
+	let value = rawPath;
+	if (value.startsWith('"') && value.endsWith('"')) {
+		try {
+			value = JSON.parse(value) as string;
+		} catch {
+			value = value.slice(1, -1);
+		}
+	}
+	return value.replace(/^[ab]\//, "");
+}
+
+function parseDiffGitLinePaths(line: string): string[] {
+	if (!line.startsWith("diff --git ")) return [];
+	const rest = line.slice("diff --git ".length);
+	const quoted = rest.match(/^("(?:\\.|[^"])+"|\/dev\/null) ("(?:\\.|[^"])+"|\/dev\/null)$/);
+	const parts = quoted ? [quoted[1], quoted[2]] : rest.split(" ");
+	if (parts.length < 2) return [];
+	const paths = parts
+		.slice(0, 2)
+		.map(unquoteGitDiffPath)
+		.filter(file => file && file !== "/dev/null");
+	return [...new Set(paths)];
+}
+
+function patchTouchedFiles(patch: string): string[] {
+	const files = new Set<string>();
+	for (const line of patch.split("\n")) {
+		for (const file of parseDiffGitLinePaths(line)) files.add(file);
+	}
+	return [...files];
+}
+
 export interface DeltaPatchResult {
 	rootPatch: string;
 	nestedPatches: NestedRepoPatch[];
@@ -234,6 +267,7 @@ export async function applyNestedPatches(
 		}
 
 		const combinedDiff = repoPatches.map(p => p.patch).join("\n");
+		const touchedFiles = [...new Set(repoPatches.flatMap(p => patchTouchedFiles(p.patch)))];
 
 		// Preserve any pre-existing dirty state (tracked + untracked) so we
 		// commit only the agent delta, not the user's in-flight work.
@@ -246,8 +280,11 @@ export async function applyNestedPatches(
 				await git.patch.applyText(nestedDir, patch);
 			}
 			if ((await git.status(nestedDir)).trim().length > 0) {
+				if (touchedFiles.length === 0) {
+					throw new Error(`Nested repo patch for ${relativePath} did not include stageable file paths.`);
+				}
 				const msg = (await commitMessage?.(combinedDiff)) ?? "changes from isolated task(s)";
-				await git.stage.files(nestedDir);
+				await git.stage.files(nestedDir, touchedFiles);
 				await git.commit(nestedDir, msg);
 			}
 		} finally {

package/src/tiny/text.ts

@@ -153,7 +153,7 @@ export function isLowSignalTitleInput(message: string): boolean {
  */
 export const NO_TITLE_SENTINEL = "none";
 
-export function normalizeGeneratedTitle(value: string | null | undefined): string | null {
+export function normalizeGeneratedTitle(value: string | null | undefined, sourceText?: string): string | null {
 	const firstLine = value?.trim().split(/\r?\n/, 1)[0]?.trim();
 	if (!firstLine) return null;
 	const title = firstLine
@@ -161,9 +161,54 @@ export function normalizeGeneratedTitle(value: string | null | undefined): strin
 		.replace(/[.!?]$/, "")
 		.trim();
 	if (!title || title.toLowerCase() === NO_TITLE_SENTINEL) return null;
-	return titleCase(title);
+	return sourceText === undefined ? title : reconcileTitleCasing(title, sourceText);
 }
 
-function titleCase(value: string): string {
-	return value.replace(/\b\p{Ll}/gu, c => c.toUpperCase());
+/**
+ * Reconcile a generated title's casing against the user's own message.
+ *
+ * The title prompt asks for sentence case, but small title models still mangle
+ * casing two ways: they sprout stray interior capitals on ordinary words
+ * (`daemon` → `dAemon`) and they flatten proper nouns the user cares about
+ * (`TinyVMM` → `tinyvmm`). The user's message is the source of truth, so per
+ * title token:
+ *  1. typed verbatim in the message → keep it (the user established the casing);
+ *  2. else the message has the same word with *distinctive* casing
+ *     (`TinyVMM`, `iOS`, `API`) → adopt the user's casing (restoration);
+ *  3. else it's a camelCase artifact (lowercase word + stray interior capital,
+ *     `dAemon`) the user never wrote → lowercase it;
+ *  4. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
+ *
+ * Restoration is limited to distinctively cased source tokens so a sentence that
+ * merely *starts* with `For` can't force a mid-title `for` to `For`.
+ */
+function reconcileTitleCasing(title: string, sourceText: string): string {
+	const verbatim = new Set<string>();
+	const distinctive = new Map<string, string>();
+	for (const [token] of sourceText.matchAll(TITLE_WORD)) {
+		verbatim.add(token);
+		if (isDistinctiveCasing(token)) {
+			const lower = token.toLowerCase();
+			if (!distinctive.has(lower)) distinctive.set(lower, token);
+		}
+	}
+	return title.replace(TITLE_WORD, token => {
+		if (verbatim.has(token)) return token;
+		const restored = distinctive.get(token.toLowerCase());
+		if (restored) return restored;
+		return isCamelArtifact(token) ? token.toLowerCase() : token;
+	});
+}
+
+/** Casing richer than a leading capital — interior or repeated uppercase
+ *  (`TinyVMM`, `iOS`, `API`). Worth restoring from the user's message. */
+function isDistinctiveCasing(token: string): boolean {
+	return /\p{L}\p{Lu}/u.test(token);
+}
+
+/** A lowercase word carrying a stray interior capital (`dAemon`, `cReate`): the
+ *  model-mangled shape we flatten when the user never wrote it. PascalCase proper
+ *  nouns (`GitHub`, `OAuth`) start uppercase and are left untouched. */
+function isCamelArtifact(token: string): boolean {
+	return /^\p{Ll}/u.test(token) && /\p{Lu}/u.test(token);
 }

package/src/tiny/worker.ts

@@ -217,14 +217,14 @@ function buildPrompt(generator: TextGenerationPipeline, message: string, systemP
 	return `${generator.tokenizer.apply_chat_template(chat, chatTemplateOptions)}${TITLE_PREFILL}`;
 }
 
-function extractTinyTitle(text: string): string | null {
+function extractTinyTitle(text: string, sourceText: string): string | null {
 	const titleStart = text.lastIndexOf(TITLE_PREFILL);
 	const withoutPrefix = titleStart >= 0 ? text.slice(titleStart + TITLE_PREFILL.length) : text;
 	const closeIndex = withoutPrefix.indexOf(TITLE_CLOSE);
 	const withoutClose = closeIndex >= 0 ? withoutPrefix.slice(0, closeIndex) : withoutPrefix;
 	const tagIndex = withoutClose.indexOf("<");
 	const withoutTag = tagIndex >= 0 ? withoutClose.slice(0, tagIndex) : withoutClose;
-	return normalizeGeneratedTitle(withoutTag);
+	return normalizeGeneratedTitle(withoutTag, sourceText);
 }
 
 async function generateTitle(
@@ -249,7 +249,7 @@ async function generateTitle(
 		return_full_text: false,
 		stopping_criteria: createStopOnTextCriteria(transformers, generator.tokenizer, TITLE_CLOSE),
 	})) as TextGenerationStringOutput;
-	return extractTinyTitle(output[0]?.generated_text ?? "");
+	return extractTinyTitle(output[0]?.generated_text ?? "", message);
 }
 
 function buildCompletionPrompt(generator: TextGenerationPipeline, promptText: string): string {

package/src/tools/bash.ts

@@ -399,8 +399,8 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 			autoBackgroundThresholdSeconds: Math.max(0, Math.floor(this.#autoBackgroundThresholdMs / 1000)),
 			hasAstGrep: this.session.settings.get("astGrep.enabled"),
 			hasAstEdit: this.session.settings.get("astEdit.enabled"),
-			hasSearch: this.session.settings.get("search.enabled"),
-			hasFind: this.session.settings.get("find.enabled"),
+			hasGrep: this.session.settings.get("grep.enabled"),
+			hasGlob: this.session.settings.get("glob.enabled"),
 		});
 	}
 

package/src/tools/builtin-names.ts

@@ -9,8 +9,8 @@ export const BUILTIN_TOOL_NAMES = [
 	"eval",
 	"ssh",
 	"github",
-	"find",
-	"search",
+	"glob",
+	"grep",
 	"lsp",
 	"inspect_image",
 	"browser",
@@ -32,3 +32,27 @@ export const BUILTIN_TOOL_NAMES = [
 ] as const;
 
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
+
+const LEGACY_BUILTIN_TOOL_NAME_ALIASES: ReadonlyMap<string, BuiltinToolName> = new Map([
+	["search", "grep"],
+	["find", "glob"],
+]);
+
+/** Return the canonical tool name for current and legacy built-in tool IDs. */
+export function normalizeToolName(name: string): string {
+	const normalized = name.toLowerCase();
+	return LEGACY_BUILTIN_TOOL_NAME_ALIASES.get(normalized) ?? normalized;
+}
+
+/** Normalize and deduplicate tool names while preserving first-seen order. */
+export function normalizeToolNames(names: Iterable<string>): string[] {
+	const out: string[] = [];
+	const seen = new Set<string>();
+	for (const name of names) {
+		const normalized = normalizeToolName(name);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		out.push(normalized);
+	}
+	return out;
+}

package/src/tools/{find.ts → glob.ts}

@@ -10,7 +10,7 @@ import { type } from "arktype";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";
-import findDescription from "../prompts/tools/find.md" with { type: "text" };
+import globDescription from "../prompts/tools/glob.md" with { type: "text" };
 import { type TruncationResult, truncateHead } from "../session/streaming-output";
 import { Ellipsis, fileHyperlink, renderFileList, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
@@ -20,6 +20,7 @@ import {
 	expandDelimitedPathEntries,
 	formatPathRelativeToCwd,
 	hasGlobPathChars,
+	isSshUrl,
 	normalizePathLikeInput,
 	parseFindPattern,
 	partitionExistingPaths,
@@ -47,13 +48,13 @@ const findSchema = type({
 	"limit?": type("number").describe("max results"),
 });
 
-export type FindToolInput = typeof findSchema.infer;
+export type GlobToolInput = typeof findSchema.infer;
 
 const DEFAULT_LIMIT = 200;
 const MAX_LIMIT = 200;
 const DEFAULT_GLOB_TIMEOUT_MS = 5000;
 
-export interface FindToolDetails {
+export interface GlobToolDetails {
 	truncation?: TruncationResult;
 	resultLimitReached?: number;
 	meta?: OutputMeta;
@@ -76,7 +77,7 @@ export interface FindToolDetails {
  * Pluggable operations for the find tool.
  * Override these to delegate file search to remote systems (e.g., SSH).
  */
-export interface FindOperations {
+export interface GlobOperations {
 	/** Check if path exists */
 	exists: (absolutePath: string) => Promise<boolean> | boolean;
 	/** Optional stat for distinguishing files vs directories. */
@@ -87,28 +88,28 @@ export interface FindOperations {
 	glob: (pattern: string, cwd: string, options: { ignore: string[]; limit: number }) => Promise<string[]> | string[];
 }
 
-export interface FindToolOptions {
+export interface GlobToolOptions {
 	/** Custom operations for find. Default: local filesystem + rg */
-	operations?: FindOperations;
+	operations?: GlobOperations;
 }
 
-interface FindTarget {
+interface GlobTarget {
 	searchPath: string;
 	globPattern: string;
 	hasGlob: boolean;
 }
 
-export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
-	readonly name = "find";
+export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
+	readonly name = "glob";
 	readonly approval = "read" as const;
 	readonly loadMode = "essential";
-	readonly label = "Find";
+	readonly label = "Glob";
 	readonly description: string;
 	readonly parameters = findSchema;
 
 	readonly examples: readonly ToolExample<typeof findSchema.infer>[] = [
 		{
-			caption: "Find files",
+			caption: "Glob files",
 			call: { paths: ["src/**/*.ts"] },
 		},
 		{
@@ -116,33 +117,33 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			call: { paths: ["src/**/*.ts", "test/**/*.ts"] },
 		},
 		{
-			caption: "Find gitignored files like .env",
+			caption: "Glob gitignored files like .env",
 			call: { paths: [".env*"], gitignore: false },
 		},
 		{
-			caption: "Find directories matching a name (returns both files and dirs; directories are suffixed with `/`)",
+			caption: "Glob directories matching a name (returns both files and dirs; directories are suffixed with `/`)",
 			call: { paths: ["**/tests"] },
 		},
 	];
 	readonly strict = true;
 
-	readonly #customOps?: FindOperations;
+	readonly #customOps?: GlobOperations;
 
 	constructor(
 		private readonly session: ToolSession,
-		options?: FindToolOptions,
+		options?: GlobToolOptions,
 	) {
 		this.#customOps = options?.operations;
-		this.description = prompt.render(findDescription);
+		this.description = prompt.render(globDescription);
 	}
 
 	async execute(
 		_toolCallId: string,
 		params: typeof findSchema.infer,
 		signal?: AbortSignal,
-		onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
+		onUpdate?: AgentToolUpdateCallback<GlobToolDetails>,
 		_context?: AgentToolContext,
-	): Promise<AgentToolResult<FindToolDetails>> {
+	): Promise<AgentToolResult<GlobToolDetails>> {
 		const { paths, limit, hidden, gitignore } = params;
 
 		return untilAborted(signal, async () => {
@@ -158,6 +159,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					normalizedPatterns.push(rawPattern);
 					continue;
 				}
+				if (isSshUrl(rawPattern)) {
+					throw new ToolError(
+						`find cannot operate on a remote ssh:// path: ${rawPattern}. ssh:// has no local file to glob; use \`read ${rawPattern}\` to list or inspect the remote path.`,
+					);
+				}
 				if (hasGlobPathChars(rawPattern)) {
 					throw new ToolError(`Glob patterns are not supported for internal URLs: ${rawPattern}`);
 				}
@@ -194,7 +200,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 
 			const multiPattern = await resolveExplicitFindPatterns(effectivePatterns, this.session.cwd);
 			const isSingle = !multiPattern;
-			const targets: FindTarget[] = multiPattern
+			const targets: GlobTarget[] = multiPattern
 				? multiPattern.targets.map(target => ({
 						searchPath: resolveToCwd(target.basePath, this.session.cwd),
 						globPattern: target.globPattern,
@@ -242,11 +248,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const buildResult = (
 				files: string[],
 				opts?: { notice?: string; forceTruncated?: boolean },
-			): AgentToolResult<FindToolDetails> => {
+			): AgentToolResult<GlobToolDetails> => {
 				const notice = opts?.notice;
 				const forceTruncated = opts?.forceTruncated ?? false;
 				if (files.length === 0) {
-					const details: FindToolDetails = {
+					const details: GlobToolDetails = {
 						scopePath,
 						fileCount: 0,
 						files: [],
@@ -272,7 +278,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const rawOutput = trailingNotes.length > 0 ? `${baseOutput}\n\n${trailingNotes.join("\n")}` : baseOutput;
 				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
-				const details: FindToolDetails = {
+				const details: GlobToolDetails = {
 					scopePath,
 					fileCount: limited.length,
 					files: limited,
@@ -337,7 +343,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				const now = Date.now();
 				if (now - lastUpdate < updateIntervalMs) return;
 				lastUpdate = now;
-				const details: FindToolDetails = {
+				const details: GlobToolDetails = {
 					scopePath,
 					fileCount: onUpdateMatches.length,
 					files: onUpdateMatches.slice(),
@@ -362,7 +368,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				};
 
 			let timedOut = false;
-			const runTarget = async (target: FindTarget): Promise<Array<{ path: string; mtime: number }>> => {
+			const runTarget = async (target: GlobTarget): Promise<Array<{ path: string; mtime: number }>> => {
 				throwIfAborted(signal);
 				let stat: fs.Stats;
 				try {
@@ -435,7 +441,7 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				partial.sort((a, b) => b.m - a.m);
 				const sortedPaths = partial.map(entry => entry.p);
 				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
-				const notice = `find timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — narrow the pattern instead of retrying blindly`;
+				const notice = `glob timed out after ${seconds}s; returning ${sortedPaths.length} partial matches — narrow the pattern instead of retrying blindly`;
 				return buildResult(sortedPaths, { notice, forceTruncated: true });
 			}
 
@@ -461,33 +467,33 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 // TUI Renderer
 // =============================================================================
 
-interface FindRenderArgs {
+interface GlobRenderArgs {
 	paths?: string | string[];
 	limit?: number;
 }
 
-function formatFindRenderPaths(paths: FindRenderArgs["paths"]): string | undefined {
+function formatGlobRenderPaths(paths: GlobRenderArgs["paths"]): string | undefined {
 	return Array.isArray(paths) ? paths.join(", ") : paths;
 }
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
 
-function findStatusIcon(uiTheme: Theme): string {
+function globStatusIcon(uiTheme: Theme): string {
 	return uiTheme.fg("toolTitle", uiTheme.symbol("icon.search"));
 }
 
-export const findToolRenderer = {
+export const globToolRenderer = {
 	inline: true,
-	renderCall(args: FindRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
+	renderCall(args: GlobRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
 		if (args.limit !== undefined) meta.push(`limit:${args.limit}`);
 
 		const text = renderStatusLine(
 			{
 				icon: "pending",
-				title: "Find",
+				title: "Glob",
 				titleColor: "toolTitle",
-				description: formatFindRenderPaths(args.paths) || "*",
+				description: formatGlobRenderPaths(args.paths) || "*",
 				meta,
 			},
 			uiTheme,
@@ -496,10 +502,10 @@ export const findToolRenderer = {
 	},
 
 	renderResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: FindToolDetails; isError?: boolean },
+		result: { content: Array<{ type: string; text?: string }>; details?: GlobToolDetails; isError?: boolean },
 		options: RenderResultOptions,
 		uiTheme: Theme,
-		args?: FindRenderArgs,
+		args?: GlobRenderArgs,
 	): Component {
 		const details = result.details;
 
@@ -524,10 +530,10 @@ export const findToolRenderer = {
 			const lines = textContent.split("\n").filter(l => l.trim());
 			const header = renderStatusLine(
 				{
-					iconOverride: findStatusIcon(uiTheme),
-					title: "Find",
+					iconOverride: globStatusIcon(uiTheme),
+					title: "Glob",
 					titleColor: "toolTitle",
-					description: formatFindRenderPaths(args?.paths),
+					description: formatGlobRenderPaths(args?.paths),
 					meta: [formatCount("file", lines.length)],
 				},
 				uiTheme,
@@ -565,9 +571,9 @@ export const findToolRenderer = {
 			const header = renderStatusLine(
 				{
 					icon: "warning",
-					title: "Find",
+					title: "Glob",
 					titleColor: "toolTitle",
-					description: formatFindRenderPaths(args?.paths),
+					description: formatGlobRenderPaths(args?.paths),
 					meta: ["0 files"],
 				},
 				uiTheme,
@@ -581,10 +587,10 @@ export const findToolRenderer = {
 		if (truncated) meta.push(uiTheme.fg("warning", "truncated"));
 		const header = renderStatusLine(
 			{
-				...(truncated ? { icon: "warning" as const } : { iconOverride: findStatusIcon(uiTheme) }),
-				title: "Find",
+				...(truncated ? { icon: "warning" as const } : { iconOverride: globStatusIcon(uiTheme) }),
+				title: "Glob",
 				titleColor: "toolTitle",
-				description: formatFindRenderPaths(args?.paths),
+				description: formatGlobRenderPaths(args?.paths),
 				meta,
 			},
 			uiTheme,