@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/test/repository-node-test-reporter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/repository-node-test-reporter.test.js

@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { promisify } from "node:util";
+import { Effect } from "effect";
+import { repositoryCommandTestEvidenceV1 } from "../adapters/repository-command-evidence.js";
+import { replayRepositoryCommandsV1 } from "../adapters/repository-command-runner.js";
+import { repositoryNodeTestArgumentsV1 } from "../adapters/repository-node-test-reporter.js";
+const recipe = {
+    id: "node-contract",
+    kind: "test",
+    executable: "node",
+    cwd: ".",
+    timeoutMs: 5_000,
+    args: [
+        "--test",
+        "--test-reporter",
+        "spec",
+        "--test-reporter-destination",
+        "old-report.txt",
+        "case.test.mjs"
+    ]
+};
+test("controlled Node reporter preserves test selection and overrides reporter redirection for direct and pnpm execution", () => {
+    const expected = ["--test-reporter=tap", "--test", "case.test.mjs"];
+    assert.deepEqual(repositoryNodeTestArgumentsV1(recipe), expected);
+    for (const wrapper of [
+        { executable: "corepack", prefix: ["pnpm@11.15.1", "exec", "node"] },
+        { executable: "pnpm", prefix: ["exec", "node"] },
+        { executable: "corepack", prefix: ["pnpm@11.15.1", "exec", "tsx"] },
+        { executable: "pnpm", prefix: ["exec", "tsx"] },
+        { executable: "tsx", prefix: [] }
+    ]) {
+        assert.deepEqual(repositoryNodeTestArgumentsV1({
+            ...recipe,
+            executable: wrapper.executable,
+            args: [...wrapper.prefix, ...recipe.args]
+        }), [...wrapper.prefix, ...expected]);
+    }
+    const script = { ...recipe, args: ["-e", "process.exit(0)"] };
+    assert.deepEqual(repositoryNodeTestArgumentsV1(script), script.args);
+});
+test("isolated Node replay forces TAP and rejects setup assertions while accepting test-body assertion evidence", async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "routekit-node-reporter-"));
+    const execute = promisify(execFile);
+    const git = (args) => execute("git", ["-C", root, ...args]);
+    try {
+        await git(["init", "-q"]);
+        await git(["config", "user.name", "Repository Fixture"]);
+        await git(["config", "user.email", "fixture@example.test"]);
+        await writeFile(path.join(root, "case.test.mjs"), "import test from 'node:test';test('contract',()=>{});\n");
+        await git(["add", "."]);
+        await git(["commit", "-qm", "independent Node fixture", "--no-gpg-sign"]);
+        for (const scenario of [
+            { source: "test('contract',()=>assert.equal(1,2));", expected: "fail" },
+            {
+                source: "test('contract',async()=>{await Promise.reject(new Error('buffered Responses SSE ended without a terminal response object'));});",
+                expected: "unknown"
+            },
+            {
+                source: "test('contract',async()=>{await assert.doesNotReject(async()=>{await Promise.reject(new Error('buffered Responses SSE ended without a terminal response object'));});});",
+                expected: "fail"
+            },
+            {
+                source: "test('contract',async()=>{let result;await assert.doesNotReject(async()=>{result=await Promise.resolve({output:[]});});assert.deepEqual(result,{output:[]});});",
+                expected: "pass"
+            },
+            {
+                source: "beforeEach(()=>assert.equal(1,2));test('contract',()=>assert.equal(2,2));",
+                expected: "unknown"
+            },
+            {
+                source: "afterEach(()=>assert.equal(1,2));test('contract',()=>assert.equal(2,2));",
+                expected: "unknown"
+            },
+            {
+                source: "beforeEach(()=>assert.equal(2,2));test('contract',()=>assert.equal(2,2));",
+                expected: "pass"
+            }
+        ]) {
+            const [result] = await Effect.runPromise(replayRepositoryCommandsV1({
+                repositoryRoot: root,
+                commit: "HEAD",
+                recipes: [recipe],
+                repetitions: 1,
+                fileOverrides: [
+                    {
+                        path: "case.test.mjs",
+                        content: `import test,{beforeEach,afterEach} from 'node:test';import assert from 'node:assert/strict';\n${scenario.source}\n`
+                    }
+                ]
+            }));
+            assert.ok(result);
+            assert.match(result.stdout, /^TAP version 13$/mu);
+            assert.equal(repositoryCommandTestEvidenceV1(result, recipe.id).outcome, scenario.expected);
+        }
+    }
+    finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});

package/dist/test/repository-oracle-concurrency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/repository-oracle-concurrency.test.js

@@ -0,0 +1,542 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { access, mkdtemp, readdir, readFile, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Effect, Fiber, Schema } from "effect";
+import { RepositoryFoundryError } from "../errors.js";
+import { RepositoryHiddenOracleV1 } from "../repository-oracle-protocol.js";
+import { evaluateRepositoryOracleAdequacyV1, repositoryOracleSolutionObservationsCompleteV1 } from "../repository-quality-policy.js";
+import { RepositoryFoundryProgressLive, reportFoundryStageV1 } from "../services/foundry-progress/service.js";
+import { buildHistoricalHiddenOracleV1 } from "../services/oracle-builder/service.js";
+const exec = promisify(execFile);
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const oracleTestOptions = { timeout: 60_000 };
+function observeOracleCompletion(fiber) {
+    // With the pinned Effect runtime, joining an interrupted fiber can remove its
+    // observer during notification and skip the concurrent interruption waiter.
+    // Observe the Exit as a success, then unwrap it outside the notification stack.
+    return Effect.runPromise(Fiber.await(fiber)).then((exit) => Effect.runPromise(exit));
+}
+async function fixture(t) {
+    const root = await realpath(await mkdtemp(join(tmpdir(), "oracle-concurrency-test-")));
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const marker = `oracle-unit-${randomUUID()}.json`;
+    const ready = `ready-${marker}`;
+    const release = `release-${marker}`;
+    const finished = `finished-${marker}`;
+    // These gates exist only in this synthetic test's isolated checkouts. They let the test
+    // observe real concurrent children and cancellation without relying on elapsed speed.
+    const testSource = (assertion) => `
+import assert from "node:assert/strict";
+import { existsSync, writeFileSync } from "node:fs";
+import { test } from "node:test";
+import { value } from "./subject.mjs";
+test("synthetic public behavior", async () => {
+  assert.equal(existsSync("single-use.json"), false);
+  writeFileSync("single-use.json", "fresh checkout");
+  writeFileSync(${JSON.stringify(ready)}, JSON.stringify({
+    checkout: process.cwd(), pid: process.pid, home: process.env.HOME, temporary: process.env.TMPDIR
+  }));
+  while (!existsSync(${JSON.stringify(release)})) await new Promise(resolve => setTimeout(resolve, 10));
+  writeFileSync(${JSON.stringify(finished)}, "finished");
+  ${assertion}
+});
+`;
+    const git = (...args) => exec("git", ["-C", root, ...args], { encoding: "utf8" });
+    await git("init", "-q");
+    await writeFile(join(root, marker), "synthetic fixture only");
+    await writeFile(join(root, "control.json"), "{}");
+    await writeFile(join(root, "case.test.mjs"), testSource("assert.equal(value, 1);"));
+    const commit = async (value) => {
+        await writeFile(join(root, "subject.mjs"), `export const value = ${value};\n`);
+        await git("add", ".");
+        await git("-c", "core.hooksPath=/dev/null", "-c", "commit.gpgSign=false", "-c", "user.name=Oracle Unit Test", "-c", "user.email=oracle@example.test", "commit", "-qm", "fixture");
+        return (await git("rev-parse", "HEAD")).stdout.trim();
+    };
+    const initialCommit = await commit(0);
+    const referenceCommit = await commit(1);
+    const recipe = {
+        id: "behavior",
+        kind: "test",
+        cwd: ".",
+        executable: "node",
+        args: ["--test", "--test-reporter=tap", "case.test.mjs"],
+        timeoutMs: 30000
+    };
+    const seed = {
+        version: 1,
+        id: "synthetic-seed",
+        status: "qualified",
+        source: { kind: "historical-fix", changeEpisodeId: "synthetic-change" },
+        summary: "Synthetic public behavior.",
+        capabilityEvidence: [{ kind: "test", id: "synthetic-behavior", path: "case.test.mjs" }],
+        initialState: { commit: initialCommit },
+        referenceCommit,
+        targetBehavior: [
+            { id: "behavior", description: "Return the expected value.", critical: true, evidence: [] }
+        ],
+        baselineObservations: [],
+        preChangeObservations: [],
+        postChangeObservations: [],
+        candidateTestIds: [],
+        environment: {
+            protectedControlPaths: ["control.json"],
+            trustedPreparationRecipes: [],
+            candidateValidationRecipes: [
+                {
+                    id: "syntax",
+                    kind: "check",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--check", "subject.mjs"],
+                    timeoutMs: 10000
+                }
+            ],
+            baselineGradeRecipes: [recipe],
+            gradeRecipes: [recipe]
+        },
+        confidence: "high",
+        risks: [],
+        rejectionReasons: []
+    };
+    const hiddenFixtureSuite = {
+        version: 1,
+        caseId: "synthetic-case",
+        fixtures: [
+            {
+                id: "boundary",
+                kind: "boundary",
+                description: "Boundary behavior.",
+                expectedBehavior: "Expected value.",
+                source: "generated",
+                testPath: "case.test.mjs",
+                expectationMode: "changes"
+            },
+            {
+                id: "metamorphic",
+                kind: "metamorphic",
+                description: "Transformed value.",
+                expectedBehavior: "Scaling preserves the behavior.",
+                source: "generated",
+                testPath: "case.test.mjs",
+                expectationMode: "preserved"
+            }
+        ],
+        overlays: [
+            {
+                path: "case.test.mjs",
+                content: testSource("assert.equal(value, 1);"),
+                fixtureIds: ["boundary"]
+            },
+            {
+                path: "case.test.mjs",
+                content: testSource("assert.equal(value * 2, 2);"),
+                fixtureIds: ["metamorphic"]
+            }
+        ]
+    };
+    const additionalSolutions = [
+        {
+            id: "alternate",
+            kind: "independent-valid",
+            family: "alternate",
+            expectedClass: "valid",
+            commit: initialCommit,
+            fileOverrides: [{ path: "subject.mjs", content: "export const value = 2 - 1;\n" }]
+        },
+        {
+            id: "wrong",
+            kind: "mutation",
+            family: "wrong",
+            expectedClass: "wrong",
+            commit: referenceCommit,
+            fileOverrides: [{ path: "subject.mjs", content: "export const value = 2;\n" }]
+        },
+        {
+            id: "policy-rejected",
+            kind: "reward-hacking",
+            family: "policy",
+            expectedClass: "wrong",
+            commit: referenceCommit,
+            fileOverrides: [{ path: "control.json", content: '{"tampered":true}' }]
+        }
+    ];
+    const running = async () => {
+        const rows = await Promise.all((await readdir(tmpdir()))
+            .filter((name) => name.startsWith("routekit-foundry-isolated-"))
+            .map(async (name) => {
+            const checkout = join(tmpdir(), name, "repository");
+            try {
+                await access(join(checkout, marker));
+                try {
+                    await access(join(checkout, finished));
+                    return undefined;
+                }
+                catch { }
+                const row = JSON.parse(await readFile(join(checkout, ready), "utf8"));
+                return { ...row, root: dirname(row.checkout) };
+            }
+            catch (error) {
+                if (error.code === "ENOENT" || error instanceof SyntaxError)
+                    return undefined;
+                throw error;
+            }
+        }));
+        return rows.filter((row) => row !== undefined);
+    };
+    return {
+        root,
+        running,
+        release,
+        input: {
+            repositoryRoot: root,
+            caseId: "synthetic-case",
+            seed,
+            hiddenFixtureSuite,
+            additionalSolutions,
+            repetitions: 2
+        }
+    };
+}
+async function firstConcurrentGroup(context, concurrency = 2) {
+    const deadline = Date.now() + 10000;
+    while (Date.now() < deadline) {
+        const rows = await context.running();
+        assert.ok(rows.length <= concurrency, "the oracle exceeded its isolated-solution concurrency");
+        if (rows.length === concurrency)
+            return rows;
+        await delay(10);
+    }
+    throw new Error(`${concurrency} independent oracle solutions never reached their gates`);
+}
+async function releaseUntilSettled(context, fiber, concurrency, seen) {
+    const completion = observeOracleCompletion(fiber);
+    let done = false;
+    void completion.then(() => {
+        done = true;
+    }, () => {
+        done = true;
+    });
+    const deadline = Date.now() + 45_000;
+    while (!done && Date.now() < deadline) {
+        const rows = await context.running();
+        assert.ok(rows.length <= concurrency, "replay children exceeded the configured concurrency");
+        for (const row of rows) {
+            seen.set(row.root, row);
+            try {
+                await writeFile(join(row.checkout, context.release), "release synthetic test gate");
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+        }
+        await delay(10);
+    }
+    assert.equal(done, true, "the bounded oracle replay did not finish");
+    return completion;
+}
+test("completed solution evidence resumes after interruption without replaying accepted solutions", oracleTestOptions, async (t) => {
+    const context = await fixture(t);
+    let partial;
+    const firstSeen = new Map();
+    const first = Effect.runFork(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        oracleConcurrency: 1,
+        onSolutionCompleted: (oracle) => Effect.sync(() => {
+            partial = oracle;
+        }).pipe(Effect.andThen(Effect.interrupt))
+    }));
+    await assert.rejects(releaseUntilSettled(context, first, 1, firstSeen));
+    assert.ok(partial);
+    assert.deepEqual([...new Set(partial.observations.map((row) => row.solutionId))], ["historical-reference"]);
+    assert.equal(firstSeen.size, 6);
+    // Real checkpoints pass through the persisted oracle schema, unlike an
+    // in-memory resume. This must preserve the executable identity.
+    partial = Schema.decodeUnknownSync(RepositoryHiddenOracleV1)(JSON.parse(JSON.stringify(partial)));
+    assert.match(partial.executionBindingDigest ?? "", /^[a-f0-9]{64}$/u);
+    await assert.rejects(Effect.runPromise(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        repetitions: (context.input.repetitions ?? 2) + 1,
+        resumeOracle: partial
+    })), /does not bind the current executable inputs/u);
+    const resumedSeen = new Map();
+    const resumed = Effect.runFork(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        oracleConcurrency: 1,
+        resumeOracle: partial
+    }));
+    const oracle = await releaseUntilSettled(context, resumed, 1, resumedSeen);
+    assert.deepEqual([...new Set(oracle.observations.map((row) => row.solutionId))], [
+        "historical-reference",
+        "historical-defect",
+        "alternate",
+        "wrong",
+        "policy-rejected"
+    ]);
+    assert.equal(resumedSeen.size, 18, "resumption must execute only the three remaining non-policy solutions");
+});
+test("oracle resumes complete replay units inside a solution without rerunning accepted repetitions", oracleTestOptions, async (t) => {
+    const context = await fixture(t);
+    let partial;
+    const checkpointAndInterrupt = (oracle) => Effect.sync(() => {
+        partial = Schema.decodeUnknownSync(RepositoryHiddenOracleV1)(JSON.parse(JSON.stringify(oracle)));
+    }).pipe(Effect.andThen(Effect.interrupt));
+    const firstSeen = new Map();
+    const first = Effect.runFork(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        oracleConcurrency: 1,
+        onReplayCompleted: checkpointAndInterrupt
+    }));
+    await assert.rejects(releaseUntilSettled(context, first, 1, firstSeen));
+    assert.ok(partial);
+    assert.equal(firstSeen.size, 1, "checkpoint precedes the next isolated repetition");
+    assert.equal(partial.executionRepetitions, 2, "the serialized checkpoint retains the full plan");
+    assert.equal(repositoryOracleSolutionObservationsCompleteV1(partial, "historical-reference"), false);
+    assert.equal(evaluateRepositoryOracleAdequacyV1(partial).admitted, false);
+    assert.equal(partial.observations.filter((row) => row.clauseId === "test-behavior").length, 1);
+    assert.equal(partial.observations.filter((row) => row.clauseId.startsWith("fixture-")).length, 0);
+    await assert.rejects(Effect.runPromise(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        resumeOracle: {
+            ...partial,
+            observations: partial.observations.filter((row) => row.clauseId !== "validation-syntax")
+        }
+    })), /incomplete replay unit/u, "a partial baseline result is not trusted as a completed replay");
+    const secondSeen = new Map();
+    const second = Effect.runFork(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        oracleConcurrency: 1,
+        resumeOracle: partial,
+        onReplayCompleted: checkpointAndInterrupt
+    }));
+    await assert.rejects(releaseUntilSettled(context, second, 1, secondSeen));
+    assert.equal(secondSeen.size, 1, "resume executes repetition two, not repetition one again");
+    assert.deepEqual(partial.observations
+        .filter((row) => row.clauseId === "test-behavior")
+        .map((row) => row.repetition), [1, 2]);
+    const counts = [];
+    const resumedSeen = new Map();
+    const resumed = Effect.runFork(buildHistoricalHiddenOracleV1({
+        ...context.input,
+        oracleConcurrency: 3,
+        resumeOracle: partial,
+        onReplayCompleted: (oracle) => Effect.sync(() => {
+            const keys = oracle.observations.map((row) => `${row.solutionId}:${row.clauseId}:${row.repetition}`);
+            assert.equal(new Set(keys).size, keys.length, "concurrent checkpoint rows never duplicate");
+            assert.ok(oracle.observations.length > (counts.at(-1) ?? 0), "concurrent progress never regresses");
+            counts.push(oracle.observations.length);
+            if (oracle.observations.length < 42) {
+                assert.equal(evaluateRepositoryOracleAdequacyV1(oracle).admitted, false, "incomplete replay evidence cannot advance the completed scientific gate");
+            }
+        })
+    }));
+    const oracle = await releaseUntilSettled(context, resumed, 3, resumedSeen);
+    assert.equal(resumedSeen.size, 22, "only the twenty-two uncommitted replay units execute");
+    assert.equal(oracle.observations.length, 42);
+    assert.ok(oracle.solutions.every((solution) => repositoryOracleSolutionObservationsCompleteV1(oracle, solution.id)));
+    const largerPlan = { ...oracle, executionRepetitions: 3 };
+    assert.equal(evaluateRepositoryOracleAdequacyV1(largerPlan).admitted, false, "two repetitions cannot satisfy a three-repetition execution plan");
+    const completeLargerPlan = {
+        ...largerPlan,
+        observations: [...oracle.observations,
+            ...oracle.observations.filter((row) => row.repetition === 2)
+                .map((row) => ({ ...row, repetition: 3 }))]
+    };
+    assert.equal(evaluateRepositoryOracleAdequacyV1(completeLargerPlan).admitted, true);
+    assert.equal(repositoryOracleSolutionObservationsCompleteV1({
+        ...oracle,
+        observations: oracle.observations.map((row) => ({ ...row, repetition: 1 }))
+    }, "historical-reference"), false, "duplicate repetitions are not independent execution");
+});
+for (const oracleConcurrency of [undefined, 1, 3, 4]) {
+    test(`oracle concurrency ${oracleConcurrency ?? "default (2)"} preserves isolated gates, fixtures, repetitions and ordering`, oracleTestOptions, async (t) => {
+        const concurrency = oracleConcurrency ?? 2;
+        const context = await fixture(t);
+        const events = [];
+        const fiber = Effect.runFork(Effect.gen(function* () {
+            yield* reportFoundryStageV1("held-out-tournament");
+            return yield* buildHistoricalHiddenOracleV1({
+                ...context.input,
+                ...(oracleConcurrency === undefined ? {} : { oracleConcurrency })
+            });
+        }).pipe(Effect.provide(RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+            events.push(event);
+        })))));
+        const completion = observeOracleCompletion(fiber);
+        let done = false;
+        void completion.then(() => {
+            done = true;
+        }, () => {
+            done = true;
+        });
+        const seen = new Map();
+        try {
+            await firstConcurrentGroup(context, concurrency);
+            // Hold the configured group so excess concurrency would expose extra waiting children.
+            await delay(250);
+            const deadline = Date.now() + 30000;
+            while (!done && Date.now() < deadline) {
+                const rows = await context.running();
+                assert.ok(rows.length <= concurrency, "replay children exceeded the configured concurrency");
+                for (const row of rows) {
+                    seen.set(row.root, row);
+                    try {
+                        await writeFile(join(row.checkout, context.release), "release synthetic test gate");
+                    }
+                    catch (error) {
+                        // A previously released child can finish and remove its checkout during this poll.
+                        if (error.code !== "ENOENT")
+                            throw error;
+                    }
+                }
+                await delay(10);
+            }
+            assert.equal(done, true, "the bounded oracle replay did not finish");
+            const oracle = await completion;
+            const ids = [
+                "historical-reference",
+                "historical-defect",
+                "alternate",
+                "wrong",
+                "policy-rejected"
+            ];
+            assert.deepEqual([...new Set(oracle.observations.map((row) => row.solutionId))], ids);
+            for (const solution of oracle.solutions) {
+                const rows = oracle.observations.filter((row) => row.solutionId === solution.id);
+                if (solution.id === "policy-rejected") {
+                    assert.deepEqual(rows.map((row) => [row.clauseId, row.repetition, row.outcome]), [
+                        ["candidate-policy-protected-paths", 1, "fail"],
+                        ["candidate-policy-protected-paths", 2, "fail"]
+                    ]);
+                    continue;
+                }
+                assert.equal(rows.length, 10);
+                for (const clause of oracle.clauses) {
+                    const observed = rows.filter((row) => row.clauseId === clause.id);
+                    assert.deepEqual(observed.map((row) => row.repetition), [1, 2]);
+                    const behavioral = clause.id === "test-behavior" || clause.id.startsWith("fixture-");
+                    assert.ok(observed.every((row) => row.outcome === (behavioral && solution.expectedClass === "wrong" ? "fail" : "pass")));
+                }
+            }
+            assert.equal(seen.size, 24, "every solution, fixture and repetition must own a fresh checkout");
+            assert.equal(new Set([...seen.values()].map((row) => row.home)).size, 24);
+            assert.equal(new Set([...seen.values()].map((row) => row.temporary)).size, 24);
+            for (const path of seen.keys())
+                await assert.rejects(access(path), { code: "ENOENT" });
+            assert.equal(await readFile(join(context.root, "subject.mjs"), "utf8"), "export const value = 1;\n");
+            const pulses = events.filter((event) => event.kind === "heartbeat" && event.detail?.startsWith("oracle "));
+            const measurements = pulses.filter((event) => event.detail?.startsWith("oracle measurement;"));
+            assert.equal(pulses.filter((event) => event.detail?.startsWith("oracle baseline replay complete;")).length, 8);
+            assert.equal(pulses.filter((event) => event.detail?.startsWith("oracle fixture replay complete;")).length, 16);
+            assert.equal(pulses.filter((event) => event.detail?.startsWith("oracle replay checkpoint;")).length, 25);
+            assert.equal(pulses.filter((event) => event.detail?.startsWith("oracle solution completed=")).length, 5);
+            assert.equal(measurements.length, 1);
+            assert.equal(measurements[0], pulses.at(-1));
+            assert.equal(measurements[0].role, "oracle-executor");
+            assert.match(measurements[0].detail, /kind=generated; solutions=5; falseAccepts=0; falseRejects=0; unstable=0; unresolved=0; adequate=(true|false)$/u);
+            assert.ok(pulses.every((event) => event.stage === "held-out-tournament"));
+            assert.doesNotMatch(JSON.stringify(pulses), /export const|tampered|expected value|subject\.mjs/u);
+        }
+        finally {
+            await Effect.runPromise(Fiber.interrupt(fiber));
+        }
+    });
+}
+for (const oracleConcurrency of [undefined, 4]) {
+    test(`interrupting oracle concurrency ${oracleConcurrency ?? "default (2)"} closes all child process groups and isolated checkouts`, oracleTestOptions, async (t) => {
+        const context = await fixture(t);
+        const fiber = Effect.runFork(buildHistoricalHiddenOracleV1({
+            ...context.input,
+            ...(oracleConcurrency === undefined ? {} : { oracleConcurrency })
+        }));
+        try {
+            const rows = await firstConcurrentGroup(context, oracleConcurrency ?? 2);
+            await Effect.runPromise(Fiber.interrupt(fiber));
+            for (const row of rows) {
+                await assert.rejects(access(row.root), { code: "ENOENT" });
+                const deadline = Date.now() + 3000;
+                for (;;) {
+                    try {
+                        process.kill(row.pid, 0);
+                    }
+                    catch (error) {
+                        assert.equal(error.code, "ESRCH");
+                        break;
+                    }
+                    assert.ok(Date.now() < deadline, "an interrupted replay child remained alive");
+                    await delay(10);
+                }
+            }
+            assert.deepEqual(await context.running(), []);
+        }
+        finally {
+            await Effect.runPromise(Fiber.interrupt(fiber));
+        }
+    });
+}
+test("an assertion during an observed oracle replay preserves its error and cleans every child", oracleTestOptions, async (t) => {
+    const context = await fixture(t);
+    const fiber = Effect.runFork(buildHistoricalHiddenOracleV1(context.input));
+    const interruptedCompletion = assert.rejects(observeOracleCompletion(fiber));
+    const originalFailure = new assert.AssertionError({
+        message: "synthetic failure while oracle children are still gated"
+    });
+    let rows = [];
+    await assert.rejects(async () => {
+        try {
+            rows = await firstConcurrentGroup(context);
+            throw originalFailure;
+        }
+        finally {
+            await Effect.runPromise(Fiber.interrupt(fiber));
+        }
+    }, (error) => error === originalFailure);
+    await interruptedCompletion;
+    assert.equal(rows.length, 2);
+    for (const row of rows) {
+        await assert.rejects(access(row.root), { code: "ENOENT" });
+        const deadline = Date.now() + 3000;
+        for (;;) {
+            try {
+                process.kill(row.pid, 0);
+            }
+            catch (error) {
+                assert.equal(error.code, "ESRCH");
+                break;
+            }
+            assert.ok(Date.now() < deadline, "an interrupted replay child remained alive");
+            await delay(10);
+        }
+    }
+    assert.deepEqual(await context.running(), []);
+});
+test("invalid oracle concurrency fails before repository access or replay", oracleTestOptions, async (t) => {
+    const context = await fixture(t);
+    for (const oracleConcurrency of [
+        0,
+        5,
+        -1,
+        1.5,
+        Number.NaN,
+        Number.POSITIVE_INFINITY,
+        null,
+        "2"
+    ]) {
+        await assert.rejects(Effect.runPromise(buildHistoricalHiddenOracleV1({
+            ...context.input,
+            repositoryRoot: join(context.root, "nonexistent-repository"),
+            oracleConcurrency: oracleConcurrency
+        })), (error) => {
+            assert.ok(error instanceof RepositoryFoundryError);
+            assert.equal(error.operation, "run-command");
+            assert.equal(error.detail, "oracleConcurrency must be an integer from 1 to 4");
+            return true;
+        });
+    }
+    assert.deepEqual(await context.running(), []);
+});

package/dist/test/repository-oracle-coverage-witness.test.d.ts

@@ -0,0 +1 @@
+export {};