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

package/src/subprocess/worker-client.ts

@@ -1,3 +1,5 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import {
 	$env,
@@ -64,7 +66,7 @@ export interface RefCountedWorkerHandle<Inbound, Outbound> extends WorkerHandle<
 
 /** The raw spawned subprocess plus the parent-side fan-out sets. */
 export interface SpawnedSubprocess<Outbound> {
-	proc: Subprocess<"ignore", "ignore", "ignore">;
+	proc: Subprocess<"ignore", "ignore", number | "ignore">;
 	inbound: Set<(message: Outbound) => void>;
 	errors: Set<(error: Error) => void>;
 	/**
@@ -74,8 +76,23 @@ export interface SpawnedSubprocess<Outbound> {
 	 * worker error so callers don't await forever.
 	 */
 	intentionalExit: { value: boolean };
+	/**
+	 * Resolves when the file-backed stderr capture has drained after worker
+	 * exit. `onExit` waits on this before surfacing the crash so the exit-error
+	 * carries the *whole* tail, not whatever happened to be flushed before the
+	 * exit event fired. Tests can await it deterministically instead of racing
+	 * wall-clock timers.
+	 */
+	stderrDrained: Promise<void>;
 }
 
+/**
+ * Bound on the tail of worker stderr surfaced with a crash. Sized to comfortably
+ * hold a full ONNX Runtime/glibc traceback (a few KiB) without letting a chatty
+ * native runtime OOM the parent on repeated warnings.
+ */
+const STDERR_TAIL_LIMIT_BYTES = 16 * 1024;
+
 export interface WorkerSpawnCommand {
 	cmd: string[];
 	cwd?: string;
@@ -126,11 +143,17 @@ export function workerEnvFromParent(overlay?: Record<string, string>): Record<st
 }
 
 /**
- * Spawn an inference worker subprocess and wire its IPC fan-out. The child
- * inherits no stdio (native model runtimes may otherwise print progress or
- * decoded text and corrupt the chat scrollback) and is `unref`'d outside `bun
- * test` so an idle worker never blocks process exit. `exitLabel` prefixes the
- * worker-error message surfaced for an unexpected (non-intentional) exit.
+ * Spawn an inference worker subprocess and wire its IPC fan-out. Stdio is
+ * captured (stderr redirected to a temp file, stdout ignored) so native
+ * runtimes can't corrupt the chat scrollback while the crash reason still
+ * reaches the parent. The file-backed capture deliberately avoids Bun
+ * `ReadableStream` pipes: even an unref'd child with a piped stderr stream can
+ * keep the parent event loop alive. After the worker exits, the last
+ * {@link STDERR_TAIL_LIMIT_BYTES} are appended to the `onExit` error so
+ * `tts/mnemopi/…: worker error` lines carry the actual stack instead of a bare
+ * exit code (issue #4324). The child is `unref`'d outside `bun test` so an idle
+ * worker never blocks process exit. `exitLabel` prefixes the worker-error
+ * message surfaced for an unexpected (non-intentional) exit.
  */
 export function createWorkerSubprocess<Outbound>(options: {
 	spawnCommand: WorkerSpawnCommand;
@@ -140,19 +163,29 @@ export function createWorkerSubprocess<Outbound>(options: {
 	const inbound = new Set<(message: Outbound) => void>();
 	const errors = new Set<(error: Error) => void>();
 	const intentionalExit = { value: false };
+	const stderrTail = new StderrTail(STDERR_TAIL_LIMIT_BYTES);
+	const stderrDrained = Promise.withResolvers<void>();
+	const stderrCapture = createStderrCapture(options.exitLabel);
+	let stderrDrainStarted = false;
+	const startStderrDrain = (): void => {
+		if (stderrDrainStarted) return;
+		stderrDrainStarted = true;
+		void drainStderrCapture(stderrCapture, options.exitLabel, stderrTail).finally(() => stderrDrained.resolve());
+	};
 	const proc = Bun.spawn({
 		cmd: options.spawnCommand.cmd,
 		cwd: options.spawnCommand.cwd,
 		env: options.env,
 		stdin: "ignore",
 		stdout: "ignore",
-		stderr: "ignore",
+		stderr: stderrCapture.target,
 		serialization: "advanced",
 		windowsHide: true,
 		ipc(message) {
 			for (const handler of inbound) handler(message as Outbound);
 		},
 		onExit(_proc, exitCode, signalCode) {
+			startStderrDrain();
 			if (exitCode === 0) return;
 			// Swallow only the expected SIGKILL from `terminate()`; every other
 			// signal exit (SIGSEGV from a native fault, OOM SIGKILL, operator
@@ -160,15 +193,133 @@ export function createWorkerSubprocess<Outbound>(options: {
 			// requests so callers don't await forever.
 			if (exitCode === null && intentionalExit.value) return;
 			const reason = exitCode !== null ? `code ${exitCode}` : `signal ${signalCode ?? "unknown"}`;
-			const err = new Error(`${options.exitLabel} exited with ${reason}`);
-			for (const handler of errors) handler(err);
+			// The stderr target is drained only after exit so idle unref'd
+			// workers do not keep the parent alive; wait for that drain before
+			// surfacing the error so the tail is complete.
+			void stderrDrained.promise.finally(() => {
+				const suffix = stderrTail.suffix();
+				const err = new Error(`${options.exitLabel} exited with ${reason}${suffix}`);
+				for (const handler of errors) handler(err);
+			});
 		},
 	});
 	// Don't keep the parent event loop alive on an idle worker; the dispose
 	// path calls `terminate()` explicitly. Bun's test runner starves IPC for
 	// unref'd subprocesses, so keep it referenced only under tests.
 	if (!isBunTestRuntime()) proc.unref();
-	return { proc, inbound, errors, intentionalExit };
+	return { proc, inbound, errors, intentionalExit, stderrDrained: stderrDrained.promise };
+}
+
+/**
+ * Bounded buffer of the *tail* of a stderr stream. Appended chunks are
+ * concatenated and truncated from the front once they exceed `limit`, so the
+ * final `suffix()` always reflects the most recent output — where native
+ * crash tracebacks land.
+ */
+class StderrTail {
+	#chunks: Uint8Array[] = [];
+	#bytes = 0;
+	constructor(readonly limit: number) {}
+
+	append(chunk: Uint8Array): void {
+		if (chunk.length === 0) return;
+		this.#chunks.push(chunk);
+		this.#bytes += chunk.length;
+		while (this.#bytes > this.limit && this.#chunks.length > 1) {
+			const head = this.#chunks.shift();
+			if (head) this.#bytes -= head.length;
+		}
+		if (this.#bytes > this.limit && this.#chunks.length === 1) {
+			const only = this.#chunks[0];
+			const start = only.length - this.limit;
+			this.#chunks[0] = only.subarray(start);
+			this.#bytes = this.limit;
+		}
+	}
+
+	/** Human-readable trailer for an exit error, or `""` when nothing was captured. */
+	suffix(): string {
+		if (this.#bytes === 0) return "";
+		const merged = new Uint8Array(this.#bytes);
+		let offset = 0;
+		for (const chunk of this.#chunks) {
+			merged.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const text = new TextDecoder().decode(merged).replace(/\s+$/u, "");
+		if (text.length === 0) return "";
+		return `: ${text}`;
+	}
+}
+
+interface StderrCapture {
+	target: number | "ignore";
+	fd: number | null;
+	dir: string | null;
+	cleanupOnExit: (() => void) | null;
+}
+
+/** Create a file-backed stderr target that does not pin Bun's event loop. */
+function createStderrCapture(exitLabel: string): StderrCapture {
+	try {
+		const dir = fs.mkdtempSync(path.join(os.tmpdir(), "omp-worker-stderr-"));
+		const fd = fs.openSync(path.join(dir, "stderr.log"), "w+");
+		const cleanupOnExit = (): void => cleanupStderrCapture({ target: fd, fd, dir, cleanupOnExit: null });
+		process.once("exit", cleanupOnExit);
+		return { target: fd, fd, dir, cleanupOnExit };
+	} catch (error) {
+		logger.debug(`${exitLabel} stderr capture unavailable`, {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		return { target: "ignore", fd: null, dir: null, cleanupOnExit: null };
+	}
+}
+
+function cleanupStderrCapture(capture: StderrCapture): void {
+	if (capture.cleanupOnExit) process.off("exit", capture.cleanupOnExit);
+	if (capture.fd !== null) {
+		try {
+			fs.closeSync(capture.fd);
+		} catch {
+			// Already closed.
+		}
+		capture.fd = null;
+	}
+	if (capture.dir) {
+		try {
+			fs.rmSync(capture.dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort temp cleanup.
+		}
+		capture.dir = null;
+	}
+}
+
+/**
+ * Drain a worker's file-backed stderr target after it exits: forward each
+ * decoded tail line to `logger.debug`, and record the bytes in `tail` so the
+ * eventual exit error can carry the most recent output. Never rejects — cleanup
+ * failures must not fault the parent.
+ */
+async function drainStderrCapture(capture: StderrCapture, exitLabel: string, tail: StderrTail): Promise<void> {
+	try {
+		if (capture.fd === null) return;
+		const size = fs.fstatSync(capture.fd).size;
+		if (size <= 0) return;
+		const length = Math.min(size, tail.limit);
+		const buffer = new Uint8Array(length);
+		fs.readSync(capture.fd, buffer, 0, length, size - length);
+		tail.append(buffer);
+		for (const rawLine of new TextDecoder().decode(buffer).split("\n")) {
+			const line = rawLine.replace(/\r$/u, "");
+			if (line.length > 0) logger.debug(`${exitLabel} stderr`, { line });
+		}
+	} catch {
+		// The worker may have exited while the parent is already tearing down,
+		// or the temp file may have been removed by process-exit cleanup.
+	} finally {
+		cleanupStderrCapture(capture);
+	}
 }
 
 /**

package/src/tools/bash.ts

@@ -46,6 +46,33 @@ export const BASH_DEFAULT_PREVIEW_LINES = 10;
 const BASH_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS = 60_000;
 
+/**
+ * Shape a shell command line for an ACP-conformant `terminal/create` request.
+ *
+ * ACP's `command` field is documented as the executable and `args` as its
+ * argv tail (see https://agentclientprotocol.com/protocol/v1/terminals), so a
+ * spec-conformant client `spawn(command, args)`s them directly — no implicit
+ * shell. A raw `bash` tool line ("git status && echo x | head") therefore has
+ * to be wrapped in an explicit shell invocation, otherwise the client tries
+ * to spawn the whole line as argv[0] and fails with `ENOENT` for anything
+ * containing a space, pipe, `&&`, redirect, or `$(...)`.
+ *
+ * The wrap reuses the same shell binary + args the local `bash-executor` would
+ * pick via `settings.getShellConfig()` — Git Bash / `bash.exe` on Windows,
+ * `$SHELL` (bash/zsh) with the `sh` fallback on POSIX — so the ACP path
+ * preserves `bash` tool semantics (`$VAR`, `$(...)`, `source`, POSIX quoting,
+ * `-l`) instead of dropping to `cmd.exe` on Windows. The agent host's shell
+ * path is used as a proxy for the client's, matching the near-universal
+ * ACP deployment shape of an editor spawning omp as a co-hosted subprocess.
+ */
+export function wrapShellLineForClientTerminal(
+	line: string,
+	shellConfig: { shell: string; args: string[]; prefix?: string | undefined },
+): { command: string; args: string[] } {
+	const finalLine = shellConfig.prefix ? `${shellConfig.prefix} ${line}` : line;
+	return { command: shellConfig.shell, args: [...shellConfig.args, finalLine] };
+}
+
 /**
  * Bash patterns flagged as safety critical for approval policy.
  *
@@ -842,8 +869,10 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		// Skip when pty=true (PTY needs the local terminal UI).
 		if (clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty) {
 			const bridgeWallTimeStart = performance.now();
+			const shellSpawn = wrapShellLineForClientTerminal(command, this.session.settings.getShellConfig());
 			const handle = await clientBridge.createTerminal({
-				command,
+				command: shellSpawn.command,
+				args: shellSpawn.args,
 				cwd: commandCwd,
 				env: resolvedEnv
 					? Object.entries(resolvedEnv).map(([name, value]) => ({ name, value: value as string }))

package/src/tools/grep.ts

@@ -1371,6 +1371,17 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 					}, 0);
 					let lastEmittedLine: number | undefined;
 					const gutterPad = " ".repeat(lineNumberWidth + 1);
+					// Track match/context lines whose displayed text was
+					// column-truncated by the native (see `crates/pi-natives/src/grep.rs`
+					// `truncate_line`, marker `...` at max_columns). Excluded from
+					// seenLines so a follow-up edit anchored at that line still
+					// requires a full-width re-read — the model saw only the
+					// prefix. The native currently propagates `truncated` only on
+					// the match line; context lines fall back to a length check
+					// against `DEFAULT_MAX_COLUMN` as a conservative heuristic.
+					const clippedLines = new Set<number>();
+					const isNativeTruncated = (line: string): boolean =>
+						line.length >= DEFAULT_MAX_COLUMN && line.endsWith("...");
 					for (const match of fileMatches) {
 						const pushLine = (lineNumber: number, line: string, isMatch: boolean) => {
 							if (lastEmittedLine !== undefined && lineNumber > lastEmittedLine + 1) {
@@ -1384,22 +1395,31 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 						if (match.contextBefore) {
 							for (const ctx of match.contextBefore) {
 								pushLine(ctx.lineNumber, ctx.line, false);
+								if (isNativeTruncated(ctx.line)) clippedLines.add(ctx.lineNumber);
 							}
 						}
 						pushLine(match.lineNumber, match.line, true);
 						if (match.truncated) {
 							linesTruncated = true;
+							clippedLines.add(match.lineNumber);
 						}
 						if (match.contextAfter) {
 							for (const ctx of match.contextAfter) {
 								pushLine(ctx.lineNumber, ctx.line, false);
+								if (isNativeTruncated(ctx.line)) clippedLines.add(ctx.lineNumber);
 							}
 						}
 						fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
 					}
 					if (hashContext?.tag) {
 						const absoluteFilePath = path.resolve(this.session.cwd, relativePath);
-						recordSeenLinesFromBody(this.session, absoluteFilePath, hashContext.tag, modelOut.join("\n"));
+						recordSeenLinesFromBody(
+							this.session,
+							absoluteFilePath,
+							hashContext.tag,
+							modelOut.join("\n"),
+							clippedLines,
+						);
 					}
 					return { model: modelOut, display: displayOut };
 				};

package/src/tools/read.ts

@@ -1559,6 +1559,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		const displayLineByNumber = new Map<number, string>();
 		const fullLines = rawSelector ? undefined : await readBracketContextFullLines(absolutePath, fileSize);
 		let columnTruncated = 0;
+		const clippedLines = new Set<number>();
 		let displayContent: { text: string; startLine: number; lineNumbers?: Array<number | null> } | undefined;
 
 		for (const range of ranges) {
@@ -1606,6 +1607,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						if (!cloned) cloned = collectedLines.slice();
 						cloned[i] = text;
 						columnTruncated = maxColumns;
+						clippedLines.add(range.startLine + i);
 					}
 				}
 				if (cloned) displayLines = cloned;
@@ -1633,7 +1635,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 						if (visibleText !== undefined) return visibleText;
 						if (maxColumns <= 0) return sourceText;
 						const truncated = truncateLine(sourceText, maxColumns);
-						if (truncated.wasTruncated) columnTruncated = maxColumns;
+						if (truncated.wasTruncated) {
+							columnTruncated = maxColumns;
+							clippedLines.add(lineNumber);
+						}
 						return truncated.text;
 					},
 				},
@@ -1651,7 +1656,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		if (shouldAddHashLines && outputText) {
 			const tag = await recordFileSnapshot(this.session, absolutePath);
 			if (tag) {
-				recordSeenLinesFromBody(this.session, absolutePath, tag, outputText);
+				recordSeenLinesFromBody(this.session, absolutePath, tag, outputText, clippedLines);
 				outputText = `${formatReadHashlineHeader(formatPathRelativeToCwd(absolutePath, this.session.cwd), tag)}\n${outputText}`;
 			}
 		}
@@ -2490,6 +2495,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					// ellipsis-truncated text made every long-line file uneditable on
 					// the next edit attempt.
 					let displayLines: string[] = collectedLines;
+					const clippedLines = new Set<number>();
 					if (!rawSelector && maxColumns > 0) {
 						let cloned: string[] | undefined;
 						for (let i = 0; i < collectedLines.length; i++) {
@@ -2498,6 +2504,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 								if (!cloned) cloned = collectedLines.slice();
 								cloned[i] = text;
 								columnTruncated = maxColumns;
+								clippedLines.add(startLineDisplay + i);
 							}
 						}
 						if (cloned) displayLines = cloned;
@@ -2580,7 +2587,10 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 									if (visibleText !== undefined) return visibleText;
 									if (maxColumns <= 0) return sourceText;
 									const truncated = truncateLine(sourceText, maxColumns);
-									if (truncated.wasTruncated) columnTruncated = maxColumns;
+									if (truncated.wasTruncated) {
+										columnTruncated = maxColumns;
+										clippedLines.add(lineNumber);
+									}
 									return truncated.text;
 								},
 							},
@@ -2654,7 +2664,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 					}
 
 					if (hashContext?.tag) {
-						recordSeenLinesFromBody(this.session, absolutePath, hashContext.tag, outputText);
+						recordSeenLinesFromBody(this.session, absolutePath, hashContext.tag, outputText, clippedLines);
 					}
 
 					if (capturedDisplayContent) {

package/src/tools/renderers.ts

@@ -74,6 +74,19 @@ export type ToolRenderer = {
 	 * `options.spinnerFrame`.
 	 */
 	animatedPartialResult?: boolean | ((args: unknown) => boolean);
+	/**
+	 * Whether replacing a streamed pending placeholder with the first result
+	 * requires a full viewport repaint. Use for merged renderers whose pending
+	 * streamed args may have committed placeholder rows that the result render
+	 * re-anchors instead of preserving.
+	 */
+	forceFirstResultViewportRepaint?: boolean;
+	/**
+	 * Whether settling a provisional partial result into the final render requires
+	 * a full viewport repaint. Use when the result renderer changes chrome or
+	 * frame topology at `options.isPartial: true -> false`.
+	 */
+	forceResultViewportRepaintOnSettle?: boolean;
 };
 
 export const toolRenderers: Record<string, ToolRenderer> = {

package/src/tools/ssh.ts

@@ -402,4 +402,12 @@ export const sshToolRenderer = {
 	// land below and strand a duplicate pending header above the final frame
 	// ([#3177](https://github.com/can1357/oh-my-pi/issues/3177)).
 	provisionalPartialResult: true,
+	// Streamed args can initially render the SSH placeholder (`⏳ SSH: […]` /
+	// `$ …`), then the first partial result inserts the `Output` section and
+	// re-anchors the frame. Force a full repaint at that seam so placeholder rows
+	// do not survive in viewport/native scrollback.
+	forceFirstResultViewportRepaint: true,
+	// The provisional pending-result frame settles into the final `⇄ SSH: [host]`
+	// frame, so clear/replay the viewport at that topology flip too.
+	forceResultViewportRepaintOnSettle: true,
 };

package/src/utils/clipboard.ts

@@ -1,8 +1,49 @@
-import { execSync } from "node:child_process";
 import type { ClipboardImage } from "@oh-my-pi/pi-natives";
 import * as native from "@oh-my-pi/pi-natives";
 import { logger } from "@oh-my-pi/pi-utils";
 
+/**
+ * Run a subprocess and capture its stdout without blocking the event loop.
+ *
+ * `readTextFromClipboard`, `readMacFileUrlsFromClipboard`, and the Termux copy
+ * path all shell out to CLI clipboard tools. The synchronous `execSync` API
+ * parks the render loop until the child exits or the timeout fires, so a hung
+ * clipboard daemon freezes the TUI for the full 2000ms budget (#4235). This
+ * helper mirrors the previous semantics — read stdout as UTF-8, throw on
+ * non-zero exit or timeout, forward optional stdin — but yields to the event
+ * loop while the child runs.
+ *
+ * @throws Error when the child fails to spawn, is killed by the timeout, or
+ *   exits with a non-zero status. Callers rely on this to fall through to the
+ *   outer catch and return an empty string / empty list.
+ */
+async function spawnCapture(cmd: string[], options: { input?: string; timeoutMs?: number } = {}): Promise<string> {
+	const timeoutMs = options.timeoutMs ?? 2000;
+	const proc = Bun.spawn(cmd, {
+		stdout: "pipe",
+		stderr: "ignore",
+		stdin: options.input !== undefined ? Buffer.from(options.input) : "ignore",
+	});
+	let timedOut = false;
+	const timer = setTimeout(() => {
+		timedOut = true;
+		proc.kill();
+	}, timeoutMs);
+	try {
+		const stdout = await new Response(proc.stdout).text();
+		await proc.exited;
+		if (timedOut) {
+			throw new Error(`${cmd[0]} timed out after ${timeoutMs}ms`);
+		}
+		if (proc.exitCode !== 0) {
+			throw new Error(`${cmd[0]} exited with code ${proc.exitCode}`);
+		}
+		return stdout;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 function hasDisplay(): boolean {
 	return process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
 }
@@ -53,11 +94,7 @@ const MAC_FILE_URL_SCRIPT = [
 export async function readMacFileUrlsFromClipboard(): Promise<string[]> {
 	if (process.platform !== "darwin") return [];
 	try {
-		const stdout = execSync("osascript -", {
-			input: MAC_FILE_URL_SCRIPT,
-			encoding: "utf8",
-			timeout: 2000,
-		}).toString();
+		const stdout = await spawnCapture(["osascript", "-"], { input: MAC_FILE_URL_SCRIPT });
 		return stdout
 			.split(/\r?\n/)
 			.map(line => line.trim())
@@ -110,7 +147,7 @@ export async function copyToClipboard(text: string): Promise<void> {
 	try {
 		if (process.env.TERMUX_VERSION) {
 			try {
-				execSync("termux-clipboard-set", { input: text, timeout: 5000 });
+				await spawnCapture(["termux-clipboard-set"], { input: text, timeoutMs: 5000 });
 				return;
 			} catch {
 				// Fall through to native
@@ -286,13 +323,13 @@ export async function readTextFromClipboard(): Promise<string> {
 	try {
 		const p = process.platform;
 		if (p === "darwin") {
-			return execSync("pbpaste", { encoding: "utf8", timeout: 2000 }).toString();
+			return await spawnCapture(["pbpaste"]);
 		}
 		if (p === "win32") {
 			return (await readTextViaPowerShell()) ?? "";
 		}
 		if (process.env.TERMUX_VERSION) {
-			return execSync("termux-clipboard-get", { encoding: "utf8", timeout: 2000 }).toString();
+			return await spawnCapture(["termux-clipboard-get"]);
 		}
 		if (isWsl()) {
 			const text = await readTextViaPowerShell();
@@ -303,14 +340,14 @@ export async function readTextFromClipboard(): Promise<string> {
 		const hasX11Display = Boolean(process.env.DISPLAY);
 		if (hasWaylandDisplay) {
 			try {
-				return execSync("wl-paste --type text/plain --no-newline", { encoding: "utf8", timeout: 2000 }).toString();
+				return await spawnCapture(["wl-paste", "--type", "text/plain", "--no-newline"]);
 			} catch {
 				if (hasX11Display) {
-					return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+					return await spawnCapture(["xclip", "-selection", "clipboard", "-o"]);
 				}
 			}
 		} else if (hasX11Display) {
-			return execSync("xclip -selection clipboard -o", { encoding: "utf8", timeout: 2000 }).toString();
+			return await spawnCapture(["xclip", "-selection", "clipboard", "-o"]);
 		}
 	} catch (error) {
 		logger.warn("clipboard: failed to read clipboard text", { error: String(error) });

package/src/utils/fetch-timeout.ts

@@ -0,0 +1,10 @@
+/** Create an abort signal that fires after a timeout and preserves caller cancellation. */
+export function withTimeoutSignal(timeoutMs: number, signal?: AbortSignal): AbortSignal {
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	return signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+}
+
+/** Detect a timeout raised by an abortable fetch. */
+export function isTimeoutError(error: unknown): boolean {
+	return error instanceof Error && error.name === "TimeoutError";
+}

package/src/web/search/index.ts

@@ -159,6 +159,13 @@ async function executeSearch(
 		antigravityEndpointMode = undefined;
 	}
 
+	let geminiModel: string | undefined;
+	try {
+		geminiModel = settings.get("providers.webSearchGeminiModel");
+	} catch {
+		geminiModel = undefined;
+	}
+
 	const failures: Array<{ provider: SearchProvider; error: unknown }> = [];
 	let lastProvider = providers[0];
 	for (const provider of providers) {
@@ -176,6 +183,7 @@ async function executeSearch(
 				authStorage,
 				sessionId,
 				antigravityEndpointMode,
+				geminiModel,
 			});
 
 			if (!hasRenderableSearchContent(response)) {

package/src/web/search/providers/base.ts

@@ -52,6 +52,7 @@ export interface SearchParams {
 	 */
 	sessionId?: string;
 	antigravityEndpointMode?: "auto" | "production" | "sandbox";
+	geminiModel?: string;
 }
 
 /** Base class for web search providers. */