@oh-my-pi/pi-coding-agent 15.10.9 → 15.10.11

package/src/tools/auto-generated-guard.ts

@@ -241,15 +241,32 @@ function buildAutoGeneratedError(displayPath: string, detected: string): ToolErr
 
 const decoder = new TextDecoder("utf-8");
 
-const autoGeneratedMap = new LRUCache<string, { marker: string | undefined }>({ max: 10 });
+const autoGeneratedMap = new LRUCache<string, { mtimeMs: number; size: number; marker: string | undefined }>({
+	max: 10,
+});
 
 async function getAutoGeneratedMarker(filePath: string): Promise<string | undefined> {
 	if (isAutoGeneratedFileName(filePath)) {
 		return filePath.split("/").pop() ?? "";
 	}
 
+	// Key the cache on (mtime, size) so a file rewritten after the first
+	// check (generator added/removed) is re-scanned instead of served stale.
+	let mtimeMs: number;
+	let size: number;
+	try {
+		const stat = await Bun.file(filePath).stat();
+		mtimeMs = stat.mtimeMs;
+		size = stat.size;
+	} catch (err) {
+		if (isEnoent(err)) {
+			return undefined;
+		}
+		throw err;
+	}
+
 	const cached = autoGeneratedMap.get(filePath);
-	if (cached) return cached.marker;
+	if (cached && cached.mtimeMs === mtimeMs && cached.size === size) return cached.marker;
 
 	let marker: string | undefined;
 	try {
@@ -262,7 +279,7 @@ async function getAutoGeneratedMarker(filePath: string): Promise<string | undefi
 		throw err;
 	}
 
-	autoGeneratedMap.set(filePath, { marker });
+	autoGeneratedMap.set(filePath, { mtimeMs, size, marker });
 	return marker;
 }
 

package/src/tools/bash-interactive.ts

@@ -11,10 +11,9 @@ import {
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import type * as XtermModule from "@xterm/headless";
 import type { Terminal as XtermTerminalType } from "@xterm/headless";
-import xterm from "@xterm/headless";
 import { Settings } from "../config/settings";
-import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
 import type { Theme } from "../modes/theme/theme";
 import { OutputSink, type OutputSummary } from "../session/streaming-output";
 import { sanitizeWithOptionalSixelPassthrough } from "../utils/sixel";
@@ -32,7 +31,17 @@ function normalizeCaptureChunk(chunk: string): string {
 	return sanitizeWithOptionalSixelPassthrough(normalized, sanitizeText);
 }
 
-const XtermTerminal = xterm.Terminal;
+// @xterm/headless is only needed once an interactive PTY session actually starts,
+// so it is loaded lazily (and memoized) instead of weighing down CLI startup.
+let xtermTerminalCtor: typeof XtermModule.Terminal | undefined;
+
+async function loadXtermTerminal(): Promise<typeof XtermModule.Terminal> {
+	if (!xtermTerminalCtor) {
+		const mod = (await import("@xterm/headless")) as typeof XtermModule & { default?: typeof XtermModule };
+		xtermTerminalCtor = (mod.default ?? mod).Terminal;
+	}
+	return xtermTerminalCtor;
+}
 
 function normalizeInputForPty(data: string, applicationCursorKeysMode: boolean): string {
 	const kitty = parseKittySequence(data);
@@ -113,8 +122,9 @@ class BashInteractiveOverlayComponent implements Component {
 		private readonly command: string,
 		private readonly uiTheme: Theme,
 		private readonly getTerminalRows: () => number,
+		terminalCtor: typeof XtermModule.Terminal,
 	) {
-		this.#terminal = new XtermTerminal({
+		this.#terminal = new terminalCtor({
 			cols: 120,
 			rows: 40,
 			disableStdin: true,
@@ -224,7 +234,7 @@ class BashInteractiveOverlayComponent implements Component {
 		}
 		return visibleLines;
 	}
-	render(width: number): string[] {
+	render(width: number): readonly string[] {
 		const safeWidth = Math.max(20, width);
 		const innerWidth = Math.max(1, safeWidth - 2);
 		const maxOverlayRows = Math.max(5, Math.floor(this.getTerminalRows() * 0.8));
@@ -298,6 +308,8 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const settings = await Settings.init();
+	// Load the xterm Terminal ctor here (async boundary) — the ui.custom factory below is sync.
+	const XtermTerminal = await loadXtermTerminal();
 	const { shell: resolvedShell } = settings.getShellConfig();
 	const sink = new OutputSink({
 		artifactPath: options.artifactPath,
@@ -308,7 +320,12 @@ export async function runInteractiveBashPty(
 	const result = await ui.custom<BashInteractiveResult>(
 		(tui, uiTheme, _keybindings, done) => {
 			const session = new PtySession();
-			const component = new BashInteractiveOverlayComponent(options.command, uiTheme, () => tui.terminal.rows);
+			const component = new BashInteractiveOverlayComponent(
+				options.command,
+				uiTheme,
+				() => tui.terminal.rows,
+				XtermTerminal,
+			);
 			component.setSession(session);
 			let finished = false;
 			const finalize = (run: PtyRunResult) => {
@@ -358,8 +375,11 @@ export async function runInteractiveBashPty(
 						command: options.command,
 						cwd: options.cwd,
 						timeoutMs: options.timeoutMs,
+						// Interactive PTY: inherit the user's environment (the Rust side
+						// applies these as overrides), with a real TERM so editors,
+						// pagers, and TUIs behave like a normal terminal.
 						env: {
-							...NON_INTERACTIVE_ENV,
+							TERM: "xterm-256color",
 							...options.env,
 						},
 						signal: options.signal,

package/src/tools/bash.ts

@@ -410,10 +410,19 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 	 */
 	#throwIfUnfinished(result: BashResult | BashInteractiveResult, timeoutSec: number, outputText: string): void {
 		if (result.cancelled) {
-			throw new ToolError(normalizeResultOutput(result) || "Command aborted");
+			// executeBash output already carries a `[Command cancelled]` notice from
+			// the sink; PTY/bridge interactive output does not, so annotate it here.
+			const out = normalizeResultOutput(result);
+			const annotated = isInteractiveResult(result) && out ? `${out}\n\n[Command aborted]` : out;
+			throw new ToolError(annotated || "Command aborted");
 		}
 		if (isInteractiveResult(result) && result.timedOut) {
-			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
+			const out = normalizeResultOutput(result);
+			throw new ToolError(
+				out
+					? `${out}\n\n[Command timed out after ${timeoutSec} seconds]`
+					: `Command timed out after ${timeoutSec} seconds`,
+			);
 		}
 		if (result.exitCode === undefined) {
 			throw new ToolError(`${outputText}\n\nCommand failed: missing exit status`);
@@ -669,7 +678,10 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		// script can't pull the entire script into the "cwd" capture.
 		if (!cwd) {
 			const cdMatch = command.match(/^cd[ \t]+((?:[^&\\\n\r]|\\.)+?)[ \t]*&&[ \t]*/);
-			if (cdMatch) {
+			// Skip extraction when the path needs shell expansion ($VAR, $(...),
+			// backticks) — resolveToCwd only expands `~`, so routing those through
+			// cwd would reject commands the shell itself handles fine.
+			if (cdMatch && !/[$`(]/.test(cdMatch[1])) {
 				cwd = cdMatch[1].trim().replace(/^["']|["']$/g, "");
 				command = command.slice(cdMatch[0].length);
 			}
@@ -771,8 +783,24 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 			});
 		}
 
+		// The client-bridge terminal provides a live terminal card in the editor;
+		// when available it wins over auto-backgrounding (both are opt-in, and
+		// auto-background would otherwise silently disable the terminal route).
+		const clientBridge = this.session.getClientBridge?.();
+		const bridgeTerminalAvailable = Boolean(
+			clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty,
+		);
+
 		const autoBgManager = this.session.asyncJobManager;
-		if (this.#autoBackgroundEnabled && !pty && autoBgManager) {
+		// At the running-job cap, fall through to direct foreground execution
+		// instead of failing every bash call until a slot frees up.
+		if (
+			this.#autoBackgroundEnabled &&
+			!pty &&
+			!bridgeTerminalAvailable &&
+			autoBgManager &&
+			!autoBgManager.atCapacity
+		) {
 			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
 			const startBackgrounded = autoBackgroundWaitMs === 0;
 			const job = this.#startManagedBashJob({
@@ -793,21 +821,23 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					notices: pendingNotices,
 				});
 			}
+			// Suppress the completion delivery up front so a job finishing while we
+			// foreground-wait cannot also be injected by the delivery loop. Lifted
+			// via resumeDeliveries() if we end up backgrounding after all.
+			autoBgManager.acknowledgeDeliveries([job.jobId]);
 			const waitResult = await this.#waitForManagedBashJob(job, autoBackgroundWaitMs, signal);
 			if (waitResult.kind === "completed") {
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
 				return waitResult.result;
 			}
 			if (waitResult.kind === "failed") {
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
 				throw waitResult.error;
 			}
 			if (waitResult.kind === "aborted") {
 				autoBgManager.cancel(job.jobId);
-				autoBgManager.acknowledgeDeliveries([job.jobId]);
 				throw new ToolAbortError(job.getLatestText() || "Command aborted");
 			}
 			job.setBackgrounded(true);
+			autoBgManager.resumeDeliveries([job.jobId]);
 			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec, {
 				requestedTimeoutSec,
 				notices: pendingNotices,
@@ -816,7 +846,6 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 
 		// Route through the client terminal when the client advertises the terminal capability.
 		// Skip when pty=true (PTY needs the local terminal UI).
-		const clientBridge = this.session.getClientBridge?.();
 		if (clientBridge?.capabilities.terminal && clientBridge.createTerminal && !pty) {
 			const bridgeWallTimeStart = performance.now();
 			const handle = await clientBridge.createTerminal({
@@ -993,6 +1022,9 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		const { path: artifactPath, id: artifactId } = (await this.session.allocateOutputArtifact?.("bash")) ?? {};
 
 		const interactiveUi = canUseInteractiveBashPty(pty, ctx) ? ctx?.ui : undefined;
+		if (pty && !interactiveUi) {
+			pendingNotices.push("pty requested but unavailable in this environment; ran without a terminal");
+		}
 		const wallTimeStart = performance.now();
 		const result: BashResult | BashInteractiveResult = interactiveUi
 			? await runInteractiveBashPty(interactiveUi, {
@@ -1017,13 +1049,22 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				});
 		const wallTimeMs = performance.now() - wallTimeStart;
 		if (result.cancelled) {
+			const out = normalizeResultOutput(result);
+			// PTY output carries no cancel/timeout notice of its own; annotate so
+			// the model can tell an abort from a plain failure.
+			const message = isInteractiveResult(result) && out ? `${out}\n\n[Command aborted]` : out || "Command aborted";
 			if (signal?.aborted) {
-				throw new ToolAbortError(normalizeResultOutput(result) || "Command aborted");
+				throw new ToolAbortError(message);
 			}
-			throw new ToolError(normalizeResultOutput(result) || "Command aborted");
+			throw new ToolError(message);
 		}
 		if (isInteractiveResult(result) && result.timedOut) {
-			throw new ToolError(normalizeResultOutput(result) || `Command timed out after ${timeoutSec} seconds`);
+			const out = normalizeResultOutput(result);
+			throw new ToolError(
+				out
+					? `${out}\n\n[Command timed out after ${timeoutSec} seconds]`
+					: `Command timed out after ${timeoutSec} seconds`,
+			);
 		}
 		return this.#buildCompletedResult(result, timeoutSec, {
 			requestedTimeoutSec,
@@ -1122,7 +1163,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 					: renderStatusLine({ icon: "pending", title: config.resolveTitle(args, options) }, uiTheme);
 			const outputBlock = new CachedOutputBlock();
 			return markFramedBlockComponent({
-				render: (width: number): string[] =>
+				render: (width: number): readonly string[] =>
 					outputBlock.render(
 						{
 							header,
@@ -1172,7 +1213,7 @@ export function createShellRenderer<TArgs>(config: ShellRendererConfig<TArgs>) {
 			const outputBlock = new CachedOutputBlock();
 
 			return markFramedBlockComponent({
-				render: (width: number): string[] => {
+				render: (width: number): readonly string[] => {
 					// REACTIVE: read mutable options at render time
 					const { renderContext } = options;
 					const expanded = renderContext?.expanded ?? options.expanded;

package/src/tools/browser/launch.ts

@@ -2,9 +2,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { $which, getPuppeteerDir, logger } from "@oh-my-pi/pi-utils";
-import * as browsers from "@puppeteer/browsers";
+import type * as BrowsersNs from "@puppeteer/browsers";
 import type { Browser, CDPSession, Page, default as Puppeteer, Target } from "puppeteer-core";
-import { PUPPETEER_REVISIONS } from "puppeteer-core/internal/revisions.js";
 import stealthTamperingScript from "../puppeteer/00_stealth_tampering.txt" with { type: "text" };
 import stealthActivityScript from "../puppeteer/01_stealth_activity.txt" with { type: "text" };
 import stealthHairlineScript from "../puppeteer/02_stealth_hairline.txt" with { type: "text" };
@@ -78,6 +77,14 @@ export async function loadPuppeteerInWorker(safeDir: string): Promise<typeof Pup
 	}
 }
 
+let browsersModule: typeof BrowsersNs | undefined;
+async function loadBrowsers(): Promise<typeof BrowsersNs> {
+	if (!browsersModule) {
+		browsersModule = await import("@puppeteer/browsers");
+	}
+	return browsersModule;
+}
+
 /**
  * Lazily download Chromium on first browser launch via @puppeteer/browsers.
  * Skipped when a system Chromium (NixOS) or PUPPETEER_EXECUTABLE_PATH is set.
@@ -92,12 +99,14 @@ async function ensureChromiumExecutable(): Promise<string | undefined> {
 	if (chromiumExecutablePromise) return chromiumExecutablePromise;
 
 	chromiumExecutablePromise = (async () => {
+		const browsers = await loadBrowsers();
 		const platform = browsers.detectBrowserPlatform();
 		if (!platform) {
 			logger.warn("Could not detect browser platform; relying on puppeteer default resolution");
 			return undefined;
 		}
 		const cacheDir = getPuppeteerDir();
+		const { PUPPETEER_REVISIONS } = await import("puppeteer-core/internal/revisions.js");
 		const buildId = await browsers.resolveBuildId(browsers.Browser.CHROME, platform, PUPPETEER_REVISIONS.chrome);
 		const executablePath = browsers.computeExecutablePath({
 			browser: browsers.Browser.CHROME,

package/src/tools/browser/readable.ts

@@ -1,5 +1,5 @@
-import { Readability } from "@mozilla/readability";
-import { parseHTML } from "linkedom";
+import type * as ReadabilityNs from "@mozilla/readability";
+import type * as LinkedomNs from "linkedom";
 import { htmlToBasicMarkdown } from "../../web/scrapers/types";
 
 export type ReadableFormat = "text" | "markdown";
@@ -20,6 +20,22 @@ function normalize(text: string | null | undefined): string | undefined {
 	return trimmed || undefined;
 }
 
+let readabilityModule: typeof ReadabilityNs | undefined;
+async function loadReadability(): Promise<typeof ReadabilityNs> {
+	if (!readabilityModule) {
+		readabilityModule = await import("@mozilla/readability");
+	}
+	return readabilityModule;
+}
+
+let linkedomModule: typeof LinkedomNs | undefined;
+async function loadLinkedom(): Promise<typeof LinkedomNs> {
+	if (!linkedomModule) {
+		linkedomModule = await import("linkedom");
+	}
+	return linkedomModule;
+}
+
 /**
  * Extract readable content from raw HTML.
  * Tries Readability (article-isolation scoring) first, then falls back to a
@@ -31,6 +47,7 @@ export async function extractReadableFromHtml(
 	url: string,
 	format: ReadableFormat,
 ): Promise<ReadableResult | null> {
+	const [{ parseHTML }, { Readability }] = await Promise.all([loadLinkedom(), loadReadability()]);
 	const { document } = parseHTML(html);
 
 	// --- Primary: Readability article extraction ---

package/src/tools/browser/registry.ts

@@ -157,7 +157,10 @@ export function holdBrowser(handle: BrowserHandle): void {
 export async function releaseBrowser(handle: BrowserHandle, opts: { kill: boolean }): Promise<void> {
 	handle.refCount = Math.max(0, handle.refCount - 1);
 	if (handle.refCount === 0) {
-		browsers.delete(handle.key);
+		// Only evict if the registry still points at THIS handle. After a disconnect,
+		// `acquireBrowser` may have already replaced the entry with a fresh live handle
+		// under the same key; deleting blindly would orphan that new browser.
+		if (browsers.get(handle.key) === handle) browsers.delete(handle.key);
 		await disposeBrowserHandle(handle, opts);
 	}
 }

package/src/tools/browser/render.ts

@@ -66,7 +66,7 @@ function dropTrailingBlankLines(text: string): string {
 function appendLine(component: Component, line: string | undefined): Component {
 	if (!line) return component;
 	const wrapped = {
-		render: (width: number): string[] => {
+		render: (width: number): readonly string[] => {
 			const base = component.render(width);
 			return [...base, line];
 		},
@@ -95,7 +95,7 @@ function renderRunCell(
 
 	let cached: { key: bigint; width: number; lines: string[] } | undefined;
 	return markFramedBlockComponent({
-		render: (width: number): string[] => {
+		render: (width: number): readonly string[] => {
 			const expanded = options.renderContext?.expanded ?? options.expanded;
 			const previewLines = options.renderContext?.previewLines ?? BROWSER_DEFAULT_PREVIEW_LINES;
 			const key = new Hasher()

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

@@ -1,4 +1,4 @@
-import { getPuppeteerDir, isCompiledBinary, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { getPuppeteerDir, logger, Snowflake, workerHostEntry } from "@oh-my-pi/pi-utils";
 import type { Page, Target } from "puppeteer-core";
 import { callSessionTool } from "../../eval/js/tool-bridge";
 import type { ToolSession } from "../../sdk";
@@ -18,14 +18,8 @@ import type {
 	WorkerOutbound,
 } from "./tab-protocol";
 
-// Worker entry. The literal string in `new Worker("./packages/coding-agent/src/tools/browser/tab-worker-entry.ts", …)`
-// below is what Bun's `--compile` static analyzer needs to bundle the worker
-// (registered as an additional entrypoint in `scripts/build-binary.ts`); in
-// dev we resolve the same source via `import.meta.url`. Replaces the older
-// `with { type: "file" }` pattern, which only copied the entry as a raw
-// asset and could not resolve the worker's relative imports inside a
-// compiled binary (issue #1011 was a false-positive fix — the regression
-// test only checked emission, not actual worker startup).
+// Coding-agent binary/bundle workers route through the CLI entrypoint with a
+// hidden argv mode, so compiled/npm builds only need one JavaScript entry.
 
 interface WorkerHandle {
 	send(msg: WorkerInbound, transferList?: Transferable[]): void;
@@ -84,21 +78,51 @@ export interface ReleaseTabOptions {
 }
 
 const tabs = new Map<string, TabSession>();
+// Per-name acquisition chain: serializes concurrent `acquireTab` calls for the
+// same tab name so the existence check and `tabs.set` (separated by several
+// awaits) cannot interleave and leak a worker + browser refCount.
+const acquireChains = new Map<string, Promise<void>>();
 const GRACE_MS = 750;
 
 export function getTab(name: string): TabSession | undefined {
 	return tabs.get(name);
 }
 
-export async function acquireTab(
+export function acquireTab(name: string, browser: BrowserHandle, opts: AcquireTabOptions): Promise<AcquireTabResult> {
+	const prior = acquireChains.get(name) ?? Promise.resolve();
+	const result = prior.then(() => acquireTabImpl(name, browser, opts));
+	const tail = result.then(
+		() => undefined,
+		() => undefined,
+	);
+	acquireChains.set(name, tail);
+	void tail.then(() => {
+		if (acquireChains.get(name) === tail) acquireChains.delete(name);
+	});
+	return result;
+}
+
+async function acquireTabImpl(
 	name: string,
 	browser: BrowserHandle,
 	opts: AcquireTabOptions,
 ): Promise<AcquireTabResult> {
+	// Serialized opens can sit behind a slow predecessor in the per-name
+	// chain; honor an abort at dequeue instead of spawning a worker and
+	// browser hold nobody is waiting for.
+	if (opts.signal?.aborted) {
+		throw new ToolAbortError("Browser tab open aborted");
+	}
+	// Temporary refCount hold so releasing an existing tab on the SAME browser
+	// below cannot drop it to refCount 0 and dispose the instance we are about
+	// to reuse (e.g. reopening the sole tab with a different dialogs policy).
+	let tempHold = false;
 	const existing = tabs.get(name);
 	if (existing) {
 		if (existing.browser === browser && existing.state === "alive") {
 			if (opts.dialogs !== undefined && opts.dialogs !== existing.dialogPolicy) {
+				holdBrowser(browser);
+				tempHold = true;
 				await releaseTab(name, { kill: false });
 			} else {
 				const reuseSteps: string[] = [];
@@ -127,12 +151,25 @@ export async function acquireTab(
 				return { tab: tabs.get(name)!, created: false };
 			}
 		} else {
+			if (existing.browser === browser) {
+				holdBrowser(browser);
+				tempHold = true;
+			}
 			await releaseTab(name, { kill: false });
 		}
 	}
 
-	const initPayload = await buildInitPayload(browser, opts);
-	let worker = await spawnTabWorker();
+	let initPayload: WorkerInitPayload;
+	let worker: WorkerHandle;
+	try {
+		initPayload = await buildInitPayload(browser, opts);
+		worker = await spawnTabWorker();
+	} catch (error) {
+		// Failing before the worker took its own hold must release the
+		// temporary one, or the browser's refCount never reaches 0 again.
+		if (tempHold || browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+		throw error;
+	}
 	let info: ReadyInfo;
 	try {
 		info = await initializeTabWorker(worker, initPayload, opts.timeoutMs + GRACE_MS);
@@ -142,7 +179,7 @@ export async function acquireTab(
 		// the inline worker here so module-resolution failures don't poison every tab open.
 		await worker.terminate().catch(() => undefined);
 		if (worker.mode === "inline") {
-			if (browser.refCount === 0) await releaseBrowser(browser, { kill: false });
+			if (tempHold || 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)", {
@@ -153,7 +190,7 @@ export async function acquireTab(
 			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 });
+			if (tempHold || 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)}`,
 			);
@@ -163,6 +200,7 @@ export async function acquireTab(
 	}
 
 	holdBrowser(browser);
+	if (tempHold) await releaseBrowser(browser, { kill: false });
 	const tab: TabSession = {
 		name,
 		browser,
@@ -474,8 +512,9 @@ async function raceWithTimeout<T>(
 
 async function spawnTabWorker(): Promise<WorkerHandle> {
 	try {
-		const worker = isCompiledBinary()
-			? new Worker("./packages/coding-agent/src/tools/browser/tab-worker-entry.ts", { type: "module" })
+		const hostEntry = workerHostEntry();
+		const worker = hostEntry
+			? new Worker(hostEntry, { type: "module", argv: ["__omp_tab_worker"] })
 			: new Worker(new URL("./tab-worker-entry.ts", import.meta.url).href, { type: "module" });
 		return wrapBunWorker(worker);
 	} catch (err) {

package/src/tools/conflict-detect.ts

@@ -68,7 +68,9 @@ export function scanConflictLines(lines: readonly string[], firstLineNumber: num
 	} | null = null;
 
 	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
+		// Strip a trailing \r so CRLF checkouts match the same markers; stored
+		// section lines are LF-normalized (splice re-applies \r on write).
+		const line = stripTrailingCr(lines[i]);
 		const ln = firstLineNumber + i;
 
 		const oursLabel = matchMarker(line, OURS_PREFIX);
@@ -338,13 +340,22 @@ export function spliceConflict(originalText: string, entry: ConflictEntry, repla
 	}
 
 	const trimmed = normalizeTrailingNewline(replacement);
-	const replacementLines = trimmed.split("\n");
+	let replacementLines = trimmed.split("\n").map(stripTrailingCr);
+	// Round-trip fidelity for CRLF files: recorded sections are LF-normalized,
+	// so re-apply \r to spliced lines when the matched region used CRLF. The
+	// final replacement line only carries \r when another line follows it.
+	if (lines[match.startIdx]!.endsWith("\r")) {
+		const hasFollowingLine = match.endIdx + 1 < lines.length;
+		replacementLines = replacementLines.map((l, i) =>
+			i < replacementLines.length - 1 || hasFollowingLine ? `${l}\r` : l,
+		);
+	}
 	const next = [...lines.slice(0, match.startIdx), ...replacementLines, ...lines.slice(match.endIdx + 1)];
 	return next.join("\n");
 }
 
 /** Reconstruct the recorded marker block as it should appear in the file. */
-function buildRecordedRegion(entry: ConflictEntry): string[] {
+function buildRecordedRegion(entry: ConflictBlock): string[] {
 	const out: string[] = [];
 	out.push(entry.oursLabel ? `${OURS_PREFIX} ${entry.oursLabel}` : OURS_PREFIX);
 	out.push(...entry.oursLines);
@@ -358,6 +369,36 @@ function buildRecordedRegion(entry: ConflictEntry): string[] {
 	return out;
 }
 
+/**
+ * True when two registered blocks record the same marker-block content
+ * (labels and all sides). Out-of-band edits can shift a block's line
+ * numbers between reads, registering a fresh id while the stale one
+ * persists; callers use content identity to treat a locate-miss for the
+ * stale twin as "already resolved" instead of a hard failure.
+ */
+export function conflictRegionsEqual(a: ConflictBlock, b: ConflictBlock): boolean {
+	const ra = buildRecordedRegion(a);
+	const rb = buildRecordedRegion(b);
+	if (ra.length !== rb.length) return false;
+	for (let i = 0; i < ra.length; i++) {
+		if (ra[i] !== rb[i]) return false;
+	}
+	return true;
+}
+
+/**
+ * True when the entry's recorded marker block still occurs in `content`
+ * (LF-normalized — recorded sections are stored LF). Distinguishes a stale
+ * re-registration of a just-resolved region (no longer present) from a
+ * DISTINCT conflict block that happens to be byte-identical (still present
+ * elsewhere in the file and must stay addressable).
+ */
+export function conflictRegionPresent(content: string, entry: ConflictBlock): boolean {
+	const region = buildRecordedRegion(entry).join("\n");
+	const normalized = content.includes("\r") ? content.replace(/\r\n/g, "\n") : content;
+	return normalized.includes(region);
+}
+
 /**
  * Find a contiguous match of `expected` inside `lines`, preferring the
  * occurrence closest to `preferredIdx` to disambiguate when an identical
@@ -391,11 +432,16 @@ function locateRegion(
 function matchesAt(lines: readonly string[], startIdx: number, expected: readonly string[]): boolean {
 	if (startIdx < 0 || startIdx + expected.length > lines.length) return false;
 	for (let i = 0; i < expected.length; i++) {
-		if (lines[startIdx + i] !== expected[i]) return false;
+		// Recorded lines are LF-normalized; tolerate CRLF on-disk lines.
+		if (stripTrailingCr(lines[startIdx + i]!) !== expected[i]) return false;
 	}
 	return true;
 }
 
+function stripTrailingCr(line: string): string {
+	return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+
 function normalizeTrailingNewline(replacement: string): string {
 	if (replacement.endsWith("\r\n")) return replacement.slice(0, -2);
 	if (replacement.endsWith("\n")) return replacement.slice(0, -1);

package/src/tools/debug.ts

@@ -592,7 +592,7 @@ export const debugToolRenderer = {
 	): Component {
 		const outputBlock = new CachedOutputBlock();
 		return markFramedBlockComponent({
-			render(width: number): string[] {
+			render(width: number): readonly string[] {
 				const action = (args?.action ?? result.details?.action ?? "debug").replaceAll("_", " ");
 				const success = !options.isPartial && !result.isError;
 				const statusIcon = success