@oh-my-pi/pi-coding-agent 17.2.4 → 17.2.6

package/src/tools/grep.ts

@@ -22,6 +22,7 @@ import type { InternalResource, ResolveContext } from "../internal-urls/types";
 import type { Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
 import { DEFAULT_MAX_COLUMN, type TruncationResult, truncateHead, truncateLine } from "../session/streaming-output";
+import { isScoutSpawnable } from "../task/spawn-policy";
 import {
 	Ellipsis,
 	fileHyperlink,
@@ -909,7 +910,17 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 	readonly label = "Grep";
 	readonly loadMode = "discoverable";
 	readonly summary = "Grep file contents using ripgrep (fast regex search)";
-	readonly description: string;
+	get description(): string {
+		const displayMode = resolveFileDisplayMode(this.session);
+		return prompt.render(grepDescription, {
+			IS_HL_MODE: displayMode.hashLines,
+			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
+			scoutAvailable: isScoutSpawnable(
+				this.session.settings.get("task.disabledAgents") as string[] | undefined,
+				this.session.getSessionSpawns?.() ?? "*",
+			),
+		});
+	}
 	readonly parameters = searchSchema;
 	readonly strict = true;
 
@@ -924,11 +935,6 @@ export class GrepTool implements AgentTool<typeof searchSchema, GrepToolDetails>
 		this.#contextOverride = context !== undefined ? Math.max(0, Math.floor(context)) : undefined;
 		const total = options?.totalMatchLimit;
 		this.#totalMatchLimit = total !== undefined ? Math.max(1, Math.floor(total)) : undefined;
-		const displayMode = resolveFileDisplayMode(session);
-		this.description = prompt.render(grepDescription, {
-			IS_HL_MODE: displayMode.hashLines,
-			IS_LINE_NUMBER_MODE: !displayMode.hashLines && displayMode.lineNumbers,
-		});
 	}
 
 	async execute(

package/src/tools/hub/launch.ts

@@ -10,7 +10,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import { daemonClientForProject } from "../../launch/client";
+import { type DaemonBrokerClient, DaemonBrokerRejectedError, daemonClientForProject } from "../../launch/client";
 import type { DaemonOperation, DaemonRpcResult, DaemonSnapshot, DaemonSpec, DaemonState } from "../../launch/protocol";
 import { renderTerminalOutputIsolated } from "../../launch/terminal-output-worker-client";
 import type { Theme, ThemeColor } from "../../modes/theme/theme";
@@ -35,6 +35,81 @@ import {
 import { styleTerminalRow } from "../terminal-output";
 import { ToolError } from "../tool-errors";
 
+interface CompletionRegistration {
+	inFlight: number;
+	retained: boolean;
+	active: boolean;
+	cleanup: (preservePending?: boolean) => void;
+}
+
+interface CompletionLease {
+	retain: () => void;
+	reject: (preservePending?: boolean) => void;
+	hasConcurrentRequest: () => boolean;
+}
+
+const completionRegistrations = new WeakMap<
+	ToolSession,
+	Map<DaemonBrokerClient, Map<string, CompletionRegistration>>
+>();
+
+function registerCompletionSink(
+	session: ToolSession,
+	client: DaemonBrokerClient,
+	owner: string,
+): CompletionLease | undefined {
+	if (!session.queueLaunchCompletion) return undefined;
+	let clients = completionRegistrations.get(session);
+	if (!clients) {
+		clients = new Map();
+		completionRegistrations.set(session, clients);
+	}
+	let owners = clients.get(client);
+	if (!owners) {
+		owners = new Map();
+		clients.set(client, owners);
+	}
+	let registration = owners.get(owner);
+	if (!registration) {
+		const unregister = client.onCompletion(owner, notification => {
+			if (session.isDisposed?.()) throw new Error("Session disposed before launch completion delivery");
+			const delivery = session.queueLaunchCompletion?.(notification);
+			if (!delivery) throw new Error("Session cannot accept launch completion delivery");
+			return delivery;
+		});
+		let unregisterDispose: (() => void) | void;
+		let unregisterSessionChange: (() => void) | void;
+		const cleanup = (preservePending = false): void => {
+			if (!registration?.active) return;
+			registration.active = false;
+			unregister({ preservePending });
+			unregisterDispose?.();
+			unregisterSessionChange?.();
+			owners.delete(owner);
+			if (owners.size === 0) clients.delete(client);
+			if (clients.size === 0) completionRegistrations.delete(session);
+		};
+		registration = { inFlight: 0, retained: false, active: true, cleanup };
+		owners.set(owner, registration);
+		unregisterDispose = session.registerDisposeCallback?.(() => cleanup(true));
+		unregisterSessionChange = session.registerSessionChangeCallback?.(() => cleanup(true));
+	}
+	registration.inFlight++;
+	let settled = false;
+	const settle = (retain: boolean, preservePending = false): void => {
+		if (settled || !registration.active) return;
+		settled = true;
+		registration.inFlight--;
+		if (retain) registration.retained = true;
+		if (!registration.retained && registration.inFlight === 0) registration.cleanup(preservePending);
+	};
+	return {
+		retain: () => settle(true),
+		hasConcurrentRequest: () => registration.active && registration.inFlight > 1,
+		reject: preservePending => settle(false, preservePending),
+	};
+}
+
 /** Broker-facing launch parameters; the hub adapts its `ps` op to `list` before calling in. */
 export interface LaunchParams {
 	op: "start" | "list" | "logs" | "wait" | "send" | "stop" | "restart" | "describe";
@@ -321,11 +396,52 @@ export async function executeLaunch(
 	signal?: AbortSignal,
 ): Promise<AgentToolResult<LaunchToolDetails>> {
 	const client = await daemonClientForProject(session.cwd);
-	const result = await client.request(operationFor(params, session), signal);
-	return {
-		content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
-		details: await toolDetails(result, params),
-	};
+	const operation = operationFor(params, session);
+	const owner = operation.op === "start" ? operation.owner : undefined;
+	const resumedOwner = params.op !== "start" ? (session.getSessionId?.() ?? undefined) : undefined;
+	const completionLease = owner
+		? registerCompletionSink(session, client, owner)
+		: resumedOwner
+			? registerCompletionSink(session, client, resumedOwner)
+			: undefined;
+	try {
+		const result = await client.request(operation, signal);
+		const sessionOwner = session.getSessionId?.();
+		let resumedDaemonFound = false;
+		const daemons =
+			result.op === "list" ? result.daemons : "daemon" in result && result.daemon ? [result.daemon] : [];
+		for (const daemon of daemons) {
+			if (!daemon.owner || daemon.owner !== sessionOwner || TERMINAL_STATES[daemon.state]) continue;
+			resumedDaemonFound = true;
+			if (daemon.owner !== resumedOwner) registerCompletionSink(session, client, daemon.owner)?.retain();
+		}
+		if (params.op === "list" && resumedOwner && !resumedDaemonFound) completionLease?.reject(true);
+		else completionLease?.retain();
+		return {
+			content: [{ type: "text", text: replaceTabs(toolContent(result, params)) }],
+			details: await toolDetails(result, params),
+		};
+	} catch (error) {
+		if (error instanceof DaemonBrokerRejectedError && owner) {
+			if (completionLease?.hasConcurrentRequest()) {
+				completionLease.reject();
+			} else {
+				try {
+					const listed = await client.request({ op: "list" }, signal);
+					const ownerStillRunning =
+						listed.op === "list" &&
+						listed.daemons.some(daemon => daemon.owner === owner && !TERMINAL_STATES[daemon.state]);
+					if (ownerStillRunning) completionLease?.retain();
+					else completionLease?.reject(true);
+				} catch {
+					completionLease?.retain();
+				}
+			}
+		} else {
+			completionLease?.retain();
+		}
+		throw error;
+	}
 }
 
 // =============================================================================

package/src/tools/index.ts

@@ -16,6 +16,7 @@ import type { GoalModeState, GoalRuntime } from "../goals";
 import { GoalTool } from "../goals/tools/goal-tool";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
+import type { DaemonCompletionNotification } from "../launch/protocol";
 import { LspTool } from "../lsp";
 import type { MCPManager } from "../mcp";
 import type { MnemopiSessionState } from "../mnemopi/state";
@@ -155,6 +156,8 @@ export interface ToolSession {
 	additionalDirectories?: string[];
 	/** Whether UI is available */
 	hasUI: boolean;
+	/** Whether this session has begun disposal. */
+	isDisposed?: () => boolean;
 	/**
 	 * Suppress the spawn specialization/coordination advisory appended to `task`
 	 * results. Set by internal/programmatic callers (e.g. the commit agent's
@@ -380,6 +383,12 @@ export interface ToolSession {
 
 	/** Queue a hidden message to be injected at the next agent turn. */
 	queueDeferredMessage?(message: CustomMessage): void;
+	/** Queue a broker supervised-process completion for the owning session. */
+	queueLaunchCompletion?(notification: DaemonCompletionNotification): Promise<void>;
+	/** Register cleanup that runs when this session is disposed; returns a handle that removes the cleanup. */
+	registerDisposeCallback?(callback: () => void): (() => void) | void;
+	/** Register cleanup that runs when this ToolSession adopts a different session ID. */
+	registerSessionChangeCallback?(callback: () => void): (() => void) | void;
 	/** Queue late LSP diagnostics (arrived after an edit/write returned) to be shown
 	 *  in the transcript and delivered to the model at the next yield, like background
 	 *  job results. */

package/src/tools/inspect-image.ts

@@ -12,9 +12,15 @@ import { prompt } from "@oh-my-pi/pi-utils";
 import { type } from "arktype";
 import { extractTextContent } from "../commit/utils";
 
-import { expandRoleAlias, getModelMatchPreferences, resolveModelFromString } from "../config/model-resolver";
+import {
+	expandRoleAlias,
+	extractExplicitThinkingSelector,
+	getModelMatchPreferences,
+	resolveModelFromString,
+} from "../config/model-resolver";
 import inspectImageDescription from "../prompts/tools/inspect-image.md" with { type: "text" };
 import inspectImageSystemPromptTemplate from "../prompts/tools/inspect-image-system.md" with { type: "text" };
+import { concreteThinkingLevel, resolveThinkingLevelForModel, toReasoningEffort } from "../thinking";
 import {
 	ImageInputTooLargeError,
 	type LoadedImageInput,
@@ -163,11 +169,17 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 		};
 
 		const activeModelPattern = this.session.getActiveModelString?.() ?? this.session.getModelString?.();
-		const model =
-			resolvePattern("@vision") ??
-			resolvePattern("@default") ??
-			resolvePattern(activeModelPattern) ??
-			availableModels[0];
+		let model: Model<Api> | undefined;
+		let selectedPattern: string | undefined;
+		for (const pattern of ["@vision", "@default", activeModelPattern]) {
+			const resolved = resolvePattern(pattern);
+			if (resolved) {
+				model = resolved;
+				selectedPattern = pattern;
+				break;
+			}
+		}
+		model ??= availableModels[0];
 		if (!model) {
 			throw new ToolError("Unable to resolve a model for inspect_image.");
 		}
@@ -233,6 +245,19 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 			return `inspect_image request timed out after ${seconds}s. Increase inspect_image.timeoutMs (currently ${timeoutMs}ms; 0 disables) or check the vision model provider.`;
 		};
 
+		// Honor the thinking effort configured on the resolved model role
+		// (e.g. `modelRoles.vision: <model>:high`). Without it the oneshot sent a
+		// suppressed/zero thinking budget, which thinking-only models (Gemini 3.x)
+		// reject with HTTP 400 ("Budget 0 is invalid. This model only works in
+		// thinking mode.").
+		const configuredThinking = concreteThinkingLevel(
+			extractExplicitThinkingSelector(selectedPattern, this.session.settings, {
+				isLiteralModelId: (provider, id) =>
+					availableModels.some(candidate => candidate.provider === provider && candidate.id === id),
+			}),
+		);
+		const reasoning = toReasoningEffort(resolveThinkingLevelForModel(model, configuredThinking));
+
 		let response: AssistantMessage;
 		try {
 			response = await instrumentedCompleteSimple(
@@ -253,6 +278,7 @@ export class InspectImageTool implements AgentTool<typeof inspectImageSchema, In
 				{
 					apiKey: modelRegistry.resolver(model, this.session.getSessionId?.() ?? undefined),
 					signal: effectiveSignal,
+					reasoning,
 				},
 				{ telemetry, oneshotKind: "inspect_image", completeImpl: this.completeImageRequest },
 			);

package/src/tools/render-utils.ts

@@ -61,6 +61,8 @@ export const PREVIEW_LIMITS = {
 	OUTPUT_COLLAPSED: 3,
 	/** Output preview lines in expanded view */
 	OUTPUT_EXPANDED: 10,
+	/** Computer script lines shown in collapsed view */
+	COMPUTER_CODE_COLLAPSED: 10,
 	/** Max hunks shown when collapsed (edit tool) */
 	DIFF_COLLAPSED_HUNKS: 8,
 	/** Max diff lines shown when collapsed (edit tool) */

package/src/tools/{browser/run-cancellation.ts → run-scope.ts}

@@ -1,10 +1,10 @@
-import { untilAborted } from "@oh-my-pi/pi-utils";
-import { ToolError, throwIfAborted } from "../tool-errors";
+import { untilAborted } from "@oh-my-pi/pi-utils/abortable";
+import { ToolError, throwIfAborted } from "./tool-errors";
 
 /**
  * Marks a run-scoped promise as observed without changing its behavior for awaited callers.
  *
- * Browser run teardown aborts can reject promises created for evaluated code after user code
+ * Run teardown aborts can reject promises created for evaluated code after user code
  * has stopped observing them (for example fire-and-forget `wait()`/facade calls). In 16.3.0
  * those zero-consumer rejections reached the process-level `unhandledRejection` handler and
  * killed every subagent sharing the process (issues #4499/#4672). Attaching a no-op rejection
@@ -33,8 +33,8 @@ export interface WaitPredicateOptions {
 /**
  * Effective `wait(predicate)` deadline for a given cell budget. Always strictly below
  * the cell budget so the named `wait(predicate) timed out` error wins the race against
- * the opaque whole-cell "Browser code execution timed out". `0`/`Infinity` ("disable")
- * map to the largest bounded deadline; negative/NaN garbage falls back to the default.
+ * the opaque whole-cell execution timeout. `0`/`Infinity` ("disable") map to the largest
+ * bounded deadline; negative/NaN garbage falls back to the default.
  */
 export function resolvePredicateTimeout(cellTimeoutMs: number, explicit?: number): number {
 	const budgetBound = Math.max(1, cellTimeoutMs - CELL_BUDGET_SLACK_MS);
@@ -44,15 +44,15 @@ export function resolvePredicateTimeout(cellTimeoutMs: number, explicit?: number
 }
 
 /**
- * Run-scoped `wait()` helper for evaluated browser code, honoring the owning run's
- * cancellation signal.
+ * Run-scoped `wait()` helper for evaluated code (browser and computer workers), honoring
+ * the owning run's cancellation signal.
  *
  * - `wait(ms)` sleeps for `ms` milliseconds.
  * - `wait(fn, { timeout?, interval? })` polls `fn` (sync or async) until it returns a
  *   truthy value and resolves with that value; throws a named `ToolError` on timeout
  *   instead of stalling into the whole-cell deadline. Predicate errors propagate.
  */
-export function waitForBrowserRun(
+export function waitForRun(
 	msOrPredicate: number | (() => unknown),
 	signal: AbortSignal,
 	opts?: WaitPredicateOptions,
@@ -86,8 +86,8 @@ export function waitForBrowserRun(
 	return markHandled(promise);
 }
 
-/** Binds a long-lived browser facade to one evaluated run's abort signal. */
-export function bindBrowserRunFacade<T extends object>(target: T, signal: AbortSignal): T {
+/** Binds a long-lived scope facade (page/tab/desktop objects) to one evaluated run's abort signal. */
+export function bindRunFacade<T extends object>(target: T, signal: AbortSignal): T {
 	const cache = new Map<PropertyKey, unknown>();
 	return new Proxy(target, {
 		get(current, prop) {
@@ -121,7 +121,7 @@ export function bindBrowserRunFacade<T extends object>(target: T, signal: AbortS
 				// brand-check internal slots that a Proxy cannot forward, and reading a
 				// signal needs no abort gating anyway.
 				if (value instanceof AbortSignal) return value;
-				const wrapped = bindBrowserRunFacade(value, signal);
+				const wrapped = bindRunFacade(value, signal);
 				cache.set(prop, wrapped);
 				return wrapped;
 			}

package/src/tools/tool-timeouts.ts

@@ -11,6 +11,7 @@ export const TOOL_TIMEOUTS = {
 	bash: { default: 300, min: 1, max: 3600 },
 	eval: { default: 30, min: 1, max: 3600 },
 	browser: { default: 30, min: 1, max: 300 },
+	computer: { default: 120, min: 1, max: 300 },
 	ssh: { default: 60, min: 1, max: 3600 },
 	fetch: { default: 20, min: 1, max: 45 },
 	lsp: { default: 20, min: 5, max: 300 },

package/src/tools/xdev.ts

@@ -36,6 +36,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { XD_URL_PREFIX } from "../internal-urls/xd-protocol";
 import type { Theme } from "../modes/theme/theme";
 import { truncateHeadBytes } from "../session/streaming-output";
+import { resolveToolTier, type ToolTier } from "./approval";
 import { renderDefaultToolExecution } from "./default-renderer";
 import type { Tool } from "./index";
 import { replaceTabs } from "./render-utils";
@@ -88,6 +89,13 @@ export interface XdevDispatch {
 	mode: "help" | "execute";
 	/** Validated inner args, kept for renderer delegation on result rebuilds. */
 	args?: Record<string, unknown>;
+	/**
+	 * Approval tier of the wrapped tool for {@link args} (`read` = no workspace
+	 * mutation). Absent for `help` dispatches and calls whose tier could not be
+	 * resolved. Consumed by the prewalk coordinator to skip read-only device
+	 * calls when deciding the model hand-off (issue #7312).
+	 */
+	tier?: ToolTier;
 	/** Details object returned by the wrapped tool, when executed. */
 	inner?: unknown;
 }
@@ -415,7 +423,18 @@ export async function dispatchXdevTool(
 		}
 
 		const validated = parseDeviceArgs(canonical as AiTool, content, toolCallId, () => renderDocs(canonical));
-		xdev = { ...xdev, args: validated };
+		// Record the wrapped tool's approval tier so the prewalk coordinator can
+		// tell a read-only device call (e.g. `lsp` navigation) from a real
+		// workspace mutation without re-decoding the payload. Best-effort: a
+		// throwing approval leaves the tier absent (prewalk then declines to
+		// switch), unlike the write gate which fails closed to `exec`.
+		let tier: ToolTier | undefined;
+		try {
+			tier = resolveToolTier(canonical, validated);
+		} catch {
+			tier = undefined;
+		}
+		xdev = { ...xdev, args: validated, tier };
 		const innerOnUpdate: AgentToolUpdateCallback | undefined = onUpdate
 			? partial =>
 					onUpdate({
@@ -425,7 +444,15 @@ export async function dispatchXdevTool(
 					})
 			: undefined;
 		const executable = state.decorateExecution?.(canonical) ?? canonical;
-		const result = await executable.execute(toolCallId, validated as never, signal, innerOnUpdate, context);
+		const executionContext = context
+			? {
+					...context,
+					xdevTierResolved: (effectiveTier: ToolTier) => {
+						xdev = { ...xdev, tier: effectiveTier };
+					},
+				}
+			: undefined;
+		const result = await executable.execute(toolCallId, validated as never, signal, innerOnUpdate, executionContext);
 		return { result, xdev: { ...xdev, inner: result.details } };
 	} catch (error) {
 		if (

package/src/utils/clipboard.ts

@@ -1,8 +1,14 @@
-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";
+import {
+	type ClipboardImage,
+	copyToClipboard as nativeCopyToClipboard,
+	readImageFromClipboard as nativeReadImageFromClipboard,
+} from "@oh-my-pi/pi-natives/clipboard";
+import * as logger from "@oh-my-pi/pi-utils/logger";
+import { SUPPORTED_IMAGE_MIME_TYPES } from "@oh-my-pi/pi-utils/mime";
 import MAC_FILE_URL_SCRIPT from "./mac-file-urls.applescript" with { type: "text" };
 
+type SpawnCaptureOptions = { input?: string; timeoutMs?: number };
+
 /**
  * Run a subprocess and capture its stdout without blocking the event loop.
  *
@@ -10,15 +16,20 @@ import MAC_FILE_URL_SCRIPT from "./mac-file-urls.applescript" with { type: "text
  * 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.
+ * helper mirrors the previous semantics — capture stdout, 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.
+ *   exits with a non-zero status. Callers rely on this to use platform
+ *   fallbacks or report an empty clipboard.
  */
-async function spawnCapture(cmd: string[], options: { input?: string; timeoutMs?: number } = {}): Promise<string> {
+async function spawnCapture(cmd: string[], options: SpawnCaptureOptions & { encoding: "bytes" }): Promise<Uint8Array>;
+async function spawnCapture(cmd: string[], options?: SpawnCaptureOptions): Promise<string>;
+async function spawnCapture(
+	cmd: string[],
+	options: SpawnCaptureOptions & { encoding?: "bytes" } = {},
+): Promise<string | Uint8Array> {
 	const timeoutMs = options.timeoutMs ?? 2000;
 	const proc = Bun.spawn(cmd, {
 		stdout: "pipe",
@@ -31,7 +42,9 @@ async function spawnCapture(cmd: string[], options: { input?: string; timeoutMs?
 		proc.kill();
 	}, timeoutMs);
 	try {
-		const stdout = await new Response(proc.stdout).text();
+		const response = new Response(proc.stdout);
+		const stdout =
+			options.encoding === "bytes" ? new Uint8Array(await response.arrayBuffer()) : await response.text();
 		await proc.exited;
 		if (timedOut) {
 			throw new Error(`${cmd[0]} timed out after ${timeoutMs}ms`);
@@ -125,7 +138,7 @@ export async function copyToClipboard(text: string): Promise<void> {
 			}
 		}
 
-		await native.copyToClipboard(text);
+		await nativeCopyToClipboard(text);
 	} catch {
 		// Ignore — clipboard copy is best-effort
 	}
@@ -255,7 +268,7 @@ async function readTextViaPowerShell(): Promise<string | null> {
  * because terminal clipboard paths can leave image payloads invisible to the
  * native bridge.
  *
- * @returns PNG payload or null when no image is available.
+ * @returns A supported image payload or null when no image is available.
  */
 export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 	if (process.env.TERMUX_VERSION) {
@@ -272,7 +285,7 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 
 	if (process.platform === "win32") {
 		try {
-			const image = await native.readImageFromClipboard();
+			const image = await nativeReadImageFromClipboard();
 			if (image) return image;
 		} catch (err) {
 			logger.warn("clipboard: native Windows image read failed", { error: String(err) });
@@ -280,11 +293,24 @@ export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
 		return await readImageViaPowerShell();
 	}
 
+	if (process.platform === "linux" && process.env.WAYLAND_DISPLAY) {
+		try {
+			const offeredMimeTypes = new Set((await spawnCapture(["wl-paste", "--list-types"])).split(/\r?\n/));
+			for (const mimeType of SUPPORTED_IMAGE_MIME_TYPES) {
+				if (!offeredMimeTypes.has(mimeType)) continue;
+				const data = await spawnCapture(["wl-paste", "--type", mimeType], { encoding: "bytes" });
+				if (data.byteLength > 0) return { data, mimeType };
+			}
+		} catch {
+			// Fall through when wl-clipboard is absent or no advertised image payload can be read.
+		}
+	}
+
 	if (!hasDisplay()) {
 		return null;
 	}
 
-	return (await native.readImageFromClipboard()) ?? null;
+	return (await nativeReadImageFromClipboard()) ?? null;
 }
 
 /**

package/src/utils/command-args.ts

@@ -39,38 +39,36 @@ export function parseCommandArgs(argsString: string): string[] {
  * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
  */
 export function substituteArgs(content: string, args: string[]): string {
-	let result = content;
-
-	// Replace $1, $2, etc. with positional args FIRST (before wildcards)
-	// This prevents wildcard replacement values containing $<digit> patterns from being re-substituted
-	result = result.replace(/\$(\d+)/g, (_, num) => {
-		const index = parseInt(num, 10) - 1;
-		return args[index] ?? "";
-	});
-
-	result = result.replace(/\$@\[(\d+)(?::(\d*)?)?\]/g, (_, startRaw: string, lengthRaw?: string) => {
-		const start = Number.parseInt(startRaw, 10);
-		if (!Number.isFinite(start) || start < 1) return "";
-		const startIndex = start - 1;
-		if (startIndex >= args.length) return "";
+	const allArgs = args.join(" ");
 
-		if (lengthRaw === undefined || lengthRaw === "") {
-			return args.slice(startIndex).join(" ");
-		}
+	return content.replace(
+		/\$@\[(\d+)(?::(\d*)?)?\]|\$ARGUMENTS|\$@|\$(\d+)/g,
+		(match, startRaw?: string, lengthRaw?: string, positionalNum?: string) => {
+			if (positionalNum !== undefined) {
+				const index = Number.parseInt(positionalNum, 10) - 1;
+				return args[index] ?? "";
+			}
 
-		const length = Number.parseInt(lengthRaw, 10);
-		if (!Number.isFinite(length) || length <= 0) return "";
-		return args.slice(startIndex, startIndex + length).join(" ");
-	});
+			if (startRaw !== undefined) {
+				const start = Number.parseInt(startRaw, 10);
+				if (!Number.isFinite(start) || start < 1) return "";
+				const startIndex = start - 1;
+				if (startIndex >= args.length) return "";
 
-	// Pre-compute all args joined (optimization)
-	const allArgs = args.join(" ");
+				if (lengthRaw === undefined || lengthRaw === "") {
+					return args.slice(startIndex).join(" ");
+				}
 
-	// Replace $ARGUMENTS with all args joined (new syntax, aligns with Claude, Codex, OpenCode)
-	result = result.replaceAll("$ARGUMENTS", allArgs);
+				const length = Number.parseInt(lengthRaw, 10);
+				if (!Number.isFinite(length) || length <= 0) return "";
+				return args.slice(startIndex, startIndex + length).join(" ");
+			}
 
-	// Replace $@ with all args joined (existing syntax)
-	result = result.replaceAll("$@", allArgs);
+			if (match === "$ARGUMENTS" || match === "$@") {
+				return allArgs;
+			}
 
-	return result;
+			return match;
+		},
+	);
 }

package/src/utils/tool-choice.ts

@@ -12,19 +12,6 @@ export function buildNamedToolChoice(toolName: string, model?: Model<Api>): Tool
 		return { type: "tool", name: toolName };
 	}
 
-	if (toolName === "computer" && model.supportsComputerUse === true) {
-		if (
-			model.api === "openai-codex-responses" ||
-			model.api === "openai-responses" ||
-			model.api === "azure-openai-responses"
-		) {
-			return { type: "computer" };
-		}
-		return undefined;
-	}
-	// Models without native computer support receive the tool as a regular
-	// function tool, so the generic named-function forcing below applies.
-
 	if (
 		model.api === "openai-codex-responses" ||
 		model.api === "openai-responses" ||

package/src/web/kagi.ts

@@ -156,6 +156,7 @@ export interface KagiSearchOptions {
 	recency?: "day" | "week" | "month" | "year";
 	sessionId?: string;
 	signal?: AbortSignal;
+	timeoutMs?: number;
 	fetch?: FetchImpl;
 }
 
@@ -253,7 +254,7 @@ export async function searchWithKagi(
 					Accept: "application/json",
 				},
 				body,
-				signal: withHardTimeout(options.signal),
+				signal: withHardTimeout(options.signal, options.timeoutMs),
 			});
 
 			if (!res.ok) {