@oh-my-pi/pi-coding-agent 15.12.3 → 15.13.0

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

@@ -2,10 +2,21 @@ import { getPuppeteerDir, logger, Snowflake, workerHostEntry } from "@oh-my-pi/p
 import type { Page, Target } from "puppeteer-core";
 import { callSessionTool } from "../../eval/js/tool-bridge";
 import type { ToolSession } from "../../sdk";
+import { webpExclusionForModel } from "../../utils/image-loading";
 import { expandPath } from "../path-utils";
 import { ToolAbortError, ToolError } from "../tool-errors";
 import { pickElectronTarget } from "./attach";
-import { type BrowserHandle, type BrowserKindTag, holdBrowser, releaseBrowser } from "./registry";
+import { CmuxTab, runCmuxCode } from "./cmux/cmux-tab";
+import { mapWaitUntil } from "./cmux/rpc";
+import { DEFAULT_VIEWPORT } from "./launch";
+import {
+	type BrowserHandle,
+	type BrowserKindTag,
+	type CmuxBrowserHandle,
+	holdBrowser,
+	type PuppeteerBrowserHandle,
+	releaseBrowser,
+} from "./registry";
 import type {
 	ReadyInfo,
 	RunErrorPayload,
@@ -39,11 +50,10 @@ export interface PendingRun {
 	toolCalls: Map<string, AbortController>;
 }
 
-export interface TabSession {
+interface TabSessionBase<TBrowser extends BrowserHandle = BrowserHandle> {
 	name: string;
-	browser: BrowserHandle;
+	browser: TBrowser;
 	targetId: string;
-	worker: WorkerHandle;
 	state: "alive" | "dead";
 	info: ReadyInfo;
 	pending: Map<string, PendingRun>;
@@ -51,6 +61,20 @@ export interface TabSession {
 	kindTag: BrowserKindTag;
 }
 
+export interface WorkerTabSession extends TabSessionBase<PuppeteerBrowserHandle> {
+	backend: "worker";
+	worker: WorkerHandle;
+}
+
+export interface CmuxTabSession extends TabSessionBase<CmuxBrowserHandle> {
+	backend: "cmux";
+	cmuxTab: CmuxTab;
+	cmuxOwnsSurface: boolean;
+	cmuxAttachedSurface?: string;
+}
+
+export type TabSession = WorkerTabSession | CmuxTabSession;
+
 export interface AcquireTabOptions {
 	url?: string;
 	waitUntil?: "load" | "domcontentloaded" | "networkidle0" | "networkidle2";
@@ -59,6 +83,7 @@ export interface AcquireTabOptions {
 	signal?: AbortSignal;
 	timeoutMs: number;
 	dialogs?: DialogPolicy;
+	cmuxSurface?: string;
 }
 
 export interface AcquireTabResult {
@@ -120,13 +145,18 @@ async function acquireTabImpl(
 	const existing = tabs.get(name);
 	if (existing) {
 		if (existing.browser === browser && existing.state === "alive") {
-			if (opts.dialogs !== undefined && opts.dialogs !== existing.dialogPolicy) {
+			const requestedCmuxSurface = "client" in browser ? (opts.cmuxSurface ?? browser.surface) : undefined;
+			if (existing.backend === "cmux" && existing.cmuxAttachedSurface !== requestedCmuxSurface) {
+				holdBrowser(browser);
+				tempHold = true;
+				await releaseTab(name, { kill: false });
+			} else if (opts.dialogs !== undefined && opts.dialogs !== existing.dialogPolicy) {
 				holdBrowser(browser);
 				tempHold = true;
 				await releaseTab(name, { kill: false });
 			} else {
 				const reuseSteps: string[] = [];
-				if (opts.viewport) {
+				if (opts.viewport && browser.kind.kind !== "cmux") {
 					const dsf = opts.viewport.deviceScaleFactor;
 					reuseSteps.push(
 						`await page.setViewport({ width: ${opts.viewport.width}, height: ${opts.viewport.height}, deviceScaleFactor: ${dsf === undefined ? "undefined" : String(dsf)} });`,
@@ -159,6 +189,16 @@ async function acquireTabImpl(
 		}
 	}
 
+	if ("client" in browser) {
+		try {
+			const result = await acquireCmuxTab(name, browser, opts);
+			if (tempHold) await releaseBrowser(browser, { kill: false });
+			return result;
+		} catch (error) {
+			if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			throw error;
+		}
+	}
 	let initPayload: WorkerInitPayload;
 	let worker: WorkerHandle;
 	try {
@@ -201,10 +241,11 @@ async function acquireTabImpl(
 
 	holdBrowser(browser);
 	if (tempHold) await releaseBrowser(browser, { kill: false });
-	const tab: TabSession = {
+	const tab: WorkerTabSession = {
 		name,
 		browser,
 		targetId: info.targetId,
+		backend: "worker",
 		worker,
 		state: "alive",
 		info,
@@ -217,11 +258,85 @@ async function acquireTabImpl(
 	return { tab, created: true };
 }
 
+async function acquireCmuxTab(
+	name: string,
+	browser: CmuxBrowserHandle,
+	opts: AcquireTabOptions,
+): Promise<AcquireTabResult> {
+	const attachedSurface = opts.cmuxSurface ?? browser.surface;
+	if (attachedSurface?.startsWith("surface:")) {
+		throw new ToolError(
+			"app.surface must be a surface UUID (e.g. CMUX_SURFACE_ID), not a 'surface:N' ref; omit it to open a new split",
+		);
+	}
+
+	let surfaceId = attachedSurface;
+	let initialUrl = opts.url;
+	let ownsSurface = false;
+	try {
+		if (!surfaceId) {
+			const params: Record<string, unknown> = { url: opts.url ?? "about:blank", focus: false };
+			if (process.env.CMUX_WORKSPACE_ID) params.workspace_id = process.env.CMUX_WORKSPACE_ID;
+			if (process.env.CMUX_SURFACE_ID) params.surface_id = process.env.CMUX_SURFACE_ID;
+			const result = await browser.client.request("browser.open_split", params, { timeoutMs: opts.timeoutMs });
+			if (typeof result.surface_id !== "string" || result.surface_id.length === 0) {
+				throw new ToolError("cmux browser.open_split did not return a surface_id");
+			}
+			surfaceId = result.surface_id;
+			ownsSurface = true;
+			if (typeof result.url === "string" && result.url.length > 0) initialUrl = result.url;
+			if (opts.url) {
+				await browser.client.request(
+					"browser.wait",
+					{
+						surface_id: surfaceId,
+						load_state: mapWaitUntil(opts.waitUntil ?? "load"),
+						timeout_ms: opts.timeoutMs,
+					},
+					{ timeoutMs: opts.timeoutMs },
+				);
+			}
+		}
+
+		const cmuxTab = new CmuxTab({ client: browser.client, surfaceId, url: initialUrl });
+		if (attachedSurface && opts.url) {
+			await cmuxTab.goto(opts.url, { waitUntil: opts.waitUntil ?? "load", timeoutMs: opts.timeoutMs });
+		}
+		const info = await cmuxTab.readyInfo(opts.viewport ?? DEFAULT_VIEWPORT);
+		holdBrowser(browser);
+		const tab: CmuxTabSession = {
+			name,
+			browser,
+			targetId: surfaceId,
+			backend: "cmux",
+			cmuxTab,
+			cmuxOwnsSurface: ownsSurface,
+			state: "alive",
+			info,
+			pending: new Map(),
+			dialogPolicy: opts.dialogs,
+			kindTag: browser.kind.kind,
+			cmuxAttachedSurface: attachedSurface,
+		};
+		tabs.set(name, tab);
+		return { tab, created: true };
+	} catch (error) {
+		if (ownsSurface && surfaceId) {
+			await browser.client.request("surface.close", { surface_id: surfaceId }).catch(() => undefined);
+		}
+		throw error;
+	}
+}
+
 export async function runInTab(name: string, opts: RunInTabOptions): Promise<RunResultOk> {
 	return await runInTabWithSnapshot(
 		name,
 		{ code: opts.code, timeoutMs: opts.timeoutMs, signal: opts.signal, session: opts.session },
-		{ cwd: opts.session.cwd, browserScreenshotDir: expandBrowserScreenshotDir(opts.session) },
+		{
+			cwd: opts.session.cwd,
+			browserScreenshotDir: expandBrowserScreenshotDir(opts.session),
+			excludeWebP: webpExclusionForModel(opts.session.getActiveModel?.()),
+		},
 	);
 }
 
@@ -243,6 +358,19 @@ async function runInTabWithSnapshot(
 		toolCalls: new Map(),
 	};
 	tab.pending.set(id, pending);
+	if (tab.backend === "cmux") {
+		try {
+			return await runCmuxCode(tab.cmuxTab, {
+				code: opts.code,
+				timeoutMs: opts.timeoutMs,
+				signal: opts.signal,
+				session: pending.session,
+				snapshot,
+			});
+		} finally {
+			tab.pending.delete(id);
+		}
+	}
 	const abort = (): void => {
 		tab.worker.send({ type: "abort", id });
 		for (const ctrl of pending.toolCalls.values()) ctrl.abort(opts.signal?.reason);
@@ -250,7 +378,14 @@ async function runInTabWithSnapshot(
 	if (opts.signal?.aborted) abort();
 	else opts.signal?.addEventListener("abort", abort, { once: true });
 	try {
-		tab.worker.send({ type: "run", id, name, code: opts.code, timeoutMs: opts.timeoutMs, session: snapshot });
+		tab.worker.send({
+			type: "run",
+			id,
+			name,
+			code: opts.code,
+			timeoutMs: opts.timeoutMs,
+			session: snapshot,
+		});
 		return await raceWithTimeout(
 			promise,
 			opts.timeoutMs + GRACE_MS,
@@ -273,12 +408,35 @@ export async function releaseTab(name: string, opts: ReleaseTabOptions = {}): Pr
 	tab.state = "dead";
 	const closeError = new ToolError(`Tab ${JSON.stringify(name)} was closed`);
 	for (const [id, pending] of tab.pending) {
-		try {
-			tab.worker.send({ type: "abort", id });
-		} catch {}
+		if (tab.backend === "worker") {
+			try {
+				tab.worker.send({ type: "abort", id });
+			} catch {}
+		}
+		for (const ctrl of pending.toolCalls.values()) ctrl.abort(closeError);
 		pending.reject(closeError);
 	}
 	tab.pending.clear();
+	if (tab.backend === "cmux") {
+		let nonLastCloseError: unknown;
+		if (wasAlive && tab.cmuxOwnsSurface) {
+			try {
+				await tab.browser.client.request("surface.close", { surface_id: tab.targetId });
+			} catch (err) {
+				if (isLastSurfaceCloseError(err)) {
+					logger.debug("Leaving cmux browser surface open because it is the last surface in the workspace", {
+						error: err instanceof Error ? err.message : String(err),
+					});
+				} else {
+					nonLastCloseError = err;
+				}
+			}
+		}
+		await releaseBrowser(tab.browser, { kill: opts.kill ?? false });
+		tabs.delete(name);
+		if (nonLastCloseError) throw nonLastCloseError;
+		return true;
+	}
 	let forced = false;
 	if (wasAlive) {
 		try {
@@ -309,7 +467,12 @@ export async function dropHeadlessTabs(): Promise<void> {
 	for (const name of names) await releaseTab(name);
 }
 
-async function buildInitPayload(browser: BrowserHandle, opts: AcquireTabOptions): Promise<WorkerInitPayload> {
+function isLastSurfaceCloseError(err: unknown): boolean {
+	const message = err instanceof Error ? err.message : String(err);
+	return /last/i.test(message);
+}
+
+async function buildInitPayload(browser: PuppeteerBrowserHandle, opts: AcquireTabOptions): Promise<WorkerInitPayload> {
 	const safeDir = getPuppeteerDir();
 	const browserWSEndpoint = browser.browser.wsEndpoint();
 	if (!browserWSEndpoint) throw new ToolError("Browser websocket endpoint is unavailable");
@@ -336,7 +499,7 @@ async function buildInitPayload(browser: BrowserHandle, opts: AcquireTabOptions)
 	};
 }
 
-function handleTabMessage(tab: TabSession, msg: WorkerOutbound): void {
+function handleTabMessage(tab: WorkerTabSession, msg: WorkerOutbound): void {
 	if (msg.type === "result") {
 		const pending = tab.pending.get(msg.id);
 		if (!pending) return;
@@ -359,7 +522,10 @@ function handleTabMessage(tab: TabSession, msg: WorkerOutbound): void {
 	if (msg.type === "log") logWorkerMessage(msg);
 }
 
-async function dispatchToolCall(tab: TabSession, msg: Extract<WorkerOutbound, { type: "tool-call" }>): Promise<void> {
+async function dispatchToolCall(
+	tab: WorkerTabSession,
+	msg: Extract<WorkerOutbound, { type: "tool-call" }>,
+): Promise<void> {
 	const pending = tab.pending.get(msg.runId);
 	if (!pending?.session.cwd) {
 		safeSend(tab, {
@@ -395,7 +561,7 @@ async function dispatchToolCall(tab: TabSession, msg: Extract<WorkerOutbound, {
 	}
 }
 
-function safeSend(tab: TabSession, msg: WorkerInbound): void {
+function safeSend(tab: WorkerTabSession, msg: WorkerInbound): void {
 	if (tab.state !== "alive") return;
 	try {
 		tab.worker.send(msg);
@@ -424,13 +590,18 @@ async function forceKillTab(name: string, reason: string): Promise<void> {
 	const error = new ToolError(reason);
 	for (const pending of tab.pending.values()) pending.reject(error);
 	tab.pending.clear();
+	if (tab.backend === "cmux") {
+		await releaseBrowser(tab.browser, { kill: false });
+		tabs.delete(name);
+		return;
+	}
 	await tab.worker.terminate().catch(() => undefined);
 	if (tab.kindTag === "headless") await closeOrphanTarget(tab);
 	await releaseBrowser(tab.browser, { kill: false });
 	tabs.delete(name);
 }
 
-async function closeOrphanTarget(tab: TabSession): Promise<void> {
+async function closeOrphanTarget(tab: WorkerTabSession): Promise<void> {
 	for (const target of tab.browser.browser.targets()) {
 		if ((await targetIdForTarget(target).catch(() => "")) !== tab.targetId) continue;
 		const page = await target.page().catch(() => null);
@@ -439,7 +610,7 @@ async function closeOrphanTarget(tab: TabSession): Promise<void> {
 	}
 }
 
-async function waitForClosed(tab: TabSession): Promise<void> {
+async function waitForClosed(tab: WorkerTabSession): Promise<void> {
 	const { promise, resolve } = Promise.withResolvers<void>();
 	const unsubscribe = tab.worker.onMessage(msg => {
 		if (msg.type === "closed") resolve();

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

@@ -981,7 +981,7 @@ export class WorkerCore {
 		}
 		const resized = await resizeImage(
 			{ type: "image", data: buffer.toBase64(), mimeType: captureMime },
-			{ maxWidth: 1024, maxHeight: 1024, maxBytes: 150 * 1024, jpegQuality: 70 },
+			{ maxWidth: 1024, maxHeight: 1024, maxBytes: 150 * 1024, jpegQuality: 70, excludeWebP: session.excludeWebP },
 		);
 		const saveFullRes = !!(explicitPath || session.browserScreenshotDir);
 		const savedBuffer = saveFullRes ? buffer : resized.buffer;

package/src/tools/browser.ts

@@ -1,10 +1,11 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import browserDescription from "../prompts/tools/browser.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
 import { enforceInlineByteCap } from "../session/streaming-output";
 import { truncateForPrompt } from "./approval";
+import { resolveCmuxKind } from "./browser/cmux/rpc";
 import { acquireBrowser, type BrowserHandle, type BrowserKind, type BrowserKindTag } from "./browser/registry";
 import type { Observation, ScreenshotResult } from "./browser/tab-protocol";
 import { acquireTab, dropHeadlessTabs, getTab, releaseAllTabs, releaseTab, runInTab } from "./browser/tab-supervisor";
@@ -14,6 +15,8 @@ import { ToolAbortError, ToolError, throwIfAborted } from "./tool-errors";
 import { toolResult } from "./tool-result";
 import { clampTimeout } from "./tool-timeouts";
 
+export { cmuxSnapshotToObservation, mapWaitUntil, resolveCmuxKind, serializeEval } from "./browser/cmux/rpc";
+export { CmuxSocketClient } from "./browser/cmux/socket-client";
 export { extractReadableFromHtml, type ReadableFormat, type ReadableResult } from "./browser/readable";
 export type { Observation, ObservationEntry } from "./browser/tab-protocol";
 
@@ -77,6 +80,12 @@ function resolveBrowserKind(params: BrowserParams, session: ToolSession): Browse
 		const exe = resolveToCwd(app.path, session.cwd);
 		return { kind: "spawned", path: exe };
 	}
+	const cmuxKind = resolveCmuxKind({
+		settingEnabled: session.settings.get("browser.cmux") as boolean | undefined,
+	});
+	if (cmuxKind) {
+		return cmuxKind;
+	}
 	const headless = session.settings.get("browser.headless") as boolean;
 	return { kind: "headless", headless };
 }
@@ -304,6 +313,9 @@ async function saveBrowserOutputArtifact(session: ToolSession, fullText: string)
 }
 
 function describeBrowser(handle: BrowserHandle): string {
+	if (!("browser" in handle)) {
+		return `cmux browser (${handle.kind.surface ?? "split"})`;
+	}
 	switch (handle.kind.kind) {
 		case "headless":
 			return `headless browser (${handle.kind.headless ? "hidden" : "visible"})`;
@@ -322,6 +334,8 @@ function describeKind(kind: BrowserKind): string {
 			return `spawned:${kind.path}`;
 		case "connected":
 			return `connected:${kind.cdpUrl}`;
+		case "cmux":
+			return `cmux:${kind.surface ?? "split"}`;
 	}
 }
 
@@ -330,6 +344,7 @@ function sameBrowserKind(a: BrowserKind, b: BrowserKind): boolean {
 	if (a.kind === "headless" && b.kind === "headless") return a.headless === b.headless;
 	if (a.kind === "spawned" && b.kind === "spawned") return a.path === b.path;
 	if (a.kind === "connected" && b.kind === "connected") return a.cdpUrl === b.cdpUrl;
+	if (a.kind === "cmux" && b.kind === "cmux") return a.socketPath === b.socketPath;
 	return false;
 }
 

package/src/tools/checkpoint.ts

@@ -1,6 +1,6 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import checkpointDescription from "../prompts/tools/checkpoint.md" with { type: "text" };
 import rewindDescription from "../prompts/tools/rewind.md" with { type: "text" };
 import type { ToolSession } from ".";

package/src/tools/debug.ts

@@ -9,7 +9,7 @@ import type {
 } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
 import { isEnoent, prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import {
 	type DapBreakpointRecord,
 	type DapCapabilities,

package/src/tools/eval-render.ts

@@ -754,8 +754,9 @@ export const evalToolRenderer = {
 
 	mergeCallAndResult: true,
 	inline: true,
-	// Pending preview shows tail-window code cells; the result render
+	// 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. Keep the preview out of native scrollback mid-run.
-	provisionalPendingPreview: true,
+	// below the first cell. Expanded output is top-anchored enough for the
+	// transcript to commit its settled prefix.
+	provisionalPendingPreview: "collapsed",
 };

package/src/tools/eval.ts

@@ -1,7 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { jsBackend, pythonBackend } from "../eval";
 import type { ExecutorBackend, ExecutorBackendResult } from "../eval/backend";
 import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../eval/bridge-timeout";
@@ -10,6 +10,7 @@ import { defaultEvalSessionId } from "../eval/session-id";
 import type { EvalCellResult, EvalDisplayOutput, EvalLanguage, EvalStatusEvent, EvalToolDetails } from "../eval/types";
 import evalDescription from "../prompts/tools/eval.md" with { type: "text" };
 import { DEFAULT_MAX_BYTES, OutputSink, type OutputSummary, TailBuffer } from "../session/streaming-output";
+import { webpExclusionForModel } from "../utils/image-loading";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
@@ -219,6 +220,7 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 			throw new ToolError("Eval tool requires a session when not using proxy executor");
 		}
 		const session = this.session;
+		const excludeWebP = webpExclusionForModel(session.getActiveModel?.());
 
 		const cells: ResolvedEvalCell[] = [];
 		for (let i = 0; i < params.cells.length; i++) {
@@ -390,11 +392,14 @@ export class EvalTool implements AgentTool<typeof evalSchema> {
 							cellDisplayOutputs.push(output);
 						}
 						if (output.type === "image") {
-							const resized = await resizeImage({
-								type: "image",
-								data: output.data,
-								mimeType: output.mimeType,
-							});
+							const resized = await resizeImage(
+								{
+									type: "image",
+									data: output.data,
+									mimeType: output.mimeType,
+								},
+								{ excludeWebP },
+							);
 							const image: ImageContent = {
 								type: "image",
 								data: resized.data,

package/src/tools/fetch.ts

@@ -17,6 +17,7 @@ import type { AgentStorage } from "../session/agent-storage";
 import { DEFAULT_MAX_BYTES, truncateHead } from "../session/streaming-output";
 import { renderStatusLine, urlHyperlink } from "../tui";
 import { CachedOutputBlock, markFramedBlockComponent } from "../tui/output-block";
+import { webpExclusionForModel } from "../utils/image-loading";
 import { formatDimensionNote, resizeImage } from "../utils/image-resize";
 import { ensureTool } from "../utils/tools-manager";
 import { extractWithParallel, findParallelApiKey, getParallelExtractContent } from "../web/parallel";
@@ -1077,6 +1078,7 @@ async function renderUrl(
 	signal: AbortSignal | undefined,
 	storage: AgentStorage | null,
 	fetchOverride?: FetchImpl,
+	excludeWebP?: true,
 ): Promise<FetchRenderResult> {
 	const notes: string[] = [];
 	const fetchedAt = new Date().toISOString();
@@ -1190,7 +1192,7 @@ async function renderUrl(
 
 				const resized = await resizeImage(
 					{ type: "image", data: Buffer.from(binary.buffer).toBase64(), mimeType: imageMimeType },
-					{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES },
+					{ maxBytes: MAX_INLINE_IMAGE_OUTPUT_BYTES, excludeWebP },
 				);
 				const isDecodedImage =
 					resized.originalWidth > 0 && resized.originalHeight > 0 && resized.width > 0 && resized.height > 0;
@@ -1666,7 +1668,16 @@ async function buildReadUrlCacheEntry(
 	}
 
 	const storage = session.settings.getStorage();
-	const result = await renderUrl(url, effectiveTimeout, raw, session.settings, signal, storage, session.fetch);
+	const result = await renderUrl(
+		url,
+		effectiveTimeout,
+		raw,
+		session.settings,
+		signal,
+		storage,
+		session.fetch,
+		webpExclusionForModel(session.getActiveModel?.()),
+	);
 	const output = buildUrlReadOutput(result, result.content);
 	const artifactId = options?.ensureArtifact ? await persistReadUrlArtifact(session, output) : undefined;
 

package/src/tools/find.ts

@@ -5,7 +5,7 @@ import * as natives from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { formatGroupedPaths, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";
 import type { Theme } from "../modes/theme/theme";

package/src/tools/gh.ts

@@ -11,7 +11,7 @@ import type {
 } from "@oh-my-pi/pi-agent-core";
 
 import { getWorktreeDir, hashPath, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { Settings } from "../config/settings";
 import githubDescription from "../prompts/tools/github.md" with { type: "text" };
 import * as git from "../utils/git";

package/src/tools/github-cache.ts

@@ -93,10 +93,11 @@ export function openDb(): Database | null {
 		const dbPath = getGithubCacheDbPath();
 		ensureParentDir(dbPath);
 		const db = new Database(dbPath);
+		// Install the busy handler BEFORE any lock-taking statement. See #2421.
+		db.run("PRAGMA busy_timeout = 5000");
 		db.run(`
 			PRAGMA journal_mode=WAL;
 			PRAGMA synchronous=NORMAL;
-			PRAGMA busy_timeout=5000;
 		`);
 		// Migrate any pre-existing table whose key/check constraint predates
 		// the current schema. The cache is regenerable, so we drop rows rather

package/src/tools/image-gen.ts

@@ -19,7 +19,7 @@ import {
 	Snowflake,
 	untilAborted,
 } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import packageJson from "../../package.json" with { type: "json" };
 
 import { isAuthenticated, type ModelRegistry } from "../config/model-registry";