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

package/src/task/render.ts

@@ -807,12 +807,15 @@ function renderReviewResult(
 
 	// Verdict line
 	const verdictColor = summary.overall_correctness === "correct" ? "success" : "error";
-	const verdictIcon = summary.overall_correctness === "correct" ? theme.status.success : theme.status.error;
+	const isCorrect = summary.overall_correctness === "correct";
+	const verdictIcon = isCorrect
+		? theme.styledSymbol("tool.task", "accent")
+		: theme.fg(verdictColor, theme.status.error);
 	lines.push(
-		`${continuePrefix} Patch is ${theme.fg(verdictColor, summary.overall_correctness)} ${theme.fg(
-			verdictColor,
-			verdictIcon,
-		)} ${theme.fg("dim", `(${(summary.confidence * 100).toFixed(0)}% confidence)`)}`,
+		`${continuePrefix} Patch is ${theme.fg(verdictColor, summary.overall_correctness)} ${verdictIcon} ${theme.fg(
+			"dim",
+			`(${(summary.confidence * 100).toFixed(0)}% confidence)`,
+		)}`,
 	);
 
 	// Explanation preview (first ~80 chars when collapsed, full when expanded)
@@ -913,7 +916,7 @@ function renderAgentResult(
 		: needsWarning
 			? theme.status.warning
 			: success
-				? theme.status.success
+				? theme.styledSymbol("tool.task", "accent")
 				: theme.status.error;
 	const iconColor = needsWarning ? "warning" : success ? "success" : mergeFailed ? "warning" : "error";
 	const statusText = aborted
@@ -1082,7 +1085,10 @@ export function renderResult(
 
 	if (!details) {
 		const text = result.content.find(c => c.type === "text")?.text || "";
-		const header = renderStatusLine({ icon: "success", title: "Task" }, theme);
+		const header = renderStatusLine(
+			{ iconOverride: theme.styledSymbol("tool.task", "accent"), title: "Task" },
+			theme,
+		);
 		return framedBlock(theme, width => ({
 			header,
 			sections: [
@@ -1102,11 +1108,17 @@ export function renderResult(
 	const isError = aborted || failed;
 	const agentCount = hasResults ? details.results.length : (details.progress?.length ?? 0);
 	const icon: ToolUIStatus = options.isPartial ? "running" : isError ? "error" : mergeFailed ? "warning" : "success";
+	// Surface the dispatched agent type (e.g. `Reviewer`) alongside the count so
+	// the header reads `Task 16 agents: Reviewer`. All tasks in one call share a
+	// single `agent` type (top-level param), so one label covers the whole batch.
+	const agentName = args?.agent?.trim();
+	const countLabel = agentCount > 0 ? `${agentCount} ${agentCount === 1 ? "agent" : "agents"}` : undefined;
+	const metaLabel = countLabel ? (agentName ? `${countLabel}: ${agentName}` : countLabel) : agentName;
 	const header = renderStatusLine(
 		{
 			icon,
 			title: "Task",
-			meta: agentCount > 0 ? [`${agentCount} ${agentCount === 1 ? "agent" : "agents"}`] : undefined,
+			meta: metaLabel ? [metaLabel] : undefined,
 		},
 		theme,
 	);

package/src/tools/ask.ts

@@ -96,7 +96,7 @@ const OTHER_OPTION = "Other (type your own)";
 const RECOMMENDED_SUFFIX = " (Recommended)";
 
 function getDoneOptionLabel(): string {
-	return `${theme.status.success} Done selecting`;
+	return `${theme.symbol("tool.ask")} Done selecting`;
 }
 
 /** Add "(Recommended)" suffix to the option at the given index if not already present */
@@ -407,6 +407,12 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 	readonly description: string;
 	readonly parameters = askSchema;
 	readonly strict = true;
+	// Run alone in its tool batch. The interactive selector/editor is a single
+	// shared UI surface (`ExtensionUiController.showHookSelector` has no queue and
+	// overwrites `ctx.hookSelector` on each call), so two concurrent `ask` calls
+	// would clobber each other: the second steals focus and orphans the first,
+	// whose promise then hangs until the user aborts the whole turn.
+	readonly concurrency = "exclusive";
 	readonly loadMode = "discoverable";
 
 	constructor(private readonly session: ToolSession) {
@@ -621,9 +627,7 @@ interface AskRenderArgs {
 /** Render a custom free-text answer as a status line plus indented continuation rows. */
 function renderCustomInputLines(uiTheme: Theme, customInput: string): string[] {
 	const lines = customInput.split("\n");
-	const out: string[] = [
-		` ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", lines[0] ?? "")}`,
-	];
+	const out: string[] = [` ${uiTheme.styledSymbol("tool.ask", "accent")} ${uiTheme.fg("toolOutput", lines[0] ?? "")}`];
 	for (let i = 1; i < lines.length; i++) out.push(`   ${uiTheme.fg("toolOutput", lines[i])}`);
 	return out;
 }
@@ -814,7 +818,12 @@ export const askToolRenderer = {
 		const question = details.question;
 		const hasSelection =
 			details.customInput !== undefined || (details.selectedOptions && details.selectedOptions.length > 0);
-		const header = renderStatusLine({ icon: hasSelection ? "success" : "warning", title: "Ask" }, uiTheme);
+		const header = renderStatusLine(
+			hasSelection
+				? { iconOverride: uiTheme.styledSymbol("tool.ask", "accent"), title: "Ask" }
+				: { icon: "warning", title: "Ask" },
+			uiTheme,
+		);
 		const dOptions = details.options;
 		const dSelected = details.selectedOptions;
 		const dMulti = details.multi;

package/src/tools/bash-interactive.ts

@@ -246,7 +246,7 @@ class BashInteractiveOverlayComponent implements Component {
 			this.#state === "running"
 				? formatStatusIcon("running", this.uiTheme)
 				: this.#state === "complete" && this.#exitCode === 0
-					? formatStatusIcon("success", this.uiTheme)
+					? this.uiTheme.styledSymbol("tool.bash", "accent")
 					: formatStatusIcon("warning", this.uiTheme);
 		const title = this.uiTheme.fg("accent", "Console");
 		const statusBadge = `${this.uiTheme.fg("dim", this.uiTheme.format.bracketLeft)}${this.#stateText()}${this.uiTheme.fg("dim", this.uiTheme.format.bracketRight)}`;

package/src/tools/bash.ts

@@ -1151,11 +1151,23 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 			const renderArgs = toBashRenderArgs(args, config);
 			const cmdLines = args ? formatBashCommandLines(renderArgs, uiTheme) : undefined;
 			const isError = result.isError === true;
-			const icon = options.isPartial ? "pending" : isError ? "error" : "success";
+			const isPartial = options.isPartial === true;
+			const success = !isPartial && !isError;
 			const header =
 				config.showHeader === false
 					? undefined
-					: renderStatusLine({ icon, title: config.resolveTitle(args, options) }, uiTheme);
+					: renderStatusLine(
+							success
+								? {
+										iconOverride: uiTheme.styledSymbol("tool.bash", "accent"),
+										title: config.resolveTitle(args, options),
+									}
+								: {
+										icon: isPartial ? "pending" : "error",
+										title: config.resolveTitle(args, options),
+									},
+							uiTheme,
+						);
 			const details = result.details;
 			const outputBlock = new CachedOutputBlock();
 

package/src/tools/browser/render.ts

@@ -146,7 +146,7 @@ function renderOpenOrCloseLine(
 	const action = (details?.action ?? args.action ?? "open") as "open" | "close" | "run";
 	const status = cellStatus(isPartial, isError);
 	const icon =
-		status === "complete" ? "success" : status === "error" ? "error" : status === "running" ? "running" : "pending";
+		status === "complete" ? "done" : status === "error" ? "error" : status === "running" ? "running" : "pending";
 
 	let title: string;
 	if (action === "close") {
@@ -163,7 +163,10 @@ function renderOpenOrCloseLine(
 	const url = details?.url ?? args.url;
 	if (url) meta.push(shortenPath(url));
 
-	const header = renderStatusLine({ icon, title, meta }, theme);
+	const header =
+		status === "complete"
+			? renderStatusLine({ iconOverride: theme.styledSymbol("tool.browser", "accent"), title, meta }, theme)
+			: renderStatusLine({ icon, title, meta }, theme);
 	if (!output) return new Text(header, 0, 0);
 	const outputLines = output.split("\n").map(line => theme.fg("toolOutput", replaceTabs(line)));
 	return new Text([header, ...outputLines].join("\n"), 0, 0);

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 => {