@oh-my-pi/pi-coding-agent 17.3.2 → 17.3.4

package/src/session/turn-recovery.ts

@@ -395,7 +395,7 @@ export class TurnRecovery {
 	}
 
 	/** Handles empty terminal assistant turns and schedules bounded recovery. */
-	handleEmptyAssistantStop(message: AssistantMessage): Promise<boolean> {
+	handleEmptyAssistantStop(message: AssistantMessage): Promise<"continue" | "terminal" | undefined> {
 		return this.#handleEmptyAssistantStop(message);
 	}
 
@@ -648,24 +648,37 @@ export class TurnRecovery {
 		return retryErrors;
 	}
 
-	async #handleEmptyAssistantStop(assistantMessage: AssistantMessage): Promise<boolean> {
-		if (!isEmptyAssistantStop(assistantMessage)) {
+	#isRecoverableProviderEmptyOutput(message: AssistantMessage): boolean {
+		if (message.stopReason !== "error") return false;
+		const id = this.#classifyRetryMessage(message);
+		if (!AIError.is(id, AIError.Flag.EmptyResponse)) return false;
+		return message.content.every(
+			block => block.type === "thinking" || (block.type === "text" && !hasNonWhitespace(block.text)),
+		);
+	}
+
+	async #handleEmptyAssistantStop(assistantMessage: AssistantMessage): Promise<"continue" | "terminal" | undefined> {
+		const providerEmptyOutput = this.#isRecoverableProviderEmptyOutput(assistantMessage);
+		if (!isEmptyAssistantStop(assistantMessage) && !providerEmptyOutput) {
 			this.#emptyStopRetryCount = 0;
-			return false;
+			return undefined;
 		}
 
 		if (this.#acceptTerminalEmptyStopForPrompt && assistantMessage.stopReason === "stop") {
 			this.#acceptTerminalEmptyStopForPrompt = false;
 			this.#discardAcceptedTerminalEmptyStop(assistantMessage);
 			this.#emptyStopRetryCount = 0;
-			return false;
+			return undefined;
 		}
 
 		this.#emptyStopRetryCount++;
 		if (this.#emptyStopRetryCount > EMPTY_STOP_MAX_RETRIES) {
 			const attempts = this.#emptyStopRetryCount - 1;
-			const finalError =
-				"Assistant returned empty stop after retry cap; try switching models or `/shake images` to remove archived frames";
+			const finalError = providerEmptyOutput
+				? "Assistant returned no final output after retry cap; try switching models"
+				: "Assistant returned empty stop after retry cap; try switching models or `/shake images` to remove archived frames";
+			assistantMessage.errorMessage = finalError;
+			if (providerEmptyOutput) assistantMessage.errorId = AIError.create();
 			logger.warn(finalError, {
 				attempts,
 				model: assistantMessage.model,
@@ -680,12 +693,12 @@ export class TurnRecovery {
 			this.#clearPendingRetryErrors();
 			this.#retryAttempt = 0;
 			this.resolveRetry();
-			// A zero-content turn carries no transcript value, while its provider usage
-			// can anchor the next prompt at the full failed-request size and re-trigger
-			// compaction at the same boundary. Remove every capped empty stop; toolUse
-			// orphans still need this for Anthropic message-history validity.
+			// A turn with no actionable output carries no transcript value, while its
+			// provider usage can anchor the next prompt at the full failed-request size
+			// and re-trigger compaction at the same boundary. Remove every capped
+			// empty output; toolUse orphans still need this for Anthropic history.
 			await this.dropPersistedAssistantTurn(assistantMessage);
-			return false;
+			return "terminal";
 		}
 		this.discardAssistantTurn(assistantMessage);
 		this.#host.agent.appendMessage({
@@ -695,7 +708,7 @@ export class TurnRecovery {
 			timestamp: Date.now(),
 		});
 		this.#host.scheduleAgentContinue({ generation: this.#host.promptGeneration() });
-		return true;
+		return "continue";
 	}
 
 	#emptyStopRetryReminder(): string {
@@ -1019,52 +1032,39 @@ export class TurnRecovery {
 		if (this.#isUsagePreflightBlocked(message)) return false;
 
 		const id = this.#classifyRetryMessage(message);
-		// Context overflow is handled by compaction, not retry
+		// Context overflow is handled by compaction, not retry.
 		const contextWindow = this.#host.model()?.contextWindow ?? 0;
 		if (AIError.isContextOverflow(message, contextWindow)) return false;
 
 		// Credential rotation and classifier fallbacks are safe only before
 		// committed text, images, tool calls, or server tools. Thinking-only
-		// output remains replay-safe. The one exception is a refusal whose ONLY
-		// replay-unsafe output is tool calls the agent loop proved never ran
-		// (`#refusalReplaySafe`): nothing reached the user and no side effect
-		// happened, so discarding the turn duplicates nothing and the fallback
-		// chain gets its chance.
-		if (this.#hasReplayUnsafeOutput(message) && !this.#refusalReplaySafe(message)) return false;
+		// output remains replay-safe. A classifier refusal or malformed-function
+		// response may also be replayed when every emitted tool call is paired
+		// with positive proof that it never executed.
+		const replaySafeUnexecutedTools =
+			(this.isClassifierRefusal(message) || AIError.is(id, AIError.Flag.MalformedFunctionCall)) &&
+			this.#unexecutedToolCallsReplaySafe(message);
+		if (this.#hasReplayUnsafeOutput(message) && !replaySafeUnexecutedTools) return false;
 		if (AIError.is(id, AIError.Flag.AccountPolicy) || this.isClassifierRefusal(message)) return true;
 		return AIError.retriable(id);
 	}
 
 	/**
-	 * True when a classifier refusal is replay-safe *despite* having emitted tool
-	 * calls, because every emitted call provably never executed.
+	 * True when every emitted tool call provably never executed and no other
+	 * replay-unsafe output exists. The caller restricts this exception to
+	 * classifier refusals and malformed-function responses.
 	 *
-	 * Anthropic's request classifier can fire after the model has already streamed
-	 * a tool call, which used to strand the turn: `#hasReplayUnsafeOutput` sees the
-	 * `toolCall` block and vetoes retry one line before the refusal could reach the
-	 * fallback-chain consult, so a refusal that a different model family would very
-	 * likely have served just ended the turn.
+	 * Gemini can report `MALFORMED_FUNCTION_CALL` after streaming an earlier,
+	 * well-formed call. Anthropic classifiers can likewise refuse after a call.
+	 * The agent loop pairs each emitted-but-unrun call with a synthetic
+	 * `executed: false` result, which proves `tool.execute()` never ran.
 	 *
-	 * That veto exists to protect against duplicating work or visible output. Neither
-	 * risk is present here: the agent loop pairs each emitted-but-unrun call with a
-	 * synthetic `executed: false` result (see {@link isSyntheticToolResultMessage}),
-	 * which is a positive record that `tool.execute()` never ran. So the veto is
-	 * lifted only when ALL of the following hold, and any uncertainty (assistant
-	 * message missing from state, a call with no result, a non-synthetic result, an
-	 * `executed` that is not exactly `false`) keeps it in place:
-	 *
-	 * - the stop is a classifier refusal/sensitivity stop;
-	 * - the only replay-unsafe blocks are tool calls — an `image`, an
-	 *   `anthropicServerTool`, or committed non-whitespace text has already rendered
-	 *   or has side effects, so replaying would duplicate it;
-	 * - at least one tool call was emitted (otherwise the plain refusal path already
-	 *   handles it);
-	 * - every emitted call id has a result after the assistant message in state, and
-	 *   every such result is synthetic with `executed === false`.
+	 * Any uncertainty keeps the replay veto in place: the assistant must exist
+	 * in state, every call must have a later synthetic result, every result must
+	 * say `executed === false`, and the turn must contain no image, server tool,
+	 * or committed non-whitespace text.
 	 */
-	#refusalReplaySafe(message: AssistantMessage): boolean {
-		if (!this.isClassifierRefusal(message)) return false;
-
+	#unexecutedToolCallsReplaySafe(message: AssistantMessage): boolean {
 		const emittedToolCallIds = new Set<string>();
 		for (const block of message.content) {
 			if (block.type === "toolCall") {
@@ -1076,7 +1076,7 @@ export class TurnRecovery {
 		}
 		if (emittedToolCallIds.size === 0) return false;
 
-		// The refused assistant message is NOT the tail of state: the agent loop
+		// The errored assistant message is NOT the tail of state: the agent loop
 		// appends the synthetic results after it before the turn ends, so locate it
 		// by walking backwards exactly as `classifyResolvedInterruptedToolTurn` does.
 		const messages = this.#host.agent.state.messages;
@@ -1803,6 +1803,10 @@ export class TurnRecovery {
 
 		const errorMessage = message.errorMessage || "Unknown error";
 		const id = this.#classifyRetryMessage(message);
+		const preserveFailedTurn =
+			options?.preserveFailedTurn === true ||
+			((classifierRefusal || AIError.is(id, AIError.Flag.MalformedFunctionCall)) &&
+				this.#unexecutedToolCallsReplaySafe(message));
 		const rateLimitReason = parseRateLimitReason(errorMessage);
 		const staleOpenAIResponsesReplayError = AIError.is(id, AIError.Flag.StaleResponsesItem);
 		const accountPolicyDenial = AIError.is(id, AIError.Flag.AccountPolicy);
@@ -2013,9 +2017,10 @@ export class TurnRecovery {
 			errorId: message.errorId,
 		});
 
-		// Resolved stream-stall tools have already emitted results. Keep that failed
-		// turn intact so continuation cannot repeat their side effects.
-		if (!options?.preserveFailedTurn) {
+		// Resolved stream-stall tools and proven-unexecuted malformed/refused
+		// calls keep their assistant/result pair. Continuation then sees explicit
+		// synthetic results and cannot repeat a side effect.
+		if (!preserveFailedTurn) {
 			this.removeAssistantMessageFromActiveContext(message, "auto-retry");
 		}
 
@@ -2058,11 +2063,10 @@ export class TurnRecovery {
 		// rejects any assistant tail, so a missed removal fails the scheduled
 		// retry locally before a provider request is ever made. Re-check the
 		// tail after the backoff (covering rebuilds during the sleep too) and
-		// strip a still-failed assistant tail by position. Never in
-		// preserveFailedTurn mode — the kept turn ends in synthetic tool
-		// results that continue() accepts — and never once a newer prompt owns
-		// the session.
-		if (!options?.preserveFailedTurn && this.#host.promptGeneration() === generation) {
+		// strip a still-failed assistant tail by position. Never when preserving
+		// the failed turn — the kept turn ends in synthetic tool results that
+		// continue() accepts — and never once a newer prompt owns the session.
+		if (!preserveFailedTurn && this.#host.promptGeneration() === generation) {
 			this.#stripFailedAssistantTail();
 		}
 

package/src/tools/read-pdf.ts

@@ -0,0 +1,135 @@
+import { pathToFileURL } from "node:url";
+import { untilAborted } from "@oh-my-pi/pi-utils";
+import type { ToolSession } from "../sdk";
+import type { BrowserHandle } from "./browser/registry";
+import type { ScreenshotResult } from "./browser/tab-protocol";
+import { ToolAbortError, ToolError } from "./tool-errors";
+
+const PDF_IMAGE_MEMBER_RE = /^(.*\.pdf):(.*)$/i;
+const PDF_PAGE_MEMBER_RE = /^(?:p|page[-_]?)(\d+)(?:[-_].*)?\.png$/i;
+const PDF_RENDER_TIMEOUT_MS = 30_000;
+
+// Chromium's PDF plugin paints in an out-of-process frame after navigation has
+// completed. Wait for document dimensions, then cross compositor boundaries
+// before capturing; otherwise the screenshot can contain only the viewer shell.
+const PDF_SCREENSHOT_CODE = `
+let viewerFrame;
+await wait(async () => {
+	for (const frame of page.frames()) {
+		try {
+			const loaded = await frame.evaluate(() => {
+				const viewer = document.querySelector("pdf-viewer");
+				const toolbar = viewer?.shadowRoot?.querySelector("viewer-toolbar");
+				const pageLength = toolbar
+					?.shadowRoot?.querySelector("viewer-page-selector")
+					?.shadowRoot?.querySelector("#pagelength")
+					?.textContent;
+				if (Number(pageLength) > 0 && !toolbar?.hasAttribute("loading_")) return true;
+
+				const plugin = document.querySelector('embed[type="application/x-google-chrome-pdf"]');
+				const sizer = document.querySelector("#sizer");
+				return plugin !== null && sizer !== null && sizer.clientWidth > 0 && sizer.clientHeight > 0;
+			});
+			if (loaded) {
+				viewerFrame = frame;
+				return true;
+			}
+		} catch {}
+	}
+	return false;
+});
+await page.screenshot({ type: "png" });
+await viewerFrame.evaluate(() => {
+	const { promise, resolve } = Promise.withResolvers();
+	requestAnimationFrame(() =>
+		requestAnimationFrame(() =>
+			requestAnimationFrame(() => requestAnimationFrame(resolve)),
+		),
+	);
+	return promise;
+});
+return await tab.screenshot({ fullPage: true, silent: true });
+`;
+
+/** A legacy PDF image-member path interpreted as a page screenshot request. */
+export interface PdfImageReadTarget {
+	/** PDF path before the member delimiter. */
+	pdfPath: string;
+	/** Original member text after the delimiter. */
+	member: string;
+	/** One-indexed page inferred from names such as `p2-img0.png`; defaults to page 1. */
+	page: number;
+}
+
+/** Parse a former PDF image-member path as a Chromium page screenshot request. */
+export function splitPdfImageReadPath(readPath: string): PdfImageReadTarget | null {
+	const match = PDF_IMAGE_MEMBER_RE.exec(readPath);
+	const pdfPath = match?.[1];
+	const member = match?.[2];
+	if (!pdfPath || member === undefined) return null;
+	const pageText = PDF_PAGE_MEMBER_RE.exec(member)?.[1];
+	const parsedPage = pageText === undefined ? 1 : Number(pageText);
+	const page = Number.isSafeInteger(parsedPage) && parsedPage > 0 ? parsedPage : 1;
+	return { pdfPath, member, page };
+}
+
+/** Render one PDF page through the browser tool's shared headless Chromium. */
+export async function renderPdfPageScreenshot(
+	session: ToolSession,
+	absolutePdfPath: string,
+	page: number,
+	signal?: AbortSignal,
+): Promise<ScreenshotResult> {
+	const [{ acquireBrowser, holdBrowser, releaseBrowser }, { acquireTab, releaseTab, runInTab }] = await Promise.all([
+		import("./browser/registry"),
+		import("./browser/tab-supervisor"),
+	]);
+	const timeoutSignal = AbortSignal.timeout(PDF_RENDER_TIMEOUT_MS);
+	const renderSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+	const tabName = `read-pdf-${Bun.randomUUIDv7()}`;
+	const url = pathToFileURL(absolutePdfPath);
+	url.hash = `page=${page}&toolbar=0&navpanes=0&view=Fit`;
+
+	let browserLease = false;
+	let tabOpened = false;
+	let browser: BrowserHandle | undefined;
+	try {
+		const acquiredBrowser = await untilAborted(renderSignal, () =>
+			acquireBrowser({ kind: "headless", headless: true }, { cwd: session.cwd, signal: renderSignal }),
+		);
+		browser = acquiredBrowser;
+		holdBrowser(acquiredBrowser);
+		browserLease = true;
+		await untilAborted(renderSignal, () =>
+			acquireTab(tabName, acquiredBrowser, {
+				url: url.href,
+				waitUntil: "load",
+				timeoutMs: PDF_RENDER_TIMEOUT_MS,
+				signal: renderSignal,
+				ownerSessionId: session.getSessionId?.() ?? undefined,
+			}),
+		);
+		tabOpened = true;
+		await releaseBrowser(acquiredBrowser, { kill: false });
+		browserLease = false;
+
+		const result = await runInTab(tabName, {
+			code: PDF_SCREENSHOT_CODE,
+			timeoutMs: PDF_RENDER_TIMEOUT_MS,
+			signal: renderSignal,
+			session,
+		});
+		const screenshot = result.screenshots.at(-1);
+		if (!screenshot) throw new ToolError(`Chromium did not capture PDF page ${page}.`);
+		return screenshot;
+	} catch (error) {
+		if (signal?.aborted) throw new ToolAbortError();
+		if (timeoutSignal.aborted) {
+			throw new ToolError(`Timed out rendering PDF page ${page} in Chromium.`);
+		}
+		throw error;
+	} finally {
+		if (tabOpened) await releaseTab(tabName, { kill: false });
+		if (browserLease && browser) await releaseBrowser(browser, { kill: false });
+	}
+}

package/src/tools/read.ts

@@ -100,7 +100,7 @@ import {
 	isRemoteMountPath,
 	type SuffixMatchCache,
 } from "./read-path-resolution";
-import { readPdfImageMember, rewritePdfImagePlaceholders, splitPdfImageMemberReadPath } from "./read-pdf-images";
+import { type PdfImageReadTarget, renderPdfPageScreenshot, splitPdfImageReadPath } from "./read-pdf";
 import { isMultiRange, isRawSelector, type ParsedSelector, parseSel, selToOffsetLimit } from "./read-selector";
 import { readSqlite, resolveSqliteReadPath } from "./read-sqlite";
 import { isProseSummaryPath, renderSummary, routeReadThroughBridge, trySummarize } from "./read-summary";
@@ -398,8 +398,13 @@ type ReadParams = ReadToolInput;
  */
 export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 	readonly name = "read";
-	readonly approval = (args: unknown): ToolTier =>
-		pathTargetsSsh(String((args as { path?: unknown }).path ?? "")) ? "exec" : "read";
+	readonly approval = (args: unknown): ToolTier => {
+		let readPath = "";
+		if (args && typeof args === "object" && "path" in args) readPath = String(args.path ?? "");
+		if (pathTargetsSsh(readPath)) return "exec";
+		const target = splitPathAndSel(readPath);
+		return target.sel === undefined && splitPdfImageReadPath(readPath) ? "exec" : "read";
+	};
 	readonly label = "Read";
 	readonly loadMode = "essential";
 	description: string;
@@ -546,6 +551,40 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		return toolResult<ReadToolDetails>({ notes, displayReadTargets }).content(content).done();
 	}
 
+	async #readPdfPageScreenshot(options: {
+		readPath: string;
+		absolutePdfPath: string;
+		page: number;
+		pdfFileSize: number;
+		suffixResolution?: { from: string; to: string };
+		signal?: AbortSignal;
+	}): Promise<AgentToolResult<ReadToolDetails>> {
+		const { readPath, absolutePdfPath, page, pdfFileSize, suffixResolution, signal } = options;
+		const screenshot = await renderPdfPageScreenshot(this.session, absolutePdfPath, page, signal);
+		const screenshotFile = Bun.file(screenshot.dest);
+		const screenshotMetadata = await readImageMetadata(screenshot.dest);
+		const loaded = await this.#loadImageContent({
+			readPath,
+			absolutePath: screenshot.dest,
+			mimeType: screenshot.mimeType,
+			imageMetadata: screenshotMetadata,
+			fileSize: screenshotFile.size,
+		});
+		if (suffixResolution) {
+			const firstText = loaded.content.find((entry): entry is TextContent => entry.type === "text");
+			if (firstText) firstText.text = prependSuffixResolutionNotice(firstText.text, suffixResolution);
+		}
+		const image = loaded.content.find((entry): entry is ImageContent => entry.type === "image");
+		const details: ReadToolDetails = {
+			...loaded.details,
+			resolvedPath: absolutePdfPath,
+			contentType: image?.mimeType ?? screenshot.mimeType,
+			fileSize: pdfFileSize,
+			suffixResolution,
+		};
+		return toolResult(details).content(loaded.content).sourcePath(loaded.sourcePath).done();
+	}
+
 	/**
 	 * Build content blocks for an on-disk image file: an `inspect_image`
 	 * metadata note when inspection is active, otherwise the decoded image
@@ -892,7 +931,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 
 		// Prefer a literal filesystem match over selector interpretation so real
 		// POSIX filenames containing selector-looking suffixes win over structured
-		// archive / sqlite / pdf-image dispatch. A selector promoted from local://
+		// archive / sqlite / unsupported PDF-image dispatch. A selector promoted from local://
 		// remains separate so it cannot be mistaken for part of the resolved path.
 		const literalSplit =
 			promotedSelector === undefined
@@ -903,6 +942,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				? readPath.includes(":") && (await probeLiteralPathExists(readPath, this.session.cwd)) !== "missing"
 				: literalSplit.sel === undefined && splitPathAndSel(readPath).sel !== undefined;
 
+		let pdfImageRead: PdfImageReadTarget | null = null;
+
 		if (!rawPathIsLiteral) {
 			const archivePath = await resolveArchiveReadPath(this.session, readPath, suffixCache, signal);
 			if (archivePath) {
@@ -925,39 +966,14 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				return readSqlite(sqlitePath, signal);
 			}
 
-			const pdfImageMemberPath = splitPdfImageMemberReadPath(readPath);
-			if (pdfImageMemberPath) {
-				let absolutePdfPath = resolveReadPath(pdfImageMemberPath.pdfPath, this.session.cwd);
-				let suffixResolution: { from: string; to: string } | undefined;
-				try {
-					const stat = await Bun.file(absolutePdfPath).stat();
-					if (stat.isDirectory())
-						throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' is a directory, not a PDF file`);
-				} catch (error) {
-					if (!isNotFoundError(error) || isRemoteMountPath(absolutePdfPath)) throw error;
-					const suffixMatch = await findSuffixMatchCached(
-						this.session,
-						suffixCache,
-						pdfImageMemberPath.pdfPath,
-						signal,
-					);
-					if (!suffixMatch) throw new ToolError(`Path '${pdfImageMemberPath.pdfPath}' not found`);
-					absolutePdfPath = suffixMatch.absolutePath;
-					suffixResolution = { from: pdfImageMemberPath.pdfPath, to: suffixMatch.displayPath };
-				}
-				return readPdfImageMember(
-					this.session,
-					this.#autoResizeImages,
-					absolutePdfPath,
-					pdfImageMemberPath.pdfPath,
-					pdfImageMemberPath.member,
-					suffixResolution,
-					signal,
-				);
-			}
+			const pdfCandidate = literalSplit.sel === undefined ? splitPdfImageReadPath(readPath) : null;
+			pdfImageRead =
+				pdfCandidate && (await probeLiteralPathExists(readPath, this.session.cwd)) === "missing"
+					? pdfCandidate
+					: null;
 		}
 
-		const localTarget = literalSplit;
+		const localTarget = pdfImageRead ? { path: pdfImageRead.pdfPath, sel: undefined } : literalSplit;
 		const localReadPath = localTarget.path;
 		const parsed = parseSel(localTarget.sel);
 
@@ -1036,6 +1052,17 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			return this.#readFileConflicts(absolutePath, suffixResolution, signal);
 		}
 
+		if (pdfImageRead) {
+			return this.#readPdfPageScreenshot({
+				readPath,
+				absolutePdfPath: absolutePath,
+				page: pdfImageRead.page,
+				pdfFileSize: fileSize,
+				suffixResolution,
+				signal,
+			});
+		}
+
 		const imageMetadata = await readImageMetadata(absolutePath);
 		const mimeType = imageMetadata?.mimeType;
 		const ext = path.extname(absolutePath).toLowerCase();
@@ -1102,8 +1129,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			// Convert document via markit.
 			const result = await convertFileWithMarkit(absolutePath, signal);
 			if (result.ok) {
-				const renderedContent =
-					ext === ".pdf" ? rewritePdfImagePlaceholders(result.content, resolvedDisplayPath) : result.content;
+				const renderedContent = result.content;
 				// Route the converted markdown through the in-memory text builder
 				// so line-range selectors (`file.pdf:50-100`, `:5-16,40-80`) and
 				// raw mode apply against the converted output. Without this,

package/src/utils/external-editor.ts

@@ -33,6 +33,27 @@ export interface OpenInEditorOptions {
 	trimTrailingNewline?: boolean;
 }
 
+/** Subprocess argv and Windows quoting mode used to launch an external editor. */
+export interface EditorSpawnCommand {
+	cmd: string[];
+	windowsVerbatimArguments: boolean;
+}
+
+/** Resolves shell argv without letting the host runtime re-quote the editor command. */
+export function resolveEditorSpawnCommand(
+	editorCmd: string,
+	tmpFile: string,
+	platform: NodeJS.Platform = process.platform,
+): EditorSpawnCommand {
+	const windows = platform === "win32";
+	// cmd.exe strips the outer /s /c quote pair; Bun must pass the embedded
+	// editor/path quotes verbatim instead of applying argv escaping to them.
+	const cmd = windows
+		? ["cmd.exe", "/d", "/s", "/c", `"${editorCmd} "${tmpFile}""`]
+		: [$which("sh") ?? "sh", "-c", `${editorCmd} "$1"`, "sh", tmpFile];
+	return { cmd, windowsVerbatimArguments: windows };
+}
+
 /**
  * Opens `content` in the user's external editor and returns the edited text.
  * Returns `null` if the editor exits with a non-zero code.
@@ -50,15 +71,13 @@ export async function openInEditor(
 	try {
 		await Bun.write(tmpFile, content);
 
+		const spawnCommand = resolveEditorSpawnCommand(editorCmd, tmpFile);
 		const [stdin, stdout, stderr] = options?.stdio ?? ["inherit", "inherit", "inherit"];
-		const cmd =
-			process.platform === "win32"
-				? ["cmd", "/c", `${editorCmd} "${tmpFile}"`]
-				: [$which("sh") ?? "sh", "-c", `${editorCmd} "$1"`, "sh", tmpFile];
-		const child = Bun.spawn(cmd, {
+		const child = Bun.spawn(spawnCommand.cmd, {
 			stdin,
 			stdout,
 			stderr,
+			windowsVerbatimArguments: spawnCommand.windowsVerbatimArguments,
 		});
 		const exitCode = await child.exited;
 		if (exitCode === 0) {

package/src/utils/markit.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import type { ConversionResult, Markit, StreamInfo } from "../markit";
 import { ToolAbortError } from "../tools/tool-errors";
 import {
@@ -8,7 +8,6 @@ import {
 	readMarkitConversionCache,
 	writeMarkitConversionCache,
 } from "./markit-cache";
-import { loadEmbeddedMupdfWasm } from "./mupdf-wasm-embed";
 
 /**
  * File extensions markit can actually convert to markdown — one per registered
@@ -31,53 +30,16 @@ export interface MarkitConversionResult {
 
 export interface MarkitFileConversionOptions {
 	/**
-	 * Directory the PDF converter writes extracted images/diagrams into. When
-	 * set, each embedded image is rendered to `<id>.png` and referenced by path
-	 * in the markdown; when unset, markit emits an `<!-- image: <id> ... -->`
-	 * placeholder comment instead.
+	 * Directory converters may use for extracted image or diagram files. Since
+	 * those files are conversion side effects, conversions using this option
+	 * bypass the markdown cache.
 	 */
 	imageDir?: string;
 }
 
-interface MuPdfWasmModuleConfig {
-	print?: (...values: unknown[]) => void;
-	printErr?: (...values: unknown[]) => void;
-	wasmBinary?: Uint8Array;
-}
-
-function logMuPdfWasmOutput(stream: "stdout" | "stderr", values: unknown[]): void {
-	const message = values.length === 1 && typeof values[0] === "string" ? values[0] : values.map(String).join(" ");
-	logger.debug("mupdf wasm output", { stream, message });
-}
-
-// `$libmupdf_wasm_Module` is declared globally (as `any`) by the mupdf package.
-// Install print hooks before the WASM module initializes so its stdout/stderr
-// route to the file logger instead of corrupting the TUI.
-function installMuPdfWasmLogger(): void {
-	const moduleConfig: MuPdfWasmModuleConfig = globalThis.$libmupdf_wasm_Module ?? {};
-	moduleConfig.print = (...values: unknown[]) => logMuPdfWasmOutput("stdout", values);
-	moduleConfig.printErr = (...values: unknown[]) => logMuPdfWasmOutput("stderr", values);
-	globalThis.$libmupdf_wasm_Module = moduleConfig;
-}
-
-// Hand the WASM module its bytes directly when the compiled binary embedded them
-// (scripts/embed-mupdf-wasm.ts); a single-file binary has no node_modules for
-// mupdf to read `mupdf-wasm.wasm` from. Source/npm builds get undefined here and
-// mupdf loads its own wasm. Must run before the mupdf module evaluates.
-function installEmbeddedMupdfWasm(): void {
-	const wasmBinary = loadEmbeddedMupdfWasm();
-	if (!wasmBinary) return;
-	const moduleConfig: MuPdfWasmModuleConfig = globalThis.$libmupdf_wasm_Module ?? {};
-	moduleConfig.wasmBinary = wasmBinary;
-	globalThis.$libmupdf_wasm_Module = moduleConfig;
-}
-
-installMuPdfWasmLogger();
-
 let markit: () => Markit | Promise<Markit> = async () => {
-	// Lazy: keep the document engine (mammoth/mupdf) off the startup
-	// import graph — it loads only when a document is first converted.
-	installEmbeddedMupdfWasm();
+	// Lazy: keep the document engine off the startup import graph — it loads
+	// only when a document is first converted.
 	const promise = import("../markit").then(({ Markit }) => {
 		const instance = new Markit();
 		markit = () => instance;

package/dist/types/markit/converters/pdf/columns.d.ts

@@ -1,35 +0,0 @@
-/**
- * Multi-column layout detection and text box reordering.
- *
- * Many PDFs (legal documents, datasheets, academic papers) use two-column
- * layouts. Without column detection, text boxes are ordered by Y position
- * only, interleaving left and right column content.
- *
- * Algorithm:
- *   1. Collect left edges of all text boxes on the page
- *   2. Find the largest horizontal gap between consecutive left edges
- *   3. If gap > MIN_GAP_RATIO of the text width and both sides have
- *      enough boxes → multi-column detected
- *   4. Assign each text box to a column based on its center X
- *   5. Return columns in reading order (left-to-right, top-to-bottom)
- *
- * This only detects the column structure. The caller is responsible for
- * processing each column's text boxes independently (table detection,
- * rendering, etc.).
- */
-import type { TextBox } from "./types.js";
-export interface ColumnLayout {
-    /** Number of columns detected (1 = single column, 2+ = multi-column). */
-    columnCount: number;
-    /** Text boxes grouped by column, in reading order (left to right). */
-    columns: TextBox[][];
-    /** X positions of column boundaries (between columns). */
-    boundaries: number[];
-}
-/**
- * Detect column layout and return text boxes grouped by column.
- *
- * For single-column pages, returns all boxes in one group.
- * For multi-column pages, returns boxes split by column in reading order.
- */
-export declare function detectColumns(textBoxes: TextBox[]): ColumnLayout;

package/dist/types/markit/converters/pdf/extract.d.ts

@@ -1,10 +0,0 @@
-import type { ImageRegion, PageContent } from "./types.js";
-/**
- * Render an image region from a PDF page as a PNG buffer.
- * Uses mupdf's DrawDevice to render just the cropped area at 2x resolution.
- */
-export declare function renderImageRegion(input: Uint8Array, region: ImageRegion): Promise<Uint8Array>;
-/**
- * Extract text boxes and vector segments from all pages of a PDF buffer.
- */
-export declare function extractPages(input: Uint8Array): Promise<PageContent[]>;