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

package/src/extensibility/custom-tools/loader.ts

@@ -18,7 +18,7 @@ import { getAllPluginToolPaths } from "../../extensibility/plugins/loader";
 // Runtime self-reference: dereference this namespace only inside loader functions to keep the index.ts cycle safe.
 import * as PiCodingAgent from "../../index";
 import * as typebox from "../typebox";
-import { createNoOpUIContext, resolvePath } from "../utils";
+import { createNoOpUIContext, resolvePath, withExitGuard } from "../utils";
 import type { CustomToolAPI, CustomToolFactory, LoadedCustomTool, ToolLoadError } from "./types";
 
 /**
@@ -45,14 +45,14 @@ async function loadTool(
 	}
 
 	try {
-		const module = await import(resolvedPath);
+		const module = await withExitGuard(() => import(resolvedPath));
 		const factory = (module.default ?? module) as CustomToolFactory;
 
 		if (typeof factory !== "function") {
 			return { tools: null, error: { path: toolPath, error: "Tool must export a default function", source } };
 		}
 
-		const toolResult = await factory(sharedApi);
+		const toolResult = await withExitGuard(async () => factory(sharedApi));
 		const toolsArray = Array.isArray(toolResult) ? toolResult : [toolResult];
 
 		const loadedTools: LoadedCustomTool[] = toolsArray.map(tool => ({

package/src/extensibility/extensions/loader.ts

@@ -521,10 +521,17 @@ export async function discoverExtensionPaths(
 		}
 	};
 
-	// 1. Discover extension modules via capability API (native .omp/.pi only)
-	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, loadOptions);
+	// 1. Discover extension modules via capability API (native .omp/.pi only).
+	// Scope the load to the native provider — the extension-module capability
+	// also has claude/codex/gemini/opencode providers, and their items were
+	// discarded here anyway (see #4198). The provider filter skips the walk
+	// entirely instead of running four foreign directory scans and dropping
+	// the results.
+	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, {
+		...loadOptions,
+		providers: ["native"],
+	});
 	for (const ext of discovered.items) {
-		if (ext._source.provider !== "native") continue;
 		addPath(ext.path);
 	}
 

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -500,7 +500,7 @@ export function createGrepToolDefinition(cwd: string, options?: GrepToolOptions)
 				toolCallId,
 				{
 					pattern,
-					paths: glob ? joinLegacyGlob(searchPath, glob) : searchPath,
+					path: glob ? joinLegacyGlob(searchPath, glob) : searchPath,
 					case: booleanField(params, "ignoreCase") ? false : undefined,
 				},
 				signal,
@@ -558,7 +558,7 @@ export function createFindToolDefinition(cwd: string, options?: FindToolOptions)
 			}
 			return tool.execute(
 				toolCallId,
-				{ paths: [joinLegacyGlob(searchPath, pattern)], hidden: true, gitignore: true, limit },
+				{ path: joinLegacyGlob(searchPath, pattern), hidden: true, gitignore: true, limit },
 				signal,
 				onUpdate,
 			);

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -3,6 +3,7 @@ import { isBuiltin } from "node:module";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary, stripWindowsExtendedLengthPathPrefix } from "@oh-my-pi/pi-utils";
+import { registerPluginCacheInvalidator } from "../../discovery/helpers";
 import { BUNDLED_PI_REGISTRY_KEYS } from "./legacy-pi-bundled-keys";
 
 const IS_COMPILED_BINARY = isCompiledBinary();
@@ -202,6 +203,22 @@ const SOURCE_MODULE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx",
 const SUPPORTED_PACKAGE_IMPORT_CONDITIONS = new Set(["bun", "node", "import", "default"]);
 const packageRootCache = new Map<string, string | null>();
 const packageImportsCache = new Map<string, Record<string, unknown> | null>();
+const nodePackageRootCache = new Map<string, Promise<string | null>>();
+const packageManifestCache = new Map<string, Promise<Record<string, unknown> | null>>();
+const bareDependencyResolutionCache = new Map<string, Promise<string | null>>();
+const realpathCache = new Map<string, Promise<string>>();
+
+function clearLegacyPiResolutionCaches(): void {
+	resolvedSpecifierFallbacks.clear();
+	packageRootCache.clear();
+	packageImportsCache.clear();
+	nodePackageRootCache.clear();
+	packageManifestCache.clear();
+	bareDependencyResolutionCache.clear();
+	realpathCache.clear();
+}
+
+registerPluginCacheInvalidator(clearLegacyPiResolutionCaches);
 const PACKAGE_IMPORT_EXCLUDED = Symbol("packageImportExcluded");
 
 // Extensions that imported TypeBox directly used to resolve against a real
@@ -730,6 +747,16 @@ function splitBarePackageSpecifier(specifier: string): BarePackageSpecifier | nu
 }
 
 async function findNodePackageRoot(packageName: string, importerPath: string): Promise<string | null> {
+	const cacheKey = `${packageName}\0${path.resolve(path.dirname(importerPath))}`;
+	const cached = nodePackageRootCache.get(cacheKey);
+	if (cached) return cached;
+
+	const promise = findNodePackageRootUncached(packageName, importerPath);
+	nodePackageRootCache.set(cacheKey, promise);
+	return promise;
+}
+
+async function findNodePackageRootUncached(packageName: string, importerPath: string): Promise<string | null> {
 	let dir = path.dirname(importerPath);
 	while (true) {
 		const candidate = path.join(dir, "node_modules", packageName);
@@ -745,6 +772,15 @@ async function findNodePackageRoot(packageName: string, importerPath: string): P
 }
 
 async function readPackageManifest(packageRoot: string): Promise<Record<string, unknown> | null> {
+	const cached = packageManifestCache.get(packageRoot);
+	if (cached) return cached;
+
+	const promise = readPackageManifestUncached(packageRoot);
+	packageManifestCache.set(packageRoot, promise);
+	return promise;
+}
+
+async function readPackageManifestUncached(packageRoot: string): Promise<Record<string, unknown> | null> {
 	try {
 		const manifest = await Bun.file(path.join(packageRoot, "package.json")).json();
 		return isRecord(manifest) ? manifest : null;
@@ -841,6 +877,17 @@ async function resolveExtensionBareDependency(specifier: string, importerPath: s
 	if (!isBareExtensionDependencySpecifier(specifier)) {
 		return null;
 	}
+
+	const cacheKey = `${specifier}\0${path.resolve(path.dirname(importerPath))}`;
+	const cached = bareDependencyResolutionCache.get(cacheKey);
+	if (cached) return cached;
+
+	const promise = resolveExtensionBareDependencyUncached(specifier, importerPath);
+	bareDependencyResolutionCache.set(cacheKey, promise);
+	return promise;
+}
+
+async function resolveExtensionBareDependencyUncached(specifier: string, importerPath: string): Promise<string | null> {
 	try {
 		const resolved = Bun.resolveSync(specifier, path.dirname(importerPath));
 		if (resolved && resolved !== specifier && !resolved.startsWith("node:") && !resolved.startsWith("bun:")) {
@@ -892,6 +939,15 @@ const hookedExtensionEntries = new Set<string>();
 
 /** Resolve symlinks in a path, falling back to the input if realpath fails. */
 async function realpathOrSelf(p: string): Promise<string> {
+	const cached = realpathCache.get(p);
+	if (cached) return cached;
+
+	const promise = realpathOrSelfUncached(p);
+	realpathCache.set(p, promise);
+	return promise;
+}
+
+async function realpathOrSelfUncached(p: string): Promise<string> {
 	try {
 		return await fs.promises.realpath(p);
 	} catch {
@@ -907,8 +963,8 @@ async function realpathOrSelf(p: string): Promise<string> {
  * wherever it physically lives (a `../src` sibling, a symlinked sub-tree, …).
  * This mirrors the module set the old temp-dir mirror tracked, minus the copy.
  */
-async function collectExtensionModules(entryRealPath: string): Promise<Set<string>> {
-	const modules = new Set<string>();
+async function collectExtensionModules(entryRealPath: string): Promise<Map<string, string>> {
+	const modules = new Map<string, string>();
 	const queue = [entryRealPath];
 	while (queue.length > 0) {
 		const file = queue.pop();
@@ -921,7 +977,7 @@ async function collectExtensionModules(entryRealPath: string): Promise<Set<strin
 		} catch {
 			continue;
 		}
-		modules.add(file);
+		modules.set(file, source);
 		const dir = path.dirname(file);
 		for (const match of source.matchAll(EXTENSION_GRAPH_SPECIFIER_REGEX)) {
 			const specifier = match[1];
@@ -949,25 +1005,38 @@ async function collectExtensionModules(entryRealPath: string): Promise<Set<strin
  * so the filter is an exact-path alternation of the graph's realpaths — it
  * never matches the host, other extensions, `node_modules` deps, or unrelated
  * project source.
+ *
+ * Returns the collected path→source map on first install so the caller can
+ * drop entries the initial import never consumed; `undefined` when the hook
+ * was already installed.
  */
-async function ensureExtensionGraphHook(entryRealPath: string): Promise<void> {
+async function ensureExtensionGraphHook(entryRealPath: string): Promise<Map<string, string> | undefined> {
 	if (hookedExtensionEntries.has(entryRealPath)) {
-		return;
+		return undefined;
 	}
 	hookedExtensionEntries.add(entryRealPath);
 
 	const modules = await collectExtensionModules(entryRealPath);
-	const alternation = [...modules].map(escapeRegExp).join("|");
+	const alternation = [...modules.keys()].map(escapeRegExp).join("|");
 	const filter = new RegExp(`^(?:${alternation})$`);
 	Bun.plugin({
 		name: `omp:legacy-pi-ext:${Bun.hash(entryRealPath).toString(36)}`,
 		setup(build) {
 			build.onLoad({ filter, namespace: "file" }, async args => {
-				const raw = await Bun.file(args.path).text();
+				const cached = modules.get(args.path);
+				let raw: string;
+				if (cached !== undefined) {
+					// consume-once: preserves ?mtime edit-pickup for the re-imported entry
+					modules.delete(args.path);
+					raw = cached;
+				} else {
+					raw = await Bun.file(args.path).text();
+				}
 				return { contents: await rewriteLegacyExtensionSource(raw, args.path), loader: getLoader(args.path) };
 			});
 		},
 	});
+	return modules;
 }
 
 /**
@@ -986,9 +1055,16 @@ export async function loadLegacyPiModule(resolvedPath: string): Promise<unknown>
 	// `bun link`/pnpm installs) so the rewrite filter matches the path Bun
 	// actually hands the hook.
 	const entryRealPath = await realpathOrSelf(path.resolve(resolvedPath));
-	await ensureExtensionGraphHook(entryRealPath);
-	// `?mtime` busts Bun's module cache so repeat loads pick up edited source.
-	return import(`${toImportSpecifier(entryRealPath)}?mtime=${Date.now()}`);
+	const pendingSources = await ensureExtensionGraphHook(entryRealPath);
+	try {
+		// `?mtime` busts Bun's module cache so repeat loads pick up edited source.
+		return await import(`${toImportSpecifier(entryRealPath)}?mtime=${Date.now()}`);
+	} finally {
+		// Drop whatever the initial import didn't consume: graph modules only
+		// reached by lazy dynamic imports must be read from disk at their actual
+		// import time, not served from this load-time snapshot.
+		pendingSources?.clear();
+	}
 }
 
 function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
@@ -1061,5 +1137,5 @@ export function installLegacyPiSpecifierShim(): void {
 
 /** Test seam: clears the memoized canonical specifier resolutions. */
 export function __resetLegacyPiResolutionCache(): void {
-	resolvedSpecifierFallbacks.clear();
+	clearLegacyPiResolutionCaches();
 }

package/src/extensibility/plugins/loader.ts

@@ -8,7 +8,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getPluginsDir, getPluginsLockfile, isEnoent } from "@oh-my-pi/pi-utils";
 import { getConfigDirPaths } from "../../config";
-import { resolveActiveProjectRegistryPath } from "../../discovery/helpers";
+import { registerPluginCacheInvalidator, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import { installLegacyPiSpecifierShim } from "./legacy-pi-compat";
 import { normalizePluginRuntimeConfig } from "./runtime-config";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
@@ -20,6 +20,18 @@ export interface ScopedInstalledPlugin extends InstalledPlugin {
 
 installLegacyPiSpecifierShim();
 
+const enabledPluginsCache = new Map<string, Promise<ScopedInstalledPlugin[]>>();
+
+function enabledPluginsCacheKey(cwd: string, home?: string): string {
+	return `${path.resolve(cwd)}\0${home === undefined ? "" : path.resolve(home)}`;
+}
+
+function clearEnabledPluginsCache(): void {
+	enabledPluginsCache.clear();
+}
+
+registerPluginCacheInvalidator(clearEnabledPluginsCache);
+
 // =============================================================================
 // Runtime Config Loading
 // =============================================================================
@@ -163,6 +175,23 @@ async function collectPluginsAtRoot(
  */
 export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {}): Promise<ScopedInstalledPlugin[]> {
 	const { home } = opts;
+	const cacheKey = enabledPluginsCacheKey(cwd, home);
+	const cached = enabledPluginsCache.get(cacheKey);
+	if (cached) return cached;
+
+	const loadPromise = loadEnabledPlugins(cwd, home);
+	enabledPluginsCache.set(cacheKey, loadPromise);
+	try {
+		return await loadPromise;
+	} catch (err) {
+		if (enabledPluginsCache.get(cacheKey) === loadPromise) {
+			enabledPluginsCache.delete(cacheKey);
+		}
+		throw err;
+	}
+}
+
+async function loadEnabledPlugins(cwd: string, home?: string): Promise<ScopedInstalledPlugin[]> {
 	const projectOverrides = await loadProjectOverrides(cwd);
 
 	const userRoot = getPluginsDir(home);

package/src/irc/bus.ts

@@ -8,10 +8,11 @@
  * agents receive the message as a non-interrupting aside at the next step
  * boundary (see AgentSession.deliverIrcMessage). Replies are real turns by
  * the recipient, observed via `wait` — with one exception: when the sender
- * awaits a reply and the recipient is mid-turn with async execution
- * disabled, the recipient session generates an ephemeral side-channel
- * auto-reply (it may be blocked in a synchronous task spawn whose batch
- * includes the sender, so a real turn could never happen in time).
+ * awaits a reply and the recipient cannot run a real reply turn in time
+ * (mid-turn with async execution disabled — possibly blocked in a
+ * synchronous task spawn whose batch includes the sender — or idle in plan
+ * mode, where autonomous wake turns are suppressed), the recipient session
+ * generates an ephemeral side-channel auto-reply.
  */
 
 import { logger, Snowflake } from "@oh-my-pi/pi-utils";

package/src/modes/components/__tests__/move-overlay.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from "bun:test";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, spyOn } from "bun:test";
 import * as fs from "node:fs";
 import * as fsp from "node:fs/promises";
 import * as os from "node:os";
@@ -163,4 +163,75 @@ describe("MoveOverlay", () => {
 		expect(result).toBeDefined();
 		expect(result!.directory).toBe(path.join(cwd, "alpha"));
 	});
+
+	it("does not stat every directory entry per keystroke", async () => {
+		// Regression: `readDirCached` used to cache names and re-`statSync` every
+		// entry per keystroke. Populate with mostly files so the old code path
+		// would have stat'd all of them; the fix classifies via `Dirent` and only
+		// falls back to `statSync` on symlink entries.
+		const bulk = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-move-overlay-bulk-"));
+		try {
+			for (let i = 0; i < 60; i++) {
+				fs.writeFileSync(path.join(bulk, `f_${String(i).padStart(3, "0")}.txt`), "x");
+			}
+			for (let i = 0; i < 10; i++) fs.mkdirSync(path.join(bulk, `sub_${i}`));
+
+			const statSpy = spyOn(fs, "statSync");
+			try {
+				const overlay = new MoveOverlay(bulk, () => {});
+				statSpy.mockClear();
+				overlay.handleInput("s");
+				overlay.handleInput("u");
+				overlay.handleInput("b");
+				// Each keystroke may `statSync` at most once — the
+				// `resolveExistingDirectory` probe on the typed prefix. Entries
+				// are classified via `Dirent`, not one stat apiece.
+				expect(statSpy.mock.calls.length).toBeLessThanOrEqual(3);
+			} finally {
+				statSpy.mockRestore();
+			}
+		} finally {
+			await fsp.rm(bulk, { recursive: true, force: true });
+		}
+	});
+
+	it("classifies unknown-type Dirents via statSync fallback", async () => {
+		// Regression: filesystems that report UV_DIRENT_UNKNOWN return Dirents
+		// whose isDirectory()/isFile()/isSymbolicLink() all report false. Those
+		// entries must fall back to statSync so /move still lists real
+		// directories on NFS/FUSE/older SMB.
+		const unknownFs = await fsp.mkdtemp(path.join(os.tmpdir(), "omp-move-overlay-unknown-"));
+		try {
+			const realDir = path.join(unknownFs, "real-dir");
+			const realFile = path.join(unknownFs, "real-file.txt");
+			fs.mkdirSync(realDir);
+			fs.writeFileSync(realFile, "x");
+
+			const fakeDirent = (name: string): fs.Dirent =>
+				({
+					name,
+					isDirectory: () => false,
+					isFile: () => false,
+					isSymbolicLink: () => false,
+					isBlockDevice: () => false,
+					isCharacterDevice: () => false,
+					isFIFO: () => false,
+					isSocket: () => false,
+				}) as fs.Dirent;
+			const readdirSpy = spyOn(fs, "readdirSync").mockReturnValue([
+				fakeDirent("real-dir"),
+				fakeDirent("real-file.txt"),
+			] as never);
+			try {
+				const overlay = new MoveOverlay(unknownFs, () => {});
+				const text = strip(overlay.render(80));
+				expect(text).toContain("real-dir/");
+				expect(text).not.toContain("real-file.txt");
+			} finally {
+				readdirSpy.mockRestore();
+			}
+		} finally {
+			await fsp.rm(unknownFs, { recursive: true, force: true });
+		}
+	});
 });

package/src/modes/components/assistant-message.ts

@@ -708,7 +708,7 @@ export class AssistantMessageComponent extends Container {
 		);
 
 		// Fast path: reuse Markdown children when shape is stable during streaming
-		if (this.#tryFastPathUpdate(message)) return;
+		if (this.#tryFastPathUpdate(message, opts)) return;
 
 		// Clear content container
 		this.#contentContainer.clear();

package/src/modes/components/move-overlay.ts

@@ -29,14 +29,14 @@ const OVERLAY_WIDTH = 68;
 
 /** TTL for the directory listing cache (ms). */
 const DIR_CACHE_TTL = 500;
-const dirCache = new Map<string, { time: number; entries: string[] }>();
+const dirCache = new Map<string, { time: number; entries: fs.Dirent[] }>();
 
-function readDirCached(dir: string): string[] {
+function readDirCached(dir: string): fs.Dirent[] {
 	const now = Date.now();
 	const cached = dirCache.get(dir);
 	if (cached && now - cached.time < DIR_CACHE_TTL) return cached.entries;
 	try {
-		const entries = fs.readdirSync(dir);
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
 		dirCache.set(dir, { time: now, entries });
 		return entries;
 	} catch {
@@ -44,6 +44,27 @@ function readDirCached(dir: string): string[] {
 	}
 }
 
+/**
+ * `Dirent.isDirectory()` reports the entry type, not the link target, so a
+ * `statSync` fallback is still needed for symlinks that point at a directory.
+ * Some filesystems (NFS, FUSE, older SMB) report `UV_DIRENT_UNKNOWN` — every
+ * `isX()` returns false — so those entries also fall back to `statSync` rather
+ * than being silently dropped from the results.
+ */
+function entryIsDirectory(dir: string, entry: fs.Dirent): boolean {
+	if (entry.isDirectory()) return true;
+	// Fast reject only for entry types we can confidently identify as non-directory.
+	if (entry.isFile() || entry.isBlockDevice() || entry.isCharacterDevice() || entry.isFIFO() || entry.isSocket()) {
+		return false;
+	}
+	// Symlink (need target type) or unknown (filesystem didn't provide a type) — stat to find out.
+	try {
+		return fs.statSync(path.join(dir, entry.name)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
 function printableInput(data: string): string {
 	const withoutPasteEnvelope = data.replaceAll("\x1b[200~", "").replaceAll("\x1b[201~", "");
 	if (withoutPasteEnvelope.includes("\x1b")) return "";
@@ -76,17 +97,13 @@ export function resolveExistingDirectory(input: string, cwd: string): string | n
 
 function listChildDirectories(dirPath: string, max: number, includeHidden = false): DirEntry[] {
 	const results: DirEntry[] = [];
-	const names = readDirCached(dirPath);
-	for (const name of names) {
+	const entries = readDirCached(dirPath);
+	for (const entry of entries) {
 		if (results.length >= max) break;
+		const { name } = entry;
 		if (!includeHidden && name.startsWith(".")) continue;
-		const full = path.join(dirPath, name);
-		try {
-			if (!fs.statSync(full).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		results.push({ value: full, label: `${name}/` });
+		if (!entryIsDirectory(dirPath, entry)) continue;
+		results.push({ value: path.join(dirPath, name), label: `${name}/` });
 	}
 	results.sort((a, b) => a.label.localeCompare(b.label));
 	return results;
@@ -118,19 +135,14 @@ function searchDirectories(prefix: string, cwd: string, max: number): DirEntry[]
 
 	const lower = query.toLowerCase();
 	const results: DirEntry[] = [];
-	const names = readDirCached(baseDir);
-	for (const name of names) {
+	const entries = readDirCached(baseDir);
+	for (const entry of entries) {
 		if (results.length >= max) break;
+		const { name } = entry;
 		if (!includeHidden && name.startsWith(".")) continue;
-		const full = path.join(baseDir, name);
-		try {
-			if (!fs.statSync(full).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		if (!query || name.toLowerCase().includes(lower)) {
-			results.push({ value: full, label: `${name}/` });
-		}
+		if (query && !name.toLowerCase().includes(lower)) continue;
+		if (!entryIsDirectory(baseDir, entry)) continue;
+		results.push({ value: path.join(baseDir, name), label: `${name}/` });
 	}
 	return results;
 }

package/src/modes/components/tool-execution.ts

@@ -334,6 +334,7 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 		// so keep their horizontal padding even when the user enables tight layout.
 		this.setIgnoreTight(true);
 
+		this.#updateSpinnerAnimation();
 		this.#updateDisplay();
 		this.#schedulePreviewDiff();
 	}
@@ -546,21 +547,47 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 	}
 
 	/**
-	 * Start or stop spinner animation for result states that visibly tick.
+	 * Start or stop spinner animation for live states that visibly tick.
 	 */
 	#updateSpinnerAnimation(): void {
-		// Spinner for: task tool with partial result, edit/write while args
-		// streaming, or a still-running job poll. Todo snapshots stay live for
-		// displacement but should remain visually static.
+		// Live partial tool blocks stay repaintable until a terminal result seals
+		// them. Todo snapshots and detached background tool progress are deliberate
+		// static exceptions because their rows can be superseded or committed to
+		// scrollback while later updates continue elsewhere.
 		const isStreamingArgs = !this.#argsComplete && (isEditLikeToolName(this.#toolName) || this.#toolName === "write");
 		const isBackgroundAsyncRunning =
 			(this.#result?.details as { async?: { state?: string } } | undefined)?.async?.state === "running";
-		const isBackgroundAsyncTask = this.#toolName === "task" && isBackgroundAsyncRunning;
-		const isPartialTask = this.#isPartial && this.#toolName === "task" && !isBackgroundAsyncTask;
-		// Detached async task progress rows are static now; progress snapshots
-		// still call #maybeFreezeBackgroundTask before applying so rows settle
-		// once the block leaves the live region.
-		const needsSpinner = isStreamingArgs || isPartialTask || this.#displaceableByToolName === "job";
+		const renderer = toolRenderers[this.#toolName] as
+			| {
+					animatedPendingPreview?: boolean | ((args: unknown) => boolean);
+					animatedPartialResult?: boolean | ((args: unknown) => boolean);
+			  }
+			| undefined;
+		const pendingAnimation = renderer?.animatedPendingPreview;
+		const partialAnimation = renderer?.animatedPartialResult;
+		const pendingCallConsumesSpinner =
+			this.#result === undefined &&
+			(renderer === undefined
+				? // Only the generic #formatToolExecution fallback consumes the frame;
+					// a custom renderCall/renderResult pair routes through the custom
+					// branch whose pending label is a static tool-name Text.
+					!this.#tool?.renderCall && !this.#tool?.renderResult
+				: typeof pendingAnimation === "function"
+					? pendingAnimation(this.#args)
+					: pendingAnimation === true);
+		const partialResultConsumesSpinner =
+			this.#result !== undefined &&
+			(renderer === undefined
+				? !this.#tool?.renderCall && !this.#tool?.renderResult
+				: typeof partialAnimation === "function"
+					? partialAnimation(this.#args)
+					: partialAnimation === true);
+		const isLivePartialTool =
+			this.#isPartial &&
+			this.#toolName !== "todo" &&
+			!isBackgroundAsyncRunning &&
+			(pendingCallConsumesSpinner || partialResultConsumesSpinner);
+		const needsSpinner = isStreamingArgs || isLivePartialTool || this.#displaceableByToolName === "job";
 		if (needsSpinner && !this.#spinnerInterval) {
 			const frameCount = theme.spinnerFrames.length;
 			const frame = sharedSpinnerFrame(frameCount);
@@ -1172,8 +1199,14 @@ export class ToolExecutionComponent extends Container implements NativeScrollbac
 	 */
 	#formatToolExecution(contentWidth: number): string {
 		const lines: string[] = [];
-		const icon = this.#isPartial ? "pending" : this.#result?.isError ? "error" : "done";
-		lines.push(renderStatusLine({ icon, title: this.#toolLabel }, theme));
+		const icon = this.#isPartial
+			? this.#spinnerFrame !== undefined
+				? "running"
+				: "pending"
+			: this.#result?.isError
+				? "error"
+				: "done";
+		lines.push(renderStatusLine({ icon, spinnerFrame: this.#spinnerFrame, title: this.#toolLabel }, theme));
 
 		const argsObject = this.#args && typeof this.#args === "object" ? (this.#args as Record<string, unknown>) : null;
 		if (!this.#expanded && argsObject && Object.keys(argsObject).length > 0) {

package/src/modes/components/tree-selector.ts

@@ -15,7 +15,7 @@ import type { TreeFilterMode } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
 import { matchesAppInterrupt, matchesSelectDown, matchesSelectUp } from "../../modes/utils/keybinding-matchers";
 import type { SessionTreeNode } from "../../session/session-entries";
-import { toPathList } from "../../tools/grep";
+import { toPathList } from "../../tools/path-utils";
 import { shortenPath } from "../../tools/render-utils";
 import { canonicalizeMessage } from "../../utils/thinking-display";
 import { DynamicBorder } from "./dynamic-border";
@@ -753,8 +753,15 @@ class TreeList implements Component {
 				return `[grep: /${pattern}/ in ${shortenPath(scope)}]`;
 			}
 			case "glob": {
-				const paths = Array.isArray(args.paths) ? args.paths.join(", ") : String(args.pattern || ".");
-				return `[glob: ${shortenPath(paths)}]`;
+				const globInput =
+					typeof args.path === "string"
+						? args.path
+						: typeof args.paths === "string" || Array.isArray(args.paths)
+							? args.paths
+							: undefined;
+				const paths = toPathList(globInput);
+				const scope = paths.length > 0 ? paths.join(", ") : ".";
+				return `[glob: ${shortenPath(scope)}]`;
 			}
 			case "ls": {
 				const path = shortenPath(String(args.path || "."));

package/src/modes/controllers/event-controller.ts

@@ -27,6 +27,7 @@ import { isSilentAbort, readQueueChipText, resolveAbortLabel } from "../../sessi
 import { previewLine, TRUNCATE_LENGTHS } from "../../tools/render-utils";
 import type { ResolveToolDetails } from "../../tools/resolve";
 import { nextActionableTask } from "../../tools/todo";
+import { SpeechEnhancer } from "../../tts/speech-enhancer";
 import { vocalizer } from "../../tts/vocalizer";
 import { canonicalizeMessage } from "../../utils/thinking-display";
 import { interruptHint } from "../shared";
@@ -111,6 +112,21 @@ export class EventController {
 	#terminalProgressActive = false;
 
 	constructor(private ctx: InteractiveModeContext) {
+		// Enhanced speech (`speech.enhanced`) rewrites blocks through the
+		// tiny/smol role with this session's registry and credentials; the
+		// vocalizer falls back to mechanical cleanup when unset. Tolerates
+		// partial contexts (tests, minimal embeddings) by wiring null.
+		const session = ctx.session;
+		vocalizer.setEnhancer(
+			session?.modelRegistry && session.agent && session.settings
+				? new SpeechEnhancer({
+						settings: session.settings,
+						registry: session.modelRegistry,
+						sessionId: session.sessionId,
+						metadataResolver: provider => session.agent.metadataForProvider(provider),
+					})
+				: null,
+		);
 		this.#streamingReveal = new StreamingRevealController({
 			getSmoothStreaming: () => this.ctx.settings.get("display.smoothStreaming"),
 			getHideThinkingBlock: () => this.ctx.effectiveHideThinkingBlock,

package/src/prompts/goals/goal-mode-context.md

@@ -0,0 +1,4 @@
+{{goalContext}}
+{{#if todoContext}}
+{{todoContext}}
+{{/if}}