@oh-my-pi/pi-coding-agent 16.5.0 → 16.5.1

package/src/config/model-registry.ts

@@ -258,7 +258,7 @@ export interface ProviderDiscoveryState {
 	error?: string;
 }
 
-/** Result of loading custom models from models.json */
+/** Result of loading custom models config. */
 interface CustomModelsResult {
 	models?: CustomModelOverlay[];
 	overrides?: Map<string, ProviderOverride>;
@@ -309,7 +309,7 @@ interface CommandApiKeyResolution {
 	value?: string;
 }
 /**
- * Resolve a models.yml secret/config value to an actual value.
+ * Resolve a models.yml/models.yaml secret/config value to an actual value.
  * `!cmd` runs a shell command and returns trimmed stdout, otherwise env vars are
  * checked first and the input falls back to a literal value.
  */
@@ -822,7 +822,7 @@ export class ModelRegistry {
 	}
 
 	/**
-	 * Reload models from disk (built-in + custom from models.json).
+	 * Reload models from disk (built-in + custom config).
 	 */
 	async refresh(strategy: ModelRefreshStrategy = "online-if-uncached"): Promise<void> {
 		this.#reloadStaticModels();
@@ -938,7 +938,7 @@ export class ModelRegistry {
 	#reloadStaticModels(): void {
 		const currentMtime = this.#modelsConfigFile.getMtimeMs();
 		if (currentMtime !== null && currentMtime === this.#lastStaticLoadMtime) {
-			// models.json unchanged since last load; reloading would be redundant.
+			// Models config unchanged since last load; reloading would be redundant.
 			return;
 		}
 		this.#modelsConfigFile.invalidate();
@@ -962,14 +962,14 @@ export class ModelRegistry {
 	}
 
 	/**
-	 * Get any error from loading models.json (undefined if no error).
+	 * Get any error from loading custom models config (undefined if no error).
 	 */
 	getError(): ConfigError | undefined {
 		return this.#configError;
 	}
 
 	#loadModels() {
-		// Load custom models from models.json first (to know which providers to override)
+		// Load custom config first (to know which providers to override).
 		const {
 			models: customModels = [],
 			overrides = new Map(),
@@ -1909,7 +1909,7 @@ export class ModelRegistry {
 
 	/**
 	 * Get all models (built-in + custom).
-	 * If models.json had errors, returns only built-in models.
+	 * If custom config had errors, returns only built-in models.
 	 */
 	getAll(): Model<Api>[] {
 		return this.#models;

package/src/config/model-resolver.ts

@@ -1209,20 +1209,27 @@ export function resolveModelOverride(
 	modelPatterns: string[],
 	modelRegistry: ModelLookupRegistry,
 	settings?: Settings,
-): { model?: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel; explicitThinkingLevel: boolean } {
+): { model?: Model<Api>; thinkingLevel?: ConfiguredThinkingLevel; explicitThinkingLevel: boolean; warning?: string } {
 	if (modelPatterns.length === 0) return { explicitThinkingLevel: false };
 	const availableModels = modelRegistry.getAvailable();
 	const matchPreferences = getModelMatchPreferences(settings);
+	let warning: string | undefined;
 	for (const pattern of modelPatterns) {
-		const { model, thinkingLevel, explicitThinkingLevel } = resolveModelRoleValue(pattern, availableModels, {
+		const {
+			model,
+			thinkingLevel,
+			explicitThinkingLevel,
+			warning: patternWarning,
+		} = resolveModelRoleValue(pattern, availableModels, {
 			settings,
 			matchPreferences,
 		});
 		if (model) {
-			return { model, thinkingLevel, explicitThinkingLevel };
+			return { model, thinkingLevel, explicitThinkingLevel, warning: patternWarning };
 		}
+		if (!warning && patternWarning) warning = patternWarning;
 	}
-	return { explicitThinkingLevel: false };
+	return { explicitThinkingLevel: false, warning };
 }
 
 /**
@@ -1236,6 +1243,11 @@ export function resolveModelOverride(
  * `modelRoles.task` pointing at an unqualified id whose only available
  * provider variant has no configured credentials — see #985).
  *
+ * `sessionId` is forwarded to `getApiKey` so that session-sticky OAuth
+ * credentials resolve correctly during the pre-flight auth check. Without it,
+ * providers with multiple OAuth accounts may return `undefined` even though
+ * the credential is usable once the subagent session starts — see #5325.
+ *
  * Keyless-by-design providers (llama.cpp, ollama, lm-studio) advertise the
  * `kNoAuth` sentinel from `getApiKey` to signal that they do not require
  * credentials. Those are treated as authenticated here so an explicitly
@@ -1251,18 +1263,20 @@ export async function resolveModelOverrideWithAuthFallback(
 	parentActiveModelPattern: string | undefined,
 	modelRegistry: ModelLookupRegistry & Pick<ModelRegistry, "getApiKey">,
 	settings?: Settings,
+	sessionId?: string,
 ): Promise<{
 	model?: Model<Api>;
 	thinkingLevel?: ConfiguredThinkingLevel;
 	explicitThinkingLevel: boolean;
 	authFallbackUsed: boolean;
+	warning?: string;
 }> {
 	const primary = resolveModelOverride(modelPatterns, modelRegistry, settings);
 	if (!primary.model || !parentActiveModelPattern) {
 		return { ...primary, authFallbackUsed: false };
 	}
 
-	const primaryKey = await modelRegistry.getApiKey(primary.model);
+	const primaryKey = await modelRegistry.getApiKey(primary.model, sessionId);
 	if (primaryKey === kNoAuth || isAuthenticated(primaryKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}
@@ -1274,12 +1288,12 @@ export async function resolveModelOverrideWithAuthFallback(
 	if (modelsAreEqual(fallback.model, primary.model)) {
 		return { ...primary, authFallbackUsed: false };
 	}
-	const fallbackKey = await modelRegistry.getApiKey(fallback.model);
+	const fallbackKey = await modelRegistry.getApiKey(fallback.model, sessionId);
 	if (!isAuthenticated(fallbackKey)) {
 		return { ...primary, authFallbackUsed: false };
 	}
 
-	return { ...fallback, authFallbackUsed: true };
+	return { ...fallback, authFallbackUsed: true, warning: primary.warning ?? fallback.warning };
 }
 
 /**

package/src/config/models-config.ts

@@ -1,5 +1,5 @@
 /**
- * models.json config file handle and provider configuration validation.
+ * Custom model/provider config file handle and validation.
  */
 
 import type { Api, ModelSpec } from "@oh-my-pi/pi-ai/types";

package/src/eval/__tests__/agent-bridge.test.ts

@@ -603,21 +603,22 @@ describe("agent() through eval runtimes", () => {
 		});
 		const { session, sessionFile, sessionId } = makeEvalSession(tempDir, "py-agent-interrupt", settings);
 		mockAgents();
-		// Subagents that ignore the abort for far longer than the kernel's SIGINT
-		// escalation window. Each kernel worker thread blocks in a synchronous
-		// `urllib` bridge call, joined by `parallel()`'s ThreadPoolExecutor exit.
-		// The host must respond the instant the cell aborts so the kernel can
-		// unwind via KeyboardInterrupt instead of being hard-killed (which used to
-		// surface "[kernel] Python kernel shutdown" and lose all session state).
+		// Each kernel worker thread blocks in a synchronous `urllib` bridge call,
+		// joined by `parallel()`'s ThreadPoolExecutor exit. The host must keep
+		// those already-started calls attached until they settle, then interrupt
+		// the kernel before `parallel()` launches another wave.
 		let inFlight = 0;
+		let completed = 0;
 		let markSaturated: (() => void) | undefined;
 		const saturated = new Promise<void>(resolve => {
 			markSaturated = resolve;
 		});
-		vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
+		const releaseAgents = Promise.withResolvers<void>();
+		const runSpy = vi.spyOn(taskExecutor, "runSubprocess").mockImplementation(async options => {
 			// task.maxConcurrency=6 → six bridge calls block at once; signal then.
 			if (++inFlight >= 6) markSaturated?.();
-			await Bun.sleep(9000); // deliberately ignores options.signal
+			await releaseAgents.promise;
+			completed++;
 			return singleResult(options, { output: options.assignment ?? "" });
 		});
 
@@ -640,8 +641,7 @@ describe("agent() through eval runtimes", () => {
 		// bridge calls (condition-driven) instead of waiting a fixed wall second.
 		void saturated.then(() => ac.abort(new Error("external interrupt")));
 
-		const start = Date.now();
-		const result = await executePython(
+		const resultPromise = executePython(
 			"import json\nprint(json.dumps(parallel([lambda n=n: agent(str(n)) for n in range(12)])))",
 			{
 				cwd: tempDir.path(),
@@ -653,13 +653,18 @@ describe("agent() through eval runtimes", () => {
 				signal: ac.signal,
 			},
 		);
-		const elapsed = Date.now() - start;
+		await saturated;
+		await Promise.resolve();
+		expect(completed).toBe(0);
+		releaseAgents.resolve();
+		const result = await resultPromise;
 
-		// Cancelled, but cleanly: no hard-kill, settled well within the kernel's 5s
-		// SIGINT escalation window rather than ~6s after it.
+		// Cancelled, but cleanly: no hard-kill, no orphaned bridge calls, and no
+		// second fan-out wave started after the deferred abort was delivered.
 		expect(result.cancelled).toBe(true);
 		expect(result.output).not.toContain("Python kernel shutdown");
-		expect(elapsed).toBeLessThan(4000);
+		expect(completed).toBe(6);
+		expect(runSpy).toHaveBeenCalledTimes(6);
 
 		// The persistent kernel survived the interrupt: prior state is intact.
 		const after = await executePython("print(PREP_MARKER)", {

package/src/eval/__tests__/bridge-timeout.test.ts

@@ -5,7 +5,9 @@ import {
 	isEvalTimeoutControlEvent,
 	withBridgeTimeoutPause,
 } from "../bridge-timeout";
+import { executeWithKernelBase, type GenericKernel } from "../executor-base";
 import type { JsStatusEvent } from "../js/shared/types";
+import type { KernelDisplayOutput } from "../py/display";
 
 describe("withBridgeTimeoutPause", () => {
 	it("emits one pause before the operation and one resume after it settles", async () => {
@@ -17,10 +19,12 @@ describe("withBridgeTimeoutPause", () => {
 				await Bun.sleep(80);
 				return "done";
 			},
+			{ deferExternalAbort: true },
 		);
 
 		expect(value).toBe("done");
 		expect(events.map(event => event.op)).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP]);
+		expect(events.every(event => event.deferExternalAbort === true)).toBe(true);
 
 		const settledCount = events.length;
 		await Bun.sleep(40);
@@ -62,3 +66,105 @@ describe("withBridgeTimeoutPause", () => {
 		expect(isEvalTimeoutControlEvent({ op: "agent", id: "subagent-1" })).toBe(false);
 	});
 });
+
+class TestCancelledError extends Error {
+	readonly timedOut: boolean;
+
+	constructor(timedOut: boolean) {
+		super(timedOut ? "timed out" : "cancelled");
+		this.name = "TestCancelledError";
+		this.timedOut = timedOut;
+	}
+}
+
+it("defers external aborts until an in-flight agent bridge call resumes", async () => {
+	const abortController = new AbortController();
+	const entered = Promise.withResolvers<void>();
+	const triggerAbort = Promise.withResolvers<void>();
+	const observed = Promise.withResolvers<boolean>();
+	const release = Promise.withResolvers<void>();
+	const kernel: GenericKernel<Record<string, string | null>> = {
+		async execute(_code, options) {
+			entered.resolve();
+			await triggerAbort.promise;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_PAUSE_OP, deferExternalAbort: true },
+			} satisfies KernelDisplayOutput);
+			abortController.abort(new Error("external interrupt"));
+			observed.resolve(options.signal?.aborted ?? false);
+			await release.promise;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_RESUME_OP, deferExternalAbort: true },
+			} satisfies KernelDisplayOutput);
+			return { status: "ok", cancelled: false, timedOut: false };
+		},
+	};
+
+	const resultPromise = executeWithKernelBase({
+		kernel,
+		code: "agent('slow')",
+		options: { signal: abortController.signal },
+		runIdPrefix: "test",
+		errorLogLabel: "test",
+		cancelledErrorClass: TestCancelledError,
+		buildKernelEnvPatch: () => ({}),
+		formatKernelTimeoutAnnotation: () => "kernel timed out",
+		formatTimeoutAnnotation: () => "timed out",
+	});
+
+	await entered.promise;
+	triggerAbort.resolve();
+	expect(await observed.promise).toBe(false);
+	release.resolve();
+	const result = await resultPromise;
+	expect(result.cancelled).toBe(true);
+	expect(result.exitCode).toBeUndefined();
+});
+
+it("does not defer external aborts for a completion bridge call", async () => {
+	const abortController = new AbortController();
+	const entered = Promise.withResolvers<void>();
+	const triggerAbort = Promise.withResolvers<void>();
+	const observed = Promise.withResolvers<boolean>();
+	const release = Promise.withResolvers<void>();
+	const kernel: GenericKernel<Record<string, string | null>> = {
+		async execute(_code, options) {
+			entered.resolve();
+			await triggerAbort.promise;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_PAUSE_OP },
+			} satisfies KernelDisplayOutput);
+			abortController.abort(new Error("external interrupt"));
+			observed.resolve(options.signal?.aborted ?? false);
+			await release.promise;
+			options.onDisplay({
+				type: "status",
+				event: { op: EVAL_TIMEOUT_RESUME_OP },
+			} satisfies KernelDisplayOutput);
+			return { status: "ok", cancelled: false, timedOut: false };
+		},
+	};
+
+	const resultPromise = executeWithKernelBase({
+		kernel,
+		code: "completion('slow')",
+		options: { signal: abortController.signal },
+		runIdPrefix: "test",
+		errorLogLabel: "test",
+		cancelledErrorClass: TestCancelledError,
+		buildKernelEnvPatch: () => ({}),
+		formatKernelTimeoutAnnotation: () => "kernel timed out",
+		formatTimeoutAnnotation: () => "timed out",
+	});
+
+	await entered.promise;
+	triggerAbort.resolve();
+	expect(await observed.promise).toBe(true);
+	release.resolve();
+	const result = await resultPromise;
+	expect(result.cancelled).toBe(true);
+	expect(result.exitCode).toBeUndefined();
+});

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

@@ -1,8 +1,14 @@
 import { afterEach, beforeEach, describe, 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";
 import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
-import { disposeAllVmContexts, setWorkerCloseTimeoutMsForTests } from "../js/context-manager";
+import {
+	disposeAllVmContexts,
+	setJsEvalWorkerThreadForTests,
+	setWorkerCloseTimeoutMsForTests,
+} from "../js/context-manager";
 import { executeJs } from "../js/executor";
 
 const originalWorker = globalThis.Worker;
@@ -181,7 +187,9 @@ function installFakeWorker(stats: FakeWorkerStats, behavior: FakeWorkerBehavior)
 
 describe("JavaScript eval worker lifecycle", () => {
 	let restoreCloseTimeoutMs = 0;
+	let restoreWorkerThread = false;
 	beforeEach(() => {
+		restoreWorkerThread = setJsEvalWorkerThreadForTests(true);
 		// Shrink the graceful-close grace period so the "close acked but the worker
 		// never exits -> force terminate" contract is proven without a real 1s wait.
 		restoreCloseTimeoutMs = setWorkerCloseTimeoutMsForTests(1);
@@ -197,6 +205,7 @@ describe("JavaScript eval worker lifecycle", () => {
 			writable: true,
 			value: originalWorker,
 		});
+		setJsEvalWorkerThreadForTests(restoreWorkerThread);
 	});
 
 	it("exits a real worker on graceful close even with ref'ed user handles", async () => {
@@ -271,6 +280,73 @@ describe("JavaScript eval worker lifecycle", () => {
 		expect(stats.terminateCalls).toBe(1);
 	});
 
+	it("falls back to a Bun Worker when the subprocess cannot spawn", async () => {
+		using tempDir = TempDir.createSync("@omp-js-spawn-fallback-");
+		// Exercise the production ladder (process -> worker -> inline), not the
+		// worker-thread test seam the surrounding describe enables.
+		setJsEvalWorkerThreadForTests(false);
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: true });
+		const originalSpawn = Bun.spawn;
+		let spawnAttempts = 0;
+		Bun.spawn = ((): never => {
+			spawnAttempts++;
+			throw new Error("subprocess spawn unavailable");
+		}) as unknown as typeof Bun.spawn;
+
+		try {
+			const session = makeSession(tempDir.path());
+			const sessionId = `js-spawn-fallback:${crypto.randomUUID()}`;
+			// The fake Worker settles runs without executing the cell, so an empty
+			// output proves the middle rung handled it — the inline fallback would
+			// have actually evaluated the expression and printed 42.
+			const result = await executeJs("return String(6 * 7);", { cwd: tempDir.path(), sessionId, session });
+			expect(result.exitCode).toBe(0);
+			expect(result.output.trim()).toBe("");
+			expect(spawnAttempts).toBe(1);
+		} finally {
+			Bun.spawn = originalSpawn;
+		}
+	});
+
+	it("falls back to a Bun Worker when the subprocess fails during initialization", async () => {
+		using tempDir = TempDir.createSync("@omp-js-init-fallback-");
+		// Exercise the production ladder (process -> worker -> inline), not the
+		// worker-thread test seam the surrounding describe enables.
+		setJsEvalWorkerThreadForTests(false);
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: true });
+		const originalSpawn = Bun.spawn;
+		let spawnAttempts = 0;
+		Bun.spawn = ((options: unknown) => {
+			spawnAttempts++;
+			const spawnOptions = options as {
+				onExit?: (proc: unknown, exitCode: number | null, signalCode: string | null) => void;
+			};
+			const fakeProcess = {
+				send: () => undefined,
+				kill: () => undefined,
+				unref: () => undefined,
+			};
+			queueMicrotask(() => spawnOptions.onExit?.(fakeProcess, 1, null));
+			return fakeProcess;
+		}) as unknown as typeof Bun.spawn;
+
+		try {
+			const session = makeSession(tempDir.path());
+			const sessionId = `js-init-fallback:${crypto.randomUUID()}`;
+			// The fake Worker settles runs without executing the cell, so empty
+			// output proves the middle rung handled the retry. Inline execution
+			// would evaluate the expression and print 42.
+			const result = await executeJs("return String(6 * 7);", { cwd: tempDir.path(), sessionId, session });
+			expect(result.exitCode).toBe(0);
+			expect(result.output.trim()).toBe("");
+			expect(spawnAttempts).toBe(1);
+		} finally {
+			Bun.spawn = originalSpawn;
+		}
+	});
+
 	it("falls back to the inline worker when the spawned worker errors during startup", async () => {
 		using tempDir = TempDir.createSync("@omp-js-worker-error-");
 		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
@@ -289,3 +365,84 @@ describe("JavaScript eval worker lifecycle", () => {
 		expect(stats.terminateCalls).toBe(1);
 	});
 });
+
+describe.skipIf(process.platform === "win32")("JavaScript eval process isolation", () => {
+	afterEach(async () => {
+		await disposeAllVmContexts();
+	});
+
+	it("runs spawned commands in the isolated POSIX process group", async () => {
+		using tempDir = TempDir.createSync("@omp-js-process-isolation-");
+		const session = makeSession(tempDir.path());
+		const evalSessionId = `js-isolation:${crypto.randomUUID()}`;
+		const result = await executeJs(
+			[
+				`const child = Bun.spawn(["/bin/sh", "-c", 'pgid=$(ps -o pgid= -p $$); printf "%s %s\\n" "$pgid" "$PPID"'], { stdout: "pipe" });`,
+				"return await new Response(child.stdout).text();",
+			].join("\n"),
+			{ cwd: tempDir.path(), sessionId: evalSessionId, session },
+		);
+		const [processGroupId, parentProcessId] = result.output.trim().split(/\s+/).map(Number);
+		expect(parentProcessId).not.toBe(process.pid);
+		expect(processGroupId).toBe(parentProcessId);
+
+		await executeJs("var saved = 41; function increment(value) { return value + 1; }", {
+			cwd: tempDir.path(),
+			sessionId: evalSessionId,
+			session,
+		});
+		const reused = await executeJs("return increment(saved);", {
+			cwd: tempDir.path(),
+			sessionId: evalSessionId,
+			session,
+		});
+		expect(reused.output.trim()).toBe("42");
+	});
+
+	it("mirrors the session cwd onto the subprocess's real cwd", async () => {
+		using tempDir = TempDir.createSync("@omp-js-process-cwd-");
+		const session = makeSession(tempDir.path());
+		const evalSessionId = `js-cwd:${crypto.randomUUID()}`;
+		const result = await executeJs("return process.cwd();", {
+			cwd: tempDir.path(),
+			sessionId: evalSessionId,
+			session,
+		});
+		// process.chdir resolves symlinks (macOS tempdirs live under /var ->
+		// /private/var), so compare physical paths.
+		expect(result.output.trim()).toBe(fs.realpathSync(tempDir.path()));
+	});
+
+	it("still runs cells when the session cwd does not exist", async () => {
+		using tempDir = TempDir.createSync("@omp-js-process-cwd-missing-");
+		const missingCwd = path.join(tempDir.path(), "deleted");
+		const session = makeSession(missingCwd);
+		const result = await executeJs("return String(6 * 7);", {
+			cwd: missingCwd,
+			sessionId: `js-cwd-missing:${crypto.randomUUID()}`,
+			session,
+		});
+		expect(result.exitCode).toBe(0);
+		expect(result.output.trim()).toBe("42");
+	});
+
+	it("keeps the isolated process alive after a stackless floated rejection", async () => {
+		using tempDir = TempDir.createSync("@omp-js-process-rejection-");
+		const session = makeSession(tempDir.path());
+		const evalSessionId = `js-rejection:${crypto.randomUUID()}`;
+		const rejected = await executeJs(
+			'var savedAfterRejection = 41; Promise.reject("stackless rejection"); await Bun.sleep(10);',
+			{ cwd: tempDir.path(), sessionId: evalSessionId, session },
+		);
+		expect(rejected.exitCode).toBe(1);
+		expect(rejected.output).toContain("Unhandled rejection (missing await?): stackless rejection");
+
+		const reused = await executeJs("return savedAfterRejection + 1;", {
+			cwd: tempDir.path(),
+			sessionId: evalSessionId,
+			session,
+		});
+		expect(reused.exitCode).toBe(0);
+		expect(reused.output.trim()).toBe("42");
+	});
+});

package/src/eval/__tests__/kernel-spawn.test.ts

@@ -3,9 +3,21 @@ import {
 	__resetWindowsConsoleProbeCache,
 	consoleAttachedViaTTY,
 	hostHasInheritableConsole,
+	shouldDetachKernel,
 	shouldHideKernelWindow,
 } from "../py/spawn-options";
 
+describe("shouldDetachKernel", () => {
+	it("starts POSIX kernels in a new session", () => {
+		expect(shouldDetachKernel("darwin")).toBe(true);
+		expect(shouldDetachKernel("linux")).toBe(true);
+	});
+
+	it("leaves Windows console inheritance to windowsHide", () => {
+		expect(shouldDetachKernel("win32")).toBe(false);
+	});
+});
+
 /**
  * `shouldHideKernelWindow` decides whether the long-lived Python kernel
  * subprocess is spawned with `windowsHide: true`. On Windows, Bun maps that

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

@@ -0,0 +1,27 @@
+import { expect, it } from "bun:test";
+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 () => {
+	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(
+		Object.entries(process.env).filter((entry): entry is [string, string] => typeof entry[1] === "string"),
+	);
+	delete env.OMP_PROCESS_ENTRY_ENV_PROBE;
+	env.HOME = tempDir.path();
+	const fixture = path.resolve(import.meta.dir, "../../../test/fixtures/js-process-entry-import.ts");
+	const proc = Bun.spawn([process.execPath, fixture], {
+		env,
+		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).toBe(0);
+	expect(stdout).toBe("");
+	expect(stderr).toBe("");
+});