@oh-my-pi/pi-coding-agent 15.10.2 → 15.10.4

package/src/eval/__tests__/{llm-bridge.test.ts → completion-bridge.test.ts}

@@ -10,10 +10,10 @@ import { Settings } from "../../config/settings";
 import type { ToolSession } from "../../tools";
 import { ToolError } from "../../tools/tool-errors";
 import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP } from "../bridge-timeout";
+import { runEvalCompletion } from "../completion-bridge";
 import { IdleTimeout } from "../idle-timeout";
 import { disposeAllVmContexts } from "../js/context-manager";
 import { executeJs } from "../js/executor";
-import { runEvalLlm } from "../llm-bridge";
 import { disposeAllKernelSessions, type PythonResult } from "../py/executor";
 
 function makeModel(provider: string, id: string, extra: Partial<Model<Api>> = {}): Model<Api> {
@@ -98,16 +98,19 @@ function assistant(opts: {
 	};
 }
 
-async function runPythonLlmInSubprocess(options: { structured: boolean; tempDir: TempDir }): Promise<PythonResult> {
+async function runPythonCompletionInSubprocess(options: {
+	structured: boolean;
+	tempDir: TempDir;
+}): Promise<PythonResult> {
 	const repoRoot = path.resolve(import.meta.dir, "../../../..");
-	const scriptPath = path.join(options.tempDir.path(), "run-python-llm.ts");
-	const resultPath = path.join(options.tempDir.path(), "python-llm-result.json");
+	const scriptPath = path.join(options.tempDir.path(), "run-python-completion.ts");
+	const resultPath = path.join(options.tempDir.path(), "python-completion-result.json");
 	const aiPath = path.resolve(import.meta.dir, "../../../../ai/src/index.ts");
 	const executorPath = path.resolve(import.meta.dir, "../py/executor.ts");
 	const settingsPath = path.resolve(import.meta.dir, "../../config/settings.ts");
 	const code = options.structured
-		? 'import json\nprint(json.dumps(llm("hi", schema={"type": "object"})))'
-		: 'print(llm("hi", model="smol"))';
+		? 'import json\nprint(json.dumps(completion("hi", schema={"type": "object"})))'
+		: 'print(completion("hi", model="smol"))';
 	const responseContent = options.structured
 		? '[{ type: "toolCall", id: "tc-1", name: "respond", arguments: { ok: true } }]'
 		: '[{ type: "text", text: "hello from python" }]';
@@ -153,7 +156,7 @@ vi.spyOn(ai, "completeSimple").mockResolvedValue({
 });
 const result = await executePython(${JSON.stringify(code)}, {
 	cwd: ${JSON.stringify(options.tempDir.path())},
-	sessionId: ${JSON.stringify(`py-llm:${options.structured ? "struct" : "plain"}`)},
+	sessionId: ${JSON.stringify(`py-completion:${options.structured ? "struct" : "plain"}`)},
 	sessionFile: ${JSON.stringify(path.join(options.tempDir.path(), "session.jsonl"))},
 	toolSession: session,
 	kernelMode: "per-call",
@@ -165,11 +168,12 @@ process.exit(0);
 	const child = await $`bun ${scriptPath}`.cwd(repoRoot).quiet().nothrow();
 	const stdout = child.stdout.toString();
 	const stderr = child.stderr.toString();
-	if (child.exitCode !== 0) throw new Error(stderr || stdout || `Python llm subprocess exited with ${child.exitCode}`);
+	if (child.exitCode !== 0)
+		throw new Error(stderr || stdout || `Python completion subprocess exited with ${child.exitCode}`);
 	return (await Bun.file(resultPath).json()) as PythonResult;
 }
 
-describe("runEvalLlm", () => {
+describe("runEvalCompletion", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
 	});
@@ -178,9 +182,9 @@ describe("runEvalLlm", () => {
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
 		const session = makeSession();
 
-		await runEvalLlm({ prompt: "q", model: "smol" }, { session });
-		await runEvalLlm({ prompt: "q", model: "default" }, { session });
-		await runEvalLlm({ prompt: "q", model: "slow" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "smol" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "default" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "slow" }, { session });
 
 		const resolved = spy.mock.calls.map(call => {
 			const model = call[0] as Model<Api>;
@@ -193,7 +197,7 @@ describe("runEvalLlm", () => {
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
 		const session = makeSession({ available: [SMOL, DEFAULT, SLOW], activeModel: "p/slow" });
 
-		await runEvalLlm({ prompt: "q", model: "default" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "default" }, { session });
 
 		const model = spy.mock.calls[0]?.[0] as Model<Api>;
 		expect(`${model.provider}/${model.id}`).toBe("p/slow");
@@ -201,7 +205,7 @@ describe("runEvalLlm", () => {
 
 	it("returns the completion text in plain mode", async () => {
 		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "the answer" }));
-		const result = await runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() });
+		const result = await runEvalCompletion({ prompt: "q", model: "smol" }, { session: makeSession() });
 		expect(result.text).toBe("the answer");
 		expect(result.details).toEqual({ model: "p/smol", tier: "smol", structured: false });
 	});
@@ -209,10 +213,10 @@ describe("runEvalLlm", () => {
 	it("supplies a non-empty systemPrompt when system is omitted (codex 'Instructions are required' guard)", async () => {
 		// The openai-codex Responses transformer drops `instructions` when no
 		// system prompt is provided, and the remote endpoint then 400s with
-		// "Instructions are required". runEvalLlm must always carry a non-empty
-		// systemPrompt so `llm("…")` without a `system` argument works.
+		// "Instructions are required". runEvalCompletion must always carry a non-empty
+		// systemPrompt so `completion("…")` without a `system` argument works.
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
-		await runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() });
+		await runEvalCompletion({ prompt: "q", model: "smol" }, { session: makeSession() });
 		const ctx = spy.mock.calls[0]?.[1] as { systemPrompt?: string[] };
 		expect(ctx.systemPrompt).toBeDefined();
 		expect(ctx.systemPrompt?.length).toBeGreaterThan(0);
@@ -221,7 +225,7 @@ describe("runEvalLlm", () => {
 
 	it("honors an explicit system prompt instead of overriding it", async () => {
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
-		await runEvalLlm({ prompt: "q", model: "smol", system: "Be terse." }, { session: makeSession() });
+		await runEvalCompletion({ prompt: "q", model: "smol", system: "Be terse." }, { session: makeSession() });
 		const ctx = spy.mock.calls[0]?.[1] as { systemPrompt?: string[] };
 		expect(ctx.systemPrompt).toEqual(["Be terse."]);
 	});
@@ -230,7 +234,7 @@ describe("runEvalLlm", () => {
 		const spy = vi
 			.spyOn(ai, "completeSimple")
 			.mockResolvedValue(assistant({ toolCall: { name: "respond", arguments: { answer: 42 } } }));
-		const result = await runEvalLlm(
+		const result = await runEvalCompletion(
 			{ prompt: "q", model: "smol", schema: { type: "object", properties: { answer: { type: "number" } } } },
 			{ session: makeSession() },
 		);
@@ -246,7 +250,7 @@ describe("runEvalLlm", () => {
 
 	it("falls back to JSON embedded in text when the model skips the respond tool", async () => {
 		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: 'here: {"answer": 7}' }));
-		const result = await runEvalLlm(
+		const result = await runEvalCompletion(
 			{ prompt: "q", model: "smol", schema: { type: "object" } },
 			{ session: makeSession() },
 		);
@@ -257,8 +261,8 @@ describe("runEvalLlm", () => {
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
 		const session = makeSession({ available: [SMOL, DEFAULT, REASONING_SLOW] });
 
-		await runEvalLlm({ prompt: "q", model: "smol" }, { session });
-		await runEvalLlm({ prompt: "q", model: "slow" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "smol" }, { session });
+		await runEvalCompletion({ prompt: "q", model: "slow" }, { session });
 
 		const smolOpts = spy.mock.calls[0]?.[2] as { reasoning?: unknown };
 		const slowOpts = spy.mock.calls[1]?.[2] as { reasoning?: unknown };
@@ -269,47 +273,49 @@ describe("runEvalLlm", () => {
 	it("does not request reasoning for the slow tier on a non-reasoning model", async () => {
 		const spy = vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "ok" }));
 		// SLOW is reasoning:false — must not trip requireSupportedEffort downstream.
-		const result = await runEvalLlm({ prompt: "q", model: "slow" }, { session: makeSession() });
+		const result = await runEvalCompletion({ prompt: "q", model: "slow" }, { session: makeSession() });
 		expect(result.text).toBe("ok");
 		const opts = spy.mock.calls[0]?.[2] as { reasoning?: unknown };
 		expect(opts.reasoning).toBeUndefined();
 	});
 
 	it("throws ToolError on invalid arguments", async () => {
-		await expect(runEvalLlm({ prompt: "" }, { session: makeSession() })).rejects.toBeInstanceOf(ToolError);
-		await expect(runEvalLlm({ prompt: "q", model: "huge" }, { session: makeSession() })).rejects.toBeInstanceOf(
-			ToolError,
-		);
+		await expect(runEvalCompletion({ prompt: "" }, { session: makeSession() })).rejects.toBeInstanceOf(ToolError);
+		await expect(
+			runEvalCompletion({ prompt: "q", model: "huge" }, { session: makeSession() }),
+		).rejects.toBeInstanceOf(ToolError);
 	});
 
 	it("throws ToolError when no model resolves for the tier", async () => {
 		const session = makeSession({ available: [DEFAULT], roles: { smol: "missing/model" } });
-		await expect(runEvalLlm({ prompt: "q", model: "smol" }, { session })).rejects.toBeInstanceOf(ToolError);
+		await expect(runEvalCompletion({ prompt: "q", model: "smol" }, { session })).rejects.toBeInstanceOf(ToolError);
 	});
 
 	it("throws ToolError when the resolved model has no API key", async () => {
 		const session = makeSession({ apiKey: null });
-		await expect(runEvalLlm({ prompt: "q", model: "smol" }, { session })).rejects.toBeInstanceOf(ToolError);
+		await expect(runEvalCompletion({ prompt: "q", model: "smol" }, { session })).rejects.toBeInstanceOf(ToolError);
 	});
 
 	it("maps error and aborted stop reasons to ToolError", async () => {
 		vi.spyOn(ai, "completeSimple").mockResolvedValueOnce(assistant({ stopReason: "error", errorMessage: "boom" }));
-		await expect(runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() })).rejects.toThrow("boom");
+		await expect(runEvalCompletion({ prompt: "q", model: "smol" }, { session: makeSession() })).rejects.toThrow(
+			"boom",
+		);
 
 		vi.spyOn(ai, "completeSimple").mockResolvedValueOnce(assistant({ stopReason: "aborted" }));
-		await expect(runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() })).rejects.toBeInstanceOf(
-			ToolError,
-		);
+		await expect(
+			runEvalCompletion({ prompt: "q", model: "smol" }, { session: makeSession() }),
+		).rejects.toBeInstanceOf(ToolError);
 	});
 
 	it("throws ToolError when plain mode produces no text", async () => {
 		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "" }));
-		await expect(runEvalLlm({ prompt: "q", model: "smol" }, { session: makeSession() })).rejects.toBeInstanceOf(
-			ToolError,
-		);
+		await expect(
+			runEvalCompletion({ prompt: "q", model: "smol" }, { session: makeSession() }),
+		).rejects.toBeInstanceOf(ToolError);
 	});
 
-	it("pauses the idle watchdog while a slow llm() request is in flight", async () => {
+	it("pauses the idle watchdog while a slow completion() request is in flight", async () => {
 		// A oneshot completion emits no status until it returns; delegated model
 		// time must be invisible to the eval timeout budget.
 		vi.spyOn(ai, "completeSimple").mockImplementation(async () => {
@@ -319,7 +325,7 @@ describe("runEvalLlm", () => {
 
 		const ops: string[] = [];
 		using idle = new IdleTimeout(60);
-		const result = await runEvalLlm(
+		const result = await runEvalCompletion(
 			{ prompt: "q", model: "smol" },
 			{
 				session: makeSession(),
@@ -333,12 +339,12 @@ describe("runEvalLlm", () => {
 		);
 
 		expect(result.text).toBe("the answer");
-		expect(ops).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP, "llm"]);
+		expect(ops).toEqual([EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP, "completion"]);
 		expect(idle.signal.aborted).toBe(false);
 	});
 });
 
-describe("llm() through eval runtimes", () => {
+describe("completion() through eval runtimes", () => {
 	afterEach(() => {
 		vi.restoreAllMocks();
 	});
@@ -348,13 +354,13 @@ describe("llm() through eval runtimes", () => {
 		await disposeAllKernelSessions();
 	});
 
-	it("exposes llm() in the JavaScript runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-js-");
+	it("exposes completion() in the JavaScript runtime", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-completion-js-");
 		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `js-llm:${crypto.randomUUID()}`;
+		const sessionId = `js-completion:${crypto.randomUUID()}`;
 		vi.spyOn(ai, "completeSimple").mockResolvedValue(assistant({ text: "hello from smol" }));
 
-		const result = await executeJs('return await llm("hi", { model: "smol" });', {
+		const result = await executeJs('return await completion("hi", { model: "smol" });', {
 			cwd: tempDir.path(),
 			sessionId,
 			session: makeSession(),
@@ -365,16 +371,16 @@ describe("llm() through eval runtimes", () => {
 		expect(result.output.trim()).toBe("hello from smol");
 	});
 
-	it("parses structured llm() output in the JavaScript runtime", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-llm-js-struct-");
+	it("parses structured completion() output in the JavaScript runtime", async () => {
+		using tempDir = TempDir.createSync("@omp-eval-completion-js-struct-");
 		const sessionFile = path.join(tempDir.path(), "session.jsonl");
-		const sessionId = `js-llm-struct:${crypto.randomUUID()}`;
+		const sessionId = `js-completion-struct:${crypto.randomUUID()}`;
 		vi.spyOn(ai, "completeSimple").mockResolvedValue(
 			assistant({ toolCall: { name: "respond", arguments: { ok: true, n: 3 } } }),
 		);
 
 		const result = await executeJs(
-			'const r = await llm("hi", { schema: { type: "object" } }); return JSON.stringify(r);',
+			'const r = await completion("hi", { schema: { type: "object" } }); return JSON.stringify(r);',
 			{ cwd: tempDir.path(), sessionId, session: makeSession(), sessionFile },
 		);
 
@@ -382,10 +388,10 @@ describe("llm() through eval runtimes", () => {
 		expect(JSON.parse(result.output.trim())).toEqual({ ok: true, n: 3 });
 	});
 
-	it("exposes llm() in the Python runtime", async () => {
-		const tempDir = TempDir.createSync("@omp-eval-llm-py-");
+	it("exposes completion() in the Python runtime", async () => {
+		const tempDir = TempDir.createSync("@omp-eval-completion-py-");
 		try {
-			const result = await runPythonLlmInSubprocess({ structured: false, tempDir });
+			const result = await runPythonCompletionInSubprocess({ structured: false, tempDir });
 			expect(result.exitCode).toBe(0);
 			expect(result.output.trim()).toBe("hello from python");
 		} finally {
@@ -393,10 +399,10 @@ describe("llm() through eval runtimes", () => {
 		}
 	});
 
-	it("parses structured llm() output in the Python runtime", async () => {
-		const tempDir = TempDir.createSync("@omp-eval-llm-py-struct-");
+	it("parses structured completion() output in the Python runtime", async () => {
+		const tempDir = TempDir.createSync("@omp-eval-completion-py-struct-");
 		try {
-			const result = await runPythonLlmInSubprocess({ structured: true, tempDir });
+			const result = await runPythonCompletionInSubprocess({ structured: true, tempDir });
 			expect(result.exitCode).toBe(0);
 			expect(JSON.parse(result.output.trim())).toEqual({ ok: true });
 		} finally {

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

@@ -0,0 +1,241 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { TempDir } from "@oh-my-pi/pi-utils";
+import { Settings } from "../../config/settings";
+import type { ToolSession } from "../../tools";
+import { disposeAllVmContexts } from "../js/context-manager";
+import { executeJs } from "../js/executor";
+
+const originalWorker = globalThis.Worker;
+
+interface FakeWorkerStats {
+	closeRequests: number;
+	terminateCalls: number;
+}
+
+interface FakeWorkerBehavior {
+	exitOnClose: boolean;
+	settleRuns: boolean;
+}
+
+function makeSession(cwd: string): ToolSession {
+	return {
+		cwd,
+		hasUI: false,
+		settings: Settings.isolated({
+			"async.enabled": false,
+			"task.isolation.mode": "none",
+			"task.enableLsp": true,
+		}),
+		taskDepth: 0,
+		enableLsp: true,
+		getSessionFile: () => null,
+		getSessionSpawns: () => "*",
+		getActiveModelString: () => "p/active",
+		getModelString: () => "p/fallback",
+		getArtifactsDir: () => null,
+		getSessionId: () => "test-session",
+		getEvalSessionId: () => "test-eval-session",
+	};
+}
+
+async function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+	let timeout: NodeJS.Timeout | undefined;
+	try {
+		return await Promise.race([
+			promise,
+			new Promise<never>((_, reject) => {
+				timeout = setTimeout(() => reject(new Error(`${label} timed out`)), ms);
+			}),
+		]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+
+async function waitForRealWorkerExitAfterClose(cwd: string): Promise<void> {
+	const worker = new originalWorker(new URL("../js/worker-entry.ts", import.meta.url).href, { type: "module" });
+	const ready = Promise.withResolvers<void>();
+	const runComplete = Promise.withResolvers<void>();
+	const closedAck = Promise.withResolvers<void>();
+	const workerClosed = Promise.withResolvers<void>();
+	const runId = `keep-alive:${crypto.randomUUID()}`;
+	const snapshot = { cwd, sessionId: `worker-exit:${crypto.randomUUID()}` };
+
+	worker.addEventListener("message", event => {
+		const msg = event.data as { type?: string; runId?: string; ok?: boolean };
+		if (msg.type === "ready") ready.resolve();
+		else if (msg.type === "result" && msg.runId === runId && msg.ok) runComplete.resolve();
+		else if (msg.type === "closed") closedAck.resolve();
+	});
+	worker.addEventListener("close", () => workerClosed.resolve());
+
+	try {
+		await withTimeout(ready.promise, 1_000, "worker ready");
+		worker.postMessage({
+			type: "run",
+			runId,
+			code: "globalThis.__keepAlive = setInterval(() => {}, 1000);\nundefined;",
+			filename: "keep-alive.js",
+			snapshot,
+		});
+		await withTimeout(runComplete.promise, 1_000, "worker run");
+		worker.postMessage({ type: "close" });
+		await withTimeout(closedAck.promise, 1_000, "worker closed ack");
+		await withTimeout(workerClosed.promise, 1_000, "worker close event");
+	} finally {
+		worker.terminate();
+	}
+}
+
+function installFakeWorker(stats: FakeWorkerStats, behavior: FakeWorkerBehavior): void {
+	class FakeWorker {
+		#messageListeners = new Set<(event: MessageEvent) => void>();
+		#closeListeners = new Set<(event: Event) => void>();
+		#readyQueued = false;
+		#exited = false;
+
+		postMessage(message: unknown): void {
+			if (!message || typeof message !== "object") return;
+			const typed = message as { type?: string; runId?: string };
+			if (typed.type === "run" && typed.runId && behavior.settleRuns) {
+				queueMicrotask(() => this.#emitMessage({ type: "result", runId: typed.runId, ok: true }));
+				return;
+			}
+			if (typed.type === "close") {
+				stats.closeRequests++;
+				queueMicrotask(() => {
+					this.#emitMessage({ type: "closed" });
+					if (behavior.exitOnClose) this.#emitClose();
+				});
+			}
+		}
+
+		addEventListener(type: string, listener: (event: MessageEvent | Event) => void): void {
+			if (type === "close") {
+				this.#closeListeners.add(listener as (event: Event) => void);
+				return;
+			}
+			if (type !== "message") return;
+			this.#messageListeners.add(listener as (event: MessageEvent) => void);
+			if (!this.#readyQueued) {
+				this.#readyQueued = true;
+				queueMicrotask(() => this.#emitMessage({ type: "ready" }));
+			}
+		}
+
+		removeEventListener(type: string, listener: (event: MessageEvent | Event) => void): void {
+			if (type === "close") {
+				this.#closeListeners.delete(listener as (event: Event) => void);
+				return;
+			}
+			if (type !== "message") return;
+			this.#messageListeners.delete(listener as (event: MessageEvent) => void);
+		}
+
+		terminate(): void {
+			stats.terminateCalls++;
+			this.#emitClose();
+		}
+
+		#emitMessage(data: unknown): void {
+			const event = new MessageEvent("message", { data });
+			for (const listener of this.#messageListeners) listener(event);
+		}
+
+		#emitClose(): void {
+			if (this.#exited) return;
+			this.#exited = true;
+			const event = new Event("close");
+			for (const listener of this.#closeListeners) listener(event);
+		}
+	}
+
+	Object.defineProperty(globalThis, "Worker", {
+		configurable: true,
+		writable: true,
+		value: FakeWorker as unknown as typeof Worker,
+	});
+}
+
+describe("JavaScript eval worker lifecycle", () => {
+	afterEach(async () => {
+		await disposeAllVmContexts();
+		Object.defineProperty(globalThis, "Worker", {
+			configurable: true,
+			writable: true,
+			value: originalWorker,
+		});
+	});
+
+	it("exits a real worker on graceful close even with ref'ed user handles", async () => {
+		using tempDir = TempDir.createSync("@omp-js-worker-real-close-");
+
+		await waitForRealWorkerExitAfterClose(tempDir.path());
+	});
+
+	it("waits for the worker to close on reset instead of force-terminating it", async () => {
+		using tempDir = TempDir.createSync("@omp-js-worker-close-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: true });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-close:${crypto.randomUUID()}`;
+
+		const first = await executeJs("globalThis.marker = 1;", { cwd: tempDir.path(), sessionId, session });
+		expect(first.exitCode).toBe(0);
+
+		const second = await executeJs("globalThis.marker = 2;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			reset: true,
+		});
+		expect(second.exitCode).toBe(0);
+		expect(stats.closeRequests).toBe(1);
+		expect(stats.terminateCalls).toBe(0);
+	});
+
+	it("terminates when close is acknowledged but the worker does not exit", async () => {
+		using tempDir = TempDir.createSync("@omp-js-worker-close-hung-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: false, settleRuns: true });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-close-hung:${crypto.randomUUID()}`;
+
+		const first = await executeJs("globalThis.marker = 1;", { cwd: tempDir.path(), sessionId, session });
+		expect(first.exitCode).toBe(0);
+
+		const second = await executeJs("globalThis.marker = 2;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			reset: true,
+		});
+		expect(second.exitCode).toBe(0);
+		expect(stats.closeRequests).toBe(1);
+		expect(stats.terminateCalls).toBe(1);
+	});
+
+	it("force-terminates instead of closing when an in-flight run is aborted", async () => {
+		using tempDir = TempDir.createSync("@omp-js-worker-abort-");
+		const stats: FakeWorkerStats = { closeRequests: 0, terminateCalls: 0 };
+		installFakeWorker(stats, { exitOnClose: true, settleRuns: false });
+
+		const session = makeSession(tempDir.path());
+		const sessionId = `js-abort:${crypto.randomUUID()}`;
+		const controller = new AbortController();
+		const resultPromise = executeJs("globalThis.neverFinishes = true;", {
+			cwd: tempDir.path(),
+			sessionId,
+			session,
+			signal: controller.signal,
+		});
+		setTimeout(() => controller.abort(new DOMException("Execution aborted", "AbortError")), 0);
+
+		const result = await resultPromise;
+		expect(result.cancelled).toBe(true);
+		expect(stats.closeRequests).toBe(0);
+		expect(stats.terminateCalls).toBe(1);
+	});
+});

package/src/eval/agent-bridge.ts

@@ -272,7 +272,12 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			persistArtifacts: Boolean(sessionFile),
 			artifactsDir,
 			contextFile,
-			enableLsp: (options.session.enableLsp ?? true) && options.session.settings.get("task.enableLsp"),
+			// Eval `agent()` subagents are short-lived programmatic helpers (data
+			// collection, structured output, parallel() fan-out). LSP server
+			// cold-start costs tens of seconds and is pure overhead here, so it is
+			// forced off regardless of the `task.enableLsp` setting — that knob only
+			// governs LSP-aware delegation through the `task` tool.
+			enableLsp: false,
 			signal: options.signal,
 			eventBus: options.session.eventBus,
 			onProgress: progress => emitProgressStatus(options.emitStatus, progress),

package/src/eval/bridge-timeout.ts

@@ -2,7 +2,7 @@
  * Timeout suspension for in-flight host-side eval bridge calls.
  *
  * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
- * own work. Host-side `agent()` / `parallel()` / `llm()` bridge calls hand
+ * own work. Host-side `agent()` / `parallel()` / `completion()` bridge calls hand
  * control to the outer TypeScript process, where the Python kernel or JS VM is
  * only waiting for a result. While that delegated work is in flight, the cell
  * timeout must be ignored completely; once the bridge returns and the runtime is