@oh-my-pi/pi-coding-agent 16.3.5 → 16.3.7

package/src/task/executor.ts

@@ -215,7 +215,12 @@ function renderIrcPeerRoster(selfId: string): string {
 	return lines.join("\n");
 }
 
-function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
+function withAbortTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	signal?: AbortSignal,
+	timeoutController?: AbortController,
+): Promise<T> {
 	if (signal?.aborted) {
 		return Promise.reject(new ToolAbortError());
 	}
@@ -225,6 +230,7 @@ function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: Ab
 	const timeoutId = setTimeout(() => {
 		if (settled) return;
 		settled = true;
+		timeoutController?.abort(new DOMException(`MCP tool call timed out after ${timeoutMs}ms`, "TimeoutError"));
 		reject(new Error(`MCP tool call timed out after ${timeoutMs}ms`));
 	}, timeoutMs);
 
@@ -232,6 +238,7 @@ function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: Ab
 		if (settled) return;
 		settled = true;
 		clearTimeout(timeoutId);
+		timeoutController?.abort();
 		reject(new ToolAbortError());
 	};
 
@@ -708,13 +715,21 @@ export function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 				const serverName = mcpTool.mcpServerName ?? "";
 				const mcpToolName = mcpTool.mcpToolName ?? "";
 				try {
+					const timeoutController = new AbortController();
+					const timeoutSignal = timeoutController.signal;
+					const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 					const result = await withAbortTimeout(
 						(async () => {
-							const connection = await mcpManager.waitForConnection(serverName);
-							return callTool(connection, mcpToolName, params as Record<string, unknown>, { signal });
+							const connection = await untilAborted(combinedSignal, () =>
+								mcpManager.waitForConnection(serverName),
+							);
+							return callTool(connection, mcpToolName, params as Record<string, unknown>, {
+								signal: combinedSignal,
+							});
 						})(),
 						MCP_CALL_TIMEOUT_MS,
 						signal,
+						timeoutController,
 					);
 					return {
 						content: (result.content ?? []).map(item =>
@@ -2161,6 +2176,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				modelRegistry,
 				settings: subagentSettings,
 				model,
+				modelPattern: model || modelOverride === undefined ? undefined : modelPatterns,
+				modelPatternAuthFallback:
+					model || modelOverride === undefined ? undefined : options.parentActiveModelPattern,
+				modelPatternFallbackRole:
+					model || modelOverride === undefined ? undefined : `${SUBAGENT_RETRY_FALLBACK_ROLE_PREFIX}${id}`,
 				thinkingLevel: effectiveThinkingLevel,
 				toolNames,
 				outputSchema,

package/src/task/isolation-runner.ts

@@ -37,6 +37,7 @@ import {
 	getRepoRoot,
 	type IsolationHandle,
 	mergeTaskBranches,
+	type NestedRepoPatch,
 	type WorktreeBaseline,
 } from "./worktree";
 
@@ -100,7 +101,7 @@ export interface IsolatedRunOptions {
 	agentId: string;
 	/** Merge mode driving how changes are captured ("branch" commits, "patch" diffs). */
 	mergeMode: "patch" | "branch";
-	/** Output dir for `${agentId}.patch` artifacts (patch mode). */
+	/** Output dir for `${agentId}.patch` artifacts (patch mode and branch-mode commit failures). */
 	artifactsDir: string;
 	/** Human description carried onto the branch commit (branch mode). */
 	description?: string;
@@ -114,12 +115,25 @@ export interface IsolatedRunOptions {
 	buildFailureResult: (err: unknown) => SingleResult;
 }
 
+async function writeIsolationPatch(
+	isolationDir: string,
+	baseline: WorktreeBaseline,
+	artifactsDir: string,
+	agentId: string,
+): Promise<{ patchPath: string; nestedPatches: NestedRepoPatch[] }> {
+	const delta = await captureDeltaPatch(isolationDir, baseline);
+	const patchPath = path.join(artifactsDir, `${agentId}.patch`);
+	await Bun.write(patchPath, delta.rootPatch);
+	return { patchPath, nestedPatches: delta.nestedPatches };
+}
+
 /**
  * Run a subagent inside an isolation worktree and capture its changes.
  *
  * Branch mode: on success, commits the diff onto `omp/task/${agentId}` and
  * returns `branchName` + `nestedPatches`. On commit failure the branch is
- * deleted and `result.error` carries the merge-failure message.
+ * deleted, the still-live isolation diff is written to `${artifactsDir}/${agentId}.patch`,
+ * and `result.error` carries the merge-failure message.
  *
  * Patch mode: on success, writes `${artifactsDir}/${agentId}.patch` and
  * returns `patchPath` + `nestedPatches`.
@@ -162,18 +176,32 @@ export async function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<S
 				const branchName = `omp/task/${opts.agentId}`;
 				await git.branch.tryDelete(opts.context.repoRoot, branchName);
 				const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
-				return { ...result, error: `Merge failed: ${msg}` };
+				try {
+					const patchResult = await writeIsolationPatch(
+						isolationDir,
+						taskBaseline,
+						opts.artifactsDir,
+						opts.agentId,
+					);
+					return {
+						...result,
+						patchPath: patchResult.patchPath,
+						nestedPatches: patchResult.nestedPatches,
+						error: `Merge failed: ${msg}`,
+					};
+				} catch (patchErr) {
+					const patchMsg = patchErr instanceof Error ? patchErr.message : String(patchErr);
+					return { ...result, error: `Merge failed: ${msg}; patch capture failed: ${patchMsg}` };
+				}
 			}
 		}
 		if (result.exitCode === 0) {
 			try {
-				const delta = await captureDeltaPatch(isolationDir, taskBaseline);
-				const patchPath = path.join(opts.artifactsDir, `${opts.agentId}.patch`);
-				await Bun.write(patchPath, delta.rootPatch);
+				const patchResult = await writeIsolationPatch(isolationDir, taskBaseline, opts.artifactsDir, opts.agentId);
 				return {
 					...result,
-					patchPath,
-					nestedPatches: delta.nestedPatches,
+					patchPath: patchResult.patchPath,
+					nestedPatches: patchResult.nestedPatches,
 				};
 			} catch (patchErr) {
 				const msg = patchErr instanceof Error ? patchErr.message : String(patchErr);
@@ -224,8 +252,9 @@ export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise
 	try {
 		if (mergeMode === "branch") {
 			if (!result.branchName && result.exitCode === 0 && !result.aborted && result.error) {
+				const patchList = result.patchPath ? `\nPatch artifact:\n- ${result.patchPath}` : "";
 				return {
-					summary: `\n\n<system-notification>Branch merge failed before a task branch could be created: ${result.error}\nTask outputs are preserved but changes were not applied.</system-notification>`,
+					summary: `\n\n<system-notification>Branch merge failed before a task branch could be created: ${result.error}\nTask outputs are preserved but changes were not applied.${patchList}</system-notification>`,
 					changesApplied: false,
 					hadAnyChanges: false,
 					mergedBranchForNestedPatches: false,

package/src/tools/__tests__/glob.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { Settings } from "../../config/settings";
+import type { ToolSession } from "..";
+import { GlobTool } from "../glob";
+import { ToolError } from "../tool-errors";
+
+const ROOT_SEARCH_ERROR = "Searching from root directory '/' is not allowed";
+
+async function expectRootSearchRejected(searchPath: string): Promise<void> {
+	const session: ToolSession = {
+		cwd: process.cwd(),
+		hasUI: false,
+		settings: Settings.isolated({}),
+		getSessionFile: () => null,
+		getSessionSpawns: () => null,
+	};
+	const tool = new GlobTool(session);
+	let thrown: unknown;
+	try {
+		await tool.execute("glob-root-regression", { path: searchPath });
+	} catch (error) {
+		thrown = error;
+	}
+
+	if (!(thrown instanceof Error)) {
+		throw new Error(`Expected glob path ${JSON.stringify(searchPath)} to reject`);
+	}
+
+	expect(thrown).toBeInstanceOf(ToolError);
+	expect(thrown.message).toBe(ROOT_SEARCH_ERROR);
+}
+
+describe("GlobTool.execute", () => {
+	test.each(["/", "//"])("rejects bare root search path %s", async searchPath => {
+		await expectRootSearchRejected(searchPath);
+	});
+});

package/src/tools/acp-bridge.ts

@@ -7,6 +7,8 @@
  * URLs) are always written directly to disk — those are OMP-owned and should
  * never be pushed into the editor.
  */
+
+import { FileChangeType, notifyWorkspaceWatchedFiles } from "../lsp/client";
 import type { ToolSession } from ".";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { isInternalUrlPath } from "./path-utils";
@@ -53,18 +55,26 @@ export async function routeWriteThroughBridge(
 	requestedPath: string,
 	absolutePath: string,
 	content: string,
+	signal?: AbortSignal,
 ): Promise<boolean> {
 	if (!shouldRouteWriteThroughBridge(session, requestedPath, absolutePath)) return false;
 
 	const bridge = session.getClientBridge?.();
 	if (!bridge?.capabilities.writeTextFile || !bridge.writeTextFile) return false;
 
+	const changeType = (await Bun.file(absolutePath).exists()) ? FileChangeType.Changed : FileChangeType.Created;
+	// The ACP protocol has no cancellation for fs writes; the most we can do is
+	// refuse to start one after the tool was aborted. Racing the promise would
+	// report failure while the editor still applies the write.
+	signal?.throwIfAborted();
 	try {
 		await bridge.writeTextFile({ path: absolutePath, content });
 	} catch (error) {
 		throw new ToolError(error instanceof Error ? error.message : String(error));
 	}
-
+	if (session.enableLsp ?? true) {
+		await notifyWorkspaceWatchedFiles(session.cwd, [{ filePath: absolutePath, type: changeType }], signal);
+	}
 	invalidateFsScanAfterWrite(absolutePath);
 	session.bumpFileMutationVersion?.(absolutePath);
 	return true;

package/src/tools/bash-command-fixup.ts

@@ -1,37 +1,4 @@
-/**
- * Conservative transforms applied to a bash command before execution.
- *
- * Two fixups are applied, each anchored to the end of a top-level segment
- * (segments split on `;`, `&&`, `||`, and background `&`):
- *
- *  1. Trailing `| head [args]` / `| tail [args]` (and the `|&` variant) — these
- *     pipes exist purely to limit output length. The harness already truncates
- *     bash output and exposes the full result via an artifact, so they only
- *     hide content the agent wanted.
- *
- *  2. A redundant trailing `2>&1` left on a segment that has no remaining pipe
- *     or other redirect. The harness already merges stderr into stdout, so the
- *     duplication is purely cosmetic — and often a leftover after fixup (1)
- *     drops a downstream pipe.
- *
- * The heavy lifting (tokenization, quoting, heredoc handling, command
- * substitution, nested compound commands) lives in Rust under
- * `pi_shell::fixup`, driven by the real `brush-parser` AST. This module is a
- * thin sync wrapper plus user-facing notice formatting.
- */
-import { applyBashFixups as nativeApplyBashFixups } from "@oh-my-pi/pi-natives";
+/** Compatibility shim for extensions importing the historical bash fixup helper. */
 
-export interface BashFixupResult {
-	/** Possibly-rewritten command. */
-	command: string;
-	/** Substrings that were stripped, in the order they were removed. */
-	stripped: string[];
-}
-
-/**
- * Apply both fixups to a bash command. On any parse failure, multi-line input,
- * or no-op transform, returns the input verbatim with `stripped: []`.
- */
-export function applyBashFixups(command: string): BashFixupResult {
-	return nativeApplyBashFixups(command);
-}
+export type { BashFixupResult } from "@oh-my-pi/pi-natives";
+export { applyBashFixups } from "@oh-my-pi/pi-natives";

package/src/tools/bash.ts

@@ -23,7 +23,6 @@ import { CachedOutputBlock, markFramedBlockComponent, outputBlockContentWidth }
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
-import { applyBashFixups } from "./bash-command-fixup";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
@@ -132,10 +131,12 @@ async function saveBashOriginalArtifact(session: ToolSession, originalText: stri
 	}
 }
 
+const BASH_TIMEOUT_DESCRIPTION = `timeout in seconds; clamped to ${TOOL_TIMEOUTS.bash.min}-${TOOL_TIMEOUTS.bash.max}`;
+
 const bashSchemaBase = type({
 	command: type("string").describe("command to execute"),
 	"env?": type({ "[string]": "string" }).describe("extra env vars"),
-	"timeout?": type("number").describe("timeout in seconds"),
+	"timeout?": type("number").describe(BASH_TIMEOUT_DESCRIPTION),
 	"cwd?": type("string").describe("working directory"),
 	"pty?": type("boolean").describe("run in pty mode"),
 });
@@ -143,7 +144,7 @@ const bashSchemaBase = type({
 const bashSchemaWithAsync = type({
 	command: "string",
 	"env?": { "[string]": "string" },
-	"timeout?": "number",
+	"timeout?": type("number").describe(BASH_TIMEOUT_DESCRIPTION),
 	"cwd?": "string",
 	"pty?": "boolean",
 	"async?": type("boolean").describe("run in background"),
@@ -684,16 +685,6 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		let command = rawCommand;
 		const env = normalizeBashEnv(rawEnv);
 
-		// Apply conservative bash fixups (strip trailing `| head|tail` and redundant
-		// `2>&1`). The helper is single-line only and refuses anything that could
-		// change semantics.
-		if (this.session.settings.get("bash.stripTrailingHeadTail")) {
-			const fixup = applyBashFixups(command);
-			if (fixup.stripped.length > 0) {
-				command = fixup.command;
-			}
-		}
-
 		// Extract leading `cd <path> && ...` into cwd when the model ignores the cwd parameter.
 		// Constrained to a single line so a `&&` that sits on a later line of a multiline
 		// script can't pull the entire script into the "cwd" capture.
@@ -1409,10 +1400,6 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 		},
 		mergeCallAndResult: true,
 		inline: true,
-		// Collapsed pending preview caps the command to a viewport-sized tail
-		// window that shifts while args stream. Expanded output is top-anchored
-		// enough for the transcript to commit its settled prefix.
-		provisionalPendingPreview: "collapsed",
 	};
 }
 

package/src/tools/browser/render.ts

@@ -34,8 +34,10 @@ interface BrowserRenderContext {
 }
 
 function describeBrowser(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string | undefined {
-	if (args.app?.cdp_url) return `connected ${args.app.cdp_url}`;
-	if (args.app?.path) return `spawned ${shortenPath(args.app.path)}`;
+	const cdpUrl = typeof args.app?.cdp_url === "string" ? args.app.cdp_url : "";
+	if (cdpUrl) return `connected ${cdpUrl}`;
+	const appPath = typeof args.app?.path === "string" ? args.app.path : "";
+	if (appPath) return `spawned ${shortenPath(appPath)}`;
 	if (args.app?.cmux !== false && (args.app?.cmux === true || args.app?.surface)) {
 		return args.app.surface ? `cmux ${args.app.surface}` : "cmux";
 	}
@@ -92,7 +94,7 @@ function renderRunCell(
 	const status = cellStatus(options.isPartial, isError);
 
 	const titleParts: string[] = [tabLabel(args, details)];
-	const url = details?.url ?? args.url;
+	const url = typeof details?.url === "string" ? details.url : typeof args.url === "string" ? args.url : "";
 	if (url) titleParts.push(shortenPath(url));
 	const browserDesc = describeBrowser(args, details);
 	if (browserDesc) titleParts.push(browserDesc);
@@ -165,7 +167,7 @@ function renderOpenOrCloseLine(
 	const meta: string[] = [];
 	const browserDesc = describeBrowser(args, details);
 	if (browserDesc) meta.push(browserDesc);
-	const url = details?.url ?? args.url;
+	const url = typeof details?.url === "string" ? details.url : typeof args.url === "string" ? args.url : "";
 	if (url) meta.push(shortenPath(url));
 
 	const header =

package/src/tools/browser/tab-supervisor.ts

@@ -48,6 +48,16 @@ export interface PendingRun {
 	session: ToolSession;
 	signal?: AbortSignal;
 	toolCalls: Map<string, AbortController>;
+	/**
+	 * Fires when `releaseTab` closes the tab out from under an in-flight run
+	 * (sibling `browser close --all`, session-scoped reap, etc.). Composed
+	 * into the cmux run's signal so `wait(...)`, cmux socket calls, and the
+	 * facade proxies unwind promptly instead of blocking to the run's
+	 * timeout. `pending.reject` still fires first so the awaiting caller
+	 * sees the tab-close error immediately; `closeAc` propagates the
+	 * cancellation into the still-running `runCmuxCode` body (issue #4499).
+	 */
+	closeAc?: AbortController;
 }
 
 interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
@@ -380,23 +390,47 @@ async function runInTabWithSnapshot(
 	if (tab.pending.size > 0) throw new ToolError(`Tab ${JSON.stringify(name)} is busy`);
 	const id = Snowflake.next();
 	const { promise, resolve, reject } = Promise.withResolvers<RunResultOk>();
+	// `releaseTab` calls `pending.reject(closeError)` when the tab dies
+	// out from under an in-flight run (sibling `browser close --all`,
+	// session-scoped reap, etc.). Both backends below MUST end up awaiting
+	// this same `promise` so:
+	//   1. The caller sees `Tab ... was closed` immediately instead of
+	//      blocking to the run's timeout, and
+	//   2. `reject(...)` always has an attached handler — a zero-consumer
+	//      rejection would fire `unhandledRejection` and the CLI's
+	//      top-level handler would tear the whole session down, killing
+	//      every other tab and subagent sharing the process (issue #4499).
+	// The cmux branch also composes `closeAc.signal` into the run's abort
+	// signal so `wait(...)`, cmux socket calls, and the facade proxies
+	// unwind promptly when the tab is closed — otherwise a `wait(60_000)`
+	// with no in-flight socket request would keep `runCmuxCode` blocked
+	// until timeout even after the tab is gone.
+	const closeAc = new AbortController();
 	const pending: PendingRun = {
 		resolve,
 		reject,
 		session: opts.session ?? ({} as ToolSession),
 		signal: opts.signal,
 		toolCalls: new Map(),
+		closeAc,
 	};
 	tab.pending.set(id, pending);
 	if (tab.backend === "cmux") {
+		const runSignal = opts.signal ? AbortSignal.any([opts.signal, closeAc.signal]) : closeAc.signal;
 		try {
-			return await runCmuxCode(tab.cmuxTab, {
+			// `runCmuxCode.then(resolve, reject)` publishes the run's real
+			// outcome to `promise`, but `releaseTab` may have already
+			// rejected it — `Promise.withResolvers` settles on the first
+			// call and later resolve/reject are no-ops, so the tab-close
+			// error still wins the race.
+			runCmuxCode(tab.cmuxTab, {
 				code: opts.code,
 				timeoutMs: opts.timeoutMs,
-				signal: opts.signal,
+				signal: runSignal,
 				session: pending.session,
 				snapshot,
-			});
+			}).then(resolve, reject);
+			return await promise;
 		} finally {
 			tab.pending.delete(id);
 		}
@@ -460,6 +494,16 @@ export async function releaseTab(name: string, opts: ReleaseTabOptions = {}): Pr
 			} catch {}
 		}
 		for (const ctrl of pending.toolCalls.values()) ctrl.abort(closeError);
+		// Propagate the closure into the cmux run's abort signal so
+		// `wait(...)`, in-flight cmux socket calls, and the facade proxies
+		// unwind promptly. Firing this BEFORE `pending.reject` means
+		// `runCmuxCode` finishes with `ToolAbortError` and its `.then(reject)`
+		// is a no-op — `promise` still settles with the tab-close error via
+		// the `reject` call below. Without it, a run that isn't currently
+		// making a socket request (e.g. `await wait(60_000)`) would keep
+		// `runCmuxCode` blocked until timeout even after `pending.reject`
+		// unblocked the caller (issue #4499 review feedback).
+		pending.closeAc?.abort(closeError);
 		pending.reject(closeError);
 	}
 	tab.pending.clear();

package/src/tools/eval-render.ts

@@ -773,24 +773,4 @@ export const evalToolRenderer = {
 
 	mergeCallAndResult: true,
 	inline: true,
-	// Collapsed pending preview shows tail-window code cells; the result render
-	// interleaves each cell's output under its code, re-laying-out every row
-	// below the first cell. Expanded output is top-anchored enough for the
-	// transcript to commit its settled prefix.
-	provisionalPendingPreview: "collapsed",
-	// Partial-result chrome is NOT byte-stable: `renderAgentProgressEvents`
-	// inserts/removes each subagent's current-tool line as it starts/stops a
-	// tool, and ticks status icon/stats/duration on already-rendered rows,
-	// while `options.isPartial` holds for the whole eval() cell (agent
-	// progress ticks never carry an `async` completed/failed state, so
-	// `event-controller.ts` keeps `isPartial: true` throughout). If this
-	// block were commit-stable during that churn, `deriveLiveCommitState`'s
-	// stable-prefix ratchet would promote agent rows that keep mutating (a
-	// "slow ticker", see transcript-container.ts) into native scrollback,
-	// and the tui resync's "duplication, never loss" contract would
-	// repeatedly re-show the frame tail under a heavy concurrent
-	// `agent()`/`parallel()` fan-out — the overlapping/duplicated tree rows
-	// seen when many subagents run at once. Once the cell settles
-	// (`isPartial === false`) the block is commit-stable again.
-	provisionalPartialResult: true,
 };

package/src/tools/glob.ts

@@ -90,6 +90,8 @@ export interface GlobOperations {
 export interface GlobToolOptions {
 	/** Custom operations for find. Default: local filesystem + rg */
 	operations?: GlobOperations;
+	/** Remap slash-only paths to the session cwd before root-search validation. */
+	rootPathAlias?: boolean;
 }
 
 interface GlobTarget {
@@ -127,12 +129,14 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 	readonly strict = true;
 
 	readonly #customOps?: GlobOperations;
+	readonly #rootPathAlias: boolean;
 
 	constructor(
 		private readonly session: ToolSession,
 		options?: GlobToolOptions,
 	) {
 		this.#customOps = options?.operations;
+		this.#rootPathAlias = options?.rootPathAlias === true;
 		this.description = prompt.render(globDescription);
 	}
 
@@ -153,9 +157,15 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 				? effectivePaths
 				: await expandDelimitedPathEntries(effectivePaths, this.session.cwd, { splitter: parseFindPattern });
 			const rawPatterns = rawPatternInputs.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const aliasResolvedPatterns = this.#rootPathAlias
+				? rawPatterns.map(pattern => (/^\/+$/.test(pattern) ? "." : pattern))
+				: rawPatterns;
+			if (aliasResolvedPatterns.some(pattern => /^\/+$/.test(pattern))) {
+				throw new ToolError("Searching from root directory '/' is not allowed");
+			}
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
-			for (const rawPattern of rawPatterns) {
+			for (const rawPattern of aliasResolvedPatterns) {
 				if (!internalRouter.canHandle(rawPattern)) {
 					normalizedPatterns.push(rawPattern);
 					continue;

package/src/tools/index.ts

@@ -451,7 +451,7 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	eval: s => new EvalTool(s),
 	ssh: loadSshTool,
 	github: GithubTool.createIf,
-	glob: s => new GlobTool(s),
+	glob: s => new GlobTool(s, { rootPathAlias: true }),
 	grep: s => new GrepTool(s),
 	lsp: LspTool.createIf,
 	inspect_image: s => new InspectImageTool(s),

package/src/tools/inspect-image-renderer.ts

@@ -33,10 +33,10 @@ function questionLine(question: string, uiTheme: Theme): string {
 
 export const inspectImageToolRenderer = {
 	renderCall(args: InspectImageRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const rawPath = args.path ?? "";
+		const rawPath = typeof args.path === "string" ? args.path : "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "…";
 		const header = renderStatusLine({ icon: "pending", title: "Inspect", description: pathDisplay }, uiTheme);
-		const question = args.question?.trim();
+		const question = typeof args.question === "string" ? args.question.trim() : "";
 		// Call is at most a status line plus a one-line question — too small to box.
 		// The container renders a lone Text cleanly with no chrome.
 		if (!question) return new Text(header, 0, 0);
@@ -51,7 +51,8 @@ export const inspectImageToolRenderer = {
 		args?: InspectImageRenderArgs,
 	): Component {
 		const details = result.details;
-		const rawPath = details?.imagePath ?? args?.path ?? "";
+		const rawPath =
+			typeof details?.imagePath === "string" ? details.imagePath : typeof args?.path === "string" ? args.path : "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "image";
 		const success = !result.isError;
 		const header = renderStatusLine(
@@ -69,7 +70,7 @@ export const inspectImageToolRenderer = {
 			uiTheme,
 		);
 
-		const question = args?.question?.trim();
+		const question = typeof args?.question === "string" ? args.question.trim() : "";
 		const outputText = result.content.find(content => content.type === "text")?.text?.trimEnd() ?? "";
 
 		if (result.isError) {