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

package/dist/test/repository-qualification-diagnostics.test.d.ts

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

package/dist/test/repository-qualification-diagnostics.test.js

@@ -0,0 +1,524 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { access, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } 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 { RepositoryCommandExecutionPort, replayRepositoryCommandsV1 } from "../adapters/repository-command-runner.js";
+import { RepositoryFoundryError } from "../errors.js";
+import { RepositoryFoundryProgressLive } from "../services/foundry-progress/service.js";
+import { qualifyHistoricalTaskSeedAcrossBatchesResumableV1, qualifyHistoricalTaskSeedAcrossBatchesV1 } from "../services/task-seed/service.js";
+const execute = promisify(execFile);
+const CANARY = "private-qualification-command-evidence";
+async function fixture(t) {
+    const root = await realpath(await mkdtemp(join(tmpdir(), "qualification-diagnostics-")));
+    t.after(() => rm(root, { recursive: true, force: true }));
+    const git = (...args) => execute("git", ["-C", root, ...args]);
+    await git("init", "-q");
+    const testSource = (assertion) => `import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, writeFileSync } from "node:fs";
+import { value } from "./subject.mjs";
+test("public contract", () => {
+  console.log(${JSON.stringify(CANARY)});
+  console.log("diagnostic-cwd=" + process.cwd());
+  assert.equal(existsSync("candidate-ran"), false);
+  writeFileSync("candidate-ran", "each repetition must be isolated");
+  ${assertion}
+});
+`;
+    await writeFile(join(root, "baseline.test.mjs"), testSource("assert.equal(1, 1);"));
+    const commit = async (value) => {
+        await writeFile(join(root, "subject.mjs"), `export const value = ${value};\n`);
+        await writeFile(join(root, "case.test.mjs"), testSource(`assert.equal(value, ${value});`));
+        await git("add", ".");
+        await git("-c", "core.hooksPath=/dev/null", "-c", "commit.gpgSign=false", "-c", "user.name=Qualification Diagnostics", "-c", "user.email=fixture@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, file) => ({
+        id,
+        kind: "test",
+        cwd: ".",
+        executable: "node",
+        args: ["--test", file],
+        timeoutMs: 5000
+    });
+    const seed = {
+        version: 1,
+        id: "diagnostic-seed",
+        status: "candidate",
+        source: { kind: "historical-fix", changeEpisodeId: "diagnostic-change" },
+        summary: "Return the reference value.",
+        capabilityEvidence: [{ kind: "test", id: "case", path: "case.test.mjs" }],
+        initialState: { commit: initialCommit },
+        referenceCommit,
+        targetBehavior: [{ id: "behavior", description: "Return one.", critical: true, evidence: [] }],
+        baselineObservations: [],
+        preChangeObservations: [],
+        postChangeObservations: [],
+        candidateTestIds: ["case"],
+        environment: {
+            protectedControlPaths: [],
+            trustedPreparationRecipes: [
+                {
+                    id: "prepare",
+                    kind: "custom",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["-e", `process.stdout.write(${JSON.stringify(CANARY)});`],
+                    timeoutMs: 5000
+                }
+            ],
+            candidateValidationRecipes: [
+                {
+                    id: "validate",
+                    kind: "check",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--check", "subject.mjs"],
+                    timeoutMs: 5000
+                }
+            ],
+            baselineGradeRecipes: [recipe("baseline", "baseline.test.mjs")],
+            gradeRecipes: [recipe("grade", "case.test.mjs")]
+        },
+        confidence: "medium",
+        risks: ["review-required"],
+        rejectionReasons: []
+    };
+    return { root, seed };
+}
+function diagnosticRun(data) {
+    const artifacts = [];
+    const events = [];
+    const effect = qualifyHistoricalTaskSeedAcrossBatchesV1({
+        repositoryRoot: data.root,
+        seed: data.seed,
+        batches: 2,
+        repetitionsPerBatch: 2
+    }).pipe(Effect.provide(RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+        events.push(event);
+    }), (artifact) => Effect.promise(async () => {
+        const report = artifact.value;
+        // Observe at recorder invocation, not after the complete qualification:
+        // the phase must already have released every candidate checkout.
+        for (const result of report.results) {
+            const checkout = /diagnostic-cwd=([^\r\n]+)/u.exec(result.stdout)?.[1];
+            if (checkout !== undefined)
+                await assert.rejects(access(checkout), { code: "ENOENT" });
+        }
+        artifacts.push(artifact);
+    }))));
+    return { effect, artifacts, events };
+}
+test("qualification records complete raw phase rows after cleanup without changing batches, repetitions, or model accounting", async (t) => {
+    const data = await fixture(t);
+    const run = diagnosticRun(data);
+    const qualification = await Effect.runPromise(run.effect);
+    assert.equal(qualification.seed.status, "qualified");
+    assert.equal(qualification.stability.stable, true);
+    assert.equal(qualification.stability.batches.length, 2);
+    assert.equal(qualification.seed.baselineObservations.length, 4);
+    assert.equal(qualification.seed.preChangeObservations.length, 4);
+    assert.equal(qualification.seed.postChangeObservations.length, 4);
+    assert.equal(run.artifacts.length, 6);
+    assert.equal(new Set(run.artifacts.map((artifact) => artifact.operationId)).size, 6);
+    assert.deepEqual(run.artifacts.map((artifact) => artifact.value.batch), [1, 1, 1, 2, 2, 2]);
+    for (const batch of [1, 2]) {
+        const reports = run.artifacts
+            .map((artifact) => artifact.value)
+            .filter((report) => report.batch === batch);
+        assert.deepEqual(reports.map((report) => report.phase).sort(), [
+            "baseline",
+            "post-change",
+            "pre-change"
+        ]);
+    }
+    for (const artifact of run.artifacts) {
+        const report = artifact.value;
+        assert.equal(artifact.response.text, JSON.stringify(report));
+        assert.equal(artifact.role, "seed-qualifier");
+        assert.equal(artifact.model, "local-replay");
+        assert.equal(artifact.request.maximumOutputTokens, 0);
+        assert.equal(report.diagnosticOnly, true);
+        assert.equal(report.admissionEvidence, false);
+        assert.equal(report.seedId, data.seed.id);
+        assert.equal(report.referenceCommit, data.seed.referenceCommit);
+        assert.deepEqual(report.results.map((result) => result.repetition), [1, 2]);
+        for (const result of report.results) {
+            assert.equal(result.commit, report.phase === "post-change" ? data.seed.referenceCommit : data.seed.initialState.commit);
+            assert.equal(result.gradeExecuted, true);
+            assert.equal(result.stage, "grade");
+            assert.equal(result.exitCode, report.phase === "pre-change" ? 1 : 0);
+            assert.equal(repositoryCommandTestEvidenceV1(result, result.recipeId).outcome, report.phase === "pre-change" ? "fail" : "pass");
+            assert.equal(result.timedOut, false);
+            assert.equal(result.outputTruncated, false);
+            assert.ok(result.stdout.includes(CANARY));
+            assert.equal(result.trustedPreparationResults.length, 1);
+            assert.equal(result.trustedPreparationResults[0].stdout, CANARY);
+            assert.equal(result.trustedPreparationResults[0].stage, "trusted-preparation");
+            assert.equal(result.candidateValidationResults.length, 1);
+            assert.equal(result.candidateValidationResults[0].stage, "candidate-validation");
+            assert.ok(result.isolationTimings);
+            for (const duration of Object.values(result.isolationTimings))
+                assert.ok(duration >= 0);
+            assert.ok(report.wallMs >= result.durationMs);
+        }
+    }
+    assert.equal(run.events.length, 6);
+    assert.ok(run.events.every((event) => event.kind === "heartbeat" && event.modelCalls === 0 && event.role === "seed-qualifier"));
+    assert.doesNotMatch(JSON.stringify(run.events), /private-qualification|stdout|stderr|diagnostic-cwd|case\.test|AssertionError/u);
+});
+test("interrupted cross-batch qualification resumes after the last durable repetition", async (t) => {
+    const data = await fixture(t);
+    let retained;
+    const checkpointed = [];
+    const checkpoint = (progress, interruptAfterTwo) => Effect.gen(function* () {
+        retained = structuredClone(progress);
+        const unit = progress.activeUnits.at(-1);
+        if (unit !== undefined) {
+            checkpointed.push(`${String(unit.batch)}:${unit.phase}:${String(unit.repetition)}`);
+        }
+        if (interruptAfterTwo && progress.activeUnits.length === 2) {
+            return yield* new RepositoryFoundryError({
+                operation: "extract-task-seeds",
+                detail: "injected interruption after two durable repetitions"
+            });
+        }
+    });
+    await assert.rejects(Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root,
+        seed: data.seed,
+        bindingDigest: "binding-v1",
+        batches: 2,
+        repetitionsPerBatch: 2,
+        checkpoint: (progress) => checkpoint(progress, true)
+    })), /injected interruption/u);
+    assert.ok(retained);
+    assert.deepEqual(checkpointed, ["1:baseline:1", "1:baseline:2"]);
+    const resumed = await Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root,
+        seed: data.seed,
+        bindingDigest: "binding-v1",
+        progress: retained,
+        batches: 2,
+        repetitionsPerBatch: 2,
+        checkpoint: (progress) => checkpoint(progress, false)
+    }));
+    assert.equal(resumed.qualification.seed.status, "qualified");
+    assert.equal(resumed.progress.completedBatches.length, 2);
+    assert.deepEqual(resumed.progress.activeUnits, []);
+    assert.equal(checkpointed.length, 12);
+    assert.equal(new Set(checkpointed).size, 12);
+    assert.equal(checkpointed[2], "1:pre-change:1");
+});
+test("an incomplete grading unit blocks qualification durably before later repetitions or batches", async (t) => {
+    const data = await fixture(t);
+    data.seed = {
+        ...data.seed,
+        environment: {
+            ...data.seed.environment,
+            baselineGradeRecipes: [
+                ...data.seed.environment.baselineGradeRecipes,
+                { ...data.seed.environment.baselineGradeRecipes[0], id: "must-not-start-after-timeout" }
+            ]
+        }
+    };
+    let retained;
+    let commands = 0;
+    let grades = 0;
+    const run = (progress) => Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root, seed: data.seed, bindingDigest: "binding-v1",
+        ...(progress === undefined ? {} : { progress }),
+        checkpoint: (value) => Effect.sync(() => { retained = structuredClone(value); })
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (input) => Effect.sync(() => {
+            commands += 1;
+            if (input.args.includes("--test")) {
+                grades += 1;
+                return { exitCode: null, timedOut: true, stdout: CANARY, stderr: "" };
+            }
+            return { exitCode: 0, stdout: "", stderr: "" };
+        })
+    })));
+    await assert.rejects(run(), /operational failure prevented grading.*stage=grade.*timeout=true/u);
+    assert.equal(grades, 1, "do not start the second repetition after a grader timeout");
+    assert.equal(retained?.activeUnits.length, 1, "retain the completed failure for diagnostics");
+    const completedCommands = commands;
+    for (const result of [
+        { timedOut: true, exitCode: null, outputTruncated: false },
+        { timedOut: false, exitCode: null, outputTruncated: false },
+        { timedOut: false, exitCode: 0, outputTruncated: true }
+    ]) {
+        const progress = structuredClone(retained);
+        const first = progress.activeUnits[0];
+        const changed = {
+            ...progress,
+            activeUnits: [{ ...first, results: first.results.map((row) => ({ ...row, ...result })) }]
+        };
+        const failure = await Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+            repositoryRoot: data.root, seed: data.seed, bindingDigest: "binding-v1",
+            progress: changed, checkpoint: () => Effect.void
+        }).pipe(Effect.result));
+        assert.equal(failure._tag, "Failure");
+        if (failure._tag === "Failure")
+            assert.equal(failure.failure.classification, "environment_blocked");
+        await assert.rejects(run(changed), /operational failure prevented grading/u);
+        assert.equal(commands, completedCommands, "unchanged failed execution is never replayed");
+    }
+});
+for (const { timedOut, continueAfterIncompleteGrade } of [false, true].flatMap((timedOut) => [false, true].map((continueAfterIncompleteGrade) => ({ timedOut, continueAfterIncompleteGrade })))) {
+    test(`incomplete replay preserves independent repetitions and explicit diagnostic continuation (timeout=${String(timedOut)}; continue=${String(continueAfterIncompleteGrade)})`, async (t) => {
+        const data = await fixture(t);
+        const checkouts = [];
+        const results = await Effect.runPromise(replayRepositoryCommandsV1({
+            repositoryRoot: data.root,
+            commit: data.seed.initialState.commit,
+            recipes: [
+                data.seed.environment.gradeRecipes[0],
+                { ...data.seed.environment.gradeRecipes[0], id: "queued-grade" }
+            ],
+            repetitions: 3,
+            ...(continueAfterIncompleteGrade ? { continueAfterIncompleteGrade } : {})
+        }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+            run: (input) => Effect.sync(() => {
+                checkouts.push(input.cwd);
+                return { exitCode: null, timedOut, stdout: CANARY, stderr: "" };
+            })
+        })));
+        const expectedCommands = continueAfterIncompleteGrade ? 6 : 3;
+        assert.equal(checkouts.length, expectedCommands);
+        assert.equal(new Set(checkouts).size, 3);
+        assert.equal(results.length, expectedCommands);
+        assert.equal(results[0].timedOut, timedOut);
+        assert.equal(results[0].stdout, CANARY);
+        for (const checkout of checkouts)
+            await assert.rejects(access(checkout), { code: "ENOENT" });
+    });
+}
+test("failed trusted preparation retains completed raw rows and skips queued phases and later batches", async (t) => {
+    const data = await fixture(t);
+    data.seed = {
+        ...data.seed,
+        environment: {
+            ...data.seed.environment,
+            trustedPreparationRecipes: [
+                {
+                    ...data.seed.environment.trustedPreparationRecipes[0],
+                    args: [
+                        "-e",
+                        `process.stdout.write(${JSON.stringify(CANARY)}); process.stderr.write("private preparation failure"); process.exit(7);`
+                    ]
+                }
+            ]
+        }
+    };
+    const run = diagnosticRun(data);
+    await assert.rejects(Effect.runPromise(run.effect), /operational failure prevented grading.*stage=trusted-preparation/u);
+    assert.equal(run.artifacts.length, 1, "later phases and batches never start");
+    assert.deepEqual(run.artifacts.map((artifact) => artifact.value.phase), [
+        "baseline"
+    ]);
+    assert.ok(run.artifacts.every((artifact) => artifact.value.batch === 1));
+    for (const artifact of run.artifacts) {
+        const report = artifact.value;
+        assert.equal(report.results.length, 2);
+        for (const result of report.results) {
+            assert.equal(result.recipeId, "prepare");
+            assert.equal(result.stage, "trusted-preparation");
+            assert.equal(result.gradeExecuted, false);
+            assert.equal(result.exitCode, 7);
+            assert.equal(repositoryCommandTestEvidenceV1(result, result.recipeId).outcome, "unknown");
+            assert.equal(result.stdout, CANARY);
+            assert.equal(result.stderr, "private preparation failure");
+            assert.equal(result.trustedPreparationResults.length, 1);
+            assert.equal(result.trustedPreparationResults[0].exitCode, 7);
+            assert.equal(result.candidateValidationResults.length, 0);
+            assert.ok(result.isolationTimings);
+            assert.ok(report.wallMs >= result.durationMs);
+        }
+    }
+    assert.equal(run.events.length, 2);
+    assert.ok(run.events.every((event) => event.modelCalls === 0));
+    assert.doesNotMatch(JSON.stringify(run.events), /unstable|flaky/u);
+    assert.doesNotMatch(JSON.stringify(run.events), /private preparation failure|private-qualification|stdout|stderr/u);
+});
+for (const timedOut of [false, true]) {
+    test(`candidate-validation ${timedOut ? "timeout" : "failure"} finishes cleanup before skipping later phases`, {
+        timeout: 30000
+    }, async (t) => {
+        const data = await fixture(t);
+        data.seed = {
+            ...data.seed,
+            environment: {
+                ...data.seed.environment,
+                candidateValidationRecipes: [
+                    {
+                        ...data.seed.environment.candidateValidationRecipes[0],
+                        args: [
+                            "-e",
+                            `console.log(${JSON.stringify(CANARY)}); console.log("diagnostic-cwd=" + process.cwd()); process.stderr.write("private validation failure"); ${timedOut ? "setInterval(() => {}, 1000);" : "process.exit(23);"}`
+                        ],
+                        timeoutMs: timedOut ? 500 : 5000
+                    }
+                ]
+            }
+        };
+        const run = diagnosticRun(data);
+        await assert.rejects(Effect.runPromise(run.effect), /operational failure prevented grading.*stage=candidate-validation/u);
+        assert.equal(run.artifacts.length, 1);
+        assert.deepEqual(run.artifacts.map((artifact) => artifact.value.phase), [
+            "baseline"
+        ]);
+        for (const artifact of run.artifacts) {
+            const report = artifact.value;
+            assert.equal(report.batch, 1);
+            assert.deepEqual(report.results.map((result) => result.repetition), [1, 2]);
+            for (const result of report.results) {
+                assert.equal(result.gradeExecuted, false);
+                assert.equal(result.stage, "candidate-validation");
+                assert.equal(result.exitCode, timedOut ? null : 23);
+                assert.equal(result.timedOut, timedOut);
+                assert.equal(repositoryCommandTestEvidenceV1(result, result.recipeId).outcome, "unknown");
+                assert.equal(result.trustedPreparationResults[0].exitCode, 0);
+                assert.equal(result.candidateValidationResults[0].stderr, "private validation failure");
+                assert.match(result.stdout, /diagnostic-cwd=/u);
+                assert.ok(result.isolationTimings);
+            }
+        }
+        assert.equal(run.events.length, 2);
+        assert.doesNotMatch(JSON.stringify(run.events), /private validation failure|private-qualification|stdout|stderr|unstable|flaky/u);
+    });
+}
+test("unknown grade execution preserves diagnostics and stops queued qualification phases and batches", async (t) => {
+    const data = await fixture(t);
+    data.seed = {
+        ...data.seed,
+        environment: {
+            ...data.seed.environment,
+            gradeRecipes: [{ ...data.seed.environment.gradeRecipes[0], args: ["-e", "process.exit(1)"] }]
+        }
+    };
+    const run = diagnosticRun(data);
+    await assert.rejects(Effect.runPromise(run.effect), /operational failure prevented grading/u);
+    assert.equal(run.artifacts.length, 2);
+    assert.deepEqual(run.artifacts.map((artifact) => artifact.value.phase), ["baseline", "pre-change"]);
+    for (const artifact of run.artifacts) {
+        const report = artifact.value;
+        assert.equal(report.results.length, 2);
+        for (const result of report.results) {
+            assert.equal(result.gradeExecuted, true);
+            assert.equal(result.stage, "grade");
+            assert.equal(repositoryCommandTestEvidenceV1(result, result.recipeId).outcome, report.phase === "baseline" ? "pass" : "unknown");
+        }
+    }
+    assert.equal(run.events.length, 3);
+});
+test("unattributable grading is retained once and cannot be retried without changing the execution binding", async (t) => {
+    const data = await fixture(t);
+    let retained;
+    let grades = 0;
+    const run = (progress) => Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root,
+        seed: data.seed,
+        bindingDigest: "unknown-evidence-v1",
+        ...(progress === undefined ? {} : { progress }),
+        checkpoint: (value) => Effect.sync(() => { retained = structuredClone(value); })
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (input) => Effect.sync(() => {
+            if (input.args.includes("--test")) {
+                grades += 1;
+                return { exitCode: 1, stdout: "", stderr: "test setup failed without assertion evidence" };
+            }
+            return { exitCode: 0, stdout: "", stderr: "" };
+        })
+    })));
+    await assert.rejects(run(), /operational failure prevented grading/u);
+    assert.equal(grades, 1);
+    assert.equal(retained?.activeUnits.length, 1);
+    await assert.rejects(run(retained), /operational failure prevented grading/u);
+    assert.equal(grades, 1);
+});
+test("pre-change compilation blocks resumable qualification once and preserves the exact failed unit", async (t) => {
+    const data = await fixture(t);
+    const seed = {
+        ...data.seed,
+        environment: {
+            ...data.seed.environment,
+            candidateValidationRecipes: [{
+                    ...data.seed.environment.candidateValidationRecipes[0],
+                    args: ["-e", [
+                            "const fs = require('node:fs');",
+                            "const reviewed = fs.readFileSync('case.test.mjs', 'utf8').includes('assert.equal(value, 1);');",
+                            "const initial = fs.readFileSync('subject.mjs', 'utf8').includes('value = 0');",
+                            "if (reviewed && initial) process.exit(2);"
+                        ].join(" ")]
+                }]
+        }
+    };
+    let retained;
+    const effect = (progress) => qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root,
+        seed,
+        bindingDigest: "compile-only-seed-v1",
+        ...(progress === undefined ? {} : { progress }),
+        checkpoint: (value) => Effect.sync(() => { retained = structuredClone(value); })
+    });
+    await assert.rejects(Effect.runPromise(effect()), /operational failure prevented grading.*phase=pre-change; stage=candidate-validation/u);
+    assert.ok(retained);
+    assert.equal(retained.completedBatches.length, 0);
+    assert.deepEqual(retained.activeUnits.map(({ phase }) => phase), ["baseline", "baseline", "pre-change"]);
+    const failed = retained.activeUnits.at(-1).results[0];
+    assert.equal(failed.gradeExecuted, false);
+    assert.equal(failed.exitCode, 2);
+    assert.equal(repositoryCommandTestEvidenceV1(failed, failed.recipeId).outcome, "unknown");
+    let resumedCommands = 0;
+    await assert.rejects(Effect.runPromise(effect(retained).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => Effect.sync(() => {
+            resumedCommands += 1;
+            return { exitCode: 0, stdout: "", stderr: "" };
+        })
+    }))), /operational failure prevented grading.*phase=pre-change/u);
+    assert.equal(resumedCommands, 0, "resuming must not repeat the failed build or start later phases");
+});
+test("legacy completed compile-only batches cannot bypass the executed evidence contract", async (t) => {
+    const data = await fixture(t);
+    const observation = (subjectId, outcome, detail) => ({
+        id: subjectId, kind: "test-command", subjectId, outcome, detail
+    });
+    const legacySeed = {
+        ...data.seed,
+        status: "qualified",
+        baselineObservations: [observation("baseline", "pass", "stage=grade; gradeExecuted=true")],
+        preChangeObservations: [observation("grade", "fail", "stage=candidate-validation; gradeExecuted=false; exit=2")],
+        postChangeObservations: [observation("grade", "pass", "stage=grade; gradeExecuted=true")]
+    };
+    let commands = 0;
+    let checkpoints = 0;
+    await assert.rejects(Effect.runPromise(qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+        repositoryRoot: data.root,
+        seed: data.seed,
+        bindingDigest: "legacy-completed-v1",
+        progress: {
+            version: 1,
+            bindingDigest: "legacy-completed-v1",
+            batchesRequired: 2,
+            repetitionsPerBatch: 2,
+            completedBatches: [{ batch: 1, seed: legacySeed }],
+            activeUnits: []
+        },
+        checkpoint: () => Effect.sync(() => { checkpoints += 1; })
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => Effect.sync(() => {
+            commands += 1;
+            return { exitCode: 0, stdout: "", stderr: "" };
+        })
+    }))), /retained qualification does not satisfy the executed behavioral evidence contract/u);
+    assert.equal(commands, 0);
+    assert.equal(checkpoints, 0);
+});

package/dist/test/repository-reference-authoring.test.d.ts

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