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

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__/prelude-agent.test.ts

@@ -105,3 +105,23 @@ describe("eval js agent() handle", () => {
 		expect("branchName" in node).toBe(false);
 	});
 });
+
+describe("eval js read() URI delegation", () => {
+	it("appends line selectors to delegated URI paths", async () => {
+		const calls: Array<{ name: string; args: unknown }> = [];
+		const sandbox = loadPrelude(async (name, args) => {
+			calls.push({ name, args });
+			return { text: "resource contents" };
+		});
+
+		const result = await vm.runInContext(`read("mcp://server/resource", { offset: 10, limit: 5 })`, sandbox);
+
+		expect(result).toBe("resource contents");
+		expect(calls).toEqual([
+			{
+				name: "read",
+				args: { path: "mcp://server/resource:10-14" },
+			},
+		]);
+	});
+});

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("");
+});

package/src/eval/agent-bridge.ts

@@ -449,130 +449,135 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 	// runtime is parked waiting for the result, and the cell timeout must
 	// not abort us mid-cherry-pick or mid-nested-commit. The clock restarts
 	// only after we hand control back to the runtime.
-	const { result, mergeSummary, changesApplied } = await withBridgeTimeoutPause(options.emitStatus, async () => {
-		let isolationContext: IsolationContext | null = null;
-		if (isIsolated) {
-			try {
-				isolationContext = await prepareIsolationContext(options.session.cwd);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				throw new ToolError(`Isolated agent() execution requires a git repository. ${message}`);
-			}
-		}
-		const preferredBackend = isIsolated ? parseIsolationMode(isolationMode) : undefined;
-
-		const result = await (async () => {
-			if (!isolationContext) {
-				return taskExecutor.runSubprocess(baseRunOptions);
-			}
-			const taskStart = Date.now();
-			return runIsolatedSubprocess({
-				baseOptions: baseRunOptions,
-				context: isolationContext,
-				preferredBackend,
-				agentId: id,
-				mergeMode,
-				artifactsDir,
-				description: trimToUndefined(parsed.label),
-				buildCommitMessage,
-				buildFailureResult: err => {
+	const { result, mergeSummary, changesApplied } = await withBridgeTimeoutPause(
+		options.emitStatus,
+		async () => {
+			let isolationContext: IsolationContext | null = null;
+			if (isIsolated) {
+				try {
+					isolationContext = await prepareIsolationContext(options.session.cwd);
+				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
-					return {
-						index: 0,
-						id,
-						agent: effectiveAgent.name,
-						agentSource: effectiveAgent.source,
-						task: renderSubagentPrompt(assignment),
-						assignment,
-						description: trimToUndefined(parsed.label),
-						exitCode: 1,
-						output: "",
-						stderr: message,
-						truncated: false,
-						durationMs: Date.now() - taskStart,
-						tokens: 0,
-						requests: 0,
-						modelOverride,
-						error: message,
-					};
-				},
-			});
-		})();
-
-		if (result.exitCode !== 0 || result.error || result.aborted) {
-			const failureMessage = buildSubagentFailureMessage(agentName, result);
-			const recoveryHint = isIsolated ? await buildIsolationRecoveryHint(result, artifactsDir) : "";
-			throw new ToolError(`${failureMessage}${recoveryHint}`);
-		}
-
-		let mergeSummary = "";
-		let changesApplied: boolean | null = null;
-		if (isIsolated && isolationContext) {
-			if (applyChanges) {
-				const outcome = await mergeIsolatedChanges({
-					result,
-					repoRoot: isolationContext.repoRoot,
-					mergeMode,
-				});
-				mergeSummary = outcome.summary;
-				changesApplied = outcome.changesApplied;
-				if (outcome.changesApplied === false) {
-					const summaryText = outcome.summary.trim();
-					const recoveryHint = await buildIsolationRecoveryHint(result, artifactsDir);
-					throw new ToolError(
-						`agent() isolated apply failed for ${result.id}${summaryText ? `: ${summaryText}` : ""}${recoveryHint}`,
-					);
+					throw new ToolError(`Isolated agent() execution requires a git repository. ${message}`);
 				}
+			}
+			const preferredBackend = isIsolated ? parseIsolationMode(isolationMode) : undefined;
 
-				const nestedSummary = await applyEligibleNestedPatches({
-					result,
-					repoRoot: isolationContext.repoRoot,
+			const result = await (async () => {
+				if (!isolationContext) {
+					return taskExecutor.runSubprocess(baseRunOptions);
+				}
+				const taskStart = Date.now();
+				return runIsolatedSubprocess({
+					baseOptions: baseRunOptions,
+					context: isolationContext,
+					preferredBackend,
+					agentId: id,
 					mergeMode,
-					changesApplied: outcome.changesApplied,
-					mergedBranchForNestedPatches: outcome.mergedBranchForNestedPatches,
-					commitMessage: buildCommitMessage(),
+					artifactsDir,
+					description: trimToUndefined(parsed.label),
+					buildCommitMessage,
+					buildFailureResult: err => {
+						const message = err instanceof Error ? err.message : String(err);
+						return {
+							index: 0,
+							id,
+							agent: effectiveAgent.name,
+							agentSource: effectiveAgent.source,
+							task: renderSubagentPrompt(assignment),
+							assignment,
+							description: trimToUndefined(parsed.label),
+							exitCode: 1,
+							output: "",
+							stderr: message,
+							truncated: false,
+							durationMs: Date.now() - taskStart,
+							tokens: 0,
+							requests: 0,
+							modelOverride,
+							error: message,
+						};
+					},
 				});
-				mergeSummary += nestedSummary;
-				if (structured && nestedSummary.trim()) {
-					const recoveryHint = await buildIsolationRecoveryHint(
-						{ ...result, patchPath: undefined, branchName: undefined },
-						artifactsDir,
-					);
-					throw new ToolError(
-						`agent() isolated nested patch apply failed for ${result.id}: ${plainIsolationSummary(nestedSummary)}${recoveryHint}`,
-					);
-				}
-			} else if (result.branchName) {
-				mergeSummary = `\n\nIsolation: changes captured on branch \`${result.branchName}\` (apply=false). Not merged.`;
-			} else if (result.patchPath) {
-				mergeSummary = `\n\nIsolation: changes captured at \`${result.patchPath}\` (apply=false). Not applied.`;
-			} else {
-				const nestedPatches = result.nestedPatches ?? [];
-				if (nestedPatches.length > 0) {
-					mergeSummary = `\n\nIsolation: changes captured for ${nestedPatches.length} nested repositor${nestedPatches.length === 1 ? "y" : "ies"} (apply=false). Not applied.`;
+			})();
+
+			if (result.exitCode !== 0 || result.error || result.aborted) {
+				const failureMessage = buildSubagentFailureMessage(agentName, result);
+				const recoveryHint = isIsolated ? await buildIsolationRecoveryHint(result, artifactsDir) : "";
+				throw new ToolError(`${failureMessage}${recoveryHint}`);
+			}
+
+			let mergeSummary = "";
+			let changesApplied: boolean | null = null;
+			if (isIsolated && isolationContext) {
+				if (applyChanges) {
+					const outcome = await mergeIsolatedChanges({
+						result,
+						repoRoot: isolationContext.repoRoot,
+						mergeMode,
+					});
+					mergeSummary = outcome.summary;
+					changesApplied = outcome.changesApplied;
+					if (outcome.changesApplied === false) {
+						const summaryText = outcome.summary.trim();
+						const recoveryHint = await buildIsolationRecoveryHint(result, artifactsDir);
+						throw new ToolError(
+							`agent() isolated apply failed for ${result.id}${summaryText ? `: ${summaryText}` : ""}${recoveryHint}`,
+						);
+					}
+
+					const nestedSummary = await applyEligibleNestedPatches({
+						result,
+						repoRoot: isolationContext.repoRoot,
+						mergeMode,
+						changesApplied: outcome.changesApplied,
+						mergedBranchForNestedPatches: outcome.mergedBranchForNestedPatches,
+						commitMessage: buildCommitMessage(),
+					});
+					mergeSummary += nestedSummary;
+					if (structured && nestedSummary.trim()) {
+						const recoveryHint = await buildIsolationRecoveryHint(
+							{ ...result, patchPath: undefined, branchName: undefined },
+							artifactsDir,
+						);
+						throw new ToolError(
+							`agent() isolated nested patch apply failed for ${result.id}: ${plainIsolationSummary(nestedSummary)}${recoveryHint}`,
+						);
+					}
+				} else if (result.branchName) {
+					mergeSummary = `\n\nIsolation: changes captured on branch \`${result.branchName}\` (apply=false). Not merged.`;
+				} else if (result.patchPath) {
+					mergeSummary = `\n\nIsolation: changes captured at \`${result.patchPath}\` (apply=false). Not applied.`;
 				} else {
-					mergeSummary = "\n\nIsolation: no changes captured.";
+					const nestedPatches = result.nestedPatches ?? [];
+					if (nestedPatches.length > 0) {
+						mergeSummary = `\n\nIsolation: changes captured for ${nestedPatches.length} nested repositor${nestedPatches.length === 1 ? "y" : "ies"} (apply=false). Not applied.`;
+					} else {
+						mergeSummary = "\n\nIsolation: no changes captured.";
+					}
 				}
 			}
-		}
-
-		// Clean up the temp artifacts dir we created for this call only when the
-		// caller will not need files from it later. Keep it when the runtime helper
-		// will return an `agent://` handle (the `.md`/`.jsonl` backing files live
-		// here) and on `apply=false` (`changesApplied === null`) where the caller
-		// consumes `details.patchPath` / `details.branchName` /
-		// `details.nestedPatches` out of band. Failed isolated applies throw
-		// earlier with a recovery hint, so they never reach this gate.
-		const shouldCleanupTempArtifacts = tempArtifactsDir && !parsed.handle && (!isIsolated || changesApplied === true);
-		if (shouldCleanupTempArtifacts) {
-			await fs.rm(artifactsDir, { recursive: true, force: true });
-			unregisterArtifactsDir?.();
-		}
-
-		options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);
-
-		return { result, mergeSummary, changesApplied };
-	});
+
+			// Clean up the temp artifacts dir we created for this call only when the
+			// caller will not need files from it later. Keep it when the runtime helper
+			// will return an `agent://` handle (the `.md`/`.jsonl` backing files live
+			// here) and on `apply=false` (`changesApplied === null`) where the caller
+			// consumes `details.patchPath` / `details.branchName` /
+			// `details.nestedPatches` out of band. Failed isolated applies throw
+			// earlier with a recovery hint, so they never reach this gate.
+			const shouldCleanupTempArtifacts =
+				tempArtifactsDir && !parsed.handle && (!isIsolated || changesApplied === true);
+			if (shouldCleanupTempArtifacts) {
+				await fs.rm(artifactsDir, { recursive: true, force: true });
+				unregisterArtifactsDir?.();
+			}
+
+			options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);
+
+			return { result, mergeSummary, changesApplied };
+		},
+		{ deferExternalAbort: true },
+	);
 
 	return {
 		text: structured ? result.output : result.output + mergeSummary,

package/src/eval/backend.ts

@@ -15,10 +15,10 @@ export interface ExecutorBackendExecOptions {
 	 * driven entirely by `signal`, which the eval tool arms as a watchdog that
 	 * pauses on bridge timeout-control status events and fires a `TimeoutError`
 	 * reason only while the Python/JS runtime owns control. Backends use this
-	 * value only for timeout-annotation text and as cold-start headroom; they MUST
-	 * NOT derive a competing wall-clock timer from it.
+	 * value only for timeout-annotation text and as cold-start headroom; undefined
+	 * disables the cell timeout. Backends MUST NOT derive a competing wall-clock timer from it.
 	 */
-	idleTimeoutMs: number;
+	idleTimeoutMs?: number;
 	reset: boolean;
 	onChunk: (chunk: string) => void;
 	/**

package/src/eval/bridge-timeout.ts

@@ -26,6 +26,15 @@ export function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean {
 	return event.op === EVAL_TIMEOUT_PAUSE_OP || event.op === EVAL_TIMEOUT_RESUME_OP;
 }
 
+/** Optional behavior for a timeout pause around a host bridge call. */
+export interface BridgeTimeoutPauseOptions {
+	/**
+	 * Marks the pause as an `agent()` call whose already-started work must finish
+	 * before an external eval abort reaches the kernel.
+	 */
+	deferExternalAbort?: boolean;
+}
+
 /**
  * Run {@link operation} while suspending the eval watchdog through
  * {@link emitStatus}. A no-op wrapper when no status sink is wired.
@@ -33,12 +42,21 @@ export function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean {
 export async function withBridgeTimeoutPause<T>(
 	emitStatus: ((event: JsStatusEvent) => void) | undefined,
 	operation: () => Promise<T>,
+	options?: BridgeTimeoutPauseOptions,
 ): Promise<T> {
 	if (!emitStatus) return operation();
-	emitStatus({ op: EVAL_TIMEOUT_PAUSE_OP });
+	emitStatus(
+		options?.deferExternalAbort
+			? { op: EVAL_TIMEOUT_PAUSE_OP, deferExternalAbort: true }
+			: { op: EVAL_TIMEOUT_PAUSE_OP },
+	);
 	try {
 		return await operation();
 	} finally {
-		emitStatus({ op: EVAL_TIMEOUT_RESUME_OP });
+		emitStatus(
+			options?.deferExternalAbort
+				? { op: EVAL_TIMEOUT_RESUME_OP, deferExternalAbort: true }
+				: { op: EVAL_TIMEOUT_RESUME_OP },
+		);
 	}
 }