@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.7

package/src/eval/__tests__/helpers-local-roots.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import * as path from "node:path";
-import { TempDir } from "@oh-my-pi/pi-utils/temp";
-import { createHelpers, type HelperContext } from "../js/shared/helpers";
-
-/**
- * The eval helpers (`read`/`write`) must substitute injected on-disk
- * roots for internal-URL schemes. Without it, `write("local://x.md")` hits a
- * stdlib `path.resolve` that collapses `local://` to `local:/`, creating a junk
- * `local:` directory under the cwd instead of landing where `read local://x.md`
- * resolves. These lock the substitution contract and its guards.
- */
-function makeCtx(cwd: string, roots: Record<string, string>): HelperContext {
-	return {
-		cwd: () => cwd,
-		env: new Map(),
-		localRoots: () => roots,
-		emitStatus: () => {},
-	};
-}
-
-describe("eval js helpers internal-url resolution", () => {
-	it("writes and reads local:// under the injected root", async () => {
-		using tmp = TempDir.createSync("@eval-helpers-local-");
-		const root = path.join(tmp.path(), "local");
-		const helpers = createHelpers(makeCtx(tmp.path(), { local: root }));
-
-		const written = await helpers.writeFile("local://notes/merge-map.md", "hello");
-		expect(written).toBe(path.join(root, "notes", "merge-map.md"));
-		expect(await Bun.file(written).text()).toBe("hello");
-		expect(await helpers.read("local://notes/merge-map.md")).toBe("hello");
-
-		// Regression: no literal `local:` directory created under the cwd.
-		expect(await Bun.file(path.join(tmp.path(), "local:")).exists()).toBe(false);
-		expect(await Bun.file(path.join(tmp.path(), "local:", "notes", "merge-map.md")).exists()).toBe(false);
-	});
-
-	it("rejects traversal and schemes without an injected root", async () => {
-		using tmp = TempDir.createSync("@eval-helpers-guard-");
-		const helpers = createHelpers(makeCtx(tmp.path(), { local: path.join(tmp.path(), "local") }));
-
-		await expect(helpers.writeFile("local://../escape.md", "x")).rejects.toThrow(/traversal|escapes/i);
-		await expect(helpers.writeFile("memory://x.md", "x")).rejects.toThrow(/not supported/i);
-		await expect(helpers.read("https://example.com/page")).rejects.toThrow(/not supported/i);
-	});
-
-	it("leaves plain relative and absolute paths resolving against the cwd", async () => {
-		using tmp = TempDir.createSync("@eval-helpers-plain-");
-		const helpers = createHelpers(makeCtx(tmp.path(), {}));
-
-		const rel = await helpers.writeFile("foo/bar.txt", "bar");
-		expect(rel).toBe(path.join(tmp.path(), "foo", "bar.txt"));
-		expect(await helpers.read("foo/bar.txt")).toBe("bar");
-	});
-});

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

@@ -1,80 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { IdleTimeout } from "../idle-timeout";
-
-/** Resolve true if `signal` aborts within `ms`, false if the window elapses first. */
-function abortedWithin(signal: AbortSignal, ms: number): Promise<boolean> {
-	if (signal.aborted) return Promise.resolve(true);
-	const { promise, resolve } = Promise.withResolvers<boolean>();
-	const timer = setTimeout(() => resolve(false), ms);
-	signal.addEventListener(
-		"abort",
-		() => {
-			clearTimeout(timer);
-			resolve(true);
-		},
-		{ once: true },
-	);
-	return promise;
-}
-
-describe("IdleTimeout", () => {
-	it("aborts with a TimeoutError reason once the idle window elapses with no activity", async () => {
-		using idle = new IdleTimeout(40);
-		expect(idle.signal.aborted).toBe(false);
-
-		const fired = await abortedWithin(idle.signal, 500);
-		expect(fired).toBe(true);
-		expect(idle.signal.aborted).toBe(true);
-		// The reason must be a TimeoutError so downstream timeout detection
-		// (kernel `isTimeoutReason`, executor `isTimedOutCancellation`) classifies
-		// the cancellation as a timeout rather than a plain abort.
-		expect(idle.signal.reason).toBeInstanceOf(DOMException);
-		expect((idle.signal.reason as DOMException).name).toBe("TimeoutError");
-	});
-
-	it("ignores elapsed time while paused and resumes with a fresh window", async () => {
-		using idle = new IdleTimeout(80);
-		idle.pause();
-		await Bun.sleep(160);
-		expect(idle.signal.aborted).toBe(false);
-
-		idle.resume();
-		const firedEarly = await abortedWithin(idle.signal, 30);
-		expect(firedEarly).toBe(false);
-		const fired = await abortedWithin(idle.signal, 500);
-		expect(fired).toBe(true);
-	});
-
-	it("reference-counts overlapping pauses", async () => {
-		using idle = new IdleTimeout(60);
-		idle.pause();
-		idle.pause();
-		await Bun.sleep(120);
-		expect(idle.signal.aborted).toBe(false);
-
-		idle.resume();
-		await Bun.sleep(90);
-		expect(idle.signal.aborted).toBe(false);
-
-		idle.resume();
-		const fired = await abortedWithin(idle.signal, 500);
-		expect(fired).toBe(true);
-	});
-	it("never fires after dispose()", async () => {
-		const idle = new IdleTimeout(30);
-		idle.dispose();
-		const fired = await abortedWithin(idle.signal, 150);
-		expect(fired).toBe(false);
-		expect(idle.signal.aborted).toBe(false);
-	});
-
-	it("ignores pause/resume after the watchdog has already fired", async () => {
-		using idle = new IdleTimeout(30);
-		await abortedWithin(idle.signal, 500);
-		expect(idle.signal.aborted).toBe(true);
-		// Late activity must not un-abort or rearm a settled watchdog.
-		idle.pause();
-		idle.resume();
-		expect(idle.signal.aborted).toBe(true);
-	});
-});

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

@@ -1,456 +0,0 @@
-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,
-	setJsEvalWorkerThreadForTests,
-	setWorkerCloseTimeoutMsForTests,
-} 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;
-	errorOnStart?: 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 {
-		worker.postMessage({ type: "init", snapshot });
-		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>();
-		#errorListeners = 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 === "error") {
-				this.#errorListeners.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(() => {
-					if (behavior.errorOnStart) this.#emitError();
-					else 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 === "error") {
-				this.#errorListeners.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);
-		}
-
-		#emitError(): void {
-			const event = new ErrorEvent("error", {
-				message: "fake worker failed to start",
-				error: new Error("fake worker failed to start"),
-			});
-			for (const listener of this.#errorListeners) listener(event);
-		}
-	}
-
-	Object.defineProperty(globalThis, "Worker", {
-		configurable: true,
-		writable: true,
-		value: FakeWorker as unknown as typeof Worker,
-	});
-}
-
-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);
-	});
-
-	afterEach(async () => {
-		// Dispose while the shrunk timeout is still active so a hung worker's afterEach
-		// close also force-terminates instantly, then restore the production default.
-		await disposeAllVmContexts();
-		setWorkerCloseTimeoutMsForTests(restoreCloseTimeoutMs);
-		Object.defineProperty(globalThis, "Worker", {
-			configurable: true,
-			writable: true,
-			value: originalWorker,
-		});
-		setJsEvalWorkerThreadForTests(restoreWorkerThread);
-	});
-
-	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);
-	});
-
-	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 };
-		installFakeWorker(stats, { exitOnClose: true, settleRuns: true, errorOnStart: true });
-
-		const session = makeSession(tempDir.path());
-		const sessionId = `js-worker-error:${crypto.randomUUID()}`;
-
-		// The spawned worker emits an `error` event instead of `ready`. Without fail-fast
-		// error handling the handshake would stall until WORKER_INIT_TIMEOUT_MS (15s); with
-		// it, the handshake rejects at once and the inline worker runs the cell.
-		const result = await executeJs("return String(6 * 7);", { cwd: tempDir.path(), sessionId, session });
-		expect(result.exitCode).toBe(0);
-		expect(result.output.trim()).toBe("42");
-		// The errored primary worker is torn down before the inline retry takes over.
-		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 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 },
-		);
-		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__/julia-prelude.test.ts

@@ -1,66 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import * as path from "node:path";
-import { $which, TempDir } from "@oh-my-pi/pi-utils";
-import { disposeJuliaKernelSessionsByOwner, executeJulia } from "../jl/executor";
-
-const HAS_JULIA = Boolean($which("julia"));
-const OWNER_ID = "julia-prelude-tests";
-
-describe.skipIf(!HAS_JULIA)("eval Julia prelude helpers", () => {
-	afterEach(async () => {
-		await disposeJuliaKernelSessionsByOwner(OWNER_ID);
-	}, 30_000);
-
-	it("supports output ranges, JSON queries, metadata, and ANSI stripping", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-julia-output-");
-		const artifactsDir = path.join(tempDir.path(), "session-artifacts");
-		await Bun.write(path.join(artifactsDir, "alpha.md"), "one\ntwo\nthree\nfour");
-		await Bun.write(path.join(artifactsDir, "json.md"), JSON.stringify({ items: [{ name: "a" }, { name: "b" }] }));
-		await Bun.write(path.join(artifactsDir, "ansi.md"), "\u001b[31mred\u001b[0m");
-
-		const result = await executeJulia(
-			`
-println("RANGE=", replace(output("alpha", offset=2, limit=2), "\\n" => "|"))
-println("QUERY=", output("json", query=".items[1].name"))
-println("STRIPPED=", output("ansi", format="stripped"))
-meta = output("alpha", format="json")
-println("META=", meta["id"], ":", meta["char_count"] > 0)
-multi = output("alpha", "json")
-println("MULTI=", length(multi), ":", multi[1]["id"], ":", multi[2]["id"])
-nothing
-`,
-			{
-				cwd: tempDir.path(),
-				artifactsDir,
-				sessionId: `julia-prelude-output:${crypto.randomUUID()}`,
-				kernelOwnerId: OWNER_ID,
-				reset: true,
-			},
-		);
-
-		expect(result.exitCode).toBe(0);
-		expect(result.output).toContain("RANGE=two|three");
-		expect(result.output).toContain('QUERY="b"');
-		expect(result.output).toContain("STRIPPED=red");
-		expect(result.output).toContain("META=alpha:true");
-		expect(result.output).toContain("MULTI=2:alpha:json");
-	}, 60_000);
-
-	it("surfaces the exception type and message in the error output, not just stack frames", async () => {
-		using tempDir = TempDir.createSync("@omp-eval-julia-error-");
-		const result = await executeJulia(`println("="^8)\nmissing_var_xyz + 1`, {
-			cwd: tempDir.path(),
-			sessionId: `julia-prelude-error:${crypto.randomUUID()}`,
-			kernelOwnerId: OWNER_ID,
-			reset: true,
-		});
-
-		// The rendered error must carry the actual exception, not only the
-		// runner-internal backtrace frames (regression: traceback-only output
-		// hid `ename`/`evalue`).
-		expect(result.output).toContain("UndefVarError");
-		expect(result.output).toContain("missing_var_xyz");
-		// Frames are still present alongside the message.
-		expect(result.output).toContain("top-level scope");
-	}, 30_000);
-});