pi-crew 0.9.56 → 0.9.57

package/scripts/test-issue-29-crash.ts

@@ -1,111 +0,0 @@
-#!/usr/bin/env -S npx tsx
-/**
- * Crash reproduction test for issue #29: verifies the defense-in-depth fix
- * in subagent-manager.ts:start() prevents unhandled rejections from
- * crashing the host process.
- *
- * Strategy: spawn a subagent whose runner throws, then do NOT await
- * record.promise. Without the fix, this triggers unhandledRejection which
- * Node.js converts to uncaughtException. With the fix, the .catch inside
- * start() absorbs the rejection.
- *
- * Run with: npx tsx scripts/test-issue-29-crash.ts
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-issue-29-crash-"));
-fs.mkdirSync(path.join(tmpDir, ".pi"), { recursive: true });
-
-console.log("Issue #29 CRASH reproduction test");
-console.log(`Project: ${tmpDir}`);
-console.log();
-
-let crashed = false;
-let crashError: Error | undefined;
-const crashEvents: string[] = [];
-
-process.on("uncaughtException", (error) => {
-	crashed = true;
-	crashError = error;
-	crashEvents.push(`uncaughtException: ${error.message}`);
-	console.error(`[CRASH] uncaughtException: ${error.message}`);
-});
-
-process.on("unhandledRejection", (reason) => {
-	crashed = true;
-	const err = reason instanceof Error ? reason : new Error(String(reason));
-	crashError = err;
-	crashEvents.push(`unhandledRejection: ${err.message}`);
-	console.error(`[CRASH] unhandledRejection: ${err.message}`);
-});
-
-async function main(): Promise<void> {
-	const piCrewRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-	const { SubagentManager } = await import(path.join(piCrewRoot, "src/runtime/subagent-manager.ts"));
-
-	const mgr = new SubagentManager();
-
-	const runnerThatThrows = async (): Promise<never> => {
-		throw new Error("simulated subagent failure (issue #29 crash test)");
-	};
-
-	const record = mgr.spawn(
-		{
-			cwd: tmpDir,
-			type: "test",
-			description: "issue-29 crash test",
-			prompt: "throw",
-			background: false,
-		},
-		runnerThatThrows as Parameters<typeof mgr.spawn>[1],
-	);
-
-	console.log(`Spawned subagent ${record.id}`);
-
-	// Do NOT await — this is the scenario that crashes pi.
-	console.log("Waiting 300ms without awaiting record.promise...");
-	await new Promise((resolve) => setTimeout(resolve, 300));
-
-	console.log();
-	console.log(`Results:`);
-	console.log(`  record.status = ${record.status}`);
-	console.log(`  process.crashed = ${crashed}`);
-	console.log(`  crashEvents = ${JSON.stringify(crashEvents)}`);
-	console.log();
-
-	fs.rmSync(tmpDir, { recursive: true, force: true });
-
-	if (crashed) {
-		console.error("✗ FAIL: process crashed (uncaughtException/unhandledRejection fired)");
-		console.error("  The defense-in-depth fix in subagent-manager.ts did NOT prevent the crash.");
-		if (crashError?.stack) {
-			console.error("  Stack trace:");
-			console.error(
-				crashError.stack
-					.split("\n")
-					.slice(0, 10)
-					.map((l) => `    ${l}`)
-					.join("\n"),
-			);
-		}
-		process.exit(1);
-	}
-
-	if (record.status !== "error") {
-		console.error(`✗ FAIL: record.status should be 'error', got '${record.status}'`);
-		process.exit(1);
-	}
-
-	console.log("✓ PASS: no crash, record marked 'error'");
-	process.exit(0);
-}
-
-main().catch((error) => {
-	console.error("Test script itself crashed:");
-	console.error(error);
-	process.exit(1);
-});

package/scripts/test-issue-29-e2e.ts

@@ -1,183 +0,0 @@
-#!/usr/bin/env -S npx tsx
-/**
- * End-to-end test for issue #29: "Hardcoded .crew/state/runs path crashes pi
- * (uncaughtException) in .pi-based projects".
- *
- * This script reproduces the EXACT scenario from the issue:
- *  1. Create a .pi/-only project (no .crew/ directory).
- *  2. Set up an uncaughtException + unhandledRejection detector.
- *  3. Trigger the bug path: start a subagent whose runner throws, then
- *     NOT await record.promise (mimics the indirect caller pattern
- *     described in the issue).
- *  4. Exit 0 if no crash, exit 1 if crash detected.
- *
- * Run with: npx tsx scripts/test-issue-29-e2e.ts
- *
- * The script must be run via `tsx` so that the dynamic ESM import of
- * subagent-manager resolves correctly.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-// ── Step 1: Set up a .pi/-only project (no .crew/) ──────────────────────
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-issue-29-e2e-"));
-fs.mkdirSync(path.join(tmpDir, ".pi"), { recursive: true });
-// CRITICALLY: no .crew/ directory
-const projectRoot = tmpDir;
-
-console.log("=".repeat(72));
-console.log("Issue #29 end-to-end reproduction test");
-console.log("=".repeat(72));
-console.log(`Project root: ${projectRoot}`);
-console.log(`Has .pi/:  ${fs.existsSync(path.join(projectRoot, ".pi"))}`);
-console.log(`Has .crew/: ${fs.existsSync(path.join(projectRoot, ".crew"))} (should be false)`);
-console.log();
-
-// ── Step 2: Install crash detectors ──────────────────────────────────────
-let crashed = false;
-let crashError: Error | undefined;
-
-process.on("uncaughtException", (error) => {
-	crashed = true;
-	crashError = error;
-	console.error("✗ FATAL: uncaughtException fired");
-	console.error("  This is the bug described in issue #29.");
-	console.error(`  Error: ${error.message}`);
-	if (error.stack) console.error(`  Stack: ${error.stack.split("\n").slice(0, 8).join("\n")}`);
-});
-
-process.on("unhandledRejection", (reason) => {
-	crashed = true;
-	const reasonErr = reason instanceof Error ? reason : new Error(String(reason));
-	crashError = reasonErr;
-	console.error("✗ FATAL: unhandledRejection fired");
-	console.error("  This is the bug described in issue #29.");
-	console.error(`  Reason: ${reasonErr.message}`);
-	if (reasonErr.stack) console.error(`  Stack: ${reasonErr.stack.split("\n").slice(0, 8).join("\n")}`);
-});
-
-// ── Step 3: Trigger the bug path ─────────────────────────────────────────
-
-async function main(): Promise<void> {
-	const piCrewRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-
-	// Dynamic import so the .ts files are loaded through tsx, not require.
-	const { SubagentManager } = await import(path.join(piCrewRoot, "src/runtime/subagent-manager.ts"));
-	const { waitForRun } = await import(path.join(piCrewRoot, "src/runtime/run-tracker.ts"));
-	const { projectCrewRoot } = await import(path.join(piCrewRoot, "src/utils/paths.ts"));
-
-	// Verify the resolver returns the .pi/teams/ path for our project.
-	const resolvedRoot = projectCrewRoot(projectRoot);
-	console.log(`projectCrewRoot(projectRoot) = ${resolvedRoot}`);
-	const expectedRoot = path.join(projectRoot, ".pi", "teams");
-	if (resolvedRoot !== expectedRoot) {
-		console.error(`✗ projectCrewRoot returned ${resolvedRoot}, expected ${expectedRoot}`);
-		process.exit(1);
-	}
-	console.log("✓ projectCrewRoot correctly resolves to .pi/teams/");
-	console.log();
-
-	// ── Test 3a: Direct waitForRun() crash path ─────────────────────────
-	console.log("Test 3a: Direct waitForRun() with non-existent runId");
-	console.log("-".repeat(72));
-	const startA = Date.now();
-	try {
-		await waitForRun("team_e2e_never_exists_xyz", projectRoot, {
-			timeoutMs: 500,
-			pollIntervalMs: 50,
-		});
-		console.error("✗ waitForRun should have thrown");
-	} catch (error) {
-		const msg = (error as Error).message;
-		const elapsed = Date.now() - startA;
-		console.log(`✓ waitForRun threw after ${elapsed}ms (as expected)`);
-		console.log(`  Message: ${msg}`);
-		if (msg.includes(".pi/teams")) {
-			console.log("✓ Error message references .pi/teams/ (resolver applied)");
-		} else if (msg.includes(".crew/state/runs")) {
-			console.error(`✗ Error message still references .crew/state/runs/ (BUG NOT FIXED)`);
-			process.exit(1);
-		} else {
-			console.error(`✗ Error message doesn't reference expected path: ${msg}`);
-			process.exit(1);
-		}
-	}
-	console.log();
-
-	// ── Test 3b: Indirect crash path via SubagentManager ────────────────
-	// This is the ACTUAL crash path: subagent fails → record.promise rejects
-	// → no caller awaits → unhandled rejection → pi crashes.
-	console.log("Test 3b: SubagentManager with runner that throws (no awaiter)");
-	console.log("-".repeat(72));
-	const mgr = new SubagentManager();
-
-	const runnerThatThrows = async (): Promise<never> => {
-		// Simulate a failed run lookup inside the subagent — this is what
-		// waitForRun() throws when the run directory doesn't exist.
-		// The runner returns a synthetic result, and then pollRunToTerminal
-		// would call waitForRun internally, but to keep the test focused we
-		// throw directly from the runner (mimics any unhandled subagent failure).
-		throw new Error(
-			`Run team_e2e_simulated not found. No run directory at ${path.join(projectRoot, ".crew", "state", "runs", "team_e2e_simulated")}`,
-		);
-	};
-
-	const record = mgr.spawn(
-		{
-			cwd: projectRoot,
-			type: "test",
-			description: "issue-29-e2e test",
-			prompt: "simulate failure",
-			background: false,
-		},
-		runnerThatThrows as Parameters<typeof mgr.spawn>[1],
-	);
-
-	console.log(`Spawned subagent ${record.id} (status: ${record.status})`);
-
-	// CRITICALLY: do NOT await record.promise — this is the scenario
-	// described in the issue where the throw escapes as an unhandled
-	// rejection because no caller awaits.
-	console.log("Waiting 500ms without awaiting record.promise...");
-	await new Promise((resolve) => setTimeout(resolve, 500));
-
-	console.log(`After 500ms:`);
-	console.log(`  record.status = ${record.status}`);
-	console.log(`  process.crashed = ${crashed}`);
-	console.log();
-
-	// ── Step 4: Final verdict ───────────────────────────────────────────
-	if (crashed) {
-		console.error("=".repeat(72));
-		console.error("✗ TEST FAILED: process crashed (uncaughtException or unhandledRejection)");
-		console.error("=".repeat(72));
-		console.error("The fix in commit a80fe6c did NOT prevent the crash.");
-		process.exit(1);
-	}
-
-	if (record.status !== "error") {
-		console.error(`✗ TEST FAILED: record.status should be 'error', got '${record.status}'`);
-		process.exit(1);
-	}
-
-	console.log("=".repeat(72));
-	console.log("✓ ALL TESTS PASSED");
-	console.log("  - projectCrewRoot correctly resolves .pi/teams/");
-	console.log("  - waitForRun() throws with .pi/teams/ in error message");
-	console.log("  - SubagentManager rejection is caught by defense-in-depth .catch");
-	console.log("  - No uncaughtException or unhandledRejection fired");
-	console.log("=".repeat(72));
-
-	// Cleanup
-	fs.rmSync(tmpDir, { recursive: true, force: true });
-	process.exit(0);
-}
-
-main().catch((error) => {
-	console.error("Test script itself crashed:");
-	console.error(error);
-	process.exit(1);
-});

package/scripts/test-issue-29-real-runtime.ts

@@ -1,330 +0,0 @@
-#!/usr/bin/env -S npx tsx
-/**
- * REAL-RUNTIME E2E test for issue #29.
- *
- * This is the most realistic test possible without invoking the full
- * `pi` agent loop. It:
- *   1. Sets up a .pi/-only project (no .crew/).
- *   2. Creates a real team run manifest via createRunManifest().
- *   3. Calls spawnBackgroundTeamRun() which spawns a REAL detached
- *      background-runner.ts process (the same path used by `team action='run'`).
- *   4. Waits for the background runner to write background.log and exit.
- *   5. Verifies EVERY path the fix touched:
- *      - logPath is at .pi/teams/state/runs/<runId>/background.log
- *      - exit-code.txt is at .pi/teams/state/runs/<runId>/exit-code.txt
- *      - manifest.json is at .pi/teams/state/runs/<runId>/manifest.json
- *      - tasks.json is at .pi/teams/state/runs/<runId>/tasks.json
- *      - events.jsonl is at .pi/teams/state/runs/<runId>/events.jsonl
- *   6. Verifies NO files leak to .crew/state/runs/...
- *   7. Captures any uncaughtException/unhandledRejection from the test
- *      process (which would indicate the bug fires).
- *
- * The test uses PI_CREW_EXECUTE_WORKERS=false so the team-runner uses
- * "scaffold" runtime (no child Pi agents spawned), but the background-
- * runner process itself is REAL — it actually runs, writes to disk, and
- * exits. This exercises all 11 fixed sites:
- *   - background-runner.ts:139 (log redirect path)
- *   - background-runner.ts:172 (exit-code path)
- *   - run-tracker.ts:82 (waitForRun slow path early-exit)
- *   - checkpoint.ts:166,177,188,199,209 (5 sites)
- *   - skill-effectiveness.ts:115,125 (when tasks complete)
- *   - decision-ledger.ts:29 (when rollouts happen)
- *
- * Run with: npx tsx scripts/test-issue-29-real-runtime.ts
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-crew-issue-29-runtime-"));
-fs.mkdirSync(path.join(tmpDir, ".pi"), { recursive: true });
-// CRITICALLY: no .crew/
-
-console.log("=".repeat(72));
-console.log("Issue #29 REAL-RUNTIME E2E test");
-console.log("  (spawns REAL detached background-runner.ts process)");
-console.log("=".repeat(72));
-console.log(`Project: ${tmpDir}`);
-console.log(`  Has .pi/  : ${fs.existsSync(path.join(tmpDir, ".pi"))}`);
-console.log(`  Has .crew/: ${fs.existsSync(path.join(tmpDir, ".crew"))} (should be false)`);
-console.log();
-
-// ── Crash detection ──────────────────────────────────────────────────────
-let crashed = false;
-let crashError: Error | undefined;
-process.on("uncaughtException", (error) => {
-	crashed = true;
-	crashError = error;
-	console.error(`[CRASH] uncaughtException: ${error.message}`);
-});
-process.on("unhandledRejection", (reason) => {
-	crashed = true;
-	const err = reason instanceof Error ? reason : new Error(String(reason));
-	crashError = err;
-	console.error(`[CRASH] unhandledRejection: ${err.message}`);
-});
-
-// Force placeholder workers in the background runner (no LLM needed).
-// The runtime resolver checks for "0" (string) to disable child worker execution.
-process.env.PI_CREW_EXECUTE_WORKERS = "0";
-process.env.PI_TEAMS_EXECUTE_WORKERS = "0";
-// We also need to set runConfig.runtime.mode = "scaffold" in the manifest
-// because the background-runner explicitly blocks PI_CREW_EXECUTE_WORKERS
-// from leaking to the child (security feature).
-
-const piCrewRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-let pass = 0;
-let fail = 0;
-const failures: string[] = [];
-
-function check(label: string, condition: boolean, detail = ""): void {
-	if (condition) {
-		pass++;
-		console.log(`  ✓ ${label}`);
-	} else {
-		fail++;
-		failures.push(label);
-		console.error(`  ✗ ${label}${detail ? ` — ${detail}` : ""}`);
-	}
-}
-
-async function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitForFile(filePath: string, timeoutMs: number): Promise<boolean> {
-	const start = Date.now();
-	while (Date.now() - start < timeoutMs) {
-		if (fs.existsSync(filePath)) return true;
-		await sleep(100);
-	}
-	return false;
-}
-
-async function main(): Promise<void> {
-	const { createRunManifest } = await import(path.join(piCrewRoot, "src/state/state-store.ts"));
-	const { discoverTeams, allTeams } = await import(path.join(piCrewRoot, "src/teams/discover-teams.ts"));
-	const { discoverWorkflows, allWorkflows } = await import(path.join(piCrewRoot, "src/workflows/discover-workflows.ts"));
-	const { spawnBackgroundTeamRun } = await import(path.join(piCrewRoot, "src/runtime/async-runner.ts"));
-	const { projectCrewRoot, clearProjectRootCache } = await import(path.join(piCrewRoot, "src/utils/paths.ts"));
-	const { loadRunManifestById } = await import(path.join(piCrewRoot, "src/state/state-store.ts"));
-
-	clearProjectRootCache();
-	const root = projectCrewRoot(tmpDir);
-	check(`projectCrewRoot returns .pi/teams/`, root === path.join(tmpDir, ".pi", "teams"));
-
-	// ── Set up a team run ─────────────────────────────────────────────
-	console.log();
-	console.log("Step 1: Create team run manifest");
-	console.log("-".repeat(72));
-
-	const teams = allTeams(discoverTeams(tmpDir));
-	const workflows = allWorkflows(discoverWorkflows(tmpDir));
-	const team = teams.find((t) => t.name === "fast-fix");
-	const workflow = workflows.find((w) => w.name === "fast-fix");
-	check("fast-fix team discovered", Boolean(team));
-	check("fast-fix workflow discovered", Boolean(workflow));
-
-	if (!team || !workflow) {
-		console.error("Cannot continue without team/workflow");
-		process.exit(1);
-	}
-
-	const { manifest } = createRunManifest({
-		cwd: tmpDir,
-		team,
-		workflow,
-		goal: "REAL RUNTIME test: spawn background runner, verify paths land in .pi/teams/state/runs/",
-		workspaceMode: "single",
-	});
-
-	// Force scaffold mode so no child Pi workers are spawned (no LLM needed).
-	// This is what the background-runner will use.
-	const scaffoldRuntimeResolution = {
-		kind: "scaffold" as const,
-		requestedMode: "scaffold" as const,
-		available: true,
-		reason: "Test: forced scaffold mode for E2E without LLM",
-		resolvedAt: new Date().toISOString(),
-	};
-	const scaffoldRunConfig = {
-		...((manifest as { runConfig?: unknown }).runConfig ?? {}),
-		executeWorkers: false,
-		runtime: {
-			...(((manifest as { runConfig?: { runtime?: unknown } }).runConfig?.runtime ?? {}) as Record<string, unknown>),
-			mode: "scaffold",
-		},
-	};
-	const manifestWithRuntime = {
-		...manifest,
-		runtimeResolution: scaffoldRuntimeResolution,
-		runConfig: scaffoldRunConfig,
-	};
-
-	// Override status to queued (createRunManifest sets it, but let's be explicit)
-	const queuedManifest = {
-		...manifestWithRuntime,
-		status: "queued" as const,
-	};
-	console.log(`  Created run: ${queuedManifest.runId}`);
-	console.log(`  stateRoot:   ${queuedManifest.stateRoot}`);
-	console.log(`  runtime:     ${queuedManifest.runtimeResolution?.kind ?? "(default)"}`);
-
-	check(
-		`manifest.stateRoot is under .pi/teams/state/runs/`,
-		queuedManifest.stateRoot === path.join(tmpDir, ".pi", "teams", "state", "runs", queuedManifest.runId),
-		`got: ${queuedManifest.stateRoot}`,
-	);
-
-	// ── Step 2: Spawn REAL background runner ──────────────────────────
-	console.log();
-	console.log("Step 2: spawnBackgroundTeamRun() — spawn REAL detached process");
-	console.log("-".repeat(72));
-
-	// Pass the queued manifest (background runner expects this format)
-	// We also need to write the manifest to disk so the runner can read it.
-	const stateDir = queuedManifest.stateRoot;
-	fs.mkdirSync(stateDir, { recursive: true });
-	fs.writeFileSync(path.join(stateDir, "manifest.json"), JSON.stringify(queuedManifest, null, 2));
-
-	const tStart = Date.now();
-	const spawnResult = await spawnBackgroundTeamRun(queuedManifest);
-	console.log(`  Spawned background runner`);
-	console.log(`    PID:     ${spawnResult.pid ?? "(unknown)"}`);
-	console.log(`    logPath: ${spawnResult.logPath}`);
-	console.log();
-
-	// ── Step 3: Verify the logPath is in the CORRECT location ─────────
-	// This is the path the background-runner.ts writes to (line 139).
-	check(
-		`logPath is under .pi/teams/state/runs/<runId>/background.log`,
-		spawnResult.logPath === path.join(stateDir, "background.log"),
-		`got: ${spawnResult.logPath}`,
-	);
-	check(`logPath is NOT under .crew/state/runs/...`, !spawnResult.logPath.includes(".crew/state/runs"));
-
-	// ── Step 4: Wait for the background runner to finish ──────────────
-	console.log();
-	console.log("Step 3: Wait for background runner to write logs and exit");
-	console.log("-".repeat(72));
-
-	// Wait for background.log to exist
-	const logWritten = await waitForFile(spawnResult.logPath, 30_000);
-	if (!logWritten) {
-		fail++;
-		failures.push("background.log was created within 30s");
-		console.error("  ✗ background.log was not created within 30s");
-	} else {
-		console.log(`  ✓ background.log created at ${spawnResult.logPath}`);
-	}
-
-	// Wait for exit-code.txt (background-runner.ts:172 writes this on exit)
-	const exitCodePath = path.join(stateDir, "exit-code.txt");
-	const exitCodeWritten = await waitForFile(exitCodePath, 30_000);
-	if (!exitCodeWritten) {
-		fail++;
-		failures.push("exit-code.txt was created within 30s");
-		console.error("  ✗ exit-code.txt was not created within 30s");
-	} else {
-		const elapsed = Date.now() - tStart;
-		console.log(`  ✓ exit-code.txt created in ${elapsed}ms`);
-		const exitCode = fs.readFileSync(exitCodePath, "utf-8").trim();
-		console.log(`    Contents: ${JSON.stringify(exitCode.slice(0, 200))}`);
-	}
-
-	// Wait for the process to actually exit
-	let processExited = false;
-	for (let i = 0; i < 50; i++) {
-		if (spawnResult.pid !== undefined) {
-			try {
-				process.kill(spawnResult.pid, 0); // Check if alive
-				await sleep(200);
-			} catch {
-				processExited = true;
-				break;
-			}
-		} else {
-			// No PID — assume the runner already exited (synchronously)
-			processExited = true;
-			break;
-		}
-	}
-	check(`background runner process exited (PID ${spawnResult.pid})`, processExited);
-
-	// ── Step 5: Verify NO files leaked to .crew/ ──────────────────────
-	console.log();
-	console.log("Step 4: Verify no .crew/ files were created");
-	console.log("-".repeat(72));
-
-	const crewDir = path.join(tmpDir, ".crew");
-	check(`no .crew/ directory was created (would indicate fallback)`, !fs.existsSync(crewDir), `found at: ${crewDir}`);
-
-	// Also check that all the expected files are under .pi/teams/
-	const expectedFiles = ["manifest.json", "tasks.json", "events.jsonl", "background.log", "exit-code.txt"];
-	for (const f of expectedFiles) {
-		const p = path.join(stateDir, f);
-		check(`${f} exists at .pi/teams/state/runs/<runId>/${f}`, fs.existsSync(p));
-	}
-
-	// ── Step 6: Verify the runner wrote meaningful content ───────────
-	console.log();
-	console.log("Step 5: Verify background runner output");
-	console.log("-".repeat(72));
-
-	if (logWritten) {
-		const logContent = fs.readFileSync(spawnResult.logPath, "utf-8");
-		const lineCount = logContent.split("\n").filter((l) => l.trim()).length;
-		check(`background.log has content (${lineCount} non-empty lines)`, lineCount > 0);
-		console.log(`    First 200 chars: ${JSON.stringify(logContent.slice(0, 200))}`);
-	}
-
-	// Verify the manifest was updated by the runner
-	const reloaded = loadRunManifestById(tmpDir, queuedManifest.runId);
-	check(`manifest can be reloaded after runner completed`, Boolean(reloaded));
-	if (reloaded) {
-		console.log(`    Final status: ${reloaded.manifest.status}`);
-		check(
-			`final status is completed/failed/cancelled (not 'running')`,
-			["completed", "failed", "cancelled"].includes(reloaded.manifest.status),
-			`got: ${reloaded.manifest.status}`,
-		);
-	}
-
-	// ── Final verdict ───────────────────────────────────────────────────
-	console.log();
-	console.log("=".repeat(72));
-	console.log(`Results: ${pass} passed, ${fail} failed, ${crashed ? "1" : "0"} crashed`);
-	if (failures.length > 0) {
-		console.error("Failures:");
-		for (const f of failures) console.error(`  - ${f}`);
-	}
-	if (crashed) {
-		console.error(`Crashed: ${crashError?.message}`);
-	}
-	console.log("=".repeat(72));
-
-	// Cleanup
-	try {
-		fs.rmSync(tmpDir, { recursive: true, force: true });
-	} catch {
-		/* ignore */
-	}
-
-	if (crashed || fail > 0) {
-		process.exit(1);
-	}
-	process.exit(0);
-}
-
-main().catch((error) => {
-	console.error("Test script itself crashed:");
-	console.error(error);
-	try {
-		fs.rmSync(tmpDir, { recursive: true, force: true });
-	} catch {
-		/* ignore */
-	}
-	process.exit(1);
-});