@oh-my-pi/pi-coding-agent 16.3.0 → 16.3.3

package/src/tiny/text.ts

@@ -152,6 +152,34 @@ const FILLER_TITLE_TOKENS = new Set<string>([
 ]);
 
 const TITLE_WORD = /[\p{L}\p{N}]+/gu;
+const COMMON_TITLE_ACRONYMS = new Set<string>([
+	"API",
+	"CLI",
+	"CPU",
+	"CRUD",
+	"CSS",
+	"DNS",
+	"ETL",
+	"GPU",
+	"HTML",
+	"HTTP",
+	"HTTPS",
+	"ID",
+	"JSON",
+	"LLM",
+	"REST",
+	"SDK",
+	"SSH",
+	"TCP",
+	"TLS",
+	"TUI",
+	"UI",
+	"URI",
+	"URL",
+	"UX",
+	"XML",
+	"YAML",
+]);
 
 /**
  * True when a first user message is too low-signal to title (greeting, ack,
@@ -191,51 +219,115 @@ export function normalizeGeneratedTitle(value: string | null | undefined, source
  * 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:
+ * casing three ways: they sprout stray interior capitals on ordinary words
+ * (`daemon` → `dAemon`), they flatten proper nouns the user cased distinctively
+ * (`TinyVMM` → `tinyvmm`), and they title-case ALL-CAPS acronyms as if they
+ * were sentence words (`CNPG` → `Cnpg`). 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* mixed casing
  *     (`TinyVMM`, `iOS`, `IDs`) → adopt the user's casing (restoration);
- *  3. else it's a camelCase artifact (lowercase word + stray interior capital,
+ *  3. else the model produced a plain title-cased artifact (`Cnpg`) whose
+ *     lowercased form is a likely ALL-CAPS acronym in a non-shouty source
+ *     (`CNPG`, `API`, `ETL`) → restore the source acronym;
+ *  4. 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`.
+ *  5. else leave it — preserves model-cased proper nouns like `GitHub`, `OAuth`.
  *
- * Restoration is limited to distinctively *mixed*-cased source tokens: a sentence
- * that merely *starts* with `For` can't force a mid-title `for` to `For`, and
- * emphatic all-caps (`ALL ERROR HANDLING`) is never re-shouted over sentence case.
+ * Restoration is limited to avoid three failure modes: a sentence that merely
+ * *starts* with `For` can't force a mid-title `for` to `For` (distinctive
+ * requires interior mixed casing); emphatic all-caps input (`ALL ERROR
+ * HANDLING`, `FIX the BUG NOW`) is never re-shouted — see {@link isShoutySource};
+ * and ordinary all-caps English words (`FIX`, `WORK`, `BUG`) are not treated as
+ * restorable acronyms unless they carry a stronger acronym signal.
  */
 function reconcileTitleCasing(title: string, sourceText: string): string {
 	const verbatim = new Set<string>();
 	const distinctive = new Map<string, string>();
+	const acronyms = new Map<string, string>();
+	const shouty = isShoutySource(sourceText);
 	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);
+		} else if (!shouty && isAllCapsAcronym(token)) {
+			const lower = token.toLowerCase();
+			if (!acronyms.has(lower)) acronyms.set(lower, token);
 		}
 	}
 	return title.replace(TITLE_WORD, token => {
 		if (verbatim.has(token)) return token;
-		const restored = distinctive.get(token.toLowerCase());
+		const lower = token.toLowerCase();
+		const restored = distinctive.get(lower);
 		if (restored) return restored;
-		return isCamelArtifact(token) ? token.toLowerCase() : token;
+		if (isTitleCasedArtifact(token)) {
+			const acronym = acronyms.get(lower);
+			if (acronym) return acronym;
+		}
+		return isCamelArtifact(token) ? lower : token;
 	});
 }
 
 /** Mixed-case identifier the user cased deliberately (`TinyVMM`, `iOS`, `IDs`):
  *  an interior/repeated capital plus at least one lowercase letter. Only these
- *  are restored when the model flattens them.
- *
- *  Pure all-caps is intentionally excluded. The model preserves its own acronyms
- *  verbatim regardless, so restoring all-caps from the source would only ever
- *  re-shout emphatic input (`ALL ERROR HANDLING`, `FIX THE BUG`) over the
- *  sentence case the prompt asks for. */
+ *  are restored when the model flattens them. */
 function isDistinctiveCasing(token: string): boolean {
 	return /\p{Ll}/u.test(token) && /\p{L}\p{Lu}/u.test(token);
 }
 
+/** Multi-letter ALL-CAPS source token with a stronger acronym signal than a
+ *  plain emphasized word. Consonant-only tokens (`CNPG`, `SQL`, `JWT`) are
+ *  restored, digit-bearing identifiers are restored, and common technical
+ *  acronyms (`API`, `JSON`, `URL`) are allowlisted. Ordinary emphasized words
+ *  (`FIX`, `WORK`, `BUG`) contain vowels and are not restored from source. */
+function isAllCapsAcronym(token: string): boolean {
+	if (!isAllCapsWord(token)) return false;
+	const upper = token.toUpperCase();
+	if (COMMON_TITLE_ACRONYMS.has(upper)) return true;
+	if (/\p{N}/u.test(token)) return true;
+	return !/[AEIOU]/.test(upper);
+}
+
+/** Multi-letter ALL-CAPS word in the source. Used for shout detection, not for
+ *  acronym restoration — shouted English words (`FIX`, `WORK`) still count as
+ *  shouty even though they are not restorable acronyms. Requires an actual
+ *  uppercase letter so caseless scripts (CJK) never register as shouting and
+ *  disable acronym restoration for those messages. */
+function isAllCapsWord(token: string): boolean {
+	const letters = token.match(/\p{L}/gu);
+	if (!letters || letters.length < 2) return false;
+	return /\p{Lu}/u.test(token) && !/\p{Ll}/u.test(token);
+}
+
+/** Plain title-cased word (`Cnpg`, `Etl`): starts uppercase, has one-or-more
+ *  lowercase letters, no interior uppercase. This is the artifact a title model
+ *  produces when it sentence-cases an unfamiliar ALL-CAPS acronym; PascalCase
+ *  proper nouns like `GitHub`/`OAuth` have an interior capital and are
+ *  excluded so we don't misidentify them. */
+function isTitleCasedArtifact(token: string): boolean {
+	if (!/^\p{Lu}/u.test(token)) return false;
+	if (!/\p{Ll}/u.test(token)) return false;
+	return !/\p{Lu}/u.test(token.slice(1));
+}
+
+/** True when the source text is shouting — ≥2 consecutive multi-letter
+ *  ALL-CAPS tokens (`FIX the BUG NOW` has `BUG NOW`; `ALL ERROR HANDLING`
+ *  has all three adjacent). Acronym restoration is disabled for shouty input
+ *  so we don't re-shout emphatic prose the model correctly de-shouted. */
+function isShoutySource(sourceText: string): boolean {
+	let run = 0;
+	for (const [token] of sourceText.matchAll(TITLE_WORD)) {
+		if (isAllCapsWord(token)) {
+			run += 1;
+			if (run >= 2) return true;
+		} else {
+			run = 0;
+		}
+	}
+	return false;
+}
+
 /** 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. */

package/src/tools/ast-grep.ts

@@ -19,7 +19,7 @@ import { createFileRecorder, formatResultPath } from "./file-recorder";
 import { classifyGroupedLines, formatGroupedFiles, groupLineIndicesByBlank } from "./grouped-file-output";
 import { formatMatchLine } from "./match-line-format";
 import type { OutputMeta } from "./output-meta";
-import { resolveToolSearchScope } from "./path-utils";
+import { resolveToolSearchScope, toPathList } from "./path-utils";
 import {
 	appendParseErrorsBulletList,
 	capParseErrors,
@@ -37,11 +37,9 @@ import { toolResult } from "./tool-result";
 
 const astGrepSchema = type({
 	pat: type("string").describe("ast pattern"),
-	paths: type("string")
-		.describe("file, directory, glob, or internal URL to search")
-		.array()
-		.atLeastLength(1)
-		.describe("files, directories, globs, or internal URLs to search"),
+	"path?": type("string").describe(
+		'file, directory, glob, or internal URL to search; pass several as a semicolon-delimited list ("src; tests"). Omitted -> searches the workspace root (".")',
+	),
 	"skip?": type("number").describe("matches to skip"),
 });
 
@@ -159,23 +157,23 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 	readonly examples: readonly ToolExample<typeof astGrepSchema.inferIn>[] = [
 		{
 			caption: "Search TypeScript files under src",
-			call: { pat: "console.log($$$)", paths: ["src/**/*.ts"] },
+			call: { pat: "console.log($$$)", path: "src/**/*.ts" },
 		},
 		{
 			caption: "Named imports from a specific package",
-			call: { pat: 'import { $$$IMPORTS } from "react"', paths: ["src/**/*.ts"] },
+			call: { pat: 'import { $$$IMPORTS } from "react"', path: "src/**/*.ts" },
 		},
 		{
 			caption: "Arrow functions assigned to a const",
-			call: { pat: "const $NAME = ($$$ARGS) => $BODY", paths: ["src/utils/**/*.ts"] },
+			call: { pat: "const $NAME = ($$$ARGS) => $BODY", path: "src/utils/**/*.ts" },
 		},
 		{
 			caption: "Method call on any object, ignoring method name with `$_`",
-			call: { pat: "logger.$_($$$ARGS)", paths: ["src/**/*.ts"] },
+			call: { pat: "logger.$_($$$ARGS)", path: "src/**/*.ts" },
 		},
 		{
 			caption: "Loosest existence check for a symbol in one file",
-			call: { pat: "processItems", paths: ["src/worker.ts"] },
+			call: { pat: "processItems", path: "src/worker.ts" },
 		},
 	];
 	readonly loadMode = "discoverable";
@@ -201,8 +199,10 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 			if (!Number.isFinite(skip) || skip < 0) {
 				throw new ToolError("skip must be a non-negative number");
 			}
+			const scopedPaths = toPathList(params.path);
+			const rawPaths = scopedPaths.length > 0 ? scopedPaths : ["."];
 			const scope = await resolveToolSearchScope({
-				rawPaths: params.paths,
+				rawPaths,
 				cwd: this.session.cwd,
 				internalUrlAction: "search",
 				settings: this.session.settings,
@@ -275,7 +275,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 			if (result.matches.length === 0) {
 				const noMatchMessage = cappedParseErrors.length
-					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `paths` before concluding absence."
+					? "No matches found. Parse issues mean the query may be mis-scoped; narrow `path` before concluding absence."
 					: "No matches found";
 				const parseMessage = cappedParseErrors.length
 					? `\n${formatParseErrors(cappedParseErrors, parseErrorsTotal).join("\n")}`
@@ -375,7 +375,7 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 				displayContent: displayLines.join("\n"),
 			};
 			if (result.limitReached) {
-				outputLines.push("", "Result limit reached; narrow paths or increase limit.");
+				outputLines.push("", "Result limit reached; narrow path or increase limit.");
 			}
 			if (cappedParseErrors.length) {
 				outputLines.push("", ...formatParseErrors(cappedParseErrors, parseErrorsTotal));
@@ -392,6 +392,8 @@ export class AstGrepTool implements AgentTool<typeof astGrepSchema, AstGrepToolD
 
 interface AstGrepRenderArgs {
 	pat?: string;
+	path?: string | string[];
+	/** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
 	paths?: string[];
 	skip?: number;
 }
@@ -402,7 +404,8 @@ export const astGrepToolRenderer = {
 	inline: true,
 	renderCall(args: AstGrepRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
 		const meta: string[] = [];
-		if (args.paths?.length) meta.push(`in ${args.paths.join(", ")}`);
+		const scopePaths = toPathList(args.path ?? args.paths);
+		if (scopePaths.length) meta.push(`in ${scopePaths.join(", ")}`);
 		if (args.skip !== undefined && args.skip > 0) meta.push(`skip:${args.skip}`);
 
 		const description = args.pat ?? "?";
@@ -436,7 +439,7 @@ export const astGrepToolRenderer = {
 			const header = renderStatusLine({ icon: "warning", title: "AST Grep", description, meta }, uiTheme);
 			const lines = [header, formatEmptyMessage("No matches found", uiTheme)];
 			if (details?.parseErrors?.length) {
-				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `paths` before concluding absence"));
+				lines.push(uiTheme.fg("warning", "Query may be mis-scoped; narrow `path` before concluding absence"));
 				appendParseErrorsBulletList(lines, details.parseErrors, uiTheme, details.parseErrorsTotal);
 			}
 			return new Text(lines.join("\n"), 0, 0);
@@ -487,7 +490,7 @@ export const astGrepToolRenderer = {
 
 		const extraLines: string[] = [];
 		if (limitReached) {
-			extraLines.push(uiTheme.fg("warning", "limit reached; narrow paths or increase limit"));
+			extraLines.push(uiTheme.fg("warning", "limit reached; narrow path or increase limit"));
 		}
 		if (details?.parseErrors?.length) {
 			extraLines.push(

package/src/tools/bash.ts

@@ -46,6 +46,33 @@ export const BASH_DEFAULT_PREVIEW_LINES = 10;
 const BASH_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS = 60_000;
 
+/**
+ * Shape a shell command line for an ACP-conformant `terminal/create` request.
+ *
+ * ACP's `command` field is documented as the executable and `args` as its
+ * argv tail (see https://agentclientprotocol.com/protocol/v1/terminals), so a
+ * spec-conformant client `spawn(command, args)`s them directly — no implicit
+ * shell. A raw `bash` tool line ("git status && echo x | head") therefore has
+ * to be wrapped in an explicit shell invocation, otherwise the client tries
+ * to spawn the whole line as argv[0] and fails with `ENOENT` for anything
+ * containing a space, pipe, `&&`, redirect, or `$(...)`.
+ *
+ * The wrap reuses the same shell binary + args the local `bash-executor` would
+ * pick via `settings.getShellConfig()` — Git Bash / `bash.exe` on Windows,
+ * `$SHELL` (bash/zsh) with the `sh` fallback on POSIX — so the ACP path
+ * preserves `bash` tool semantics (`$VAR`, `$(...)`, `source`, POSIX quoting,
+ * `-l`) instead of dropping to `cmd.exe` on Windows. The agent host's shell
+ * path is used as a proxy for the client's, matching the near-universal
+ * ACP deployment shape of an editor spawning omp as a co-hosted subprocess.
+ */
+export function wrapShellLineForClientTerminal(
+	line: string,
+	shellConfig: { shell: string; args: string[]; prefix?: string | undefined },
+): { command: string; args: string[] } {
+	const finalLine = shellConfig.prefix ? `${shellConfig.prefix} ${line}` : line;
+	return { command: shellConfig.shell, args: [...shellConfig.args, finalLine] };
+}
+
 /**
  * Bash patterns flagged as safety critical for approval policy.
  *
@@ -842,8 +869,10 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		// Skip when pty=true (PTY needs the local terminal UI).
 		if (clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty) {
 			const bridgeWallTimeStart = performance.now();
+			const shellSpawn = wrapShellLineForClientTerminal(command, this.session.settings.getShellConfig());
 			const handle = await clientBridge.createTerminal({
-				command,
+				command: shellSpawn.command,
+				args: shellSpawn.args,
 				cwd: commandCwd,
 				env: resolvedEnv
 					? Object.entries(resolvedEnv).map(([name, value]) => ({ name, value: value as string }))
@@ -1151,22 +1180,30 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 		renderCall(args: TArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 			const renderArgs = toBashRenderArgs(args, config);
 			const cmdLines = formatBashCommandLines(renderArgs, uiTheme);
-			const header =
-				config.showHeader === false
-					? undefined
-					: renderStatusLine({ icon: "pending", title: config.resolveTitle(args, options) }, uiTheme);
 			const outputBlock = new CachedOutputBlock();
 			return markFramedBlockComponent({
-				render: (width: number): readonly string[] =>
-					outputBlock.render(
+				render: (width: number): readonly string[] => {
+					const header =
+						config.showHeader === false
+							? undefined
+							: renderStatusLine(
+									{
+										icon: options.spinnerFrame !== undefined ? "running" : "pending",
+										spinnerFrame: options.spinnerFrame,
+										title: config.resolveTitle(args, options),
+									},
+									uiTheme,
+								);
+					return outputBlock.render(
 						{
 							header,
-							state: "pending",
+							state: options.spinnerFrame !== undefined ? "running" : "pending",
 							sections: [{ lines: capPreviewLines(cmdLines, uiTheme, { expanded: options.expanded }) }],
 							width,
 						},
 						uiTheme,
-					),
+					);
+				},
 				invalidate: () => {
 					outputBlock.invalidate();
 				},

package/src/tools/browser/render.ts

@@ -187,6 +187,8 @@ function extractTextOutput(content: Array<{ type: string; text?: string }> | und
 }
 
 export const browserToolRenderer = {
+	animatedPendingPreview: (args: unknown) => (args as BrowserRenderArgs).action === "run",
+	animatedPartialResult: (args: unknown) => (args as BrowserRenderArgs).action === "run",
 	renderCall(args: BrowserRenderArgs, options: RenderResultOptions, theme: Theme): Component {
 		const action = args.action;
 		if (action === "run") {

package/src/tools/debug.ts

@@ -583,6 +583,7 @@ function summarizeDebugCall(args: DebugRenderArgs): string {
 }
 
 export const debugToolRenderer = {
+	animatedPartialResult: true,
 	renderCall(args: DebugRenderArgs, _options: RenderResultOptions, theme: Theme): Component {
 		const text = renderStatusLine({ icon: "pending", title: "Debug", description: summarizeDebugCall(args) }, theme);
 		return new Text(text, 0, 0);

package/src/tools/eval-render.ts

@@ -489,6 +489,8 @@ function formatCellOutputLines(
 }
 
 export const evalToolRenderer = {
+	animatedPendingPreview: true,
+	animatedPartialResult: true,
 	renderCall(args: EvalRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 		const cells = getRenderCells(args);
 
@@ -502,7 +504,7 @@ export const evalToolRenderer = {
 
 		return markFramedBlockComponent({
 			render: (width: number): readonly string[] => {
-				const key = `${options.expanded ? 1 : 0}|${previewWindowRows()}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
+				const key = `${options.expanded ? 1 : 0}|${options.spinnerFrame ?? "-"}|${previewWindowRows()}|${cells.map(c => `${c.language}:${c.title ?? ""}:${c.code.length}`).join("|")}`;
 				if (cached && cached.key === key && cached.width === width) {
 					return cached.result;
 				}
@@ -518,7 +520,8 @@ export const evalToolRenderer = {
 							index: i,
 							total: cells.length,
 							title: cell.title,
-							status: "pending",
+							status: options.spinnerFrame !== undefined ? "running" : "pending",
+							spinnerFrame: options.spinnerFrame,
 							width,
 							// Viewport-sized tail window following the newest streamed code
 							// line; renderResult keeps the same cap so the cell never snaps

package/src/tools/gh-renderer.ts

@@ -416,6 +416,9 @@ function renderWatchCall(args: GithubToolRenderArgs, options: RenderResultOption
 }
 
 export const githubToolRenderer = {
+	// No animatedPendingPreview: renderCall materializes plain Text components
+	// once per display rebuild (no render closure), so a live spinner interval
+	// would request 30fps repaints while the visible glyph stays frozen.
 	renderCall(args: GithubToolRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
 		const op = typeof args.op === "string" && args.op.trim().length > 0 ? args.op.trim() : undefined;
 		if (op === "run_watch") {

package/src/tools/glob.ts

@@ -26,6 +26,7 @@ import {
 	partitionExistingPaths,
 	resolveExplicitFindPatterns,
 	resolveToCwd,
+	toPathList,
 } from "./path-utils";
 import {
 	createCachedComponent,
@@ -38,11 +39,9 @@ import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 
 const findSchema = type({
-	paths: type("string")
-		.describe("glob including search path")
-		.array()
-		.atLeastLength(1)
-		.describe("globs including search paths"),
+	"path?": type("string").describe(
+		'glob, file, or directory to search — a single path or a semicolon-delimited list ("src/**/*.ts; test/**/*.ts"). Omitted -> searches the workspace root (".")',
+	),
 	"hidden?": type("boolean").describe("include hidden files"),
 	"gitignore?": type("boolean").describe("respect gitignore"),
 	"limit?": type("number").describe("max results"),
@@ -110,19 +109,19 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 	readonly examples: readonly ToolExample<typeof findSchema.infer>[] = [
 		{
 			caption: "Glob files",
-			call: { paths: ["src/**/*.ts"] },
+			call: { path: "src/**/*.ts" },
 		},
 		{
-			caption: "Multiple targets — separate array elements",
-			call: { paths: ["src/**/*.ts", "test/**/*.ts"] },
+			caption: "Multiple targets — semicolon-delimited list",
+			call: { path: "src/**/*.ts; test/**/*.ts" },
 		},
 		{
 			caption: "Glob gitignored files like .env",
-			call: { paths: [".env*"], gitignore: false },
+			call: { path: ".env*", gitignore: false },
 		},
 		{
 			caption: "Glob directories matching a name (returns both files and dirs; directories are suffixed with `/`)",
-			call: { paths: ["**/tests"] },
+			call: { path: "**/tests" },
 		},
 	];
 	readonly strict = true;
@@ -144,13 +143,15 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<GlobToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<GlobToolDetails>> {
-		const { paths, limit, hidden, gitignore } = params;
+		const { path: pathInput, limit, hidden, gitignore } = params;
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
+			const scopedPaths = toPathList(pathInput);
+			const effectivePaths = scopedPaths.length > 0 ? scopedPaths : ["."];
 			const rawPatternInputs = this.#customOps
-				? paths
-				: await expandDelimitedPathEntries(paths, this.session.cwd, { splitter: parseFindPattern });
+				? effectivePaths
+				: await expandDelimitedPathEntries(effectivePaths, this.session.cwd, { splitter: parseFindPattern });
 			const rawPatterns = rawPatternInputs.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
@@ -180,7 +181,7 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 				normalizedPatterns.push(resource.sourcePath);
 			}
 			if (normalizedPatterns.some(pattern => pattern.length === 0)) {
-				throw new ToolError("`paths` must contain non-empty globs or paths");
+				throw new ToolError("`path` must contain non-empty globs or paths");
 			}
 
 			// Tolerate missing entries in a multi-path call: skip ones whose base
@@ -468,12 +469,15 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 // =============================================================================
 
 interface GlobRenderArgs {
+	path?: string | string[];
+	/** Legacy pre-`path` argument name; kept so historical transcripts still render a scope. */
 	paths?: string | string[];
 	limit?: number;
 }
 
-function formatGlobRenderPaths(paths: GlobRenderArgs["paths"]): string | undefined {
-	return Array.isArray(paths) ? paths.join(", ") : paths;
+function formatGlobRenderPaths(args: GlobRenderArgs | undefined): string | undefined {
+	const list = toPathList(args?.path ?? args?.paths);
+	return list.length > 0 ? list.join(", ") : undefined;
 }
 
 const COLLAPSED_LIST_LIMIT = PREVIEW_LIMITS.COLLAPSED_ITEMS;
@@ -493,7 +497,7 @@ export const globToolRenderer = {
 				icon: "pending",
 				title: "Glob",
 				titleColor: "toolTitle",
-				description: formatGlobRenderPaths(args.paths) || "*",
+				description: formatGlobRenderPaths(args) || "*",
 				meta,
 			},
 			uiTheme,
@@ -533,7 +537,7 @@ export const globToolRenderer = {
 					iconOverride: globStatusIcon(uiTheme),
 					title: "Glob",
 					titleColor: "toolTitle",
-					description: formatGlobRenderPaths(args?.paths),
+					description: formatGlobRenderPaths(args),
 					meta: [formatCount("file", lines.length)],
 				},
 				uiTheme,
@@ -573,7 +577,7 @@ export const globToolRenderer = {
 					icon: "warning",
 					title: "Glob",
 					titleColor: "toolTitle",
-					description: formatGlobRenderPaths(args?.paths),
+					description: formatGlobRenderPaths(args),
 					meta: ["0 files"],
 				},
 				uiTheme,
@@ -590,7 +594,7 @@ export const globToolRenderer = {
 				...(truncated ? { icon: "warning" as const } : { iconOverride: globStatusIcon(uiTheme) }),
 				title: "Glob",
 				titleColor: "toolTitle",
-				description: formatGlobRenderPaths(args?.paths),
+				description: formatGlobRenderPaths(args),
 				meta,
 			},
 			uiTheme,