@glubean/cli 0.2.2 → 0.2.4

package/dist/commands/run.js

@@ -1,15 +1,15 @@
-import { discoverSessionFile, evaluateThresholds, MetricCollector, normalizePositiveTimeoutMs, RunOrchestrator, TestExecutor, toSingleExecutionOptions, buildRunContext, } from "@glubean/runner";
+import { bootstrap, evaluateThresholds, MetricCollector, ProjectRunner, buildRunContext, } from "@glubean/runner";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { stat, readdir, readFile, writeFile, mkdir, rm } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
 import { glob } from "node:fs/promises";
 import { loadConfig, mergeRunOptions, toSharedRunConfig } from "../lib/config.js";
-import { loadEnvFile } from "../lib/env.js";
+import { loadProjectEnv } from "@glubean/runner";
 import { resolveEnvFileName } from "../lib/active_env.js";
 import { shouldSkipTest } from "../lib/skip.js";
 import { CLI_VERSION } from "../version.js";
 import { extractContractCases, extractFromSource } from "@glubean/scanner/static";
-import { extractContractFromFile } from "@glubean/scanner";
+import { extractContractFromFile, loadProjectOverlays } from "@glubean/scanner";
+import { applyEnvTemplating } from "@glubean/runner";
 // ANSI color codes for pretty output
 const colors = {
     reset: "\x1b[0m",
@@ -54,10 +54,24 @@ const DEFAULT_EXTENSIONS = ["ts"];
 function isGlob(target) {
     return /[*?{[]/.test(target);
 }
-const TEST_FILE_SUFFIXES = [".test.ts", ".contract.ts", ".flow.ts"];
+// Test files: anything that may CONTRIBUTE runnable tests OR overlay
+// registrations during a run. `.bootstrap.ts` files don't produce
+// runnables themselves, but they MUST be loaded so `contract.bootstrap()`
+// calls execute and register overlays before discovery runs (attachment-
+// model §7.4). `discoverTests()` is responsible for distinguishing
+// bootstrap-only files from runnable-emitting ones.
+const TEST_FILE_SUFFIXES = [
+    ".test.ts",
+    ".contract.ts",
+    ".flow.ts",
+    ".bootstrap.ts",
+];
 function isGlubeanTestFile(name) {
     return TEST_FILE_SUFFIXES.some((suffix) => name.endsWith(suffix));
 }
+function isBootstrapOnlyFile(name) {
+    return name.endsWith(".bootstrap.ts");
+}
 async function walkTestFiles(dir, result) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -104,6 +118,14 @@ async function resolveTestFiles(target) {
     return [abs];
 }
 export async function discoverTests(filePath) {
+    // `.bootstrap.ts` files register overlays as a side-effect of import; they
+    // produce no runnable tests of their own. We don't even need to import here
+    // because the project-wide `loadProjectOverlays()` ran before discovery.
+    // Returning [] here keeps these files in the walker (so filtered runs
+    // still evaluate them transitively) without surfacing phantom test entries.
+    if (isBootstrapOnlyFile(filePath)) {
+        return [];
+    }
     const content = await readFile(filePath, "utf-8");
     if (filePath.includes(".contract.") || filePath.includes(".flow.")) {
         // Runtime extraction via shared function (supports .with() syntax).
@@ -128,20 +150,18 @@ export async function discoverTests(filePath) {
             }
         }
         // Each flow has a single orchestrator Test (setup → steps → teardown).
-        // Discover it as one runnable entry with the flow id.
-        if (result.flows) {
-            for (const flow of result.flows) {
-                results.push({
-                    exportName: flow.exportName,
-                    meta: {
-                        id: flow.id,
-                        description: flow.description,
-                        // Flow-level meta.skip was propagated to TestMeta.deferred
-                        // by the flow builder (contract-core.ts), surfaced via the
-                        // extracted projection's description where applicable.
-                    },
-                });
-            }
+        // Discover it as one runnable entry with the flow id. Post-Phase 2f
+        // flows live as `kind: "flow"` entries inside `result.attachments`.
+        for (const att of result.attachments) {
+            if (att.kind !== "flow")
+                continue;
+            results.push({
+                exportName: att.exportName,
+                meta: {
+                    id: att.flow.id,
+                    description: att.flow.description,
+                },
+            });
         }
         if (results.length > 0)
             return results;
@@ -308,7 +328,13 @@ export async function runCommand(target, options = {}) {
             process.exit(1);
         }
     }
-    const envVars = await loadEnvFile(envPath);
+    // Canonical env loading: reads both .env and .env.secrets, expands
+    // `${NAME}` references (same file forward refs, cross-file refs, and
+    // process.env fallback), splits back into {vars, secrets} with secrets
+    // winning on collision. See @glubean/runner:loadProjectEnv.
+    const { vars: envVars, secrets } = await loadProjectEnv(rootDir, envFileName);
+    // Warn separately on the missing-secrets case so users get a visual
+    // signal — loadProjectEnv itself treats missing files as silent empties.
     const secretsPath = resolve(rootDir, `${envFileName}.secrets`);
     let secretsExist = true;
     try {
@@ -317,7 +343,6 @@ export async function runCommand(target, options = {}) {
     catch {
         secretsExist = false;
     }
-    const secrets = secretsExist ? await loadEnvFile(secretsPath) : {};
     if (!secretsExist && Object.keys(envVars).length > 0) {
         console.warn(`${colors.yellow}Warning: secrets file '${envFileName}.secrets' not found in ${rootDir}${colors.reset}`);
     }
@@ -369,6 +394,29 @@ export async function runCommand(target, options = {}) {
             process.exit(1);
         }
     }
+    // ── Bootstrap plugins BEFORE discovery ─────────────────────────────────
+    // CLI's `discoverTests` dynamically imports each .contract.ts / .test.ts
+    // in this process. If the file uses plugin-registered names like
+    // `contract.graphql.with(...)` before the plugin's manifest is installed,
+    // the import throws ("Cannot read properties of undefined (reading
+    // 'with')"). ProjectRunner calls bootstrap() too, but that happens AFTER
+    // our discovery — too late. Matching MCP's `glubean_openapi` pattern here:
+    // explicit bootstrap before any parent-process contract file import. The
+    // call is idempotent (bootstrap tracks loadState internally), so
+    // ProjectRunner's internal call is a no-op second visit.
+    await bootstrap(rootDir);
+    // ── Eager-load overlay registrations (attachment-model §7.4) ────────────
+    // A filtered run (e.g. `glubean run path/to/single.contract.ts`) would
+    // otherwise miss sibling `*.bootstrap.ts` overlay registrations that
+    // wrap cases in the filtered-in contract. §7.4 mandates eager loading
+    // before any test runs so overlay registration is deterministic.
+    // Idempotent: ProjectRunner re-invokes the same helper (no-op second
+    // visit thanks to mtime-keyed module cache).
+    const overlayLoad = await loadProjectOverlays(rootDir);
+    for (const err of overlayLoad.errors) {
+        console.error(`${colors.yellow}⚠ Bootstrap overlay failed to load:${colors.reset} ${err.file}`);
+        console.error(`${colors.dim}${err.error}${colors.reset}`);
+    }
     // ── Discover tests across all files ─────────────────────────────────────
     console.log(`${colors.dim}Discovering tests...${colors.reset}`);
     const allFileTests = [];
@@ -452,6 +500,113 @@ export async function runCommand(target, options = {}) {
         console.log(`${colors.dim}${parts.join(" + ")} (${testsToRun.length}/${totalDiscovered} tests)${colors.reset}`);
     }
     console.log(`\n${colors.bold}Running ${testsToRun.length} test(s)...${colors.reset}\n`);
+    // ── Spike 3: runner input channels (attachment-model §8) ────────────────
+    // `--input-json` / `--bootstrap-json` / `--force-standalone` apply to a
+    // single targeted case; require --filter to resolve to exactly one test.
+    // Maps are JSON-encoded `{ [testId]: <value> }` and passed to the harness
+    // subprocess via env vars (which the harness reads in `setExplicitInput`
+    // / `setBootstrapInput` / `setForceStandalone` calls before user import).
+    const hasInputFlag = options.inputJson !== undefined ||
+        options.bootstrapJson !== undefined ||
+        options.forceStandalone === true;
+    if (hasInputFlag) {
+        // §5.1 invariant: explicit input always wins; overlay (and therefore
+        // its bootstrap-params channel) is NOT invoked. Per the proposal's
+        // "no run-bootstrap-for-side-effects-then-use-my-input mode" rule,
+        // the two channels are exclusive at the surface boundary too —
+        // dispatcher would silently drop the bootstrap input otherwise.
+        if (options.inputJson !== undefined &&
+            options.bootstrapJson !== undefined) {
+            console.error(`\n${colors.red}❌ --input-json and --bootstrap-json are mutually exclusive.${colors.reset}\n` +
+                `${colors.dim}Per attachment-model §5.1: explicit input bypasses the overlay, so bootstrap params would be ignored. Pick one channel per run.${colors.reset}\n`);
+            process.exit(1);
+        }
+        if (testsToRun.length !== 1) {
+            console.error(`\n${colors.red}❌ --input-json / --bootstrap-json / --force-standalone require ` +
+                `--filter to match exactly one testId. Matched ${testsToRun.length} tests.${colors.reset}\n`);
+            if (testsToRun.length > 1) {
+                const ids = testsToRun.map((t) => t.test.meta.id).slice(0, 10);
+                console.error(`${colors.dim}First matches: ${ids.join(", ")}${ids.length < testsToRun.length ? "…" : ""}${colors.reset}`);
+            }
+            process.exit(1);
+        }
+        const targetTestId = testsToRun[0].test.meta.id;
+        async function resolveJsonFlag(raw, flagName) {
+            let text;
+            if (raw.startsWith("@")) {
+                const filePath = resolve(raw.slice(1));
+                try {
+                    text = await readFile(filePath, "utf-8");
+                }
+                catch (err) {
+                    console.error(`\n${colors.red}❌ ${flagName}: could not read ${filePath}: ` +
+                        `${err instanceof Error ? err.message : String(err)}${colors.reset}\n`);
+                    process.exit(1);
+                }
+            }
+            else {
+                text = raw;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch (err) {
+                console.error(`\n${colors.red}❌ ${flagName}: invalid JSON: ` +
+                    `${err instanceof Error ? err.message : String(err)}${colors.reset}\n`);
+                process.exit(1);
+            }
+        }
+        // Templating env: project-loaded vars+secrets + process.env. Secrets
+        // win over vars; process.env wins over both (matches `loadProjectEnv`'s
+        // own precedence). §8 — substitution happens before schema validation.
+        const templatingEnv = {
+            ...envVars,
+            ...secrets,
+            ...process.env,
+        };
+        if (options.inputJson !== undefined) {
+            const parsed = await resolveJsonFlag(options.inputJson, "--input-json");
+            let templated;
+            try {
+                templated = applyEnvTemplating(parsed, templatingEnv);
+            }
+            catch (err) {
+                console.error(`\n${colors.red}❌ --input-json: ${err instanceof Error ? err.message : String(err)}${colors.reset}\n`);
+                process.exit(1);
+            }
+            process.env["GLUBEAN_RUNNER_EXPLICIT_INPUT_MAP"] = JSON.stringify({
+                [targetTestId]: templated,
+            });
+            console.log(`${colors.dim}  --input-json: ${targetTestId}${colors.reset}`);
+        }
+        if (options.bootstrapJson !== undefined) {
+            const parsed = await resolveJsonFlag(options.bootstrapJson, "--bootstrap-json");
+            let templated;
+            try {
+                templated = applyEnvTemplating(parsed, templatingEnv);
+            }
+            catch (err) {
+                console.error(`\n${colors.red}❌ --bootstrap-json: ${err instanceof Error ? err.message : String(err)}${colors.reset}\n`);
+                process.exit(1);
+            }
+            process.env["GLUBEAN_RUNNER_BOOTSTRAP_INPUT_MAP"] = JSON.stringify({
+                [targetTestId]: templated,
+            });
+            console.log(`${colors.dim}  --bootstrap-json: ${targetTestId}${colors.reset}`);
+        }
+        if (options.forceStandalone === true) {
+            process.env["GLUBEAN_RUNNER_FORCE_STANDALONE_IDS"] = JSON.stringify([
+                targetTestId,
+            ]);
+            console.warn(`${colors.yellow}⚠ --force-standalone enabled for ${targetTestId} (debug)${colors.reset}`);
+        }
+    }
+    else {
+        // Clear stale state from prior runs in the same process.
+        delete process.env["GLUBEAN_RUNNER_EXPLICIT_INPUT_MAP"];
+        delete process.env["GLUBEAN_RUNNER_BOOTSTRAP_INPUT_MAP"];
+        delete process.env["GLUBEAN_RUNNER_FORCE_STANDALONE_IDS"];
+    }
     if (options.pick) {
         process.env.GLUBEAN_PICK = options.pick;
         console.log(`${colors.dim}  pick: ${options.pick}${colors.reset}`);
@@ -460,10 +615,9 @@ export async function runCommand(target, options = {}) {
         delete process.env.GLUBEAN_PICK;
     }
     const shared = toSharedRunConfig(effectiveRun);
-    const executor = TestExecutor.fromSharedConfig(shared, {
-        cwd: rootDir,
-        ...(options.inspectBrk && { inspectBrk: options.inspectBrk }),
-    });
+    // Note: TestExecutor construction is delegated to ProjectRunner below
+    // (it builds one via TestExecutor.fromSharedConfig with identical cwd +
+    // inspectBrk params when no executor option is passed).
     let passed = 0;
     let failed = 0;
     let skipped = 0;
@@ -490,40 +644,15 @@ export async function runCommand(target, options = {}) {
         group.push(entry);
         fileGroups.set(entry.filePath, group);
     }
-    // ── Session discovery and setup ───────────────────────────────────────────
+    // ── Session + execution + teardown via ProjectRunner ─────────────────────
+    //
+    // Replaces the prior inline RunOrchestrator + per-file TestExecutor loop
+    // (~540 lines) with a single event-stream consumer. Per-event presentation
+    // handlers (trace / assertion / step / etc.) are byte-for-byte unchanged;
+    // only the outer wiring swaps from direct executor.run(...) to the facade.
+    //
+    // See internal/30-execution/2026-04-23-rf-1b-cli-migration/execution-log.md.
     const sessionState = {};
-    const sessionFile = options.noSession
-        ? undefined
-        : discoverSessionFile(startDir, rootDir);
-    const orchestrator = new RunOrchestrator(executor);
-    if (sessionFile) {
-        console.log(`${colors.dim}Session: ${relative(process.cwd(), sessionFile)}${colors.reset}`);
-        let sessionFailed = false;
-        for await (const event of orchestrator.runSessionSetup(sessionFile, { vars: envVars, secrets, interactive }, toSingleExecutionOptions(shared))) {
-            if (event.type === "session:set") {
-                sessionState[event.key] = event.value;
-            }
-            else if (event.type === "status" && event.status === "failed") {
-                sessionFailed = true;
-                console.log(`  ${colors.red}✗ Session setup failed${event.error ? `: ${event.error}` : ""}${colors.reset}`);
-            }
-            else if (event.type === "log") {
-                console.log(`  ${colors.dim}[session] ${event.message}${colors.reset}`);
-            }
-        }
-        if (sessionFailed) {
-            // Best-effort teardown before exiting
-            for await (const _event of orchestrator.runSessionTeardown(sessionFile, { vars: envVars, secrets }, sessionState, toSingleExecutionOptions(shared))) {
-                // Silently consume teardown events
-            }
-            console.log(`\n${colors.red}Session setup failed. All tests skipped.${colors.reset}`);
-            process.exit(1);
-        }
-        const keyCount = Object.keys(sessionState).length;
-        if (keyCount > 0) {
-            console.log(`${colors.dim}  ${keyCount} session value${keyCount > 1 ? "s" : ""} set${colors.reset}`);
-        }
-    }
     const compactUrl = (url) => {
         try {
             const u = new URL(url);
@@ -543,372 +672,475 @@ export async function runCommand(target, options = {}) {
             return `${colors.dim}${status}${colors.reset}`;
         return `${colors.green}${status}${colors.reset}`;
     };
-    for (const [groupFilePath, fileTests] of fileGroups) {
-        if (isMultiFile) {
-            const relPath = relative(process.cwd(), groupFilePath);
-            console.log(`${colors.bold}📁 ${relPath}${colors.reset}`);
+    // Per-test state, scoped across file:event boundaries. Reset on each
+    // "start" event inside file:event handlers.
+    let currentGroupFilePath = "";
+    let currentTestMap;
+    let testId = "";
+    let testName = "";
+    let testItem = null;
+    let startTime = Date.now();
+    let testEvents = [];
+    let assertions = [];
+    let success = false;
+    let errorMsg;
+    let peakMemoryMB;
+    let stepAssertionCount = 0;
+    let stepTraceLines = [];
+    let testStarted = false;
+    const addLogEntry = (type, message, data) => {
+        if (effectiveRun.logFile) {
+            logEntries.push({
+                timestamp: new Date().toISOString(),
+                testId,
+                testName,
+                type,
+                message,
+                data,
+            });
         }
-        if (failureLimit !== undefined && failed >= failureLimit) {
-            for (const { test } of fileTests) {
-                skipped++;
-                const name = test.meta.name || test.meta.id;
-                console.log(`  ${colors.yellow}○${colors.reset} ${name} ${colors.dim}(skipped — fail-fast)${colors.reset}`);
-            }
-            continue;
+    };
+    const finalizeTest = () => {
+        if (!testStarted)
+            return;
+        testStarted = false;
+        const duration = Date.now() - startTime;
+        const allAssertionsPassed = assertions.every((a) => a.passed);
+        const finalSuccess = success && allAssertionsPassed;
+        collectedRuns.push({
+            testId,
+            testName,
+            tags: testItem?.meta.tags,
+            filePath: currentGroupFilePath,
+            events: testEvents,
+            success: finalSuccess,
+            durationMs: duration,
+            groupId: testItem?.meta.groupId,
+        });
+        addLogEntry("result", finalSuccess ? "PASSED" : "FAILED", {
+            duration,
+            success: finalSuccess,
+            peakMemoryMB,
+        });
+        const peakMB = peakMemoryMB ? parseFloat(peakMemoryMB) : 0;
+        if (peakMB > overallPeakMemoryMB) {
+            overallPeakMemoryMB = peakMB;
         }
-        // ── Skip tests based on requires/defaultRun capability profile ──
-        const runnableTests = [];
-        for (const ft of fileTests) {
-            const skipReason = shouldSkipTest(ft.test.meta, capabilityProfile);
-            if (skipReason) {
-                skipped++;
-                const name = ft.test.meta.name || ft.test.meta.id;
-                console.log(`  ${colors.yellow}⊘${colors.reset} ${name} ${colors.dim}— skipped (${skipReason})${colors.reset}`);
-                // Record as a skipped test run for result output
-                collectedRuns.push({
-                    testId: ft.test.meta.id,
-                    testName: name,
-                    tags: ft.test.meta.tags,
-                    filePath: groupFilePath,
-                    events: [{ type: "status", status: "skipped", reason: skipReason }],
-                    success: true,
-                    durationMs: 0,
-                    groupId: ft.test.meta.groupId,
-                });
-                continue;
-            }
-            runnableTests.push(ft);
+        const testHttpCalls = testEvents.filter((e) => e.type === "trace").length;
+        const testSteps = testEvents.filter((e) => e.type === "step_end").length;
+        const miniStats = [];
+        miniStats.push(`${duration}ms`);
+        if (testHttpCalls > 0)
+            miniStats.push(`${testHttpCalls} calls`);
+        if (assertions.length > 0)
+            miniStats.push(`${assertions.length} checks`);
+        if (testSteps > 0)
+            miniStats.push(`${testSteps} steps`);
+        if (finalSuccess) {
+            console.log(`    ${colors.green}✓ PASSED${colors.reset} ${colors.dim}(${miniStats.join(", ")})${colors.reset}`);
+            passed++;
         }
-        if (runnableTests.length === 0)
-            continue;
-        const testIds = runnableTests.map((ft) => ft.test.meta.id);
-        const exportNames = {};
-        for (const ft of runnableTests) {
-            exportNames[ft.test.meta.id] = ft.exportName;
+        else {
+            console.log(`    ${colors.red}✗ FAILED${colors.reset} ${colors.dim}(${miniStats.join(", ")})${colors.reset}`);
+            failed++;
         }
-        const testMap = new Map(runnableTests.map((ft) => [ft.test.meta.id, ft]));
-        const testFileUrl = pathToFileURL(groupFilePath).toString();
-        const batchTimeout = runnableTests.reduce((sum, ft) => {
-            return sum +
-                (normalizePositiveTimeoutMs(ft.test.meta.timeout) ??
-                    shared.perTestTimeoutMs ?? 30_000);
-        }, 0);
-        let testId = "";
-        let testName = "";
-        let testItem = null;
-        let startTime = Date.now();
-        let testEvents = [];
-        let assertions = [];
-        let success = false;
-        let errorMsg;
-        let peakMemoryMB;
-        let stepAssertionCount = 0;
-        let stepTraceLines = [];
-        let testStarted = false;
-        const addLogEntry = (type, message, data) => {
-            if (effectiveRun.logFile) {
-                logEntries.push({
-                    timestamp: new Date().toISOString(),
-                    testId,
-                    testName,
-                    type,
-                    message,
-                    data,
-                });
+        if (peakMB > MEMORY_WARNING_THRESHOLD_MB) {
+            if (peakMB > CLOUD_MEMORY_LIMITS.free) {
+                console.log(`      ${colors.yellow}⚠ Memory (${peakMemoryMB} MB) exceeds Free cloud runner limit (${CLOUD_MEMORY_LIMITS.free} MB).${colors.reset}`);
             }
-        };
-        const finalizeTest = () => {
-            if (!testStarted)
-                return;
-            testStarted = false;
-            const duration = Date.now() - startTime;
-            const allAssertionsPassed = assertions.every((a) => a.passed);
-            const finalSuccess = success && allAssertionsPassed;
-            collectedRuns.push({
-                testId,
-                testName,
-                tags: testItem?.meta.tags,
-                filePath: groupFilePath,
-                events: testEvents,
-                success: finalSuccess,
-                durationMs: duration,
-                groupId: testItem?.meta.groupId,
-            });
-            addLogEntry("result", finalSuccess ? "PASSED" : "FAILED", {
-                duration,
-                success: finalSuccess,
-                peakMemoryMB,
-            });
-            const peakMB = peakMemoryMB ? parseFloat(peakMemoryMB) : 0;
-            if (peakMB > overallPeakMemoryMB) {
-                overallPeakMemoryMB = peakMB;
+            else {
+                console.log(`      ${colors.yellow}⚠ Memory (${peakMemoryMB} MB) is approaching Free cloud runner limit (${CLOUD_MEMORY_LIMITS.free} MB).${colors.reset}`);
             }
-            const testHttpCalls = testEvents.filter((e) => e.type === "trace").length;
-            const testSteps = testEvents.filter((e) => e.type === "step_end").length;
-            const miniStats = [];
-            miniStats.push(`${duration}ms`);
-            if (testHttpCalls > 0)
-                miniStats.push(`${testHttpCalls} calls`);
-            if (assertions.length > 0)
-                miniStats.push(`${assertions.length} checks`);
-            if (testSteps > 0)
-                miniStats.push(`${testSteps} steps`);
-            if (finalSuccess) {
-                console.log(`    ${colors.green}✓ PASSED${colors.reset} ${colors.dim}(${miniStats.join(", ")})${colors.reset}`);
-                passed++;
+        }
+        for (const assertion of assertions) {
+            if (!assertion.passed) {
+                console.log(`      ${colors.red}✗ ${assertion.message}${colors.reset}`);
+                if (assertion.expected !== undefined || assertion.actual !== undefined) {
+                    if (assertion.expected !== undefined) {
+                        console.log(`        ${colors.dim}Expected: ${JSON.stringify(assertion.expected)}${colors.reset}`);
+                    }
+                    if (assertion.actual !== undefined) {
+                        console.log(`        ${colors.dim}Actual:   ${JSON.stringify(assertion.actual)}${colors.reset}`);
+                    }
+                }
+            }
+        }
+        if (errorMsg) {
+            console.log(`      ${colors.red}Error: ${errorMsg}${colors.reset}`);
+        }
+    };
+    // Pre-filter tests by capability profile so file:start can emit the
+    // ⊘ lines inline (preserves the pre-migration output layout where these
+    // lines appear between the file header and the first runnable test of
+    // the file). `runnableByFile` is what actually feeds ProjectRunner.
+    const fileCapabilitySkips = new Map();
+    const runnableByFile = new Map();
+    for (const [filePath, fileTests] of fileGroups) {
+        const skips = [];
+        const runnable = [];
+        for (const ft of fileTests) {
+            const reason = shouldSkipTest(ft.test.meta, capabilityProfile);
+            if (reason) {
+                skips.push({ ft, reason });
             }
             else {
-                console.log(`    ${colors.red}✗ FAILED${colors.reset} ${colors.dim}(${miniStats.join(", ")})${colors.reset}`);
-                failed++;
+                runnable.push(ft);
             }
-            if (peakMB > MEMORY_WARNING_THRESHOLD_MB) {
-                if (peakMB > CLOUD_MEMORY_LIMITS.free) {
-                    console.log(`      ${colors.yellow}⚠ Memory (${peakMemoryMB} MB) exceeds Free cloud runner limit (${CLOUD_MEMORY_LIMITS.free} MB).${colors.reset}`);
+        }
+        if (skips.length > 0)
+            fileCapabilitySkips.set(filePath, skips);
+        if (runnable.length > 0)
+            runnableByFile.set(filePath, runnable);
+    }
+    // Flatten in fileGroups insertion order so ProjectRunner processes files
+    // in the same order the old inline loop did.
+    const runnableTests = [];
+    for (const filePath of fileGroups.keys()) {
+        const runnable = runnableByFile.get(filePath);
+        if (runnable)
+            runnableTests.push(...runnable);
+    }
+    // Files ProjectRunner actually started. Any fileGroups entry that never
+    // gets file:start is a fail-fast skip — handled post run:complete.
+    const startedFiles = new Set();
+    const runner = new ProjectRunner({
+        rootDir,
+        sharedConfig: shared,
+        sessionStartDir: startDir,
+        vars: envVars,
+        secrets,
+        // Cast — CLI's DiscoveredTestMeta.requires is a plain `string | undefined`
+        // (scanner output, openly typed). ProjectRunnerTest narrows it to the
+        // CaseRequires literal union. Widening happens upstream at scanner.
+        tests: runnableTests.map((t) => ({
+            filePath: t.filePath,
+            exportName: t.exportName,
+            meta: t.test.meta,
+        })),
+        noSession: !!options.noSession,
+        interactive,
+        ...(options.inspectBrk !== undefined && { inspectBrk: options.inspectBrk }),
+        metricCollector,
+    });
+    for await (const ev of runner.run()) {
+        switch (ev.type) {
+            case "bootstrap:start":
+            case "bootstrap:done":
+            case "discovery:done":
+            case "session:setup:start":
+            case "session:teardown:start":
+            case "session:teardown:done":
+                // Silent — either internal plumbing, or already covered by a more
+                // specific event (e.g. session:discovered already printed the
+                // "Session: <path>" header before setup:start arrived).
+                break;
+            case "bootstrap:failed":
+                console.error(`\n${colors.red}Bootstrap failed: ${ev.error.message}${colors.reset}`);
+                process.exit(1);
+                break;
+            case "session:discovered":
+                if (ev.sessionFile) {
+                    console.log(`${colors.dim}Session: ${relative(process.cwd(), ev.sessionFile)}${colors.reset}`);
                 }
-                else {
-                    console.log(`      ${colors.yellow}⚠ Memory (${peakMemoryMB} MB) is approaching Free cloud runner limit (${CLOUD_MEMORY_LIMITS.free} MB).${colors.reset}`);
+                break;
+            case "session:setup:event": {
+                const se = ev.event;
+                if (se.type === "session:set") {
+                    sessionState[se.key] = se.value;
                 }
+                else if (se.type === "status" && se.status === "failed") {
+                    console.log(`  ${colors.red}✗ Session setup failed${se.error ? `: ${se.error}` : ""}${colors.reset}`);
+                }
+                else if (se.type === "log") {
+                    console.log(`  ${colors.dim}[session] ${se.message}${colors.reset}`);
+                }
+                break;
             }
-            for (const assertion of assertions) {
-                if (!assertion.passed) {
-                    console.log(`      ${colors.red}✗ ${assertion.message}${colors.reset}`);
-                    if (assertion.expected !== undefined || assertion.actual !== undefined) {
-                        if (assertion.expected !== undefined) {
-                            console.log(`        ${colors.dim}Expected: ${JSON.stringify(assertion.expected)}${colors.reset}`);
-                        }
-                        if (assertion.actual !== undefined) {
-                            console.log(`        ${colors.dim}Actual:   ${JSON.stringify(assertion.actual)}${colors.reset}`);
-                        }
-                    }
+            case "session:setup:done": {
+                const count = ev.stateKeys.length;
+                if (count > 0) {
+                    console.log(`${colors.dim}  ${count} session value${count > 1 ? "s" : ""} set${colors.reset}`);
                 }
+                break;
             }
-            if (errorMsg) {
-                console.log(`      ${colors.red}Error: ${errorMsg}${colors.reset}`);
+            case "session:setup:failed":
+                console.log(`\n${colors.red}Session setup failed. All tests skipped.${colors.reset}`);
+                process.exit(1);
+                break;
+            case "session:teardown:event": {
+                const te = ev.event;
+                if (te.type === "log") {
+                    console.log(`  ${colors.dim}[session] ${te.message}${colors.reset}`);
+                }
+                else if (te.type === "status" && te.status === "failed") {
+                    console.log(`  ${colors.yellow}⚠ Session teardown failed${te.error ? `: ${te.error}` : ""}${colors.reset}`);
+                }
+                break;
             }
-        };
-        for await (const event of executor.run(testFileUrl, "", {
-            vars: envVars,
-            secrets,
-            ...(Object.keys(sessionState).length > 0 && { session: sessionState }),
-        }, {
-            ...toSingleExecutionOptions(shared),
-            timeout: batchTimeout,
-            testIds,
-            exportNames,
-            // Pass concurrency to harness when the batch has parallel-marked tests.
-            // The harness uses p-queue to run them concurrently within a single process.
-            ...(runnableTests.some((ft) => ft.test.meta.parallel) && shared.concurrency > 1
-                ? { concurrency: shared.concurrency }
-                : {}),
-        })) {
-            switch (event.type) {
-                case "start": {
-                    const entry = testMap.get(event.id);
-                    testId = event.id;
-                    testName = entry?.test.meta.name || event.name || event.id;
-                    testItem = entry?.test || null;
-                    startTime = Date.now();
-                    testEvents = [];
-                    assertions = [];
-                    success = false;
-                    errorMsg = undefined;
-                    peakMemoryMB = undefined;
-                    stepAssertionCount = 0;
-                    stepTraceLines = [];
-                    testStarted = true;
-                    const tags = testItem?.meta.tags?.length
-                        ? ` ${colors.dim}[${testItem.meta.tags.join(", ")}]${colors.reset}`
-                        : "";
-                    console.log(`  ${colors.cyan}●${colors.reset} ${testName}${tags}`);
-                    if (testItem?.meta.description) {
-                        console.log(`    ${colors.dim}${testItem.meta.description}${colors.reset}`);
+            case "file:start": {
+                currentGroupFilePath = ev.filePath;
+                startedFiles.add(ev.filePath);
+                const runnable = runnableByFile.get(ev.filePath) ?? [];
+                currentTestMap = new Map(runnable.map((ft) => [ft.test.meta.id, ft]));
+                if (isMultiFile) {
+                    const relPath = relative(process.cwd(), ev.filePath);
+                    console.log(`${colors.bold}📁 ${relPath}${colors.reset}`);
+                }
+                // Inline capability-skip display — preserves pre-migration layout
+                // where ⊘ lines sit between the file header and the first runnable
+                // test of the file.
+                const skips = fileCapabilitySkips.get(ev.filePath);
+                if (skips) {
+                    for (const { ft, reason } of skips) {
+                        skipped++;
+                        const name = ft.test.meta.name || ft.test.meta.id;
+                        console.log(`  ${colors.yellow}⊘${colors.reset} ${name} ${colors.dim}— skipped (${reason})${colors.reset}`);
+                        collectedRuns.push({
+                            testId: ft.test.meta.id,
+                            testName: name,
+                            tags: ft.test.meta.tags,
+                            filePath: ev.filePath,
+                            events: [{ type: "status", status: "skipped", reason }],
+                            success: true,
+                            durationMs: 0,
+                            groupId: ft.test.meta.groupId,
+                        });
                     }
-                    break;
                 }
-                case "status":
-                    success = event.status === "completed";
-                    if (event.error) {
-                        errorMsg = event.error;
-                        addLogEntry("error", event.error);
+                break;
+            }
+            case "file:event": {
+                const event = ev.event;
+                switch (event.type) {
+                    case "start": {
+                        const entry = currentTestMap?.get(event.id);
+                        testId = event.id;
+                        testName = entry?.test.meta.name || event.name || event.id;
+                        testItem = entry?.test || null;
+                        startTime = Date.now();
+                        testEvents = [];
+                        assertions = [];
+                        success = false;
+                        errorMsg = undefined;
+                        peakMemoryMB = undefined;
+                        stepAssertionCount = 0;
+                        stepTraceLines = [];
+                        testStarted = true;
+                        const tags = testItem?.meta.tags?.length
+                            ? ` ${colors.dim}[${testItem.meta.tags.join(", ")}]${colors.reset}`
+                            : "";
+                        console.log(`  ${colors.cyan}●${colors.reset} ${testName}${tags}`);
+                        if (testItem?.meta.description) {
+                            console.log(`    ${colors.dim}${testItem.meta.description}${colors.reset}`);
+                        }
+                        break;
                     }
-                    if (event.peakMemoryMB)
-                        peakMemoryMB = event.peakMemoryMB;
-                    finalizeTest();
-                    break;
-                case "error":
-                    success = false;
-                    if (!errorMsg)
-                        errorMsg = event.message;
-                    addLogEntry("error", event.message);
-                    break;
-                case "log":
-                    addLogEntry("log", event.message);
-                    if (event.message.startsWith("Loading test module:"))
+                    case "status":
+                        success = event.status === "completed";
+                        if (event.error) {
+                            errorMsg = event.error;
+                            addLogEntry("error", event.error);
+                        }
+                        if (event.peakMemoryMB)
+                            peakMemoryMB = event.peakMemoryMB;
+                        finalizeTest();
+                        break;
+                    case "error":
+                        success = false;
+                        if (!errorMsg)
+                            errorMsg = event.message;
+                        addLogEntry("error", event.message);
+                        break;
+                    case "log":
+                        addLogEntry("log", event.message);
+                        if (event.message.startsWith("Loading test module:"))
+                            break;
+                        console.log(`      ${colors.dim}${event.message}${colors.reset}`);
+                        break;
+                    case "assertion":
+                        assertions.push({
+                            passed: event.passed,
+                            message: event.message,
+                            actual: event.actual,
+                            expected: event.expected,
+                        });
+                        stepAssertionCount++;
+                        addLogEntry("assertion", event.message, {
+                            passed: event.passed,
+                            actual: event.actual,
+                            expected: event.expected,
+                        });
+                        if (effectiveRun.verbose) {
+                            const icon = event.passed ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+                            console.log(`        ${icon} ${colors.dim}${event.message}${colors.reset}`);
+                        }
+                        break;
+                    case "trace": {
+                        const traceTarget = event.data.target ?? `${event.data.method ?? "?"} ${event.data.url ?? "?"}`;
+                        const traceDuration = event.data.durationMs ?? event.data.duration ?? 0;
+                        const traceProtocol = event.data.protocol ?? "http";
+                        const traceMsg = `${traceTarget} → ${event.data.status} (${traceDuration}ms)`;
+                        addLogEntry("trace", traceMsg, event.data);
+                        traceCollector.push({
+                            testId,
+                            protocol: traceProtocol,
+                            target: traceTarget,
+                            method: event.data.method,
+                            url: event.data.url,
+                            status: event.data.status,
+                        });
+                        const displayTarget = event.data.method && event.data.url
+                            ? `${colors.dim}${event.data.method}${colors.reset} ${compactUrl(event.data.url)}`
+                            : `${colors.dim}${traceTarget}${colors.reset}`;
+                        const compactTrace = `${displayTarget} ${colors.dim}→${colors.reset} ${colorStatus(event.data.status)} ${colors.dim}${traceDuration}ms${colors.reset}`;
+                        stepTraceLines.push(compactTrace);
+                        console.log(`      ${colors.dim}↳${colors.reset} ${compactTrace}`);
+                        if (effectiveRun.verbose && event.data.requestBody) {
+                            console.log(`        ${colors.dim}req: ${JSON.stringify(event.data.requestBody).slice(0, 120)}${colors.reset}`);
+                        }
+                        if (effectiveRun.verbose && event.data.responseBody) {
+                            const body = JSON.stringify(event.data.responseBody);
+                            console.log(`        ${colors.dim}res: ${body.slice(0, 120)}${body.length > 120 ? "…" : ""}${colors.reset}`);
+                        }
                         break;
-                    console.log(`      ${colors.dim}${event.message}${colors.reset}`);
-                    break;
-                case "assertion":
-                    assertions.push({
-                        passed: event.passed,
-                        message: event.message,
-                        actual: event.actual,
-                        expected: event.expected,
-                    });
-                    stepAssertionCount++;
-                    addLogEntry("assertion", event.message, {
-                        passed: event.passed,
-                        actual: event.actual,
-                        expected: event.expected,
-                    });
-                    if (effectiveRun.verbose) {
-                        const icon = event.passed ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
-                        console.log(`        ${icon} ${colors.dim}${event.message}${colors.reset}`);
                     }
-                    break;
-                case "trace": {
-                    const traceTarget = event.data.target ?? `${event.data.method ?? "?"} ${event.data.url ?? "?"}`;
-                    const traceDuration = event.data.durationMs ?? event.data.duration ?? 0;
-                    const traceProtocol = event.data.protocol ?? "http";
-                    const traceMsg = `${traceTarget} → ${event.data.status} (${traceDuration}ms)`;
-                    addLogEntry("trace", traceMsg, event.data);
-                    traceCollector.push({
-                        testId,
-                        protocol: traceProtocol,
-                        target: traceTarget,
-                        method: event.data.method,
-                        url: event.data.url,
-                        status: event.data.status,
-                    });
-                    const displayTarget = event.data.method && event.data.url
-                        ? `${colors.dim}${event.data.method}${colors.reset} ${compactUrl(event.data.url)}`
-                        : `${colors.dim}${traceTarget}${colors.reset}`;
-                    const compactTrace = `${displayTarget} ${colors.dim}→${colors.reset} ${colorStatus(event.data.status)} ${colors.dim}${traceDuration}ms${colors.reset}`;
-                    stepTraceLines.push(compactTrace);
-                    console.log(`      ${colors.dim}↳${colors.reset} ${compactTrace}`);
-                    if (effectiveRun.verbose && event.data.requestBody) {
-                        console.log(`        ${colors.dim}req: ${JSON.stringify(event.data.requestBody).slice(0, 120)}${colors.reset}`);
+                    case "action": {
+                        const a = event.data;
+                        if (a.category === "http:request")
+                            break;
+                        const statusColor = a.status === "ok" ? colors.green : a.status === "error" ? colors.red : colors.yellow;
+                        const statusIcon = a.status === "ok" ? "✓" : a.status === "error" ? "✗" : "⏱";
+                        addLogEntry("action", `[${a.category}] ${a.target} ${a.duration}ms ${a.status}`, a);
+                        console.log(`      ${colors.dim}↳${colors.reset} ${colors.cyan}${a.category}${colors.reset} ${a.target} ${colors.dim}${a.duration}ms${colors.reset} ${statusColor}${statusIcon}${colors.reset}`);
+                        break;
                     }
-                    if (effectiveRun.verbose && event.data.responseBody) {
-                        const body = JSON.stringify(event.data.responseBody);
-                        console.log(`        ${colors.dim}res: ${body.slice(0, 120)}${body.length > 120 ? "…" : ""}${colors.reset}`);
+                    case "event": {
+                        const evData = event.data;
+                        addLogEntry("event", `[${evData.type}]`, evData);
+                        if (effectiveRun.verbose) {
+                            const summary = JSON.stringify(evData.data).slice(0, 80);
+                            console.log(`      ${colors.dim}[${evData.type}] ${summary}${colors.reset}`);
+                        }
+                        break;
                     }
-                    break;
-                }
-                case "action": {
-                    const a = event.data;
-                    if (a.category === "http:request")
+                    case "metric": {
+                        // ProjectRunner already accumulates into metricCollector (passed
+                        // in above). CLI only handles verbose display + log entry.
+                        const unit = event.unit ? ` ${event.unit}` : "";
+                        const tagStr = event.tags
+                            ? ` ${colors.dim}{${Object.entries(event.tags)
+                                .map(([k, v]) => `${k}=${v}`)
+                                .join(", ")}}${colors.reset}`
+                            : "";
+                        const metricMsg = `${event.name} = ${event.value}${unit}`;
+                        addLogEntry("metric", metricMsg, {
+                            name: event.name,
+                            value: event.value,
+                            unit: event.unit,
+                            tags: event.tags,
+                        });
+                        if (effectiveRun.verbose) {
+                            console.log(`      ${colors.blue}📊 ${metricMsg}${colors.reset}${tagStr}`);
+                        }
                         break;
-                    const statusColor = a.status === "ok" ? colors.green : a.status === "error" ? colors.red : colors.yellow;
-                    const statusIcon = a.status === "ok" ? "✓" : a.status === "error" ? "✗" : "⏱";
-                    addLogEntry("action", `[${a.category}] ${a.target} ${a.duration}ms ${a.status}`, a);
-                    console.log(`      ${colors.dim}↳${colors.reset} ${colors.cyan}${a.category}${colors.reset} ${a.target} ${colors.dim}${a.duration}ms${colors.reset} ${statusColor}${statusIcon}${colors.reset}`);
-                    break;
-                }
-                case "event": {
-                    const ev = event.data;
-                    addLogEntry("event", `[${ev.type}]`, ev);
-                    if (effectiveRun.verbose) {
-                        const summary = JSON.stringify(ev.data).slice(0, 80);
-                        console.log(`      ${colors.dim}[${ev.type}] ${summary}${colors.reset}`);
                     }
-                    break;
-                }
-                case "metric": {
-                    metricCollector.add(event.name, event.value);
-                    const unit = event.unit ? ` ${event.unit}` : "";
-                    const tagStr = event.tags
-                        ? ` ${colors.dim}{${Object.entries(event.tags)
-                            .map(([k, v]) => `${k}=${v}`)
-                            .join(", ")}}${colors.reset}`
-                        : "";
-                    const metricMsg = `${event.name} = ${event.value}${unit}`;
-                    addLogEntry("metric", metricMsg, {
-                        name: event.name,
-                        value: event.value,
-                        unit: event.unit,
-                        tags: event.tags,
-                    });
-                    if (effectiveRun.verbose) {
-                        console.log(`      ${colors.blue}📊 ${metricMsg}${colors.reset}${tagStr}`);
+                    case "step_start":
+                        stepAssertionCount = 0;
+                        stepTraceLines = [];
+                        console.log(`    ${colors.cyan}┌${colors.reset} ${colors.dim}step ${event.index + 1}/${event.total}${colors.reset} ${colors.bold}${event.name}${colors.reset}`);
+                        break;
+                    case "step_end": {
+                        const stepIcon = event.status === "passed"
+                            ? `${colors.green}✓${colors.reset}`
+                            : event.status === "failed"
+                                ? `${colors.red}✗${colors.reset}`
+                                : `${colors.yellow}○${colors.reset}`;
+                        const stepParts = [];
+                        if (event.durationMs !== undefined)
+                            stepParts.push(`${event.durationMs}ms`);
+                        if (event.assertions > 0)
+                            stepParts.push(`${event.assertions} assertions`);
+                        const httpInStep = stepTraceLines.length;
+                        if (httpInStep > 0)
+                            stepParts.push(`${httpInStep} API call${httpInStep > 1 ? "s" : ""}`);
+                        console.log(`    ${colors.cyan}└${colors.reset} ${stepIcon} ${colors.dim}${stepParts.join(" · ")}${colors.reset}`);
+                        if (event.error) {
+                            console.log(`      ${colors.red}${event.error}${colors.reset}`);
+                        }
+                        break;
                     }
-                    break;
-                }
-                case "step_start":
-                    stepAssertionCount = 0;
-                    stepTraceLines = [];
-                    console.log(`    ${colors.cyan}┌${colors.reset} ${colors.dim}step ${event.index + 1}/${event.total}${colors.reset} ${colors.bold}${event.name}${colors.reset}`);
-                    break;
-                case "step_end": {
-                    const stepIcon = event.status === "passed"
-                        ? `${colors.green}✓${colors.reset}`
-                        : event.status === "failed"
-                            ? `${colors.red}✗${colors.reset}`
-                            : `${colors.yellow}○${colors.reset}`;
-                    const stepParts = [];
-                    if (event.durationMs !== undefined)
-                        stepParts.push(`${event.durationMs}ms`);
-                    if (event.assertions > 0)
-                        stepParts.push(`${event.assertions} assertions`);
-                    const httpInStep = stepTraceLines.length;
-                    if (httpInStep > 0)
-                        stepParts.push(`${httpInStep} API call${httpInStep > 1 ? "s" : ""}`);
-                    console.log(`    ${colors.cyan}└${colors.reset} ${stepIcon} ${colors.dim}${stepParts.join(" · ")}${colors.reset}`);
-                    if (event.error) {
-                        console.log(`      ${colors.red}${event.error}${colors.reset}`);
+                    case "summary":
+                        runStats.httpRequestTotal += event.data.httpRequestTotal;
+                        runStats.httpErrorTotal += event.data.httpErrorTotal;
+                        runStats.assertionTotal += event.data.assertionTotal;
+                        runStats.assertionFailed += event.data.assertionFailed;
+                        runStats.warningTotal += event.data.warningTotal;
+                        runStats.warningTriggered += event.data.warningTriggered;
+                        runStats.stepTotal += event.data.stepTotal;
+                        runStats.stepPassed += event.data.stepPassed;
+                        runStats.stepFailed += event.data.stepFailed;
+                        break;
+                    case "warning": {
+                        const warnIcon = event.condition ? `${colors.green}✓${colors.reset}` : `${colors.yellow}⚠${colors.reset}`;
+                        console.log(`      ${warnIcon} ${colors.yellow}${event.message}${colors.reset}`);
+                        break;
                     }
-                    break;
+                    case "schema_validation":
+                        if (effectiveRun.verbose) {
+                            const icon = event.success ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
+                            console.log(`      ${icon} ${colors.dim}schema: ${event.label}${colors.reset}`);
+                        }
+                        break;
+                    case "session:set":
+                        // ProjectRunner accumulates internally for cross-file forwarding;
+                        // CLI keeps its copy only for symmetry with pre-migration code
+                        // paths (useful e.g. for debug logging).
+                        sessionState[event.key] = event.value;
+                        continue;
                 }
-                case "summary":
-                    runStats.httpRequestTotal += event.data.httpRequestTotal;
-                    runStats.httpErrorTotal += event.data.httpErrorTotal;
-                    runStats.assertionTotal += event.data.assertionTotal;
-                    runStats.assertionFailed += event.data.assertionFailed;
-                    runStats.warningTotal += event.data.warningTotal;
-                    runStats.warningTriggered += event.data.warningTriggered;
-                    runStats.stepTotal += event.data.stepTotal;
-                    runStats.stepPassed += event.data.stepPassed;
-                    runStats.stepFailed += event.data.stepFailed;
-                    break;
-                case "warning": {
-                    const warnIcon = event.condition ? `${colors.green}✓${colors.reset}` : `${colors.yellow}⚠${colors.reset}`;
-                    console.log(`      ${warnIcon} ${colors.yellow}${event.message}${colors.reset}`);
-                    break;
+                if (testStarted)
+                    testEvents.push(event);
+                break;
+            }
+            case "file:complete":
+                // Mirror the old inline loop's tail cleanup: if the harness died
+                // mid-test or emitted no start event, promote the leftover state
+                // to a visible failure row.
+                if (!testStarted && errorMsg) {
+                    console.log(`  ${colors.red}✗ ${errorMsg}${colors.reset}`);
+                    failed++;
                 }
-                case "schema_validation":
-                    if (effectiveRun.verbose) {
-                        const icon = event.success ? `${colors.green}✓${colors.reset}` : `${colors.red}✗${colors.reset}`;
-                        console.log(`      ${icon} ${colors.dim}schema: ${event.label}${colors.reset}`);
+                if (testStarted) {
+                    if (!errorMsg)
+                        errorMsg = "Process exited before test completed";
+                    finalizeTest();
+                }
+                break;
+            case "run:complete":
+                // Fail-fast skip display: any file ProjectRunner never started
+                // (because the failure limit kicked in between file groups) gets
+                // the old "○ (skipped — fail-fast)" lines here, preserving the
+                // pre-migration output layout.
+                if (failureLimit !== undefined && ev.failedCount >= failureLimit) {
+                    for (const [filePath, fileTests] of fileGroups) {
+                        if (startedFiles.has(filePath))
+                            continue;
+                        if (isMultiFile) {
+                            const relPath = relative(process.cwd(), filePath);
+                            console.log(`${colors.bold}📁 ${relPath}${colors.reset}`);
+                        }
+                        for (const { test } of fileTests) {
+                            skipped++;
+                            const name = test.meta.name || test.meta.id;
+                            console.log(`  ${colors.yellow}○${colors.reset} ${name} ${colors.dim}(skipped — fail-fast)${colors.reset}`);
+                        }
                     }
-                    break;
-                case "session:set":
-                    // Accumulate session writes from tests for subsequent files
-                    sessionState[event.key] = event.value;
-                    // Do NOT fall through to testEvents — internal only
-                    continue;
-            }
-            if (testStarted)
-                testEvents.push(event);
-        }
-        if (!testStarted && errorMsg) {
-            // Harness failed before emitting any test start (e.g. module load error)
-            console.log(`  ${colors.red}✗ ${errorMsg}${colors.reset}`);
-            failed++;
-        }
-        if (testStarted) {
-            if (!errorMsg)
-                errorMsg = "Process exited before test completed";
-            finalizeTest();
-        }
-    }
-    // ── Session teardown ───────────────────────────────────────────────────
-    if (sessionFile) {
-        for await (const event of orchestrator.runSessionTeardown(sessionFile, { vars: envVars, secrets }, sessionState, toSingleExecutionOptions(shared))) {
-            if (event.type === "log") {
-                console.log(`  ${colors.dim}[session] ${event.message}${colors.reset}`);
-            }
-            else if (event.type === "status" && event.status === "failed") {
-                console.log(`  ${colors.yellow}⚠ Session teardown failed${event.error ? `: ${event.error}` : ""}${colors.reset}`);
-            }
+                }
+                break;
+            case "run:failed":
+                // Terminal failure — actual exit already happened in
+                // bootstrap:failed / session:setup:failed above.
+                break;
         }
     }
     const totalDurationMs = Date.now() - totalStartTime;