@oh-my-pi/pi-coding-agent 3.30.0 → 3.31.0

package/src/core/tools/web-scrapers/w3c.ts

@@ -0,0 +1,163 @@
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput, htmlToBasicMarkdown, loadPage } from "./types";
+
+type JsonRecord = Record<string, unknown>;
+
+function asRecord(value: unknown): JsonRecord | null {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value as JsonRecord;
+}
+
+function getString(record: JsonRecord | null, key: string): string | undefined {
+	if (!record) return undefined;
+	const value = record[key];
+	return typeof value === "string" ? value : undefined;
+}
+
+function getRecord(record: JsonRecord | null, key: string): JsonRecord | null {
+	if (!record) return null;
+	return asRecord(record[key]);
+}
+
+function getArray(record: JsonRecord | null, key: string): unknown[] | undefined {
+	if (!record) return undefined;
+	const value = record[key];
+	return Array.isArray(value) ? value : undefined;
+}
+
+function extractShortname(pathname: string): string | null {
+	const trimmed = pathname.replace(/\/+$/g, "");
+	const segments = trimmed.split("/").filter(Boolean);
+
+	if (segments.length < 2 || segments[0] !== "TR") return null;
+
+	if (segments.length === 2) {
+		const shortname = segments[1];
+		if (/^\d{4}$/.test(shortname)) return null;
+		return decodeURIComponent(shortname);
+	}
+
+	if (segments.length >= 3 && /^\d{4}$/.test(segments[1])) {
+		const version = segments[2];
+		const match = version.match(/^[A-Za-z]+-(.+)-\d{8}$/);
+		if (match?.[1]) return decodeURIComponent(match[1]);
+	}
+
+	return null;
+}
+
+function normalizeStatus(status?: string): { code?: string; label?: string } {
+	if (!status) return {};
+	const lower = status.toLowerCase();
+
+	if (lower.includes("working draft")) return { code: "WD", label: status };
+	if (lower.includes("candidate recommendation")) return { code: "CR", label: status };
+	if (lower.includes("proposed recommendation")) return { code: "PR", label: status };
+	if (lower.includes("recommendation")) return { code: "REC", label: status };
+
+	return { label: status };
+}
+
+function extractEditors(editorsPayload: JsonRecord | null): string[] {
+	const links = getRecord(editorsPayload, "_links");
+	const editors = getArray(links, "editors") ?? [];
+	const names: string[] = [];
+
+	for (const entry of editors) {
+		const record = asRecord(entry);
+		const title = getString(record, "title");
+		if (title) names.push(title);
+	}
+
+	return names;
+}
+
+export const handleW3c: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	try {
+		const parsed = new URL(url);
+		if (parsed.hostname !== "www.w3.org" && parsed.hostname !== "w3.org") return null;
+
+		const shortname = extractShortname(parsed.pathname);
+		if (!shortname) return null;
+
+		const fetchedAt = new Date().toISOString();
+
+		const specUrl = `https://api.w3.org/specifications/${encodeURIComponent(shortname)}`;
+		const latestUrl = `https://api.w3.org/specifications/${encodeURIComponent(shortname)}/versions/latest`;
+
+		const [specResult, latestResult] = await Promise.all([
+			loadPage(specUrl, { timeout, signal, headers: { Accept: "application/json" } }),
+			loadPage(latestUrl, { timeout, signal, headers: { Accept: "application/json" } }),
+		]);
+
+		if (!specResult.ok || !latestResult.ok) return null;
+
+		const specPayload = asRecord(JSON.parse(specResult.content));
+		const latestPayload = asRecord(JSON.parse(latestResult.content));
+		if (!specPayload || !latestPayload) return null;
+
+		const title = getString(specPayload, "title");
+		const shortnameValue = getString(specPayload, "shortname") ?? shortname;
+		const description = getString(specPayload, "description") ?? getString(specPayload, "abstract");
+		const abstract = description ? htmlToBasicMarkdown(description) : undefined;
+
+		const latestVersionUrl =
+			getString(latestPayload, "uri") ??
+			getString(latestPayload, "shortlink") ??
+			getString(specPayload, "shortlink");
+
+		const latestStatus = getString(latestPayload, "status");
+		const normalizedStatus = normalizeStatus(latestStatus);
+
+		const specLinks = getRecord(specPayload, "_links");
+		const historyUrl = getString(getRecord(specLinks, "version-history"), "href");
+
+		const latestLinks = getRecord(latestPayload, "_links");
+		const editorsUrl = getString(getRecord(latestLinks, "editors"), "href");
+
+		let editors: string[] = [];
+		if (editorsUrl) {
+			const editorsResult = await loadPage(editorsUrl, { timeout: Math.min(timeout, 10), signal });
+			if (editorsResult.ok) {
+				try {
+					const editorsPayload = asRecord(JSON.parse(editorsResult.content));
+					editors = editorsPayload ? extractEditors(editorsPayload) : [];
+				} catch {}
+			}
+		}
+
+		let md = `# ${title ?? shortnameValue}\n\n`;
+		if (abstract) md += `## Abstract\n\n${abstract}\n\n`;
+
+		md += "## Metadata\n\n";
+		md += `**Shortname:** ${shortnameValue}\n`;
+		if (normalizedStatus.code) {
+			md += `**Status:** ${normalizedStatus.code}`;
+			if (normalizedStatus.label) md += ` (${normalizedStatus.label})`;
+			md += "\n";
+		} else if (normalizedStatus.label) {
+			md += `**Status:** ${normalizedStatus.label}\n`;
+		}
+		if (editors.length) md += `**Editors:** ${editors.join(", ")}\n`;
+		if (latestVersionUrl) md += `**Latest Version:** ${latestVersionUrl}\n`;
+		if (historyUrl) md += `**History:** ${historyUrl}\n`;
+
+		const output = finalizeOutput(md);
+		return {
+			url,
+			finalUrl: latestVersionUrl ?? url,
+			contentType: "text/markdown",
+			method: "w3c-api",
+			content: output.content,
+			fetchedAt,
+			truncated: output.truncated,
+			notes: ["Fetched via W3C API"],
+		};
+	} catch {}
+
+	return null;
+};

package/src/core/tools/{web-fetch-handlers → web-scrapers}/wikidata.ts

@@ -90,7 +90,11 @@ type WikidataValue =
 /**
  * Handle Wikidata URLs via EntityData API
  */
-export const handleWikidata: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleWikidata: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		if (!parsed.hostname.includes("wikidata.org")) return null;
@@ -104,7 +108,7 @@ export const handleWikidata: SpecialHandler = async (url: string, timeout: numbe
 
 		// Fetch entity data from API
 		const apiUrl = `https://www.wikidata.org/wiki/Special:EntityData/${qid}.json`;
-		const result = await loadPage(apiUrl, { timeout });
+		const result = await loadPage(apiUrl, { timeout, signal });
 
 		if (!result.ok) return null;
 
@@ -149,7 +153,7 @@ export const handleWikidata: SpecialHandler = async (url: string, timeout: numbe
 			}
 
 			// Fetch labels for referenced entities (limit to 50)
-			const entityLabels = await resolveEntityLabels(Array.from(entityIdsToResolve).slice(0, 50), timeout);
+			const entityLabels = await resolveEntityLabels(Array.from(entityIdsToResolve).slice(0, 50), timeout, signal);
 
 			// Group claims by property
 			const processedProperties: string[] = [];
@@ -256,7 +260,11 @@ function getLocalizedAliases(
 /**
  * Resolve entity IDs to their labels via wbgetentities API
  */
-async function resolveEntityLabels(entityIds: string[], timeout: number): Promise<Record<string, string>> {
+async function resolveEntityLabels(
+	entityIds: string[],
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<Record<string, string>> {
 	if (entityIds.length === 0) return {};
 
 	const labels: Record<string, string> = {};
@@ -268,7 +276,7 @@ async function resolveEntityLabels(entityIds: string[], timeout: number): Promis
 		const apiUrl = `https://www.wikidata.org/w/api.php?action=wbgetentities&ids=${batch.join("|")}&props=labels&languages=en&format=json`;
 
 		try {
-			const result = await loadPage(apiUrl, { timeout: Math.min(timeout, 10) });
+			const result = await loadPage(apiUrl, { timeout: Math.min(timeout, 10), signal });
 			if (result.ok) {
 				const data = JSON.parse(result.content) as {
 					entities: Record<string, { labels?: Record<string, { value: string }> }>;

package/src/core/tools/{web-fetch-handlers → web-scrapers}/wikipedia.ts

@@ -5,7 +5,11 @@ import { finalizeOutput, loadPage } from "./types";
 /**
  * Handle Wikipedia URLs via Wikipedia API
  */
-export const handleWikipedia: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleWikipedia: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
 	try {
 		const parsed = new URL(url);
 		// Match *.wikipedia.org
@@ -21,7 +25,7 @@ export const handleWikipedia: SpecialHandler = async (url: string, timeout: numb
 
 		// Use Wikipedia API to get plain text extract
 		const apiUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(title)}`;
-		const summaryResult = await loadPage(apiUrl, { timeout });
+		const summaryResult = await loadPage(apiUrl, { timeout, signal });
 
 		let md = "";
 
@@ -38,7 +42,7 @@ export const handleWikipedia: SpecialHandler = async (url: string, timeout: numb
 
 		// Get full article content via mobile-html or parse API
 		const contentUrl = `https://${lang}.wikipedia.org/api/rest_v1/page/mobile-html/${encodeURIComponent(title)}`;
-		const contentResult = await loadPage(contentUrl, { timeout });
+		const contentResult = await loadPage(contentUrl, { timeout, signal });
 
 		if (contentResult.ok) {
 			const doc = parseHtml(contentResult.content);

package/src/core/tools/{web-fetch-handlers → web-scrapers}/youtube.ts

@@ -1,6 +1,8 @@
 import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
+import type { FileSink } from "bun";
+import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import type { RenderResult, SpecialHandler } from "./types";
 import { finalizeOutput } from "./types";
@@ -8,20 +10,44 @@ import { finalizeOutput } from "./types";
 /**
  * Execute a command and return stdout
  */
-function exec(
+async function exec(
 	cmd: string,
 	args: string[],
-	options?: { timeout?: number; input?: string | Buffer },
-): { stdout: string; stderr: string; ok: boolean } {
-	const result = Bun.spawnSync([cmd, ...args], {
-		stdin: options?.input ? (options.input as any) : "ignore",
+	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
+): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
+	const proc = Bun.spawn([cmd, ...args], {
+		stdin: options?.input ? "pipe" : "ignore",
 		stdout: "pipe",
 		stderr: "pipe",
+		timeout: options?.timeout,
+		signal: options?.signal,
 	});
+
+	if (options?.input && proc.stdin) {
+		const stdin = proc.stdin as FileSink;
+		const payload = typeof options.input === "string" ? new TextEncoder().encode(options.input) : options.input;
+		stdin.write(payload);
+		const flushed = stdin.flush();
+		if (flushed instanceof Promise) {
+			await flushed;
+		}
+		const ended = stdin.end();
+		if (ended instanceof Promise) {
+			await ended;
+		}
+	}
+
+	const [stdout, stderr] = await Promise.all([
+		(proc.stdout as ReadableStream<Uint8Array>).text(),
+		(proc.stderr as ReadableStream<Uint8Array>).text(),
+	]);
+	const exitCode = await proc.exited;
+
 	return {
-		stdout: result.stdout?.toString() ?? "",
-		stderr: result.stderr?.toString() ?? "",
-		ok: result.exitCode === 0,
+		stdout,
+		stderr,
+		ok: exitCode === 0,
+		exitCode,
 	};
 }
 
@@ -124,12 +150,18 @@ function formatDuration(seconds: number): string {
 /**
  * Handle YouTube URLs - fetch metadata and transcript
  */
-export const handleYouTube: SpecialHandler = async (url: string, timeout: number): Promise<RenderResult | null> => {
+export const handleYouTube: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	signal?.throwIfAborted();
 	const yt = parseYouTubeUrl(url);
 	if (!yt) return null;
 
 	// Ensure yt-dlp is available (auto-download if missing)
 	const ytdlp = await ensureTool("yt-dlp", true);
+	signal?.throwIfAborted();
 	if (!ytdlp) {
 		return {
 			url,
@@ -148,9 +180,16 @@ export const handleYouTube: SpecialHandler = async (url: string, timeout: number
 	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
 
 	// Fetch video metadata
-	const metaResult = exec(ytdlp, ["--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl], {
-		timeout: timeout * 1000,
-	});
+	signal?.throwIfAborted();
+	const metaResult = await exec(
+		ytdlp,
+		["--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		{
+			timeout: timeout * 1000,
+			signal,
+		},
+	);
+	signal?.throwIfAborted();
 
 	let title = "YouTube Video";
 	let channel = "";
@@ -190,21 +229,29 @@ export const handleYouTube: SpecialHandler = async (url: string, timeout: number
 	let transcriptSource = "";
 
 	// First, list available subtitles
-	const listResult = exec(ytdlp, ["--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl], {
-		timeout: timeout * 1000,
-	});
+	signal?.throwIfAborted();
+	const listResult = await exec(
+		ytdlp,
+		["--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		{
+			timeout: timeout * 1000,
+			signal,
+		},
+	);
+	signal?.throwIfAborted();
 
 	const hasManualSubs = listResult.stdout.includes("[info] Available subtitles");
 	const hasAutoSubs = listResult.stdout.includes("[info] Available automatic captions");
 
 	// Create temp directory for subtitle download
 	const tmpDir = tmpdir();
-	const tmpBase = path.join(tmpDir, `yt-${yt.videoId}-${Date.now()}`);
+	const tmpBase = path.join(tmpDir, `yt-${yt.videoId}-${nanoid()}`);
 
 	try {
 		// Try manual subtitles first (English preferred)
 		if (hasManualSubs) {
-			const subResult = exec(
+			signal?.throwIfAborted();
+			const subResult = await exec(
 				ytdlp,
 				[
 					"--write-sub",
@@ -219,13 +266,15 @@ export const handleYouTube: SpecialHandler = async (url: string, timeout: number
 					tmpBase,
 					videoUrl,
 				],
-				{ timeout: timeout * 1000 },
+				{ timeout: timeout * 1000, signal },
 			);
 
 			if (subResult.ok) {
 				// Find the downloaded subtitle file using glob
+				signal?.throwIfAborted();
 				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
 				if (subFiles.length > 0) {
+					signal?.throwIfAborted();
 					const vttContent = await Bun.file(subFiles[0]).text();
 					transcript = cleanVttToText(vttContent);
 					transcriptSource = "manual";
@@ -236,7 +285,8 @@ export const handleYouTube: SpecialHandler = async (url: string, timeout: number
 
 		// Fall back to auto-generated captions
 		if (!transcript && hasAutoSubs) {
-			const autoResult = exec(
+			signal?.throwIfAborted();
+			const autoResult = await exec(
 				ytdlp,
 				[
 					"--write-auto-sub",
@@ -251,12 +301,14 @@ export const handleYouTube: SpecialHandler = async (url: string, timeout: number
 					tmpBase,
 					videoUrl,
 				],
-				{ timeout: timeout * 1000 },
+				{ timeout: timeout * 1000, signal },
 			);
 
 			if (autoResult.ok) {
+				signal?.throwIfAborted();
 				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
 				if (subFiles.length > 0) {
+					signal?.throwIfAborted();
 					const vttContent = await Bun.file(subFiles[0]).text();
 					transcript = cleanVttToText(vttContent);
 					transcriptSource = "auto-generated";

package/src/core/tools/write.ts

@@ -6,6 +6,7 @@ import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/inte
 import writeDescription from "../../prompts/tools/write.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
 import type { ToolSession } from "../sdk";
+import { untilAborted } from "../utils";
 import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import { formatDiagnostics, replaceTabs, shortenPath } from "./render-utils";
@@ -34,27 +35,29 @@ export function createWriteTool(session: ToolSession): AgentTool<typeof writeSch
 			{ path, content }: { path: string; content: string },
 			signal?: AbortSignal,
 		) => {
-			const absolutePath = resolveToCwd(path, session.cwd);
-
-			const diagnostics = await writethrough(absolutePath, content, signal);
-
-			let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
-			if (!diagnostics) {
+			return untilAborted(signal, async () => {
+				const absolutePath = resolveToCwd(path, session.cwd);
+
+				const diagnostics = await writethrough(absolutePath, content, signal);
+
+				let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+				if (!diagnostics) {
+					return {
+						content: [{ type: "text", text: resultText }],
+						details: {},
+					};
+				}
+
+				const messages = diagnostics?.messages;
+				if (messages && messages.length > 0) {
+					resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+					resultText += messages.map((d) => `  ${d}`).join("\n");
+				}
 				return {
 					content: [{ type: "text", text: resultText }],
-					details: {},
+					details: { diagnostics },
 				};
-			}
-
-			const messages = diagnostics?.messages;
-			if (messages && messages.length > 0) {
-				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
-				resultText += messages.map((d) => `  ${d}`).join("\n");
-			}
-			return {
-				content: [{ type: "text", text: resultText }],
-				details: { diagnostics },
-			};
+			});
 		},
 	};
 }

package/src/core/voice.ts

@@ -2,6 +2,7 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { completeSimple, type Model } from "@mariozechner/pi-ai";
+import { nanoid } from "nanoid";
 import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
 import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
@@ -99,7 +100,7 @@ function buildRecordingCommand(filePath: string, sampleRate: number, channels: n
 export async function startVoiceRecording(_settings: VoiceSettings): Promise<VoiceRecordingHandle> {
 	const sampleRate = DEFAULT_SAMPLE_RATE;
 	const channels = DEFAULT_CHANNELS;
-	const filePath = join(tmpdir(), `omp-voice-${Date.now()}.wav`);
+	const filePath = join(tmpdir(), `omp-voice-${nanoid()}.wav`);
 	const command = buildRecordingCommand(filePath, sampleRate, channels);
 	if (!command) {
 		throw new Error("No audio recorder found (install sox, arecord, or ffmpeg).");
@@ -233,7 +234,7 @@ function getPlayerCommand(filePath: string, format: VoiceSynthesisResult["format
 }
 
 export async function playAudio(audio: Uint8Array, format: VoiceSynthesisResult["format"]): Promise<void> {
-	const filePath = join(tmpdir(), `omp-voice-tts-${Date.now()}.${format}`);
+	const filePath = join(tmpdir(), `omp-tts-${nanoid()}.${format}`);
 	await Bun.write(filePath, audio);
 
 	const command = getPlayerCommand(filePath, format);

package/src/lib/worktree/collapse.ts

@@ -1,3 +1,4 @@
+import { nanoid } from "nanoid";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
 import { git, gitWithStdin } from "./git";
 import { find, remove, type Worktree } from "./operations";
@@ -89,7 +90,7 @@ async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
 		throw new WorktreeError("Failed to resolve HEAD", WorktreeErrorCode.COLLAPSE_FAILED);
 	}
 	const originalHead = headResult.stdout.trim();
-	const tempBranch = `wt-collapse-${Date.now()}`;
+	const tempBranch = `wt-collapse-${nanoid()}`;
 
 	await requireGitSuccess(await git(["checkout", "-b", tempBranch], src.path), "Failed to create temp branch");
 

package/src/lib/worktree/git.ts

@@ -17,22 +17,6 @@ type WritableLike = {
 
 const textEncoder = new TextEncoder();
 
-async function readStream(stream: ReadableStream<Uint8Array> | undefined): Promise<string> {
-	if (!stream) return "";
-	const reader = stream.getReader();
-	const chunks: Uint8Array[] = [];
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return Buffer.concat(chunks).toString();
-}
-
 async function writeStdin(handle: unknown, stdin: string): Promise<void> {
 	if (!handle || typeof handle === "number") return;
 	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
@@ -77,8 +61,8 @@ export async function gitWithStdin(args: string[], stdin: string, cwd?: string):
 	await writeStdin(proc.stdin, stdin);
 
 	const [stdout, stderr, exitCode] = await Promise.all([
-		readStream(proc.stdout as ReadableStream<Uint8Array>),
-		readStream(proc.stderr as ReadableStream<Uint8Array>),
+		(proc.stdout as ReadableStream<Uint8Array>).text(),
+		(proc.stderr as ReadableStream<Uint8Array>).text(),
 		proc.exited,
 	]);
 

package/src/main.ts

@@ -7,6 +7,8 @@
 
 import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
 import chalk from "chalk";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { listModels } from "./cli/list-models";
@@ -187,6 +189,59 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	return undefined;
 }
 
+async function maybeAutoChdir(parsed: Args): Promise<void> {
+	if (parsed.allowHome || parsed.cwd) {
+		return;
+	}
+
+	const home = homedir();
+	if (!home) {
+		return;
+	}
+
+	const normalizePath = (value: string) => {
+		const resolved = resolve(value);
+		return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+	};
+
+	const cwd = normalizePath(process.cwd());
+	const normalizedHome = normalizePath(home);
+	if (cwd !== normalizedHome) {
+		return;
+	}
+
+	const isDirectory = async (path: string) => {
+		try {
+			const stat = await Bun.file(path).stat();
+			return stat.isDirectory();
+		} catch {
+			return false;
+		}
+	};
+
+	const candidates = [join(home, "tmp"), "/tmp", "/var/tmp"];
+	for (const candidate of candidates) {
+		try {
+			if (!(await isDirectory(candidate))) {
+				continue;
+			}
+			process.chdir(candidate);
+			return;
+		} catch {
+			// Try next candidate.
+		}
+	}
+
+	try {
+		const fallback = tmpdir();
+		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
+			process.chdir(fallback);
+		}
+	} catch {
+		// Ignore fallback errors.
+	}
+}
+
 /** Discover SYSTEM.md file if no CLI system prompt was provided */
 function discoverSystemPromptFile(): string | undefined {
 	// Check project-local first (.omp/SYSTEM.md, .pi/SYSTEM.md legacy)
@@ -318,6 +373,10 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	const parsed = parseArgs(args);
+	time("parseArgs");
+	await maybeAutoChdir(parsed);
+
 	// Run migrations (pass cwd for project-local migrations)
 	const { migratedAuthProviders: migratedProviders, deprecationWarnings } = await runMigrations(process.cwd());
 
@@ -326,9 +385,6 @@ export async function main(args: string[]) {
 	const modelRegistry = await discoverModels(authStorage);
 	time("discoverModels");
 
-	const parsed = parseArgs(args);
-	time("parseArgs");
-
 	if (parsed.version) {
 		console.log(VERSION);
 		return;