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

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

@@ -1,115 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-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
- * option to `CREATE_NO_WINDOW`, which detaches the child from any inherited
- * console — breaking both (a) `LoadLibraryExW` for NumPy/pandas native
- * extensions and (b) SIGINT delivery via `GenerateConsoleCtrlEvent`. See
- * issue #1960. The tests below pin the three layered concerns the PR review
- * surfaced:
- *
- * 1. `shouldHideKernelWindow` — pure predicate over a single boolean.
- * 2. `consoleAttachedViaTTY` — the TTY-OR fallback used when the Win32 FFI
- *    probe is unavailable; covers the partial-redirection cases.
- * 3. `hostHasInheritableConsole` — the integration boundary. Off-Windows it
- *    short-circuits to the TTY fallback; on Windows it is expected to
- *    consult `kernel32!GetConsoleWindow()` first, which is the authoritative
- *    signal even for the all-stdio-redirected case.
- */
-describe("shouldHideKernelWindow", () => {
-	it("inherits the host console on Windows when one is attached", () => {
-		// Reporter's repro: omp launched in Windows Terminal, host has a
-		// console, kernel must inherit so `import pandas` doesn't deadlock in
-		// `_multiarray_umath` and SIGINT can recover the cell.
-		expect(shouldHideKernelWindow({ platform: "win32", hostHasInheritableConsole: true })).toBe(false);
-	});
-
-	it("hides on Windows only when the host has no console at all (true service / daemon)", () => {
-		// CREATE_NO_WINDOW here suppresses the console window Windows would
-		// otherwise auto-allocate for the console-app Python kernel.
-		expect(shouldHideKernelWindow({ platform: "win32", hostHasInheritableConsole: false })).toBe(true);
-	});
-
-	it("never sets windowsHide off-Windows (the option is a Win32-only flag)", () => {
-		// On POSIX `windowsHide` is a no-op; the predicate must return false
-		// everywhere off-Windows so the spawn site matches pre-fix behavior.
-		expect(shouldHideKernelWindow({ platform: "linux", hostHasInheritableConsole: true })).toBe(false);
-		expect(shouldHideKernelWindow({ platform: "linux", hostHasInheritableConsole: false })).toBe(false);
-		expect(shouldHideKernelWindow({ platform: "darwin", hostHasInheritableConsole: true })).toBe(false);
-		expect(shouldHideKernelWindow({ platform: "darwin", hostHasInheritableConsole: false })).toBe(false);
-	});
-});
-
-describe("consoleAttachedViaTTY (FFI fallback heuristic)", () => {
-	// The OR of three TTY signals correctly classifies the realistic shell
-	// redirection scenarios that motivated widening the check beyond stdout
-	// in the first review pass (PR #1961). The all-three-redirected case
-	// (false here) is the gap that the Win32 FFI probe in
-	// `hostHasInheritableConsole` is meant to close — this fallback is best-
-	// effort.
-
-	it("treats a fully interactive launch as console-attached", () => {
-		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: true, stderrIsTTY: true })).toBe(true);
-	});
-
-	it("treats `omp -p '...' > out.txt` (stdout-only redirect) as console-attached", () => {
-		// The reviewer's first-pass repro: stdout off the terminal, stdin
-		// and stderr still attached. OR keeps the console.
-		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: false, stderrIsTTY: true })).toBe(true);
-	});
-
-	it("treats stdin-only redirects (`< in.txt`) as console-attached", () => {
-		expect(consoleAttachedViaTTY({ stdinIsTTY: false, stdoutIsTTY: true, stderrIsTTY: true })).toBe(true);
-	});
-
-	it("treats stderr-only redirects (`2> err.log`) as console-attached", () => {
-		expect(consoleAttachedViaTTY({ stdinIsTTY: true, stdoutIsTTY: true, stderrIsTTY: false })).toBe(true);
-	});
-
-	it("returns false only when none of stdin/stdout/stderr is a TTY", () => {
-		// This is the gap: a real Windows Terminal session with all three
-		// streams redirected (`omp ... < in > out 2> err`) lands here.
-		// `hostHasInheritableConsole` uses the Win32 FFI probe to recover
-		// the right answer in that scenario; this helper is the fallback.
-		expect(consoleAttachedViaTTY({ stdinIsTTY: false, stdoutIsTTY: false, stderrIsTTY: false })).toBe(false);
-	});
-});
-
-describe("hostHasInheritableConsole", () => {
-	afterEach(() => {
-		__resetWindowsConsoleProbeCache();
-	});
-
-	if (process.platform !== "win32") {
-		it("matches the TTY-OR fallback off-Windows", () => {
-			// Off-Windows, `windowsHide` is a no-op anyway, but we still
-			// expose `hostHasInheritableConsole` symmetrically. Confirm it
-			// degrades to the same OR the call site would compute by hand.
-			const tty = consoleAttachedViaTTY({
-				stdinIsTTY: !!process.stdin.isTTY,
-				stdoutIsTTY: !!process.stdout.isTTY,
-				stderrIsTTY: !!process.stderr.isTTY,
-			});
-			expect(hostHasInheritableConsole()).toBe(tty);
-		});
-	}
-});

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

@@ -1,156 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import * as vm from "node:vm";
-import { JAVASCRIPT_PRELUDE_SOURCE } from "../js/shared/prelude";
-
-/**
- * The eval `agent()` helper grows a `handle` option that turns its bare
- * text result into a DAG node dict carrying the spawned agent's recoverable
- * `agent://<id>` handle, so a downstream `pipeline`/`parallel` stage can wire
- * the transcript by reference instead of re-inlining it. These lock the node
- * shape, backward compatibility of the default path, the schema interaction,
- * and the no-`details` fallback (the helper must never throw).
- *
- * The prelude source is executed verbatim in a throwaway VM context with only
- * the host bridge (`__omp_call_tool__`) stubbed — no worker, no kernel — so the
- * test runs against the real shipped helper, not a re-implementation.
- */
-function loadPrelude(callTool: (name: string, args: unknown) => Promise<unknown>): Record<string, unknown> {
-	const sandbox: Record<string, unknown> = { __omp_call_tool__: callTool };
-	vm.createContext(sandbox);
-	vm.runInContext(JAVASCRIPT_PRELUDE_SOURCE, sandbox);
-	return sandbox;
-}
-
-type AgentHelper = (prompt: string, opts?: Record<string, unknown>) => Promise<unknown>;
-
-describe("eval js agent() handle", () => {
-	it("returns a DAG node carrying the agent:// handle when handle is set", async () => {
-		let seenName: string | undefined;
-		let seenArgs: Record<string, unknown> | undefined;
-		const sandbox = loadPrelude(async (name, args) => {
-			seenName = name;
-			seenArgs = args as Record<string, unknown>;
-			return { text: "hello world", details: { agent: "task", id: "abc123", model: "m", structured: false } };
-		});
-		const node = await (sandbox.agent as AgentHelper)("say hi", { handle: true });
-		expect(seenName).toBe("__agent__");
-		expect(seenArgs?.handle).toBe(true);
-		expect(node).toEqual({
-			text: "hello world",
-			output: "hello world",
-			handle: "agent://abc123",
-			id: "abc123",
-			agent: "task",
-		});
-	});
-
-	it("returns bare text by default (backward compatible)", async () => {
-		const sandbox = loadPrelude(async () => ({
-			text: "hello world",
-			details: { agent: "task", id: "abc123", structured: false },
-		}));
-		const out = await (sandbox.agent as AgentHelper)("say hi");
-		expect(out).toBe("hello world");
-	});
-
-	it("keeps positional isolation controls stable while appending schemaMode", async () => {
-		let seenArgs: Record<string, unknown> | undefined;
-		const sandbox = loadPrelude(async (_name, args) => {
-			seenArgs = args as Record<string, unknown>;
-			return { text: '{"ok":true}', details: { agent: "task", id: "legacy", structured: false } };
-		});
-		const positionalAgent = sandbox.agent as (
-			prompt: string,
-			options?: unknown,
-			...rest: unknown[]
-		) => Promise<unknown>;
-		const schema = { type: "object", properties: { ok: { type: "boolean" } } };
-
-		await positionalAgent("scout", "reviewer", "p/model", "Legacy", schema, true, false, true, "strict");
-
-		expect(seenArgs).toEqual({
-			prompt: "scout",
-			agent: "reviewer",
-			model: "p/model",
-			label: "Legacy",
-			schema,
-			isolated: true,
-			apply: false,
-			merge: true,
-			schemaMode: "strict",
-			handle: false,
-		});
-	});
-
-	it("carries the parsed object under data when schema and handle combine", async () => {
-		const payload = JSON.stringify({ k: 1 });
-		const sandbox = loadPrelude(async () => ({
-			text: payload,
-			details: { agent: "task", id: "id-9", structured: true },
-		}));
-		const node = (await (sandbox.agent as AgentHelper)("emit", {
-			schema: { type: "object" },
-			handle: true,
-		})) as Record<string, unknown>;
-		expect(node.handle).toBe("agent://id-9");
-		expect(node.data).toEqual({ k: 1 });
-		expect(node.text).toBe(payload);
-	});
-
-	it("falls back to a null handle without throwing when the bridge omits details", async () => {
-		const sandbox = loadPrelude(async () => ({ text: "lonely" }));
-		const node = await (sandbox.agent as AgentHelper)("x", { handle: true });
-		expect(node).toEqual({ text: "lonely", output: "lonely", handle: null, id: null, agent: null });
-	});
-
-	it("exposes patchPath/branchName/nestedPatches/changesApplied/isolated/isolationSummary on the handle", async () => {
-		const payload = JSON.stringify({ ok: true });
-		const sandbox = loadPrelude(async () => ({
-			text: payload,
-			details: {
-				agent: "task",
-				id: "iso-1",
-				structured: true,
-				isolated: true,
-				patchPath: "/artifacts/iso-1.patch",
-				changesApplied: null,
-				nestedPatches: [{ relativePath: "nested", patch: "diff --git a/file b/file\n" }],
-				isolationSummary: "Isolation: changes captured at `/artifacts/iso-1.patch` (apply=false). Not applied.",
-			},
-		}));
-		const node = (await (sandbox.agent as AgentHelper)("scout", {
-			schema: { type: "object" },
-			isolated: true,
-			apply: false,
-			handle: true,
-		})) as Record<string, unknown>;
-		expect(node.handle).toBe("agent://iso-1");
-		expect(node.data).toEqual({ ok: true });
-		expect(node.isolated).toBe(true);
-		expect(node.patchPath).toBe("/artifacts/iso-1.patch");
-		expect(node.nestedPatches).toEqual([{ relativePath: "nested", patch: "diff --git a/file b/file\n" }]);
-		expect(node.changesApplied).toBeNull();
-		expect(node.isolationSummary).toContain("/artifacts/iso-1.patch");
-		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

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

package/src/eval/py/__tests__/prelude.test.ts

@@ -1,104 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { PYTHON_PRELUDE } from "../prelude";
-
-const pythonPath = Bun.env.PYTHON ?? "python3";
-
-async function runPrelude(
-	code: string,
-	env: Record<string, string>,
-): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-	const prelude = PYTHON_PRELUDE.replace(
-		"from __future__ import annotations",
-		"from __future__ import annotations\n__omp_display = lambda *args, **kwargs: None",
-	);
-	const script = `${prelude}\n${code}`;
-	const proc = Bun.spawn([pythonPath, "-c", script], {
-		stdout: "pipe",
-		stderr: "pipe",
-		env: { ...process.env, ...env },
-	});
-	const [stdout, stderr, exitCode] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		proc.exited,
-	]);
-	return { stdout, stderr, exitCode };
-}
-
-describe("python prelude", () => {
-	it("exposes read(path, offset?, limit?) with positional optional args", () => {
-		// The eval docs advertise `read(path, offset?=1, limit?=None)`. A
-		// keyword-only signature (`def read(path, *, offset=1, limit=None)`)
-		// makes `read("file", 10)` raise `TypeError: read() takes 1 positional
-		// argument but 2 were given`, which agents in the wild repeatedly hit.
-		// Lock the contract so the helper accepts both positional and keyword
-		// forms.
-		const match = PYTHON_PRELUDE.match(/def\s+read\(([^)]+)\)/);
-		expect(match).not.toBeNull();
-		const signature = match?.[1] ?? "";
-		expect(signature).not.toContain("*,");
-		expect(signature).toContain("offset");
-		expect(signature).toContain("limit");
-	});
-
-	it("appends line selectors to delegated URI paths", async () => {
-		const requests: unknown[] = [];
-		const server = Bun.serve({
-			hostname: "127.0.0.1",
-			port: 0,
-			fetch: async request => {
-				requests.push(await request.json());
-				return Response.json({
-					ok: true,
-					value: { text: "resource contents", details: { resolvedPath: "/tmp/resource.txt" } },
-				});
-			},
-		});
-
-		try {
-			const result = await runPrelude(
-				[`print(read("artifact://21", 3, 2))`, `print(read("mcp://server/resource", 10, 5))`].join("\n"),
-				{
-					PI_TOOL_BRIDGE_URL: server.url.toString(),
-					PI_TOOL_BRIDGE_TOKEN: "test-token",
-					PI_TOOL_BRIDGE_SESSION: "test-session",
-				},
-			);
-
-			expect(result).toEqual({
-				stdout: "resource contents\nresource contents\n",
-				stderr: "",
-				exitCode: 0,
-			});
-			expect(requests).toEqual([
-				{
-					session: "test-session",
-					run: null,
-					name: "read",
-					args: { path: "artifact://21:3-4" },
-				},
-				{
-					session: "test-session",
-					run: null,
-					name: "read",
-					args: { path: "mcp://server/resource:10-14" },
-				},
-			]);
-		} finally {
-			server.stop(true);
-		}
-	});
-
-	it("exposes isolation artifacts on the agent() handle node", () => {
-		// agent(..., handle=True) is the only escape hatch for
-		// recovering apply=False patch/branch/nested artifacts (the bare
-		// schema return is just the parsed object), so the helper MUST
-		// translate the bridge's camelCase details onto the node — otherwise
-		// an isolated apply=False workflow loses captured nested patches.
-		expect(PYTHON_PRELUDE).toContain('("patchPath", "patch_path")');
-		expect(PYTHON_PRELUDE).toContain('("branchName", "branch_name")');
-		expect(PYTHON_PRELUDE).toContain('("nestedPatches", "nested_patches")');
-		expect(PYTHON_PRELUDE).toContain('("changesApplied", "changes_applied")');
-		expect(PYTHON_PRELUDE).toContain('("isolationSummary", "isolation_summary")');
-	});
-});

package/src/eval/py/__tests__/runner-shell-output.test.ts

@@ -1,157 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import * as path from "node:path";
-
-interface RunnerFrame {
-	type?: string;
-	id?: string;
-	data?: string;
-	status?: string;
-}
-
-const pythonPath = Bun.env.PYTHON ?? "python3";
-const runnerPath = path.resolve(import.meta.dir, "..", "runner.py");
-const repoRoot = path.resolve(import.meta.dir, "../../../../../..");
-const encoder = new TextEncoder();
-
-function shellQuote(value: string): string {
-	return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-
-async function runCell(code: string): Promise<RunnerFrame[]> {
-	const proc = Bun.spawn([pythonPath, "-u", runnerPath], {
-		cwd: repoRoot,
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
-		env: {
-			...process.env,
-			PYTHONUNBUFFERED: "1",
-			PYTHONIOENCODING: "utf-8",
-		},
-	});
-	const stderr = new Response(proc.stderr).text();
-	const reader = proc.stdout.getReader();
-	const decoder = new TextDecoder();
-	let pending = "";
-	const frames: RunnerFrame[] = [];
-
-	async function readFrame(): Promise<RunnerFrame> {
-		while (true) {
-			const newline = pending.indexOf("\n");
-			if (newline >= 0) {
-				const line = pending.slice(0, newline);
-				pending = pending.slice(newline + 1);
-				return JSON.parse(line) as RunnerFrame;
-			}
-			const { value, done } = await reader.read();
-			if (done) {
-				throw new Error(`Python runner exited before done frame: ${await stderr}`);
-			}
-			pending += decoder.decode(value, { stream: true });
-		}
-	}
-
-	try {
-		proc.stdin.write(encoder.encode(`${JSON.stringify({ id: "r1", code })}\n`));
-		proc.stdin.flush();
-		while (true) {
-			const frame = await readFrame();
-			frames.push(frame);
-			if (frame.type === "done") break;
-		}
-		proc.stdin.write(encoder.encode(`${JSON.stringify({ type: "exit" })}\n`));
-		proc.stdin.end();
-		const exitCode = await proc.exited;
-		if (exitCode !== 0) {
-			throw new Error(`Python runner exited ${exitCode}: ${await stderr}`);
-		}
-		return frames;
-	} finally {
-		try {
-			reader.releaseLock();
-		} catch {
-			// Reader may already be released by stream closure.
-		}
-		try {
-			proc.kill("SIGKILL");
-		} catch {
-			// Process already exited.
-		}
-	}
-}
-
-describe("Python runner shell output streaming", () => {
-	it("streams !cmd output chunks before the child process exits", async () => {
-		const child = [
-			"import sys,time",
-			"sys.stdout.write('first\\n')",
-			"sys.stdout.flush()",
-			"time.sleep(0.2)",
-			"sys.stdout.write('second\\n')",
-			"sys.stdout.flush()",
-		].join(";");
-		const frames = await runCell(
-			[
-				`result = !${pythonPath} -c ${shellQuote(child)}`,
-				"print('return=' + str(result.returncode) + ' lines=' + repr(list(result)))",
-			].join("\n"),
-		);
-		const stdout = frames.filter(frame => frame.type === "stdout").map(frame => frame.data);
-
-		expect(stdout[0]).toBe("first\n");
-		expect(stdout.join("")).toContain("second\n");
-		expect(stdout.join("")).toContain("return=0 lines=['first', 'second']");
-	});
-
-	it("caps !cmd output and captured result by line count with a truncation notice", async () => {
-		const child = ["import sys", "sys.stdout.write(('x' + chr(10)) * 3100)", "sys.stdout.flush()"].join(";");
-		const frames = await runCell(
-			[
-				`result = !${pythonPath} -c ${shellQuote(child)}`,
-				"print('captured=' + str(len(result)) + ' return=' + str(result.returncode))",
-			].join("\n"),
-		);
-		const stdout = frames
-			.filter(frame => frame.type === "stdout")
-			.map(frame => frame.data)
-			.join("");
-
-		expect(stdout).toContain("[output truncated: shell helper exceeded");
-		expect(stdout).toContain("captured=3000 return=0");
-		expect(stdout).not.toContain("captured=3100");
-	});
-
-	it("caps newline-free !cmd output by bytes with a truncation notice", async () => {
-		const child = ["import sys", "sys.stdout.write('z' * (1024 * 1024 + 17))", "sys.stdout.flush()"].join(";");
-		const frames = await runCell(
-			[
-				`result = !${pythonPath} -c ${shellQuote(child)}`,
-				"print('capturedChars=' + str(len(result.n)) + ' return=' + str(result.returncode))",
-			].join("\n"),
-		);
-		const stdout = frames
-			.filter(frame => frame.type === "stdout")
-			.map(frame => frame.data)
-			.join("");
-
-		expect(stdout).toContain("[output truncated: shell helper exceeded");
-		expect(stdout).toContain("capturedChars=1048576 return=0");
-		expect(stdout).not.toContain("capturedChars=1048593");
-	});
-
-	it("streams newline-free %%bash output without waiting for EOF", async () => {
-		const child = [
-			"import sys,time",
-			"sys.stdout.write('first')",
-			"sys.stdout.flush()",
-			"time.sleep(0.2)",
-			"sys.stdout.write('second')",
-			"sys.stdout.flush()",
-		].join(";");
-		const frames = await runCell(`%%bash\n${pythonPath} -c ${shellQuote(child)}`);
-		const stdout = frames.filter(frame => frame.type === "stdout").map(frame => frame.data);
-
-		expect(stdout[0]).toBe("first");
-		expect(stdout.join("")).toBe("firstsecond");
-	});
-});