@oh-my-pi/pi-coding-agent 15.1.6 → 15.1.8

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

@@ -120,14 +120,34 @@ export async function acquireTab(
 	}
 
 	const initPayload = await buildInitPayload(browser, opts);
-	const worker = await spawnTabWorker();
+	let worker = await spawnTabWorker();
 	let info: ReadyInfo;
 	try {
 		info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
 	} catch (error) {
+		// `BuildMessage`-class failures arrive asynchronously via the worker's `error` event,
+		// after `spawnTabWorker`'s synchronous try/catch has already returned. Fall back to
+		// the inline worker here so module-resolution failures don't poison every tab open.
 		await worker.terminate().catch(() => undefined);
-		if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
-		throw error;
+		if (worker.mode === "inline") {
+			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			throw error;
+		}
+		logger.warn("Tab worker init failed; retrying with inline tab worker (no sync-loop guard)", {
+			error: error instanceof Error ? error.message : String(error),
+		});
+		worker = await spawnInlineWorker();
+		try {
+			info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
+		} catch (inlineError) {
+			await worker.terminate().catch(() => undefined);
+			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			const finalError = new ToolError(
+				`Failed to start browser tab worker (inline fallback also failed): ${inlineError instanceof Error ? inlineError.message : String(inlineError)}`,
+			);
+			(finalError as { cause?: unknown }).cause = error;
+			throw finalError;
+		}
 	}
 
 	holdBrowser(browser);

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

@@ -459,7 +459,8 @@ export class WorkerCore {
 				if (payload.dialogs) this.#applyDialogPolicy(payload.dialogs);
 				if (payload.url) {
 					await this.#page.goto(payload.url, {
-						waitUntil: payload.waitUntil ?? "networkidle2",
+						// Default to "load" because dev servers with HMR/WS never reach networkidle.
+						waitUntil: payload.waitUntil ?? "load",
 						timeout: payload.timeoutMs,
 					});
 				}
@@ -667,7 +668,8 @@ export class WorkerCore {
 			goto: async (url, opts) => {
 				this.#clearElementCache();
 				await untilAborted(signal, () =>
-					page.goto(url, { waitUntil: opts?.waitUntil ?? "networkidle2", timeout: timeoutMs }),
+					// 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 }),

package/src/tools/browser.ts

@@ -45,7 +45,7 @@ const browserSchema = z.object({
 		.describe("auto-handle dialogs")
 		.optional(),
 	code: z.string().describe("js body to run in tab").optional(),
-	timeout: z.number().default(30).describe("timeout in seconds").optional(),
+	timeout: z.number().default(30).describe("timeout in seconds (default 30, max 300)").optional(),
 	all: z.boolean().describe("close every tab").optional(),
 	kill: z.boolean().describe("also kill spawned-app browsers").optional(),
 });

package/src/tools/debug.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import type {
 	AgentTool,
 	AgentToolContext,
@@ -6,7 +7,7 @@ import type {
 	RenderResultOptions,
 } from "@oh-my-pi/pi-agent-core";
 import { type Component, Text } from "@oh-my-pi/pi-tui";
-import { prompt } from "@oh-my-pi/pi-utils";
+import { isEnoent, prompt } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import {
 	type DapBreakpointRecord,
@@ -37,7 +38,7 @@ import { renderStatusLine } from "../tui";
 import { CachedOutputBlock } from "../tui/output-block";
 import type { ToolSession } from ".";
 import type { OutputMeta } from "./output-meta";
-import { resolveToCwd } from "./path-utils";
+import { formatPathRelativeToCwd, resolveToCwd } from "./path-utils";
 import {
 	formatExpandHint,
 	formatStatusIcon,
@@ -469,6 +470,21 @@ function getConfiguredAdapters(cwd: string): string {
 	const adapters = getAvailableAdapters(cwd).map(adapter => adapter.name);
 	return adapters.length > 0 ? adapters.join(", ") : "none";
 }
+async function validateLaunchProgram(program: string, cwd: string): Promise<void> {
+	let isDirectory: boolean;
+	try {
+		isDirectory = (await fs.stat(program)).isDirectory();
+	} catch (error) {
+		if (isEnoent(error)) return;
+		throw error;
+	}
+	if (!isDirectory) return;
+
+	const displayPath = formatPathRelativeToCwd(program, cwd, { trailingSlash: true });
+	throw new ToolError(
+		`launch program resolves to a directory: ${displayPath}. Pass an executable file path, or for Python use adapter "debugpy" with program set to the .py file.`,
+	);
+}
 
 interface DebugRenderArgs extends Partial<DebugParams> {}
 
@@ -628,6 +644,7 @@ export class DebugTool implements AgentTool<typeof debugSchema, DebugToolDetails
 				}
 				const commandCwd = params.cwd ? resolveToCwd(params.cwd, this.session.cwd) : this.session.cwd;
 				const program = resolveToCwd(params.program, commandCwd);
+				await validateLaunchProgram(program, commandCwd);
 				const adapter = selectLaunchAdapter(program, commandCwd, params.adapter);
 				if (!adapter) {
 					throw new ToolError(

package/src/tools/find.ts

@@ -38,14 +38,41 @@ const findSchema = z
 	.object({
 		paths: z.array(z.string().describe("glob including search path")).min(1).describe("globs including search paths"),
 		hidden: z.boolean().default(true).describe("include hidden files").optional(),
+		gitignore: z.boolean().default(true).describe("respect gitignore").optional(),
 		limit: z.number().default(1000).describe("max results").optional(),
+		timeout: z.number().min(0.5).max(60).default(5).describe("timeout in seconds (0.5–60)").optional(),
 	})
 	.strict();
 
 export type FindToolInput = z.infer<typeof findSchema>;
 
 const DEFAULT_LIMIT = 1000;
-const GLOB_TIMEOUT_MS = 5000;
+const DEFAULT_GLOB_TIMEOUT_MS = 5000;
+const MIN_GLOB_TIMEOUT_MS = 500;
+const MAX_GLOB_TIMEOUT_MS = 60_000;
+
+/**
+ * Reject comma-separated path lists packed into a single array element
+ * (`["a.py,b.py"]`). The schema is array-of-string; agents that pass a
+ * single comma-joined element get silent no-matches otherwise.
+ *
+ * Commas inside brace expansion (`{a,b}`) are legitimate glob syntax and
+ * must pass through.
+ */
+function validateFindPathInputs(paths: readonly string[]): void {
+	for (const entry of paths) {
+		let braceDepth = 0;
+		for (let i = 0; i < entry.length; i++) {
+			const ch = entry.charCodeAt(i);
+			if (ch === 0x7b /* { */) braceDepth++;
+			else if (ch === 0x7d /* } */) {
+				if (braceDepth > 0) braceDepth--;
+			} else if (ch === 0x2c /* , */ && braceDepth === 0) {
+				throw new ToolError(`paths is an array — pass ["a", "b"] not ["a,b"] (got ${JSON.stringify(entry)})`);
+			}
+		}
+	}
+}
 
 export interface FindToolDetails {
 	truncation?: TruncationResult;
@@ -109,10 +136,11 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 		onUpdate?: AgentToolUpdateCallback<FindToolDetails>,
 		_context?: AgentToolContext,
 	): Promise<AgentToolResult<FindToolDetails>> {
-		const { paths, limit, hidden } = params;
+		const { paths, limit, hidden, gitignore, timeout } = params;
 
 		return untilAborted(signal, async () => {
 			const formatScopePath = (targetPath: string): string => formatPathRelativeToCwd(targetPath, this.session.cwd);
+			validateFindPathInputs(paths);
 			const rawPatterns = paths.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
@@ -165,7 +193,10 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 				throw new ToolError("Limit must be a positive number");
 			}
 			const includeHidden = hidden ?? true;
-			const timeoutSignal = AbortSignal.timeout(GLOB_TIMEOUT_MS);
+			const useGitignore = gitignore ?? true;
+			const requestedTimeoutMs = timeout != null ? Math.round(timeout * 1000) : DEFAULT_GLOB_TIMEOUT_MS;
+			const timeoutMs = Math.min(MAX_GLOB_TIMEOUT_MS, Math.max(MIN_GLOB_TIMEOUT_MS, requestedTimeoutMs));
+			const timeoutSignal = AbortSignal.timeout(timeoutMs);
 			const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 			const formatMatchPath = (matchPath: string, fileType?: natives.FileType): string => {
 				const hadTrailingSlash = matchPath.endsWith("/") || matchPath.endsWith("\\");
@@ -178,33 +209,41 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			const missingPathsNote =
 				missingPaths.length > 0 ? `Skipped missing paths: ${missingPaths.join(", ")}` : undefined;
 
-			const buildResult = (files: string[]): AgentToolResult<FindToolDetails> => {
+			const buildResult = (
+				files: string[],
+				opts?: { notice?: string; forceTruncated?: boolean },
+			): AgentToolResult<FindToolDetails> => {
+				const notice = opts?.notice;
+				const forceTruncated = opts?.forceTruncated ?? false;
 				if (files.length === 0) {
 					const details: FindToolDetails = {
 						scopePath,
 						fileCount: 0,
 						files: [],
-						truncated: false,
+						truncated: forceTruncated,
 						missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
 					};
-					const text = missingPathsNote
-						? `No files found matching pattern\n${missingPathsNote}`
-						: "No files found matching pattern";
-					return toolResult(details).text(text).done();
+					const parts = ["No files found matching pattern"];
+					if (notice) parts.push(notice);
+					if (missingPathsNote) parts.push(missingPathsNote);
+					return toolResult(details).text(parts.join("\n")).done();
 				}
 
 				const listLimit = applyListLimit(files, { limit: effectiveLimit });
 				const limited = listLimit.items;
 				const limitMeta = listLimit.meta;
 				const baseOutput = limited.join("\n");
-				const rawOutput = missingPathsNote ? `${baseOutput}\n\n${missingPathsNote}` : baseOutput;
+				const trailingNotes: string[] = [];
+				if (notice) trailingNotes.push(notice);
+				if (missingPathsNote) trailingNotes.push(missingPathsNote);
+				const rawOutput = trailingNotes.length > 0 ? `${baseOutput}\n\n${trailingNotes.join("\n")}` : baseOutput;
 				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 
 				const details: FindToolDetails = {
 					scopePath,
 					fileCount: limited.length,
 					files: limited,
-					truncated: Boolean(limitMeta.resultLimit || truncation.truncated),
+					truncated: Boolean(forceTruncated || limitMeta.resultLimit || truncation.truncated),
 					resultLimitReached: limitMeta.resultLimit?.reached,
 					truncation: truncation.truncated ? truncation : undefined,
 					missingPaths: missingPaths.length > 0 ? missingPaths : undefined,
@@ -278,14 +317,12 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					details,
 				});
 			};
-			const onMatch = onUpdate
-				? (err: Error | null, match: natives.GlobMatch | null) => {
-						if (err || signal?.aborted || !match?.path) return;
-						const relativePath = formatMatchPath(match.path, match.fileType);
-						onUpdateMatches.push(relativePath);
-						emitUpdate();
-					}
-				: undefined;
+			const onMatch = (err: Error | null, match: natives.GlobMatch | null) => {
+				if (err || signal?.aborted || !match?.path) return;
+				const relativePath = formatMatchPath(match.path, match.fileType);
+				onUpdateMatches.push(relativePath);
+				emitUpdate();
+			};
 
 			const doGlob = async (useGitignore: boolean) =>
 				untilAborted(combinedSignal, () =>
@@ -304,8 +341,9 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 					),
 				);
 
+			let timedOut = false;
 			try {
-				const result = await doGlob(true);
+				const result = await doGlob(useGitignore);
 				// Sort by mtime descending (most recent first) in JS instead of native.
 				// This allows native glob to early-terminate at maxResults.
 				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
@@ -313,12 +351,30 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {
 					if (timeoutSignal.aborted && !signal?.aborted) {
-						const timeoutSeconds = Math.max(1, Math.round(GLOB_TIMEOUT_MS / 1000));
-						throw new ToolError(`find timed out after ${timeoutSeconds}s`);
+						timedOut = true;
+						matches = [];
+					} else {
+						throw new ToolAbortError();
 					}
-					throw new ToolAbortError();
+				} else {
+					throw error;
+				}
+			}
+
+			if (timedOut) {
+				// Drain the partial matches accumulated during streaming and return them
+				// instead of throwing — empty results after a multi-second wait force the
+				// caller to retry blind, which is the worst possible outcome.
+				const seen = new Set<string>();
+				const partial: string[] = [];
+				for (const entry of onUpdateMatches) {
+					if (seen.has(entry)) continue;
+					seen.add(entry);
+					partial.push(entry);
 				}
-				throw error;
+				const seconds = timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}` : (timeoutMs / 1000).toFixed(1);
+				const notice = `find timed out after ${seconds}s; returning ${partial.length} partial matches — increase timeout or narrow pattern`;
+				return buildResult(partial, { notice, forceTruncated: true });
 			}
 
 			const relativized: string[] = [];

package/src/tools/read.ts

@@ -800,10 +800,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		// context (added below if offset is explicit).
 		const requestedStart = offset ? Math.max(0, offset - 1) : 0;
 		const ignoreResultLimits = options.ignoreResultLimits ?? false;
-		const requestedEnd =
-			limit !== undefined && !ignoreResultLimits
-				? Math.min(requestedStart + limit, allLines.length)
-				: allLines.length;
+		const requestedEnd = limit !== undefined ? Math.min(requestedStart + limit, allLines.length) : allLines.length;
 		// Expand only on sides the user actually constrained: leading context
 		// when offset>1, trailing context when a finite limit was set.
 		const expanded = expandRangeWithContext(
@@ -811,7 +808,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			requestedEnd,
 			allLines.length,
 			offset !== undefined && offset > 1,
-			limit !== undefined && !ignoreResultLimits,
+			limit !== undefined,
 		);
 		const startLine = expanded.startLine;
 		const endLineExpanded = expanded.endLine;
@@ -842,7 +839,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		const endLine = endLineExpanded;
 		const selectedContent = allLines.slice(startLine, endLine).join("\n");
-		const userLimitedLines = limit !== undefined && !ignoreResultLimits ? endLine - startLine : undefined;
+		const userLimitedLines = limit !== undefined ? endLine - startLine : undefined;
 		const truncation = ignoreResultLimits ? noTruncResult(selectedContent) : truncateHead(selectedContent);
 
 		const shouldAddHashLines = displayMode.hashLines;

package/src/tools/resolve.ts

@@ -51,28 +51,43 @@ export function queueResolveHandler(
 	const forced = session.buildToolChoice?.("resolve");
 	if (!queue || !forced || typeof forced === "string") return;
 
-	queue.pushOnce(forced, {
-		label: `pending-action:${options.sourceToolName}`,
-		now: true,
-		onRejected: () => "requeue",
-		onInvoked: async (input: unknown) =>
-			runResolveInvocation(input as ResolveParams, {
-				sourceToolName: options.sourceToolName,
-				label: options.label,
-				apply: options.apply,
-				reject: options.reject,
-			}),
-	});
+	const steerReminder = (): void => {
+		session.steer?.({
+			customType: "resolve-reminder",
+			content: [
+				"<system-reminder>",
+				"This is a preview. Call the `resolve` tool to apply or discard these changes.",
+				"</system-reminder>",
+			].join("\n"),
+			details: { toolName: options.sourceToolName },
+		});
+	};
 
-	session.steer?.({
-		customType: "resolve-reminder",
-		content: [
-			"<system-reminder>",
-			"This is a preview. Call the `resolve` tool to apply or discard these changes.",
-			"</system-reminder>",
-		].join("\n"),
-		details: { toolName: options.sourceToolName },
-	});
+	const pushDirective = (): void => {
+		queue.pushOnce(forced, {
+			label: `pending-action:${options.sourceToolName}`,
+			now: true,
+			onRejected: () => "requeue",
+			onInvoked: async (input: unknown) =>
+				runResolveInvocation(input as ResolveParams, {
+					sourceToolName: options.sourceToolName,
+					label: options.label,
+					apply: options.apply,
+					reject: options.reject,
+					onApplyError: () => {
+						// Apply threw (e.g. ast_edit overlapping replacements). Re-push the
+						// same directive so the preview remains pending and the model can
+						// `discard` or fix-and-retry on the next turn instead of being
+						// stranded with no pending action to address.
+						pushDirective();
+						steerReminder();
+					},
+				}),
+		});
+	};
+
+	pushDirective();
+	steerReminder();
 }
 
 /**
@@ -89,6 +104,11 @@ export async function runResolveInvocation(
 		label: string;
 		apply(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown>>;
 		reject?(reason: string, extra?: Record<string, unknown>): Promise<AgentToolResult<unknown> | undefined>;
+		/** Invoked synchronously when `apply()` throws, before the error is rethrown.
+		 *  The queued caller uses this to re-push the resolve directive so the
+		 *  pending preview survives a failed apply (e.g. overlapping ast_edit
+		 *  replacements) and the model can `discard` or fix-and-retry. */
+		onApplyError?(error: unknown): void;
 	},
 ): Promise<AgentToolResult<ResolveToolDetails>> {
 	const baseDetails: ResolveToolDetails = {
@@ -99,7 +119,19 @@ export async function runResolveInvocation(
 		...(params.extra != null ? { extra: params.extra } : {}),
 	};
 	if (params.action === "apply") {
-		const result = await options.apply(params.reason, params.extra);
+		let result: AgentToolResult<unknown>;
+		try {
+			result = await options.apply(params.reason, params.extra);
+		} catch (error) {
+			try {
+				options.onApplyError?.(error);
+			} catch {
+				// Requeue hook must not mask the original apply failure.
+			}
+			if (error instanceof ToolError) throw error;
+			const message = error instanceof Error ? error.message : String(error);
+			throw new ToolError(`Apply failed: ${message}`);
+		}
 		return {
 			...result,
 			details: {

package/src/tools/search.ts

@@ -63,6 +63,29 @@ export const SINGLE_FILE_MATCHES = 200;
  * pagination headroom so the caller can see total file count. */
 const INTERNAL_TOTAL_CAP = 2000;
 
+/**
+ * Detect a `,` that is not inside a `{…}` brace expansion. Used to catch
+ * `paths: ["a,b"]` mistakes where the caller flattened multiple entries
+ * into a single string instead of passing a JSON array of strings.
+ */
+function containsTopLevelComma(entry: string): boolean {
+	let depth = 0;
+	for (let i = 0; i < entry.length; i++) {
+		const ch = entry[i];
+		if (ch === "\\" && i + 1 < entry.length) {
+			i++;
+			continue;
+		}
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			if (depth > 0) depth--;
+		} else if (ch === "," && depth === 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
 export interface SearchToolDetails {
 	truncation?: TruncationResult;
 	fileLimitReached?: number;
@@ -124,6 +147,11 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 			if (normalizedSkip < 0 || !Number.isFinite(normalizedSkip)) {
 				throw new ToolError("Skip must be a non-negative number");
 			}
+			for (const entry of paths) {
+				if (containsTopLevelComma(entry)) {
+					throw new ToolError('paths is an array — pass ["a", "b"] not ["a,b"]');
+				}
+			}
 			const normalizedContextBefore = this.session.settings.get("search.contextBefore");
 			const normalizedContextAfter = this.session.settings.get("search.contextAfter");
 			const ignoreCase = i ?? false;
@@ -148,6 +176,9 @@ export class SearchTool implements AgentTool<typeof searchSchema, SearchToolDeta
 				missingPaths,
 				immutableSourcePaths,
 			} = scope;
+			if (missingPaths.length > 0 && missingPaths.length === paths.length) {
+				throw new ToolError(`Path not found: ${missingPaths.join(", ")}; pass each path as its own array element`);
+			}
 			const { globFilter } = scope;
 			const baseDisplayMode = resolveFileDisplayMode(this.session);
 			const immutableDisplayMode = resolveFileDisplayMode(this.session, { immutable: true });

package/src/tools/todo-write.ts

@@ -150,9 +150,15 @@ function resolveTaskOrError(
 	}
 	const hit = findTaskByContent(phases, content);
 	if (!hit) {
-		const totalTasks = phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
-		const hint = totalTasks === 0 ? " (todo list is empty — was it replaced or not yet created?)" : "";
-		errors.push(`Task "${content}" not found${hint}`);
+		if (/^task-\d+$/.test(content)) {
+			errors.push(
+				`Task "${content}" not found. Tasks are referenced by content, not by IDs — pass the task's full text from the previous result.`,
+			);
+		} else {
+			const totalTasks = phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
+			const hint = totalTasks === 0 ? " (todo list is empty — was it replaced or not yet created?)" : "";
+			errors.push(`Task "${content}" not found${hint}`);
+		}
 	}
 	return hit;
 }
@@ -209,7 +215,7 @@ function appendItems(phases: TodoPhase[], entry: TodoOpEntryValue, errors: strin
 	for (const content of entry.items) {
 		if (findTaskByContent(phases, content)) {
 			errors.push(`Task "${content}" already exists`);
-			continue;
+			return phases;
 		}
 		phase.tasks.push({ content, status: "pending" });
 	}
@@ -513,6 +519,7 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 		return {
 			content: [{ type: "text", text: formatSummary(updated, errors) }],
 			details: { phases: updated, storage },
+			isError: errors.length > 0 ? true : undefined,
 		};
 	}
 }

package/src/tools/tool-timeouts.ts

@@ -10,7 +10,7 @@ export interface ToolTimeoutConfig {
 export const TOOL_TIMEOUTS = {
 	bash: { default: 300, min: 1, max: 3600 },
 	eval: { default: 30, min: 1, max: 600 },
-	browser: { default: 30, min: 1, max: 30 },
+	browser: { default: 30, min: 1, max: 300 },
 	ssh: { default: 60, min: 1, max: 3600 },
 	fetch: { default: 20, min: 1, max: 45 },
 	lsp: { default: 20, min: 5, max: 60 },

package/src/utils/tools-manager.ts

@@ -248,31 +248,38 @@ async function downloadTool(tool: ToolName, signal?: AbortSignal): Promise<strin
 
 // Install a Python package via uv (preferred) or pip
 async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<boolean> {
-	// Try uv first (faster, better isolation)
-	const uv = $which("uv");
-	if (uv) {
-		const result = await ptree.exec(["uv", "tool", "install", pkg], {
-			signal,
-			allowNonZero: true,
-			allowAbort: true,
-			stderr: "full",
-		});
-		if (result.exitCode === 0) return true;
-	}
+	try {
+		// Try uv first (faster, better isolation)
+		const uv = $which("uv");
+		if (uv) {
+			const result = await ptree.exec([uv, "tool", "install", pkg], {
+				signal,
+				allowNonZero: true,
+				allowAbort: true,
+				stderr: "full",
+			});
+			if (result.exitCode === 0) return true;
+		}
 
-	// Fall back to pip
-	const pip = $which("pip3") || $which("pip");
-	if (pip) {
-		const result = await ptree.exec(["pip", "install", "--user", pkg], {
-			signal,
-			allowNonZero: true,
-			allowAbort: true,
-			stderr: "full",
+		// Fall back to pip
+		const pip = $which("pip3") || $which("pip");
+		if (pip) {
+			const result = await ptree.exec([pip, "install", "--user", pkg], {
+				signal,
+				allowNonZero: true,
+				allowAbort: true,
+				stderr: "full",
+			});
+			return result.exitCode === 0;
+		}
+
+		return false;
+	} catch (error) {
+		logger.warn(`Failed to install Python package ${pkg}`, {
+			error: error instanceof Error ? error.message : String(error),
 		});
-		return result.exitCode === 0;
+		return false;
 	}
-
-	return false;
 }
 
 // Termux package names for tools

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

@@ -425,6 +425,9 @@ async function callCodexSearch(
 
 	const finalAnswer = answerParts.join("\n\n").trim();
 	const streamedAnswer = streamedAnswerParts.join("").trim();
+	if (isImagePlaceholderAnswer(finalAnswer) && streamedAnswer.length === 0) {
+		throw new SearchProviderError("codex", "Codex returned image-only response", 502);
+	}
 	const answer =
 		finalAnswer.length > 0 && !isImagePlaceholderAnswer(finalAnswer)
 			? finalAnswer

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

@@ -174,6 +174,25 @@ export function findApiKey(): string | null {
 	return getEnvApiKey("perplexity") ?? null;
 }
 
+/**
+ * Decode a Perplexity JWT's `exp` claim, in ms. Returns `undefined` when the
+ * token has no `exp` (which is the common case — Perplexity sessions are
+ * server-side and effectively non-expiring from the client's POV).
+ */
+function jwtExpiryMs(token: string): number | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) return undefined;
+	const payload = parts[1];
+	if (!payload) return undefined;
+	try {
+		const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8")) as { exp?: unknown };
+		if (typeof decoded.exp !== "number" || !Number.isFinite(decoded.exp)) return undefined;
+		return decoded.exp * 1000;
+	} catch {
+		return undefined;
+	}
+}
+
 async function findOAuthToken(): Promise<string | null> {
 	const now = Date.now();
 	try {
@@ -183,7 +202,11 @@ async function findOAuthToken(): Promise<string | null> {
 			if (record.credential.type !== "oauth") continue;
 			const credential = record.credential as PerplexityOAuthCredential;
 			if (!credential.access) continue;
-			if (credential.expires <= now + OAUTH_EXPIRY_BUFFER_MS) continue;
+			// Trust the JWT's own `exp` claim if it has one; otherwise treat as
+			// non-expiring. The stored `expires` field is unreliable: older logins
+			// wrote `loginTime + 1h` even though Perplexity JWTs typically lack `exp`.
+			const jwtExpiry = jwtExpiryMs(credential.access);
+			if (jwtExpiry !== undefined && jwtExpiry <= now + OAUTH_EXPIRY_BUFFER_MS) continue;
 			return credential.access;
 		}
 	} catch {