@oh-my-pi/pi-coding-agent 15.10.4 → 15.10.6

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

@@ -8,6 +8,7 @@ import type {
 	Browser,
 	Dialog,
 	ElementHandle,
+	ElementScreenshotOptions,
 	HTTPResponse,
 	KeyInput,
 	Page,
@@ -78,6 +79,14 @@ type DialogPolicy = "accept" | "dismiss";
 type DragTarget = string | { readonly x: number; readonly y: number };
 type ActionabilityResult = { ok: true; x: number; y: number } | { ok: false; reason: string };
 
+/**
+ * Per-op ceiling for puppeteer-internal helpers that should resolve quickly
+ * (`observe`, `screenshot`, `extract`). Kept below the default 30s cell budget so a
+ * single stalled helper fails fast with a named error and leaves budget for the rest
+ * of the cell. Effective cap is `min(cellBudget, QUICK_OP_TIMEOUT_MS)`.
+ */
+const QUICK_OP_TIMEOUT_MS = 20_000;
+
 interface ScreenshotOptions {
 	selector?: string;
 	fullPage?: boolean;
@@ -404,12 +413,36 @@ async function clickQueryHandlerText(
 	);
 }
 
+export interface InflightOp {
+	label: string;
+	startedAt: number;
+}
+
 interface ActiveRun {
 	id: string;
 	ac: AbortController;
 	displays: RunResultOk["displays"];
 	screenshots: ScreenshotResult[];
 	pendingTools: Map<string, { resolve(value: unknown): void; reject(error: Error): void }>;
+	/** Helper invocations currently awaiting the page/network, keyed by op id. */
+	inflight: Map<number, InflightOp>;
+	opCounter: number;
+}
+
+/** Human-readable label for a screenshot op, used in op tracking + timeout errors. */
+export function describeScreenshot(opts?: ScreenshotOptions): string {
+	if (opts?.selector) return `tab.screenshot({ selector: ${JSON.stringify(opts.selector)} })`;
+	if (opts?.fullPage) return "tab.screenshot({ fullPage: true })";
+	return "tab.screenshot()";
+}
+
+/** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
+export function describeInflight(inflight: Map<number, InflightOp>): string {
+	const now = Date.now();
+	return [...inflight.values()]
+		.sort((a, b) => a.startedAt - b.startedAt)
+		.map(op => `${op.label} (${((now - op.startedAt) / 1000).toFixed(1)}s)`)
+		.join(", ");
 }
 
 export class WorkerCore {
@@ -560,13 +593,21 @@ export class WorkerCore {
 		const signal = AbortSignal.any([timeoutSignal, ac.signal]);
 		const displays: RunResultOk["displays"] = [];
 		const screenshots: ScreenshotResult[] = [];
-		const active: ActiveRun = { id: msg.id, ac, displays, screenshots, pendingTools: new Map() };
+		const active: ActiveRun = {
+			id: msg.id,
+			ac,
+			displays,
+			screenshots,
+			pendingTools: new Map(),
+			inflight: new Map(),
+			opCounter: 0,
+		};
 		this.#active = active;
 		try {
 			throwIfAborted(signal);
 			const page = this.#requirePage();
 			const browser = this.#requireBrowser();
-			const tabApi = this.#createTabApi(msg.name, msg.timeoutMs, signal, msg.session, displays, screenshots);
+			const tabApi = this.#createTabApi(msg.name, msg.timeoutMs, signal, msg.session, displays, screenshots, active);
 			const runtime = this.#ensureRuntime(msg.session);
 			runtime.setCwd(msg.session.cwd);
 			runtime.setRunScope({
@@ -580,11 +621,16 @@ export class WorkerCore {
 			});
 			const { promise: cancelRejection, reject: rejectCancel } = Promise.withResolvers<never>();
 			const onCancel = (): void => {
-				rejectCancel(
-					timeoutSignal.aborted
-						? new ToolError(`Browser code execution timed out after ${msg.timeoutMs}ms`)
-						: new ToolAbortError(),
-				);
+				if (timeoutSignal.aborted) {
+					const stalled = describeInflight(active.inflight);
+					rejectCancel(
+						new ToolError(
+							`Browser code execution timed out after ${msg.timeoutMs}ms${stalled ? ` (stalled on ${stalled})` : ""}`,
+						),
+					);
+				} else {
+					rejectCancel(new ToolAbortError());
+				}
 				// Cancel in-flight tool calls so user code's awaited proxies reject promptly.
 				for (const pending of active.pendingTools.values()) {
 					pending.reject(new ToolAbortError());
@@ -670,6 +716,39 @@ export class WorkerCore {
 		else pending.reject(replyError(reply.error));
 	}
 
+	/**
+	 * Wrap a tab helper so it (a) registers in the active run's in-flight map for
+	 * timeout diagnostics and (b) honors an optional per-op deadline that fails fast
+	 * with a named error instead of silently consuming the whole cell budget. Pass
+	 * `Number.POSITIVE_INFINITY` for `perOpTimeoutMs` to bound the op only by the cell
+	 * budget (used for `evaluate` running user code and for locator helpers that already
+	 * carry puppeteer's own `.setTimeout(timeoutMs)`).
+	 */
+	async #runOp<T>(
+		active: ActiveRun,
+		label: string,
+		cellSignal: AbortSignal,
+		perOpTimeoutMs: number,
+		fn: (signal: AbortSignal) => Promise<T>,
+	): Promise<T> {
+		const opId = active.opCounter++;
+		active.inflight.set(opId, { label, startedAt: Date.now() });
+		const capped = Number.isFinite(perOpTimeoutMs) && perOpTimeoutMs > 0;
+		const opTimeout = capped ? AbortSignal.timeout(perOpTimeoutMs) : undefined;
+		const opSignal = opTimeout ? AbortSignal.any([cellSignal, opTimeout]) : cellSignal;
+		try {
+			return await fn(opSignal);
+		} catch (err) {
+			// Per-op deadline fired (not the cell budget, not an explicit abort) → named, actionable error.
+			if (opTimeout?.aborted && !cellSignal.aborted) {
+				throw new ToolError(`${label} timed out after ${perOpTimeoutMs}ms`);
+			}
+			throw err;
+		} finally {
+			active.inflight.delete(opId);
+		}
+	}
+
 	#createTabApi(
 		name: string,
 		timeoutMs: number,
@@ -677,98 +756,125 @@ export class WorkerCore {
 		session: SessionSnapshot,
 		displays: RunResultOk["displays"],
 		screenshots: ScreenshotResult[],
+		active: ActiveRun,
 	): TabApi {
 		const page = this.#requirePage();
+		const quickOpMs = Math.min(timeoutMs, QUICK_OP_TIMEOUT_MS);
+		const INF = Number.POSITIVE_INFINITY;
+		const op = <T>(label: string, perOpMs: number, fn: (sig: AbortSignal) => Promise<T>): Promise<T> =>
+			this.#runOp(active, label, signal, perOpMs, fn);
 		return {
 			name,
 			page,
 			signal,
 			url: () => page.url(),
-			title: () => page.title(),
-			goto: async (url, opts) => {
-				this.#clearElementCache();
-				await untilAborted(signal, () =>
+			title: () => op("tab.title()", INF, sig => untilAborted(sig, () => page.title())),
+			goto: (url, opts) =>
+				op(`tab.goto(${JSON.stringify(url)})`, INF, async sig => {
+					this.#clearElementCache();
 					// Default to "load" because dev servers with HMR/WS never reach networkidle.
-					page.goto(url, { waitUntil: opts?.waitUntil ?? "load", timeout: timeoutMs }),
-				);
-			},
-			observe: opts => this.#collectObservation({ ...opts, signal }),
-			screenshot: async opts => await this.#captureScreenshot(session, displays, screenshots, signal, opts),
-			extract: async (format = "markdown") => {
-				const html = (await untilAborted(signal, () => page.content())) as string;
-				const result = await extractReadableFromHtml(html, page.url(), format);
-				if (!result) {
-					throw new ToolError(`tab.extract(${JSON.stringify(format)}) found no readable content on ${page.url()}`);
-				}
-				const content = format === "markdown" ? result.markdown : result.text;
-				if (!content) {
-					throw new ToolError(
-						`tab.extract(${JSON.stringify(format)}) produced empty ${format} content for ${page.url()}`,
-					);
-				}
-				return content;
-			},
-			click: async selector => {
-				const resolved = normalizeSelector(selector);
-				if (resolved.startsWith("text/")) await clickQueryHandlerText(page, resolved, timeoutMs, signal);
-				else await untilAborted(signal, () => page.locator(resolved).setTimeout(timeoutMs).click());
-			},
-			type: async (selector, text) => {
-				const handle = (await untilAborted(signal, () =>
-					page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-				)) as ElementHandle;
-				try {
-					await untilAborted(signal, () => handle.type(text, { delay: 0 }));
-				} finally {
-					await handle.dispose();
-				}
-			},
-			fill: async (selector, value) => {
-				await untilAborted(signal, () =>
-					page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).fill(value),
-				);
-			},
-			press: async (key, opts) => {
-				const selector = opts?.selector;
-				if (selector) await untilAborted(signal, () => page.focus(normalizeSelector(selector)));
-				await untilAborted(signal, () => page.keyboard.press(key));
-			},
-			scroll: async (deltaX, deltaY) => {
-				await untilAborted(signal, () => page.mouse.wheel({ deltaX, deltaY }));
-			},
-			drag: async (from, to) => await this.#drag(from, to, signal),
-			waitFor: async selector =>
-				(await untilAborted(signal, () =>
-					page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-				)) as ElementHandle,
-			evaluate: async (fn, ...args) =>
-				(await untilAborted(signal, () =>
-					typeof fn === "string" ? page.evaluate(fn) : page.evaluate(fn as (...a: unknown[]) => unknown, ...args),
-				)) as never,
-			scrollIntoView: async selector => {
-				const handle = (await untilAborted(signal, () =>
-					page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
-				)) as ElementHandle;
-				try {
-					await untilAborted(signal, () =>
-						handle.evaluate(el => {
-							const target = el as unknown as {
-								scrollIntoView: (opts: { behavior: string; block: string; inline: string }) => void;
-							};
-							target.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
-						}),
+					await untilAborted(sig, () =>
+						page.goto(url, { waitUntil: opts?.waitUntil ?? "load", timeout: timeoutMs }),
 					);
-				} finally {
-					await handle.dispose().catch(() => undefined);
-				}
-			},
-			select: async (selector, ...values) => await this.#select(selector, values, timeoutMs, signal),
-			uploadFile: async (selector, ...filePaths) =>
-				await this.#uploadFile(selector, filePaths, timeoutMs, signal, session),
-			waitForUrl: async (pattern, opts) => await this.#waitForUrl(pattern, opts?.timeout ?? timeoutMs, signal),
-			waitForResponse: async (pattern, opts) =>
-				await this.#waitForResponse(pattern, opts?.timeout ?? timeoutMs, signal),
-			id: async id => await this.#resolveCachedHandle(id),
+				}),
+			observe: opts => op("tab.observe()", quickOpMs, sig => this.#collectObservation({ ...opts, signal: sig })),
+			screenshot: opts =>
+				op(describeScreenshot(opts), quickOpMs, sig =>
+					this.#captureScreenshot(session, displays, screenshots, sig, opts),
+				),
+			extract: (format = "markdown") =>
+				op(`tab.extract(${JSON.stringify(format)})`, quickOpMs, async sig => {
+					const html = (await untilAborted(sig, () => page.content())) as string;
+					const result = await extractReadableFromHtml(html, page.url(), format);
+					if (!result) {
+						throw new ToolError(
+							`tab.extract(${JSON.stringify(format)}) found no readable content on ${page.url()}`,
+						);
+					}
+					const content = format === "markdown" ? result.markdown : result.text;
+					if (!content) {
+						throw new ToolError(
+							`tab.extract(${JSON.stringify(format)}) produced empty ${format} content for ${page.url()}`,
+						);
+					}
+					return content;
+				}),
+			click: selector =>
+				op(`tab.click(${JSON.stringify(selector)})`, INF, async sig => {
+					const resolved = normalizeSelector(selector);
+					if (resolved.startsWith("text/")) await clickQueryHandlerText(page, resolved, timeoutMs, sig);
+					else await untilAborted(sig, () => page.locator(resolved).setTimeout(timeoutMs).click());
+				}),
+			type: (selector, text) =>
+				op(`tab.type(${JSON.stringify(selector)})`, INF, async sig => {
+					const handle = (await untilAborted(sig, () =>
+						page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
+					)) as ElementHandle;
+					try {
+						await untilAborted(sig, () => handle.type(text, { delay: 0 }));
+					} finally {
+						await handle.dispose();
+					}
+				}),
+			fill: (selector, value) =>
+				op(`tab.fill(${JSON.stringify(selector)})`, INF, sig =>
+					untilAborted(sig, () => page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).fill(value)),
+				),
+			press: (key, opts) =>
+				op(`tab.press(${JSON.stringify(key)})`, INF, async sig => {
+					const selector = opts?.selector;
+					if (selector) await untilAborted(sig, () => page.focus(normalizeSelector(selector)));
+					await untilAborted(sig, () => page.keyboard.press(key));
+				}),
+			scroll: (deltaX, deltaY) =>
+				op("tab.scroll()", INF, sig => untilAborted(sig, () => page.mouse.wheel({ deltaX, deltaY }))),
+			drag: (from, to) => op("tab.drag()", INF, sig => this.#drag(from, to, sig)),
+			waitFor: selector =>
+				op(
+					`tab.waitFor(${JSON.stringify(selector)})`,
+					INF,
+					async sig =>
+						(await untilAborted(sig, () =>
+							page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
+						)) as ElementHandle,
+				),
+			evaluate: (fn, ...args) =>
+				op("tab.evaluate()", INF, sig =>
+					untilAborted(sig, () =>
+						typeof fn === "string"
+							? page.evaluate(fn)
+							: page.evaluate(fn as (...a: unknown[]) => unknown, ...args),
+					),
+				) as never,
+			scrollIntoView: selector =>
+				op(`tab.scrollIntoView(${JSON.stringify(selector)})`, INF, async sig => {
+					const handle = (await untilAborted(sig, () =>
+						page.locator(normalizeSelector(selector)).setTimeout(timeoutMs).waitHandle(),
+					)) as ElementHandle;
+					try {
+						await untilAborted(sig, () =>
+							handle.evaluate(el => {
+								const target = el as unknown as {
+									scrollIntoView: (opts: { behavior: string; block: string; inline: string }) => void;
+								};
+								target.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+							}),
+						);
+					} finally {
+						await handle.dispose().catch(() => undefined);
+					}
+				}),
+			select: (selector, ...values) =>
+				op(`tab.select(${JSON.stringify(selector)})`, INF, sig => this.#select(selector, values, timeoutMs, sig)),
+			uploadFile: (selector, ...filePaths) =>
+				op(`tab.uploadFile(${JSON.stringify(selector)})`, INF, sig =>
+					this.#uploadFile(selector, filePaths, timeoutMs, sig, session),
+				),
+			waitForUrl: (pattern, opts) =>
+				op("tab.waitForUrl()", INF, sig => this.#waitForUrl(pattern, opts?.timeout ?? timeoutMs, sig)),
+			waitForResponse: (pattern, opts) =>
+				op("tab.waitForResponse()", INF, sig => this.#waitForResponse(pattern, opts?.timeout ?? timeoutMs, sig)),
+			id: id => this.#resolveCachedHandle(id),
 		};
 	}
 
@@ -832,7 +938,21 @@ export class WorkerCore {
 			)) as ElementHandle | null;
 			if (!handle) throw new ToolError("Screenshot selector did not resolve to an element");
 			try {
-				buffer = (await untilAborted(signal, () => handle.screenshot({ type: "png" }))) as Buffer;
+				// Bring the element into view with a single instant scroll instead of puppeteer's
+				// scrollIntoViewIfNeeded(), whose IntersectionObserver promise can stall indefinitely
+				// on continuously-animating pages (WebGL / backdrop-filter "glass" effects). Best-effort.
+				await untilAborted(signal, () =>
+					handle.evaluate(el => {
+						const target = el as unknown as {
+							scrollIntoView: (opts: { behavior: string; block: string; inline: string }) => void;
+						};
+						target.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+					}),
+				).catch(() => undefined);
+				// scrollIntoView:false skips the same IntersectionObserver check inside screenshot();
+				// captureBeyondViewport (puppeteer's default) still renders the clipped region.
+				const shotOpts: ElementScreenshotOptions = { type: "png", scrollIntoView: false };
+				buffer = (await untilAborted(signal, () => handle.screenshot(shotOpts))) as Buffer;
 			} finally {
 				await handle.dispose().catch(() => undefined);
 			}

package/src/tools/debug.ts

@@ -594,8 +594,11 @@ export const debugToolRenderer = {
 		return markFramedBlockComponent({
 			render(width: number): string[] {
 				const action = (args?.action ?? result.details?.action ?? "debug").replaceAll("_", " ");
-				const status = options.isPartial ? "running" : result.isError ? "error" : "success";
-				const header = `${formatStatusIcon(status, theme, options.spinnerFrame)} Debug ${action}`;
+				const success = !options.isPartial && !result.isError;
+				const statusIcon = success
+					? theme.styledSymbol("tool.debug", "accent")
+					: formatStatusIcon(options.isPartial ? "running" : "error", theme, options.spinnerFrame);
+				const header = `${statusIcon} Debug ${action}`;
 				const summaryLines = result.details?.snapshot
 					? formatSessionSnapshot(result.details.snapshot).map(line => replaceTabs(line))
 					: [];

package/src/tools/eval-render.ts

@@ -172,7 +172,7 @@ function renderAgentProgressEvents(events: EvalStatusEvent[], theme: Theme, spin
 		const status = agentEventStatus(event.status);
 		const iconStatus =
 			status === "completed"
-				? "success"
+				? "done"
 				: status === "failed"
 					? "error"
 					: status === "aborted"
@@ -182,10 +182,13 @@ function renderAgentProgressEvents(events: EvalStatusEvent[], theme: Theme, spin
 							: "running";
 		const iconColor =
 			status === "completed" ? "success" : status === "failed" || status === "aborted" ? "error" : "accent";
-		const icon = formatStatusIcon(iconStatus, theme, status === "running" ? spinnerFrame : undefined);
+		const icon =
+			status === "completed"
+				? theme.styledSymbol("tool.eval", "accent")
+				: theme.fg(iconColor, formatStatusIcon(iconStatus, theme, status === "running" ? spinnerFrame : undefined));
 
 		const id = eventString(event.id) ?? "agent";
-		let line = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", theme.bold(id))}`;
+		let line = `${prefix} ${icon} ${theme.fg("accent", theme.bold(id))}`;
 
 		if (status === "failed" || status === "aborted") {
 			line += ` ${formatBadge(status, iconColor, theme)}`;

package/src/tools/eval.ts

@@ -30,7 +30,7 @@ const evalCellSchema = z.object({
 	language: z.enum(["py", "js"]).describe('runtime: "py" for the IPython kernel, "js" for the persistent JS VM'),
 	code: z.string().describe("cell body, verbatim. Use top-level await freely."),
 	title: z.string().optional().describe('short label shown in transcript (e.g. "imports", "load config")'),
-	timeout: z.number().int().min(1).max(600).optional().describe("per-cell timeout in seconds (1-600, default 30)"),
+	timeout: z.number().int().min(1).max(3600).optional().describe("per-cell timeout in seconds (1-3600, default 30)"),
 	reset: z
 		.boolean()
 		.optional()

package/src/tools/gh-renderer.ts

@@ -163,8 +163,8 @@ function getJobStateVisual(
 ): { iconRaw: string; iconColor: ToolUIColor; textColor: ThemeColor } {
 	if (job.conclusion && SUCCESS_CONCLUSIONS.has(job.conclusion)) {
 		return {
-			iconRaw: theme.status.success,
-			iconColor: "success",
+			iconRaw: theme.symbol("tool.gh"),
+			iconColor: "accent",
 			textColor: "success",
 		};
 	}
@@ -327,14 +327,21 @@ function renderFallbackComponent(
 	const title = formatOpTitle(args.op);
 	const meta = buildOpMeta(args);
 	const isError = result.isError === true;
-	const status: ToolUIStatus = isError ? "error" : text ? "success" : "warning";
+	const success = !isError && Boolean(text);
 	const header = renderStatusLine(
-		{
-			icon: status,
-			title,
-			titleColor: isError ? "error" : "accent",
-			meta,
-		},
+		success
+			? {
+					iconOverride: theme.styledSymbol("tool.gh", "accent"),
+					title,
+					titleColor: "accent",
+					meta,
+				}
+			: {
+					icon: isError ? "error" : "warning",
+					title,
+					titleColor: isError ? "error" : "accent",
+					meta,
+				},
 		theme,
 	);
 
@@ -438,12 +445,19 @@ export const githubToolRenderer = {
 		if (watch) {
 			const isError = result.isError === true;
 			const header = renderStatusLine(
-				{
-					icon: isError ? "error" : "success",
-					title: "GitHub Run Watch",
-					titleColor: isError ? "error" : "accent",
-					meta: [getWatchHeader(watch)],
-				},
+				isError
+					? {
+							icon: "error",
+							title: "GitHub Run Watch",
+							titleColor: "error",
+							meta: [getWatchHeader(watch)],
+						}
+					: {
+							iconOverride: uiTheme.styledSymbol("tool.gh", "accent"),
+							title: "GitHub Run Watch",
+							titleColor: "accent",
+							meta: [getWatchHeader(watch)],
+						},
 				uiTheme,
 			);
 			return framedBlock(uiTheme, width => {

package/src/tools/index.ts

@@ -59,11 +59,7 @@ import { type TodoPhase, TodoTool } from "./todo";
 import { WriteTool } from "./write";
 import { YieldTool } from "./yield";
 
-// Exa MCP tools (22 tools)
-
 export * from "../edit";
-export * from "../exa";
-export type * from "../exa/types";
 export * from "../goals";
 export * from "../lsp";
 export * from "../session/streaming-output";
@@ -342,6 +338,38 @@ export function computeEssentialBuiltinNames(settings: Settings): string[] {
 	return [...DEFAULT_ESSENTIAL_TOOL_NAMES];
 }
 
+/**
+ * Filter the initial active tool set when `tools.discoveryMode === "all"`.
+ *
+ * Non-essential discoverable built-ins are hidden — the model rediscovers them
+ * via `search_tool_bm25` and activates them on demand. A tool survives hiding
+ * when it is essential, explicitly requested, restored from a prior selection,
+ * or required by a forced tool_choice feature (`forceActive`). The last case is
+ * load-bearing: a named tool_choice (e.g. the eager `todo` prelude) must
+ * reference a tool present in the request, or the provider rejects it with 400.
+ */
+export function filterInitialToolsForDiscoveryAll(
+	initialToolNames: string[],
+	opts: {
+		loadModeOf: (name: string) => BuiltinToolLoadMode | undefined;
+		essentialNames: ReadonlySet<string>;
+		explicitlyRequested: ReadonlySet<string>;
+		restored: ReadonlySet<string>;
+		forceActive: ReadonlySet<string>;
+	},
+): string[] {
+	return initialToolNames.filter(name => {
+		const loadMode = opts.loadModeOf(name);
+		if (!loadMode) return true; // not a built-in — leave MCP/custom/extension to existing logic
+		if (loadMode === "essential") return true;
+		if (opts.essentialNames.has(name)) return true;
+		if (opts.explicitlyRequested.has(name)) return true;
+		if (opts.restored.has(name)) return true;
+		if (opts.forceActive.has(name)) return true;
+		return false;
+	});
+}
+
 /**
  * Public callable factory map. External callers may invoke `BUILTIN_TOOLS.read(session)` or
  * `BUILTIN_TOOLS[name](session)` to construct a tool directly.

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

@@ -53,12 +53,19 @@ export const inspectImageToolRenderer = {
 		const details = result.details;
 		const rawPath = details?.imagePath ?? args?.path ?? "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "image";
+		const success = !result.isError;
 		const header = renderStatusLine(
-			{
-				icon: result.isError ? "error" : "success",
-				title: "Inspect",
-				description: pathDisplay,
-			},
+			success
+				? {
+						iconOverride: uiTheme.styledSymbol("tool.inspectImage", "accent"),
+						title: "Inspect",
+						description: pathDisplay,
+					}
+				: {
+						icon: "error",
+						title: "Inspect",
+						description: pathDisplay,
+					},
 			uiTheme,
 		);
 

package/src/tools/job.ts

@@ -355,7 +355,7 @@ const PREVIEW_LINE_WIDTH = 80;
 function statusToIcon(status: JobSnapshot["status"]): ToolUIStatus {
 	switch (status) {
 		case "completed":
-			return "success";
+			return "done";
 		case "failed":
 			return "error";
 		case "cancelled":
@@ -468,11 +468,14 @@ export const jobToolRenderer = {
 						itemType: "job",
 						renderItem: job => {
 							const lines: string[] = [];
-							const icon = formatStatusIcon(
-								statusToIcon(job.status),
-								uiTheme,
-								job.status === "running" ? options.spinnerFrame : undefined,
-							);
+							const icon =
+								job.status === "completed"
+									? uiTheme.styledSymbol("tool.job", "accent")
+									: formatStatusIcon(
+											statusToIcon(job.status),
+											uiTheme,
+											job.status === "running" ? options.spinnerFrame : undefined,
+										);
 							const typeBadge = formatBadge(job.type, statusToColor(job.status), uiTheme);
 							const idText = uiTheme.fg("muted", job.id);
 							const rawLabelLines = (job.label || "(no label)").split(/\r?\n/);

package/src/tools/memory-render.ts

@@ -49,10 +49,11 @@ function queryHeader(
 	icon: ToolUIStatus,
 	theme: Theme,
 	meta?: string[],
+	iconOverride?: string,
 ): string {
 	const trimmed = replaceTabs((query ?? "").trim());
 	const description = trimmed ? truncateToWidth(trimmed, 80, Ellipsis.Unicode) : undefined;
-	return renderStatusLine({ icon, title, description, meta }, theme);
+	return renderStatusLine({ icon, iconOverride, title, description, meta }, theme);
 }
 
 function retainComponent(contents: string[], header: string, getExpanded: () => boolean, theme: Theme): Component {
@@ -96,7 +97,11 @@ export const retainToolRenderer = {
 		// trailing period so it reads cleanly as a status meta segment.
 		const summary = resultText(result).replace(/\.$/, "");
 		const header = renderStatusLine(
-			{ icon: "success", title: "Retain", meta: summary ? [summary] : undefined },
+			{
+				iconOverride: theme.styledSymbol("tool.memory", "accent"),
+				title: "Retain",
+				meta: summary ? [summary] : undefined,
+			},
 			theme,
 		);
 		return retainComponent(contents, header, () => options.expanded, theme);
@@ -121,9 +126,11 @@ export const recallToolRenderer = {
 		const text = resultText(result);
 		const match = text.match(/^Found (\d+) relevant/);
 		const found = match ? Number(match[1]) : 0;
-		const icon: ToolUIStatus = found > 0 ? "success" : "warning";
 		const meta = [found > 0 ? `${found} found` : "no matches"];
-		const header = queryHeader("Recall", args?.query, icon, theme, meta);
+		const header =
+			found > 0
+				? queryHeader("Recall", args?.query, "success", theme, meta, theme.styledSymbol("tool.memory", "accent"))
+				: queryHeader("Recall", args?.query, "warning", theme, meta);
 		if (found === 0) {
 			return new Text(header, 0, 0);
 		}
@@ -163,7 +170,14 @@ export const reflectToolRenderer = {
 		if (result.isError) {
 			return new Text(formatErrorMessage(resultText(result) || "Reflect failed", theme), 0, 0);
 		}
-		const header = queryHeader("Reflect", args?.query, "success", theme);
+		const header = queryHeader(
+			"Reflect",
+			args?.query,
+			"success",
+			theme,
+			undefined,
+			theme.styledSymbol("tool.memory", "accent"),
+		);
 		const answer = resultText(result);
 		const answerLines = answer.split("\n").filter(line => line.trim().length > 0);
 		return createCachedComponent(