@velum-labs/routekit-eval-setup 1.0.26 → 1.1.0

package/dist/test/basis-repair.test.js

@@ -0,0 +1,338 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { after, test } from "node:test";
+import { promisify } from "node:util";
+import { layer as NodeServicesLayer } from "@effect/platform-node/NodeServices";
+import { routingBasisDigestV3, routingContractDigest } from "@velum-labs/routekit-eval-contracts";
+import { Effect, Layer } from "effect";
+import { EvalProjectArtifactsLive } from "../project-artifacts.js";
+import { inspectBasisCandidatesV3, makeBasisCandidateDatasetV3 } from "../basis-validation.js";
+import { EvalAuthoringTransport } from "../project-authoring.js";
+import { EvalProjectStore, EvalProjectStoreLive } from "../project-store.js";
+import { BasisOnboarding, BasisOnboardingLive } from "../services/basis-onboarding/service.js";
+import { BasisRepair, BasisRepairLive } from "../services/basis-repair/service.js";
+const execFilePromise = promisify(execFile);
+const roots = [];
+after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
+const configuration = {
+    workloadDescription: "RouteKit repository changes",
+    candidateModels: [
+        "openai/FORBIDDEN_ROUTING_MODEL",
+        "openai/other"
+    ],
+    classifierModel: "openai/classifier",
+    authorModel: "openai/author",
+    judgeModel: "openai/judge",
+    objective: { kind: "highest-quality" },
+    maximumUnknownWeight: 0.3
+};
+const basisFixture = () => JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/routing-basis-v3.example.json", import.meta.url), "utf8"));
+const task = (index) => ({
+    caseId: `case-${String(index).padStart(3, "0")}`,
+    occurredAt: new Date(Date.UTC(2026, 0, 1) + index * 86_400_000).toISOString(),
+    taskDigest: routingContractDigest("routekit.repair-test-task.v1", "task", index),
+    summary: index >= 13
+        ? `FORBIDDEN_FINAL_TASK_${String(index)}`
+        : `Construction or validation task ${String(index)}`,
+    changedPathDigest: routingContractDigest("routekit.repair-test-paths.v1", "paths", [`src/${String(index)}.ts`]),
+    changedPaths: [`src/${String(index)}.ts`]
+});
+async function repository() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-basis-repair-"));
+    roots.push(root);
+    await execFilePromise("git", ["init", "-q", root]);
+    await execFilePromise("git", [
+        "-C",
+        root,
+        "config",
+        "user.name",
+        "RouteKit Test"
+    ]);
+    await execFilePromise("git", [
+        "-C",
+        root,
+        "config",
+        "user.email",
+        "routekit@example.test"
+    ]);
+    await writeFile(path.join(root, "README.md"), "# Frozen repair source\n");
+    await execFilePromise("git", ["-C", root, "add", "README.md"]);
+    await execFilePromise("git", [
+        "-C",
+        root,
+        "commit",
+        "-q",
+        "-m",
+        "initial"
+    ]);
+    return root;
+}
+function candidateFor(repositoryDigest) {
+    const source = basisFixture();
+    const semantic = {
+        ...source,
+        basisDigest: "0".repeat(64),
+        repositoryDigest,
+        facetSnapshot: {
+            ...source.facetSnapshot,
+            repositoryDigest
+        }
+    };
+    const basis = {
+        ...semantic,
+        basisDigest: routingBasisDigestV3(semantic)
+    };
+    return {
+        candidateId: basis.basisId,
+        recipeId: "incumbent-enriched-8",
+        basis,
+        basisDigest: basis.basisDigest,
+        generationConfigurationDigest: "a".repeat(64),
+        evidenceDigest: "b".repeat(64),
+        createdAt: "2026-08-23T00:00:00.000Z"
+    };
+}
+test("repair is isolated, immutable, and excludes validation/final/model evidence", async () => {
+    const root = await repository();
+    const infrastructure = Layer.mergeAll(EvalProjectStoreLive, EvalProjectArtifactsLive).pipe(Layer.provide(NodeServicesLayer));
+    const onboarding = BasisOnboardingLive.pipe(Layer.provide(infrastructure));
+    const initialized = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* BasisOnboarding).initialize({
+            repositoryRoot: root,
+            requestedRef: "HEAD",
+            allowDirty: false,
+            configuration,
+            tasks: Array.from({ length: 41 }, (_, index) => task(index))
+        });
+    }).pipe(Effect.provide(onboarding)));
+    assert.equal(initialized.stage, "basis-generation-ready");
+    const candidate = candidateFor(initialized.snapshot.repositoryDigest);
+    const validationPlanDigest = "c".repeat(64);
+    const selectionReportDigest = "d".repeat(64);
+    const review = {
+        ...initialized,
+        revision: 3,
+        stage: "basis-validation-review",
+        candidates: [candidate],
+        structureReports: [
+            {
+                candidateId: candidate.candidateId,
+                basisDigest: candidate.basisDigest,
+                eligible: true,
+                dimensionCount: candidate.basis.dimensions.length,
+                definitionBytes: 1,
+                findings: [
+                    {
+                        severity: "warning",
+                        code: "reviewed-boundary-warning",
+                        dimensionIds: [candidate.basis.dimensions[0].id],
+                        detail: "Clarify one reviewed semantic boundary."
+                    }
+                ]
+            }
+        ],
+        datasets: [],
+        validationPlan: {
+            version: 1,
+            planDigest: validationPlanDigest,
+            repositoryDigest: initialized.snapshot.repositoryDigest,
+            splitDigest: initialized.split.splitDigest,
+            classifierBindings: [
+                {
+                    candidateId: candidate.candidateId,
+                    basisDigest: candidate.basisDigest,
+                    classifierConfigurationDigest: "e".repeat(64)
+                }
+            ],
+            candidateIds: [candidate.candidateId],
+            datasetDigests: [],
+            repetitions: 1,
+            plannedPrimaryCalls: 1,
+            maximumAttempts: 2,
+            requiredTotalInputTokens: 1,
+            requiredTotalOutputTokens: 1,
+            acknowledgeUnpricedExposure: true
+        },
+        validationResults: [
+            {
+                version: 1,
+                candidateId: candidate.candidateId,
+                basisDigest: candidate.basisDigest,
+                validationDatasetDigest: "f".repeat(64),
+                classifierConfigurationDigest: "e".repeat(64),
+                predictions: [
+                    {
+                        caseId: "FORBIDDEN_VALIDATION_PREDICTION",
+                        basisDigest: candidate.basisDigest,
+                        scores: candidate.basis.dimensions.map((dimension) => ({
+                            dimensionId: dimension.id,
+                            score: 0
+                        })),
+                        unknownProbability: 1,
+                        classifierConfigurationDigest: "e".repeat(64)
+                    }
+                ],
+                caseCount: 1,
+                skippedInvalidCount: 0,
+                activeMae: 0.2,
+                activeF1: 0.8,
+                topDimensionAgreement: 0.8,
+                unknownMae: 0.2,
+                unknownBrier: 0.04,
+                unknownAccuracy: 0.8,
+                falseUnknownRate: 0,
+                missedUnknownRate: 0.2,
+                referenceUnknownRate: 0.2,
+                averageActiveDimensionCount: 1,
+                selectionScore: 0.3,
+                provisional: false
+            }
+        ],
+        selection: {
+            version: 1,
+            selectionReportDigest,
+            repositoryDigest: initialized.snapshot.repositoryDigest,
+            validationPlanDigest,
+            objectiveVersion: "basis-selection-v1",
+            rankedCandidateIds: [candidate.candidateId],
+            paretoCandidateIds: [candidate.candidateId],
+            selectedCandidateId: candidate.candidateId,
+            provisional: false
+        }
+    };
+    await Effect.runPromise(Effect.gen(function* () {
+        yield* (yield* EvalProjectStore).saveDocument(root, review);
+    }).pipe(Effect.provide(infrastructure)));
+    const summarySemantic = {
+        version: 1,
+        sourceCandidateId: candidate.candidateId,
+        sourceBasisDigest: candidate.basisDigest,
+        errorCategories: [
+            {
+                code: "boundary-ambiguity",
+                dimensionIds: [candidate.basis.dimensions[0].id],
+                summary: "Clarify the reviewed boundary without exposing examples."
+            }
+        ]
+    };
+    const summary = {
+        ...summarySemantic,
+        summaryDigest: routingContractDigest("routekit.basis-repair-summary.v1", "summary", summarySemantic)
+    };
+    let serializedInput = "";
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        complete: (input) => Effect.sync(() => {
+            serializedInput = input.input;
+            const fixture = basisFixture();
+            const { repositoryDigest: _repositoryDigest, ...facetSnapshot } = fixture.facetSnapshot;
+            return JSON.stringify({
+                facetSnapshot,
+                dimensions: fixture.dimensions
+            });
+        })
+    }));
+    const repairPlanLive = BasisRepairLive.pipe(Layer.provide(infrastructure));
+    const plan = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* BasisRepair).plan({
+            repositoryRoot: root,
+            sourceCandidateId: candidate.candidateId,
+            authorModel: "openai/repair-author",
+            summary
+        });
+    }).pipe(Effect.provide(repairPlanLive)));
+    const repairExecuteLive = BasisRepairLive.pipe(Layer.provide(infrastructure));
+    const repaired = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* BasisRepair)
+            .execute({
+            repositoryRoot: root,
+            plan,
+            summary
+        })
+            .pipe(Effect.provide(transport));
+    }).pipe(Effect.provide(repairExecuteLive)));
+    assert.equal(repaired.candidate.basis.provenance.origin?.kind, "repair");
+    assert.equal(repaired.candidate.basis.provenance.origin?.sourceBasisId, candidate.basis.basisId);
+    assert.doesNotMatch(serializedInput, /FORBIDDEN_FINAL_TASK/u);
+    assert.doesNotMatch(serializedInput, /FORBIDDEN_VALIDATION_PREDICTION/u);
+    assert.doesNotMatch(serializedInput, /FORBIDDEN_ROUTING_MODEL/u);
+    assert.doesNotMatch(serializedInput, /activeMae|selectionScore/u);
+    const afterRepair = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* EvalProjectStore).loadDocument(root);
+    }).pipe(Effect.provide(infrastructure)));
+    assert.deepEqual(afterRepair, review);
+    assert.equal(review.candidates.length, 1);
+    assert.equal(review.selection.selectedCandidateId, candidate.candidateId);
+    const resumed = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* BasisRepair)
+            .execute({
+            repositoryRoot: root,
+            plan,
+            summary
+        })
+            .pipe(Effect.provide(transport));
+    }).pipe(Effect.provide(repairExecuteLive)));
+    assert.deepEqual(resumed, repaired);
+    const labelProtocol = {
+        version: 1,
+        protocolDigest: "9".repeat(64),
+        kind: "reviewed-human",
+        author: "Author",
+        reviewer: "Reviewer",
+        blindness: "candidate-output-hidden",
+        activeDimensionThreshold: 0.25,
+        unknownThreshold: 0.3
+    };
+    const candidates = [candidate, repaired.candidate];
+    const datasets = candidates.map((entry) => makeBasisCandidateDatasetV3({
+        splitDigest: review.split.splitDigest,
+        candidate: entry,
+        tasks: review.split.validation,
+        labelProtocol,
+        labels: review.split.validation.map((validationTask) => ({
+            caseId: validationTask.caseId,
+            basisDigest: entry.basisDigest,
+            scores: entry.basis.dimensions.map((dimension, index) => ({
+                dimensionId: dimension.id,
+                score: index === 0 ? 1 : 0
+            })),
+            unknownProbability: 0
+        }))
+    }));
+    const validationSemantic = {
+        version: 1,
+        repositoryDigest: review.snapshot.repositoryDigest,
+        splitDigest: review.split.splitDigest,
+        classifierBindings: candidates.map((entry, index) => ({
+            candidateId: entry.candidateId,
+            basisDigest: entry.basisDigest,
+            classifierConfigurationDigest: String(index + 1).repeat(64)
+        })),
+        candidateIds: candidates.map((entry) => entry.candidateId),
+        datasetDigests: datasets.map((dataset) => dataset.datasetDigest),
+        repetitions: 1,
+        plannedPrimaryCalls: candidates.length * review.split.validation.length,
+        maximumAttempts: candidates.length * review.split.validation.length * 2,
+        requiredTotalInputTokens: 1_000,
+        requiredTotalOutputTokens: 1_000,
+        acknowledgeUnpricedExposure: true
+    };
+    const validationPlan = {
+        ...validationSemantic,
+        planDigest: routingContractDigest("routekit.basis-validation-plan.v1", "plan", validationSemantic)
+    };
+    const repairReady = await Effect.runPromise(Effect.gen(function* () {
+        return yield* (yield* BasisOnboarding).prepareRepairValidation({
+            repositoryRoot: root,
+            repairCandidate: repaired.candidate,
+            datasets,
+            validationPlan
+        });
+    }).pipe(Effect.provide(onboarding)));
+    assert.equal(repairReady.stage, "basis-validation-ready");
+    assert.deepEqual(repairReady.candidates.map((entry) => entry.candidateId), candidates.map((entry) => entry.candidateId));
+    assert.equal(inspectBasisCandidatesV3([repaired.candidate])[0].eligible, true);
+});

package/dist/test/basis-v3.test.d.ts

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

package/dist/test/basis-v3.test.js

@@ -0,0 +1,262 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import { routingContractDigest } from "@velum-labs/routekit-eval-contracts";
+import { DEFAULT_BASIS_CANDIDATE_RECIPES_V3, selectConstructionTasksForRecipeV3, splitBasisTasksChronologicallyV3 } from "../basis-candidates.js";
+import { approveSelectedBasisV3, evaluateBasisCandidateValidationV3, inspectBasisCandidatesV3, makeBasisCandidateDatasetV3, selectValidatedBasisCandidatesV3 } from "../basis-validation.js";
+import { projectRoutingBasisV3 } from "../basis-projection.js";
+const basisFixture = () => JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/routing-basis-v3.example.json", import.meta.url), "utf8"));
+const task = (index) => ({
+    caseId: `case-${String(index).padStart(3, "0")}`,
+    occurredAt: new Date(Date.UTC(2026, 0, 1) + index * 86_400_000).toISOString(),
+    taskDigest: routingContractDigest("routekit.test-task.v1", "task", index),
+    summary: `Task ${String(index)}`,
+    changedPathDigest: routingContractDigest("routekit.test-paths.v1", "paths", [`src/${String(index)}.ts`]),
+    changedPaths: [`src/${String(index)}.ts`]
+});
+const candidate = () => {
+    const basis = basisFixture();
+    return {
+        candidateId: basis.basisId,
+        recipeId: "incumbent-enriched-8",
+        basis,
+        basisDigest: basis.basisDigest,
+        generationConfigurationDigest: "a".repeat(64),
+        evidenceDigest: "b".repeat(64),
+        createdAt: "2026-08-23T00:00:00.000Z"
+    };
+};
+const labelProtocol = {
+    version: 1,
+    protocolDigest: "c".repeat(64),
+    kind: "reviewed-human",
+    author: "Author",
+    reviewer: "Reviewer",
+    blindness: "candidate-output-hidden",
+    activeDimensionThreshold: 0.25,
+    unknownThreshold: 0.3
+};
+test("default basis portfolio is incumbent plus the exact seven challengers", () => {
+    assert.deepEqual(DEFAULT_BASIS_CANDIDATE_RECIPES_V3.map((recipe) => recipe.id), [
+        "incumbent-enriched-8",
+        "structure-only-8",
+        "hybrid-paths-20-diverse-8",
+        "hybrid-paths-40-diverse-6",
+        "hybrid-paths-40-diverse-8",
+        "hybrid-paths-40-diverse-10",
+        "hybrid-paths-40-recent-8",
+        "hybrid-paths-80-diverse-8"
+    ]);
+    assert.equal(DEFAULT_BASIS_CANDIDATE_RECIPES_V3.length, 8);
+    assert.equal(DEFAULT_BASIS_CANDIDATE_RECIPES_V3[1]
+        ?.includeChangedPathStatistics, false);
+});
+test("chronological split keeps held-out cohorts disjoint and marks sparse histories provisional", () => {
+    const full = splitBasisTasksChronologicallyV3(Array.from({ length: 50 }, (_, index) => task(index)));
+    assert.equal(full.construction.length, 10);
+    assert.equal(full.validation.length, 12);
+    assert.equal(full.final.length, 28);
+    assert.equal(full.provisional, false);
+    const ids = [
+        ...full.construction,
+        ...full.validation,
+        ...full.final
+    ].map((entry) => entry.caseId);
+    assert.equal(new Set(ids).size, ids.length);
+    const sparse = splitBasisTasksChronologicallyV3(Array.from({ length: 10 }, (_, index) => task(index)));
+    assert.equal(sparse.provisional, true);
+    assert.ok(sparse.warnings.some((warning) => warning.includes("validation")));
+    assert.ok(sparse.warnings.some((warning) => warning.includes("final")));
+    const diverseRecipe = DEFAULT_BASIS_CANDIDATE_RECIPES_V3.find((recipe) => recipe.id === "hybrid-paths-20-diverse-8");
+    const recentRecipe = DEFAULT_BASIS_CANDIDATE_RECIPES_V3.find((recipe) => recipe.id === "hybrid-paths-40-recent-8");
+    assert.deepEqual(selectConstructionTasksForRecipeV3(full, diverseRecipe).map((entry) => entry.caseId), full.construction.map((entry) => entry.caseId));
+    assert.deepEqual(selectConstructionTasksForRecipeV3(full, recentRecipe).map((entry) => entry.caseId), full.construction.map((entry) => entry.caseId));
+});
+test("candidate dataset identity binds task, label, split, basis, and label protocol", () => {
+    const record = candidate();
+    const tasks = [task(1)];
+    const labels = [
+        {
+            caseId: tasks[0].caseId,
+            basisDigest: record.basisDigest,
+            scores: record.basis.dimensions.map((dimension, index) => ({
+                dimensionId: dimension.id,
+                score: index === 0 ? 1 : 0
+            })),
+            unknownProbability: 0
+        }
+    ];
+    const original = makeBasisCandidateDatasetV3({
+        splitDigest: "d".repeat(64),
+        candidate: record,
+        tasks,
+        labelProtocol,
+        labels
+    });
+    const changedTask = makeBasisCandidateDatasetV3({
+        splitDigest: "d".repeat(64),
+        candidate: record,
+        tasks: [{ ...tasks[0], summary: "Changed task" }],
+        labelProtocol,
+        labels
+    });
+    const changedLabel = makeBasisCandidateDatasetV3({
+        splitDigest: "d".repeat(64),
+        candidate: record,
+        tasks,
+        labelProtocol,
+        labels: [{ ...labels[0], unknownProbability: 0.2 }]
+    });
+    assert.notEqual(original.datasetDigest, changedTask.datasetDigest);
+    assert.notEqual(original.datasetDigest, changedLabel.datasetDigest);
+});
+test("V3 basis projection preserves dimension ids and evaluator boundaries", () => {
+    const record = candidate();
+    const projection = projectRoutingBasisV3(record.basis);
+    assert.equal(projection.basisDigest, record.basisDigest);
+    assert.deepEqual(projection.dimensions.map((dimension) => dimension.id), record.basis.dimensions.map((dimension) => dimension.id));
+    assert.deepEqual(projection.dimensions[0], {
+        id: record.basis.dimensions[0].id,
+        description: record.basis.dimensions[0].description,
+        includes: record.basis.dimensions[0].inclusions,
+        excludes: record.basis.dimensions[0].exclusions
+    });
+    assert.notEqual(projection.projectedBasisDigest, record.basisDigest);
+});
+test("validation, Pareto selection, and approval are exact-digest bound", () => {
+    const record = candidate();
+    const structure = inspectBasisCandidatesV3([record])[0];
+    assert.equal(structure.eligible, true);
+    const validationTask = task(1);
+    const scores = record.basis.dimensions.map((dimension, index) => ({
+        dimensionId: dimension.id,
+        score: index === 0 ? 1 : 0
+    }));
+    const dataset = makeBasisCandidateDatasetV3({
+        splitDigest: "d".repeat(64),
+        candidate: record,
+        tasks: [validationTask],
+        labelProtocol,
+        labels: [
+            {
+                caseId: validationTask.caseId,
+                basisDigest: record.basisDigest,
+                scores,
+                unknownProbability: 0
+            }
+        ]
+    });
+    const validationPlan = {
+        version: 1,
+        planDigest: "e".repeat(64),
+        repositoryDigest: record.basis.repositoryDigest,
+        splitDigest: "d".repeat(64),
+        classifierBindings: [
+            {
+                candidateId: record.candidateId,
+                basisDigest: record.basisDigest,
+                classifierConfigurationDigest: "f".repeat(64)
+            }
+        ],
+        candidateIds: [record.candidateId],
+        datasetDigests: [dataset.datasetDigest],
+        repetitions: 1,
+        plannedPrimaryCalls: 1,
+        maximumAttempts: 2,
+        requiredTotalInputTokens: 1,
+        requiredTotalOutputTokens: 1,
+        acknowledgeUnpricedExposure: true
+    };
+    const validation = evaluateBasisCandidateValidationV3({
+        candidate: record,
+        dataset,
+        validationPlan,
+        predictions: [
+            {
+                caseId: validationTask.caseId,
+                basisDigest: record.basisDigest,
+                scores,
+                unknownProbability: 0,
+                classifierConfigurationDigest: validationPlan.classifierBindings[0]
+                    .classifierConfigurationDigest
+            }
+        ],
+        provisional: false
+    });
+    assert.equal(validation.selectionScore, 0);
+    const selection = selectValidatedBasisCandidatesV3({
+        repositoryDigest: record.basis.repositoryDigest,
+        validationPlan,
+        candidates: [record],
+        structureReports: [structure],
+        validationResults: [validation]
+    });
+    assert.equal(selection.selectedCandidateId, record.candidateId);
+    assert.deepEqual(selection.paretoCandidateIds, [record.candidateId]);
+    const snapshot = {
+        repositoryRootDigest: "1".repeat(64),
+        requestedRef: "HEAD",
+        commit: "2".repeat(64),
+        tree: "3".repeat(64),
+        repositoryDigest: record.basis.repositoryDigest,
+        capturedAt: "2026-08-23T00:00:00.000Z",
+        dirty: false,
+        sourceInventoryDigest: "4".repeat(64)
+    };
+    assert.doesNotThrow(() => approveSelectedBasisV3({
+        projectId: "project",
+        approvedBy: "Reviewer",
+        approvedAt: "2026-08-23T00:00:00.000Z",
+        snapshot,
+        candidate: record,
+        structure,
+        validation,
+        selection
+    }));
+    assert.throws(() => approveSelectedBasisV3({
+        projectId: "project",
+        approvedBy: "Reviewer",
+        approvedAt: "2026-08-23T00:00:00.000Z",
+        snapshot: { ...snapshot, dirty: true },
+        candidate: record,
+        structure,
+        validation,
+        selection
+    }), /dirty/);
+    const provisionalSelectionSemantic = {
+        version: selection.version,
+        repositoryDigest: selection.repositoryDigest,
+        validationPlanDigest: selection.validationPlanDigest,
+        objectiveVersion: selection.objectiveVersion,
+        rankedCandidateIds: selection.rankedCandidateIds,
+        paretoCandidateIds: selection.paretoCandidateIds,
+        selectedCandidateId: selection.selectedCandidateId,
+        provisional: true
+    };
+    assert.throws(() => approveSelectedBasisV3({
+        projectId: "project",
+        approvedBy: "Reviewer",
+        approvedAt: "2026-08-23T00:00:00.000Z",
+        snapshot,
+        candidate: record,
+        structure,
+        validation: { ...validation, provisional: true },
+        selection: {
+            ...provisionalSelectionSemantic,
+            selectionReportDigest: routingContractDigest("routekit.basis-selection-report.v1", "selection", provisionalSelectionSemantic)
+        }
+    }), /acknowledgement/);
+    assert.throws(() => approveSelectedBasisV3({
+        projectId: "project",
+        approvedBy: "Reviewer",
+        approvedAt: "2026-08-23T00:00:00.000Z",
+        snapshot,
+        candidate: record,
+        structure,
+        validation,
+        selection: {
+            ...selection,
+            selectedCandidateId: "changed"
+        }
+    }), /digest/);
+});

package/dist/test/project-v2.test.d.ts

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