@oh-my-pi/pi-coding-agent 17.1.3 → 17.1.4

package/src/config/settings-schema.ts

@@ -234,38 +234,50 @@ export type AnyUiMetadata = UiBase & {
 	ordered?: boolean;
 };
 
-interface BooleanDef {
+/**
+ * Marks a setting whose value is a credential.
+ *
+ * Lives at the top level rather than inside `ui` so it can also describe a
+ * setting the settings panel never shows and therefore cannot carry
+ * `ui.secret`. Read it through `isCredential`, which is the single accessor
+ * both the CLI and the settings panel consult.
+ */
+interface CredentialMarker {
+	credential?: true;
+}
+
+interface BooleanDef extends CredentialMarker {
 	type: "boolean";
 	default: boolean | undefined;
 	ui?: UiBoolean;
 }
 
-interface StringDef {
+interface StringDef extends CredentialMarker {
 	type: "string";
 	default: string | undefined;
 	ui?: UiString;
 }
 
-interface NumberDef {
+interface NumberDef extends CredentialMarker {
 	type: "number";
 	default: number | undefined;
 	ui?: UiNumber;
 }
 
-interface EnumDef<T extends readonly string[]> {
+interface EnumDef<T extends readonly string[]> extends CredentialMarker {
 	type: "enum";
 	values: T;
 	default: T[number];
 	ui?: UiEnum<T>;
 }
 
-interface ArrayDef<T> {
+interface ArrayDef<T> extends CredentialMarker {
 	type: "array";
 	default: T[];
 	ui?: UiArray;
 }
 
-interface RecordDef<T> {
+interface RecordDef<T> extends CredentialMarker {
 	type: "record";
 	default: Record<string, T>;
 	ui?: UiBase;
@@ -378,7 +390,7 @@ export const SETTINGS_SCHEMA = {
 	// Env (`OMP_AUTH_BROKER_URL` / `OMP_AUTH_BROKER_TOKEN`) takes precedence so
 	// per-machine overrides remain trivial.
 	"auth.broker.url": { type: "string", default: undefined },
-	"auth.broker.token": { type: "string", default: undefined },
+	"auth.broker.token": { type: "string", default: undefined, credential: true },
 
 	autoResume: {
 		type: "boolean",
@@ -2776,6 +2788,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"mnemopi.embeddingApiKey": {
 		type: "string",
+		credential: true,
 		default: undefined,
 		ui: {
 			tab: "memory",
@@ -2820,6 +2833,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"mnemopi.llmApiKey": {
 		type: "string",
+		credential: true,
 		default: undefined,
 		ui: {
 			tab: "memory",
@@ -2862,6 +2876,7 @@ export const SETTINGS_SCHEMA = {
 
 	"hindsight.apiToken": {
 		type: "string",
+		credential: true,
 		default: undefined,
 		ui: {
 			tab: "memory",
@@ -2869,7 +2884,6 @@ export const SETTINGS_SCHEMA = {
 			label: "Hindsight API Token",
 			description: "Bearer token for authenticated Hindsight servers",
 			condition: "hindsightActive",
-			secret: true,
 		},
 	},
 
@@ -5249,6 +5263,7 @@ export const SETTINGS_SCHEMA = {
 	"searxng.token": {
 		type: "string",
 		default: undefined,
+		credential: true,
 	},
 
 	"searxng.basicUsername": {
@@ -5259,6 +5274,7 @@ export const SETTINGS_SCHEMA = {
 	"searxng.basicPassword": {
 		type: "string",
 		default: undefined,
+		credential: true,
 	},
 
 	"searxng.categories": {
@@ -5314,6 +5330,7 @@ export const SETTINGS_SCHEMA = {
 	"dev.autoqaPush.token": {
 		type: "string",
 		default: undefined,
+		credential: true,
 	},
 
 	/**
@@ -5400,6 +5417,20 @@ export function hasUi(path: SettingPath): boolean {
 	return "ui" in SETTINGS_SCHEMA[path];
 }
 
+/**
+ * Whether a setting holds a credential and must never be printed or exported
+ * without an explicit request. Drives both CLI redaction and settings-panel
+ * masking, so the two cannot disagree.
+ */
+export function isCredential(path: SettingPath): boolean {
+	const def = SETTINGS_SCHEMA[path];
+	if ("credential" in def && def.credential === true) return true;
+	// `ui.secret` predates this marker and still means "never display". Reading
+	// both here keeps ONE accessor, so the two spellings cannot produce
+	// different behaviour on different surfaces.
+	return getUi(path)?.secret === true;
+}
+
 /** Get UI metadata for a path (undefined if no UI) */
 export function getUi(path: SettingPath): AnyUiMetadata | undefined {
 	const def = SETTINGS_SCHEMA[path];

package/src/config/settings.ts

@@ -321,6 +321,10 @@ export class Settings {
 	#project: RawSettings = {};
 	/** Extra config.yml-style overlays passed by CLI */
 	#configOverlay: RawSettings = {};
+	/** Project settings file that most recently supplied shellPath. */
+	#projectShellPathSource: string | undefined;
+	/** Explicit config overlay that most recently supplied shellPath. */
+	#overlayShellPathSource: string | undefined;
 	/** Runtime overrides (not persisted) */
 	#overrides: RawSettings = {};
 	/** Merged view (global + project + overrides) */
@@ -592,8 +596,10 @@ export class Settings {
 		cloned.#configPath = this.#configPath;
 		cloned.#global = structuredClone(this.#global);
 		cloned.#project = this.#persist ? await cloned.#loadProjectSettings() : structuredClone(this.#project);
+		if (!this.#persist) cloned.#projectShellPathSource = this.#projectShellPathSource;
 		cloned.#configFiles = [...this.#configFiles];
 		cloned.#configOverlay = structuredClone(this.#configOverlay);
+		cloned.#overlayShellPathSource = this.#overlayShellPathSource;
 		cloned.#overrides = this.#buildOriginalOverrides();
 		cloned.#rebuildMerged();
 		cloned.#fireAllHooks();
@@ -652,7 +658,17 @@ export class Settings {
 	 */
 	getShellConfig() {
 		const shell = this.get("shellPath");
-		return procmgr.getShellConfig(shell);
+		let configSource = this.#configPath ?? path.join(this.#agentDir, MAIN_CONFIG_FILENAMES[0]);
+		if (Object.hasOwn(this.#project, "shellPath")) {
+			configSource = this.#projectShellPathSource ?? "the active project configuration";
+		}
+		if (Object.hasOwn(this.#configOverlay, "shellPath")) {
+			configSource = this.#overlayShellPathSource ?? "the active config overlay";
+		}
+		if (Object.hasOwn(this.#overrides, "shellPath")) {
+			configSource = "the runtime settings override";
+		}
+		return procmgr.getShellConfig(shell, { configSource });
 	}
 
 	/**
@@ -1089,12 +1105,14 @@ export class Settings {
 	}
 
 	async #loadProjectSettings(): Promise<RawSettings> {
+		this.#projectShellPathSource = undefined;
 		try {
 			const result = await loadCapability(settingsCapability.id, { cwd: this.#cwd });
 			let merged: RawSettings = {};
 			for (const item of result.items as SettingsCapabilityItem[]) {
 				if (item.level === "project") {
 					merged = this.#deepMerge(merged, item.data as RawSettings);
+					if (Object.hasOwn(item.data, "shellPath")) this.#projectShellPathSource = item.path;
 				}
 			}
 			const nativeProject = await this.#loadYaml(path.join(this.#cwd, ".omp", "config.yml"));
@@ -1104,14 +1122,18 @@ export class Settings {
 			}
 			return this.#migrateRawSettings(merged);
 		} catch {
+			this.#projectShellPathSource = undefined;
 			return {};
 		}
 	}
 
 	async #loadConfigOverlays(): Promise<RawSettings> {
+		this.#overlayShellPathSource = undefined;
 		let merged: RawSettings = {};
 		for (const filePath of this.#configFiles) {
-			merged = this.#deepMerge(merged, await this.#loadOverlayYaml(filePath));
+			const overlay = await this.#loadOverlayYaml(filePath);
+			merged = this.#deepMerge(merged, overlay);
+			if (Object.hasOwn(overlay, "shellPath")) this.#overlayShellPathSource = filePath;
 		}
 		return merged;
 	}

package/src/cursor.ts

@@ -10,11 +10,16 @@ import type {
 import type {
 	CursorMcpCall,
 	CursorShellStreamCallbacks,
+	CursorTodoSnapshot,
 	CursorExecHandlers as ICursorExecHandlers,
 	ToolResultMessage,
 } from "@oh-my-pi/pi-ai";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
 import { resolveToCwd } from "./tools/path-utils";
+import type { TodoPhase, TodoStatus } from "./tools/todo";
+
+/** Phase used for Cursor-owned tasks with no local phase grouping. */
+const CURSOR_TODO_PHASE = "Tasks";
 
 interface CursorExecBridgeOptions {
 	cwd: string;
@@ -32,6 +37,18 @@ interface CursorExecBridgeOptions {
 	 * callers with a restricted tool set (advisors) opt out.
 	 */
 	allowNativeDelete?: boolean;
+	/**
+	 * Mirror Cursor's server-owned todo list into local session state. Cursor
+	 * resolves `update_todos` / `read_todos` remotely, so without this bridge
+	 * the provider's list and the local `todo` state diverge silently.
+	 */
+	setTodoPhases?: (phases: TodoPhase[]) => void;
+	getTodoPhases?: () => TodoPhase[];
+	/**
+	 * Persist the mirrored list to the session branch so it survives reloads.
+	 * Cursor emits no local `todo` toolResult, so nothing else records it.
+	 */
+	persistTodoPhases?: (phases: TodoPhase[]) => void;
 }
 
 function createToolResultMessage(
@@ -177,6 +194,49 @@ function formatMcpToolErrorMessage(toolName: string, availableTools: string[]):
 	return `MCP tool "${toolName}" not found. Available tools: ${list}`;
 }
 
+/**
+ * One-line summary for the synthesized todo result. Cursor's server-resolved
+ * call produces no local tool output, but the transcript entry still needs
+ * text content alongside the phases the UI renders.
+ */
+function formatTodoSyncSummary(phases: TodoPhase[]): string {
+	const tasks = phases.flatMap(phase => phase.tasks);
+	if (tasks.length === 0) return "No todos";
+	const done = tasks.filter(task => task.status === "completed").length;
+	return `${done}/${tasks.length} tasks completed`;
+}
+
+/**
+ * Persisted result for a server-resolved todo call.
+ *
+ * `details` is only attached for an authoritative snapshot, and then
+ * `details.phases` is load-bearing rather than decoration: `todoToolRenderer`
+ * rebuilds the rendered list exclusively from it, so a mirrored update that
+ * omitted it would replay as `Todo 0 tasks` after a reload.
+ *
+ * A refusal or a server error carries no `details`. Echoing the current phases
+ * there would replay a call that changed nothing as if it had re-asserted the
+ * whole list — and `event-controller` feeds `details.phases` straight into
+ * `setTodos`, so a refused `read_todos` would overwrite live UI state.
+ */
+function buildTodoSyncResult(
+	toolCallId: string,
+	phases: TodoPhase[] | undefined,
+	error: string | null,
+): ToolResultMessage {
+	return {
+		role: "toolResult",
+		toolCallId,
+		toolName: "todo",
+		content: [
+			{ type: "text", text: error ?? (phases ? formatTodoSyncSummary(phases) : "Todo snapshot not mirrored") },
+		],
+		details: phases ? { phases, storage: "session" } : undefined,
+		isError: error !== null,
+		timestamp: Date.now(),
+	};
+}
+
 export class CursorExecHandlers implements ICursorExecHandlers {
 	constructor(private options: CursorExecBridgeOptions) {}
 
@@ -341,6 +401,99 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		return toolResultMessage;
 	}
 
+	/**
+	 * Settle a completed native Cursor todo call, mirroring its list when the
+	 * server supplied an authoritative one.
+	 *
+	 * Cursor's snapshot is a flat list, so tasks already known locally keep
+	 * their phase and only their status is updated; unknown tasks land in a
+	 * single fallback phase. Statuses come straight from the server snapshot —
+	 * no local normalization, or an all-pending remote list would gain a
+	 * phantom in-progress task the remote list does not have.
+	 *
+	 * The snapshot is also persisted to the session branch. Every other
+	 * provider's todo state survives a reload because `todo` runs locally and
+	 * its `toolResult` (carrying `details.phases`) lands in the branch, which
+	 * `#syncTodoPhasesFromBranch` replays. Cursor resolves the tool remotely and
+	 * emits no such result, so without an explicit entry the list is in-memory
+	 * only and every reload, rewind, compaction, or session switch drops it.
+	 *
+	 * This ALWAYS settles the call and returns the result to persist, even when
+	 * nothing is mirrored. Two reasons it cannot bail out early:
+	 *
+	 * - the interactive card leaves `pendingTools` only on a matching
+	 *   `tool_execution_end`, so staying silent leaves it animating forever;
+	 * - an unpaired `toolCall` is stripped as dangling by `buildSessionContext`,
+	 *   erasing the interaction from every rebuilt transcript.
+	 *
+	 * A `null` snapshot means nothing may be mirrored — a server `error`, or a
+	 * benign refusal: a filtered, truncated, or empty read, or a snapshot the
+	 * local model cannot represent. Local state is left untouched, and the result
+	 * carries no `details` (text `"Todo snapshot not mirrored"`): `event-controller`
+	 * feeds `details.phases` straight into `setTodos`, so echoing the current list
+	 * back would let a call that changed nothing overwrite live UI state.
+	 */
+	todoSync(snapshot: CursorTodoSnapshot | null, toolCallId: string, error: string | null = null): ToolResultMessage {
+		const setPhases = this.options.setTodoPhases;
+		const existing = this.options.getTodoPhases?.() ?? [];
+
+		// Mirroring is gated on having both a snapshot and somewhere to put it.
+		// Settling the call is NOT: the interactive card leaves `pendingTools`
+		// only on a matching `tool_execution_end`, so a refusal, a server error,
+		// or a host with no local todo state must still resolve it.
+		let phases: TodoPhase[] | undefined;
+		if (snapshot && setPhases) {
+			const phaseByContent = new Map<string, string>();
+			for (const phase of existing) {
+				for (const task of phase.tasks) phaseByContent.set(task.content, phase.name);
+			}
+
+			const grouped = new Map<string, TodoPhase["tasks"]>();
+			for (const todo of snapshot.todos) {
+				const name = phaseByContent.get(todo.content) ?? CURSOR_TODO_PHASE;
+				let tasks = grouped.get(name);
+				if (!tasks) {
+					tasks = [];
+					grouped.set(name, tasks);
+				}
+				tasks.push({ content: todo.content, status: todo.status as TodoStatus });
+			}
+
+			// Preserve the local phase order; phases new to this snapshot append.
+			const next: TodoPhase[] = [];
+			for (const phase of existing) {
+				const tasks = grouped.get(phase.name);
+				if (!tasks) continue;
+				next.push({ name: phase.name, tasks });
+				grouped.delete(phase.name);
+			}
+			for (const [name, tasks] of grouped) next.push({ name, tasks });
+			setPhases(next);
+			this.options.persistTodoPhases?.(next);
+			phases = next;
+		}
+
+		const result = buildTodoSyncResult(toolCallId, phases, error);
+		// This completion is emitted synchronously mid-parse, while the streamed
+		// `toolcall_start` that creates the visible card rides
+		// `AssistantMessageEventStream` and lands a microtask later. When Cursor
+		// packs start and completion into one HTTP/2 chunk the completion arrives
+		// first; the interactive controller holds it as an orphan and replays it
+		// once the streamed block creates the card (`event-controller.ts`,
+		// `#orphanedToolCompletions`). Emitting a synthetic `tool_execution_start`
+		// here instead was measured and rejected: settling deletes the pending
+		// entry, and the next cumulative `message_update` re-creates the card —
+		// one settled card plus one stuck forever.
+		this.options.emitEvent?.({
+			type: "tool_execution_end",
+			toolCallId,
+			toolName: "todo",
+			result: { content: result.content, details: result.details },
+			isError: error !== null,
+		});
+		return result;
+	}
+
 	async mcp(call: CursorMcpCall) {
 		const toolName = call.toolName || call.name;
 		const toolCallId = decodeToolCallId(call.toolCallId);

package/src/dap/session.ts

@@ -960,16 +960,50 @@ export class DapSessionManager {
 		signal?: AbortSignal,
 		timeoutMs: number = 30_000,
 	): Promise<{ snapshot: DapSessionSummary; threads: DapThread[] }> {
-		const session = this.#touchActiveSession();
-		const response = await this.#sendRequestWithConfig<DapThreadsResponse>(
-			session,
-			"threads",
-			undefined,
-			signal,
-			timeoutMs,
-		);
-		session.threads = response?.threads ?? [];
-		return { snapshot: buildSummary(session), threads: session.threads };
+		const anchor = this.#touchActiveSession();
+		// A js-debug launch is a session tree: the root may be a threadless
+		// launcher while each real thread lives in a child (main script,
+		// `[worker N]`, …), and other adapters keep every thread on the root.
+		// Querying only the active session would surface just one session's
+		// threads, so aggregate across the whole live tree. No topology guess:
+		// a threadless launcher simply returns no threads (or an error we skip).
+		const targets = this.#liveTreeSessions(anchor);
+		const merged: DapThread[] = [];
+		const seen = new Set<string>();
+		for (const target of targets) {
+			let threads: DapThread[];
+			try {
+				const response = await this.#sendRequestWithConfig<DapThreadsResponse>(
+					target,
+					"threads",
+					undefined,
+					signal,
+					timeoutMs,
+				);
+				threads = response?.threads ?? [];
+			} catch (error) {
+				// Caller cancellation is not an adapter failure: propagate it instead
+				// of degrading a cancelled call into a successful partial result.
+				if (signal?.aborted) throw error;
+				logger.warn("Failed to list threads for debug session", {
+					sessionId: target.id,
+					error: toErrorMessage(error),
+				});
+				continue;
+			}
+			target.threads = threads;
+			// DAP thread IDs are scoped per client session, so identical IDs from
+			// different sessions (e.g. two identical worker scripts) are distinct
+			// live threads and MUST be preserved; only collapse an exact repeat
+			// within a single session's response.
+			for (const thread of threads) {
+				const key = `${target.id}\0${thread.id}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				merged.push(thread);
+			}
+		}
+		return { snapshot: buildSummary(anchor), threads: merged };
 	}
 
 	async stackTrace(
@@ -1371,7 +1405,13 @@ export class DapSessionManager {
 		if (parentSessionId) {
 			this.#sessions.get(parentSessionId)?.childSessionIds.add(session.id);
 		}
-		this.#activeSessionId = session.id;
+		// Focus follows stops, not registrations: a lazily-attached child (e.g. a
+		// js-debug `[worker N]` session) must not steal focus from a sibling that
+		// is already stopped at a breakpoint / entry. Only claim focus when no
+		// live, stopped session currently holds it.
+		if (!this.#hasLiveStoppedActiveSession()) {
+			this.#activeSessionId = session.id;
+		}
 		const heartbeat = setInterval(() => {
 			if (!client.isAlive()) {
 				session.status = "terminated";
@@ -1696,6 +1736,12 @@ export class DapSessionManager {
 		return session;
 	}
 
+	/** True when the current active session is live and paused at a stop. */
+	#hasLiveStoppedActiveSession(): boolean {
+		const active = this.#getActiveSessionOrNull();
+		return active !== null && active.status === "stopped" && active.client.isAlive();
+	}
+
 	#getActiveSessionOrThrow(): DapSession {
 		const session = this.#getActiveSessionOrNull();
 		if (!session) {
@@ -1729,6 +1775,19 @@ export class DapSessionManager {
 		return sessions;
 	}
 
+	/**
+	 * Live (non-terminated, connected) sessions in `session`'s tree, or the
+	 * session itself when the tree has collapsed. Used to fan `threads` out
+	 * across the whole tree; a threadless session just reports no threads, so
+	 * this makes no assumption about which node owns them.
+	 */
+	#liveTreeSessions(session: DapSession): DapSession[] {
+		const live = this.#getTreeSessions(session).filter(
+			candidate => candidate.status !== "terminated" && candidate.client.isAlive(),
+		);
+		return live.length > 0 ? live : [session];
+	}
+
 	#touchSessionAndAncestors(session: DapSession): void {
 		const now = Date.now();
 		let current: DapSession | undefined = session;

package/src/eval/__tests__/js-context-manager.test.ts

@@ -426,10 +426,18 @@ describe.skipIf(process.platform === "win32")("JavaScript eval process isolation
 		expect(result.output.trim()).toBe("42");
 	});
 
-	it("keeps the isolated process alive after a stackless floated rejection", async () => {
+	it("keeps the isolated process alive after handled and stackless floated rejections", async () => {
 		using tempDir = TempDir.createSync("@omp-js-process-rejection-");
 		const session = makeSession(tempDir.path());
 		const evalSessionId = `js-rejection:${crypto.randomUUID()}`;
+		const handled = await executeJs('await Promise.reject("handled rejection").catch(() => undefined); return 42;', {
+			cwd: tempDir.path(),
+			sessionId: evalSessionId,
+			session,
+		});
+		expect(handled.exitCode).toBe(0);
+		expect(handled.output.trim()).toBe("42");
+
 		const rejected = await executeJs(
 			'var savedAfterRejection = 41; Promise.reject("stackless rejection"); await Bun.sleep(10);',
 			{ cwd: tempDir.path(), sessionId: evalSessionId, session },

package/src/eval/__tests__/process-entry-import.test.ts

@@ -1,8 +1,9 @@
 import { expect, it } from "bun:test";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import { TempDir } from "@oh-my-pi/pi-utils";
 
-it("imports the JS process entry without loading dotenv before profile bootstrap", async () => {
+it("imports the CLI entry graph without loading dotenv before profile bootstrap", async () => {
 	using tempDir = TempDir.createSync("@omp-js-process-import-");
 	await Bun.write(path.join(tempDir.path(), ".env"), "OMP_PROCESS_ENTRY_ENV_PROBE=loaded-too-early\n");
 	const env = Object.fromEntries(
@@ -25,3 +26,112 @@ it("imports the JS process entry without loading dotenv before profile bootstrap
 	expect(stdout).toBe("");
 	expect(stderr).toBe("");
 });
+
+async function pingComputerWorker(
+	entry: string,
+	id: string,
+	argv: string[] = ["__omp_worker_computer"],
+): Promise<unknown> {
+	const worker = new Worker(entry, {
+		type: "module",
+		argv,
+	});
+	const response = Promise.withResolvers<unknown>();
+	worker.addEventListener("message", event => response.resolve(event.data));
+	worker.addEventListener("error", event => response.reject(event.error ?? new Error(event.message)));
+	worker.postMessage({ type: "ping", id });
+	try {
+		return await response.promise;
+	} finally {
+		worker.terminate();
+	}
+}
+
+it("starts ordinary CLI paths without loading the native computer addon", async () => {
+	const cliPath = path.resolve(import.meta.dir, "../../cli.ts");
+	for (const args of [
+		["--no-addons", cliPath, "--version"],
+		[cliPath, "--help"],
+	]) {
+		const proc = Bun.spawn([process.execPath, ...args], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const [exitCode, stderr] = await Promise.all([proc.exited, new Response(proc.stderr).text()]);
+		expect(exitCode, `${args.at(-1)}: ${stderr}`).toBe(0);
+	}
+});
+
+it("dispatches the computer worker through the CLI host selector in a child process", async () => {
+	const fixture = path.resolve(import.meta.dir, "../../../test/fixtures/computer-worker-cli-selector.ts");
+	const proc = Bun.spawn([process.execPath, "--no-addons", fixture], {
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [exitCode, stdout, stderr] = await Promise.all([
+		proc.exited,
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
+	expect(exitCode, stderr).toBe(0);
+	expect(stdout).toBe('{"type":"pong","id":"computer-cli-selector"}\n');
+});
+
+it("loads the computer worker module directly outside a declared CLI host", async () => {
+	const entry = new URL("../../tools/computer/worker-entry.ts", import.meta.url).href;
+	const response = await pingComputerWorker(entry, "computer-direct-module", []);
+	expect(response).toEqual({ type: "pong", id: "computer-direct-module" });
+});
+
+it("dispatches the computer worker from a single npm-style host bundle", async () => {
+	const packageDir = path.resolve(import.meta.dir, "../../..");
+	const outDir = fs.mkdtempSync(path.join(packageDir, ".computer-worker-bundle-"));
+	try {
+		const output = await Bun.build({
+			entrypoints: [path.join(packageDir, "test/fixtures/computer-worker-bundled-host.ts")],
+			outdir: outDir,
+			naming: "cli.js",
+			target: "bun",
+			external: ["@oh-my-pi/pi-natives"],
+			define: { "process.env.PI_BUNDLED": JSON.stringify("true") },
+			throw: false,
+		});
+		expect(output.logs).toEqual([]);
+		expect(output.outputs.map(file => path.basename(file.path))).toEqual(["cli.js"]);
+		const response = await pingComputerWorker(output.outputs[0]!.path, "computer-npm-bundle");
+		expect(response).toEqual({ type: "pong", id: "computer-npm-bundle" });
+	} finally {
+		fs.rmSync(outDir, { recursive: true, force: true });
+	}
+});
+
+it("keeps non-computer selectors isolated in a compiled single-entry worker host", async () => {
+	using tempDir = TempDir.createSync("@omp-compiled-worker-selector-");
+	const packageDir = path.resolve(import.meta.dir, "../../..");
+	const outfile = path.join(tempDir.path(), process.platform === "win32" ? "worker-host.exe" : "worker-host");
+	const build = Bun.spawn(
+		[
+			process.execPath,
+			"build",
+			"--compile",
+			"--target=bun",
+			`--outfile=${outfile}`,
+			path.join(packageDir, "test/fixtures/compiled-worker-selector-host.ts"),
+		],
+		{ cwd: packageDir, stdout: "pipe", stderr: "pipe" },
+	);
+	const [buildExitCode, buildStderr] = await Promise.all([build.exited, new Response(build.stderr).text()]);
+	expect(buildExitCode, buildStderr).toBe(0);
+	const proc = Bun.spawn([outfile], {
+		cwd: packageDir,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [exitCode, stdout, stderr] = await Promise.all([
+		proc.exited,
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
+	expect(exitCode, stderr).toBe(0);
+	expect(stdout).toBe('{"ok":true,"kind":"pong"}\n');
+});

package/src/eval/js/process-entry.ts

@@ -1,11 +1,14 @@
-import { WorkerCore } from "./worker-core";
+import { type RejectionInterceptor, WorkerCore } from "./worker-core";
 import type { WorkerInbound, WorkerOutbound } from "./worker-protocol";
 
 /** Start the JavaScript evaluator inside a subprocess IPC transport. */
-export function startJsEvalProcess(transport: {
-	send(message: WorkerOutbound): void;
-	onMessage(handler: (message: WorkerInbound) => void): () => void;
-}): void {
+export function startJsEvalProcess(
+	transport: {
+		send(message: WorkerOutbound): void;
+		onMessage(handler: (message: WorkerInbound) => void): () => void;
+	},
+	interceptUnhandledRejections: RejectionInterceptor,
+): void {
 	new WorkerCore(
 		{
 			send: message => transport.send(message),
@@ -22,6 +25,7 @@ export function startJsEvalProcess(transport: {
 			// the project instead of the install dir. Worker threads cannot pass
 			// this — `process.chdir` is unavailable there.
 			chdir: cwd => process.chdir(cwd),
+			interceptUnhandledRejections,
 		},
 	);
 }