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

package/dist/test/repository-foundry-quality.test.js

@@ -0,0 +1,1138 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import { Effect, Layer } from "effect";
+import { EvalAuthoringTransport } from "../project-authoring.js";
+import { assertRepositoryBehaviorMapV1 } from "../repository-behavior-protocol.js";
+import { repositoryCandidateCaseProjectionV1 } from "../repository-benchmark-protocol.js";
+import { assertRepositoryHiddenFixtureSuiteV1 } from "../repository-fixture-protocol.js";
+import { admitRepositoryBenchmarkCaseV1, compileValidatedBenchmarkLibraryV1, evaluateRepositoryOracleAdequacyV1, repositoryBehavioralFingerprintV1 } from "../repository-quality-policy.js";
+import { compileRepositoryRoutingBenchmarkV1 } from "../repository-routing-quality-policy.js";
+import { gpt56RepositoryRoutingModelPlanV1 } from "../repository-routing-model-protocol.js";
+import { assertRepositoryRoutingLabelingPlanV1 } from "../repository-routing-plan-protocol.js";
+import { assertRepositoryTaskSeedV1 } from "../repository-task-seed-protocol.js";
+import { compileRepositoryFoundryImprovementCycleV1 } from "../services/improvement-loop/service.js";
+import { authorRepositoryReviewedDimensionLabelV1 } from "../services/dimension-labeling/service.js";
+import { RepositoryFoundryLanguageModelLive } from "../services/language-model/service.js";
+import { executeRepositoryRoutingLabelingV1, planRepositoryRoutingLabelingV1 } from "../services/routing-benchmark/service.js";
+const oracle = (overrides = {}) => ({
+    version: 1,
+    caseId: "case-stream-order",
+    hardFailurePolicy: "any-critical-hard-clause-fails",
+    fixtures: [
+        {
+            id: "provider-sequence",
+            kind: "counterfactual",
+            description: "A provider sequence with a changed terminal-event state.",
+            expectedBehavior: "The terminal-event invariant remains explicit.",
+            expectationMode: "changes",
+            source: "reviewed",
+            testPath: "packages/provider/src/stream.test.ts"
+        }
+    ],
+    clauses: [
+        {
+            id: "ordered",
+            kind: "ordered-events",
+            critical: true,
+            description: "The stream has exactly one terminal event and no later output.",
+            eventTypes: ["output", "completed"],
+            terminalEvent: "completed"
+        },
+        {
+            id: "usage",
+            kind: "property",
+            critical: true,
+            description: "Usage is preserved.",
+            propertyId: "usage-preserved",
+            fixtureIds: ["provider-sequence"]
+        }
+    ],
+    solutions: [
+        {
+            id: "historical-reference",
+            kind: "historical-reference",
+            family: "valid",
+            expectedClass: "valid"
+        },
+        {
+            id: "alternate-valid",
+            kind: "independent-valid",
+            family: "valid",
+            expectedClass: "valid"
+        },
+        {
+            id: "duplicate-terminal",
+            kind: "mutation",
+            family: "event-order",
+            expectedClass: "wrong"
+        },
+        {
+            id: "drops-usage",
+            kind: "model-near-miss",
+            family: "integration",
+            expectedClass: "wrong"
+        }
+    ],
+    observations: [
+        ...["historical-reference", "alternate-valid"].flatMap((solutionId) => ["ordered", "usage"].flatMap((clauseId) => [
+            {
+                solutionId,
+                clauseId,
+                repetition: 1,
+                outcome: "pass",
+                detail: "passed"
+            },
+            {
+                solutionId,
+                clauseId,
+                repetition: 2,
+                outcome: "pass",
+                detail: "passed"
+            }
+        ])),
+        {
+            solutionId: "duplicate-terminal",
+            clauseId: "ordered",
+            repetition: 1,
+            outcome: "fail",
+            detail: "two terminal events"
+        },
+        {
+            solutionId: "duplicate-terminal",
+            clauseId: "ordered",
+            repetition: 2,
+            outcome: "fail",
+            detail: "two terminal events"
+        },
+        {
+            solutionId: "duplicate-terminal",
+            clauseId: "usage",
+            repetition: 1,
+            outcome: "pass",
+            detail: "usage happened to survive"
+        },
+        {
+            solutionId: "duplicate-terminal",
+            clauseId: "usage",
+            repetition: 2,
+            outcome: "pass",
+            detail: "usage happened to survive"
+        },
+        {
+            solutionId: "drops-usage",
+            clauseId: "ordered",
+            repetition: 1,
+            outcome: "pass",
+            detail: "ordering fixed"
+        },
+        {
+            solutionId: "drops-usage",
+            clauseId: "ordered",
+            repetition: 2,
+            outcome: "pass",
+            detail: "ordering fixed"
+        },
+        {
+            solutionId: "drops-usage",
+            clauseId: "usage",
+            repetition: 1,
+            outcome: "fail",
+            detail: "usage missing"
+        },
+        {
+            solutionId: "drops-usage",
+            clauseId: "usage",
+            repetition: 2,
+            outcome: "fail",
+            detail: "usage missing"
+        }
+    ],
+    knownLimitations: [],
+    ...overrides
+});
+const findings = [
+    "authenticity",
+    "specification-sufficiency",
+    "oracle-adequacy",
+    "stability",
+    "distinctness",
+    "realism",
+    "leakage",
+    "triviality",
+    "coverage"
+];
+const routingBasis = () => JSON.parse(readFileSync(new URL("../../../../test/fixtures/routing-v3/examples/routing-basis-v3.example.json", import.meta.url), "utf8"));
+const routingPolicy = {
+    activeDimensionThreshold: 0.5,
+    maximumUnknownProbability: 0.2,
+    minimumDominanceMargin: 0.35,
+    minimumCasesPerDimension: 1
+};
+const reviewedDimensionLabel = (input) => {
+    const labelFor = (primaryDimensionId, secondaryDimensionId) => ({
+        caseId: input.caseId,
+        basisDigest: input.basis.basisDigest,
+        scores: input.basis.dimensions.map((dimension) => ({
+            dimensionId: dimension.id,
+            score: dimension.id === primaryDimensionId
+                ? 0.8
+                : dimension.id === secondaryDimensionId
+                    ? 0.55
+                    : 0.02
+        })),
+        unknownProbability: 0.05
+    });
+    const reviewerBDimensionId = input.reviewerBDimensionId ?? input.primaryDimensionId;
+    return {
+        version: 1,
+        caseId: input.caseId,
+        basisDigest: input.basis.basisDigest,
+        authorModel: "codex/gpt-5.6-sol",
+        authorCallId: "call-dimension-labeler",
+        authorDetail: "The visible task is dominated by the selected semantic workload.",
+        authorEvidenceIds: ["benchmark-case:/visible", "routing-basis:/dimensions/0"],
+        label: labelFor(input.primaryDimensionId, input.secondaryDimensionId),
+        reviews: [
+            {
+                reviewerId: "dimension-critic-a",
+                model: "codex/gpt-5.6-terra",
+                callId: "call-dimension-critic-a",
+                outcome: "approve",
+                primaryDimensionId: input.primaryDimensionId,
+                detail: "The visible task and repository evidence are dominated by this dimension.",
+                evidenceIds: ["benchmark-case:/visible", "routing-basis:/dimensions/0"],
+                independentLabel: labelFor(input.primaryDimensionId)
+            },
+            {
+                reviewerId: "dimension-critic-b",
+                model: "codex/gpt-5.6-luna",
+                callId: "call-dimension-critic-b",
+                outcome: reviewerBDimensionId === input.primaryDimensionId ? "approve" : "reject",
+                primaryDimensionId: reviewerBDimensionId,
+                detail: "The nearest confusable dimensions are explicitly excluded.",
+                evidenceIds: ["benchmark-case:/qualityFindings/0", "routing-basis:/dimensions/0"],
+                independentLabel: labelFor(reviewerBDimensionId)
+            }
+        ]
+    };
+};
+test("fixture protocol encodes counterfactual changes and metamorphic preservation", () => {
+    const base = {
+        version: 1,
+        caseId: "case-fixture-mode-contract",
+        overlays: [
+            {
+                path: "src/behavior.test.ts",
+                content: "test('fixture', () => {});",
+                fixtureIds: ["metamorphic-mode"]
+            }
+        ]
+    };
+    assert.throws(() => assertRepositoryHiddenFixtureSuiteV1({
+        ...base,
+        fixtures: [
+            {
+                id: "metamorphic-mode",
+                kind: "metamorphic",
+                description: "Vary a non-semantic input.",
+                expectedBehavior: "The externally observable result is preserved.",
+                expectationMode: "changes",
+                source: "generated",
+                testPath: "src/behavior.test.ts"
+            }
+        ]
+    }), /expectationMode/u);
+    assert.doesNotThrow(() => assertRepositoryHiddenFixtureSuiteV1({
+        ...base,
+        fixtures: [
+            {
+                id: "metamorphic-mode",
+                kind: "metamorphic",
+                description: "Vary a non-semantic input.",
+                expectedBehavior: "The externally observable result is preserved.",
+                expectationMode: "preserved",
+                source: "generated",
+                testPath: "src/behavior.test.ts"
+            }
+        ]
+    }));
+});
+const admittedCase = (id = "case-stream-order", fingerprint) => {
+    const hidden = oracle({ caseId: id });
+    const adequacy = evaluateRepositoryOracleAdequacyV1(hidden);
+    return admitRepositoryBenchmarkCaseV1({
+        draft: {
+            version: 1,
+            id,
+            capabilityId: "provider-stream-translation",
+            familyId: "terminal-event-repair",
+            seedId: "seed-historical-stream-fix",
+            lane: "repository-agent",
+            visible: {
+                lane: "repository-agent",
+                id,
+                requestText: "Fix the adapter so it emits one terminal event and preserves usage.",
+                checkoutCommit: "a".repeat(40),
+                allowedTools: ["read", "search", "edit", "shell", "test"],
+                constraints: ["Do not change the public wire contract."]
+            },
+            hidden,
+            adequacy,
+            qualityFindings: findings.map((axis) => ({
+                axis,
+                outcome: "pass",
+                detail: `${axis} passed`,
+                evidence: [],
+                evidenceIds: [`test-fixture:${axis}`]
+            })),
+            behavioralFingerprint: fingerprint ??
+                repositoryBehavioralFingerprintV1({
+                    capabilityId: "provider-stream-translation",
+                    familyId: "terminal-event-repair",
+                    behaviorClauses: ["one terminal event", "no output after terminal", "preserve usage"],
+                    oracle: hidden
+                })
+        }
+    });
+};
+test("oracle adequacy accepts valid alternatives and rejects every wrong family", () => {
+    const report = evaluateRepositoryOracleAdequacyV1(oracle());
+    assert.equal(report.admitted, true);
+    assert.deepEqual(report.falseAcceptedSolutionIds, []);
+    assert.deepEqual(report.falseRejectedSolutionIds, []);
+    assert.deepEqual(report.unstableSolutionIds, []);
+    assert.deepEqual(report.insufficientObservationPairs, []);
+    assert.deepEqual(report.mutationFamilyKills, [
+        { family: "event-order", killed: 1, total: 1 },
+        { family: "integration", killed: 1, total: 1 }
+    ]);
+});
+test("oracle adequacy rejects surviving wrong solutions, false rejections, and instability", () => {
+    const weak = oracle({
+        observations: oracle().observations.map((observation) => {
+            if (observation.solutionId === "duplicate-terminal" && observation.clauseId === "ordered") {
+                return { ...observation, outcome: "pass" };
+            }
+            if (observation.solutionId === "alternate-valid" &&
+                observation.clauseId === "usage" &&
+                observation.repetition === 2) {
+                return { ...observation, outcome: "fail" };
+            }
+            return observation;
+        })
+    });
+    const report = evaluateRepositoryOracleAdequacyV1(weak);
+    assert.equal(report.admitted, false);
+    assert.deepEqual(report.falseAcceptedSolutionIds, ["duplicate-terminal"]);
+    assert.deepEqual(report.falseRejectedSolutionIds, ["alternate-valid"]);
+    assert.deepEqual(report.unstableSolutionIds, ["alternate-valid"]);
+});
+test("oracle adequacy cannot count an unexecuted critical clause as a mutant kill", () => {
+    const incomplete = oracle({
+        observations: oracle().observations.filter((observation) => !(observation.solutionId === "duplicate-terminal" && observation.clauseId === "usage"))
+    });
+    const report = evaluateRepositoryOracleAdequacyV1(incomplete);
+    assert.equal(report.admitted, false);
+    assert.deepEqual(report.insufficientObservationPairs, ["duplicate-terminal/usage"]);
+    assert.deepEqual(report.mutationFamilyKills.find((family) => family.family === "event-order"), { family: "event-order", killed: 0, total: 1 });
+});
+test("inconclusive execution neither earns mutant kills nor fabricates oracle classification errors", () => {
+    const incomplete = oracle({
+        observations: oracle().observations.map((observation) => observation.solutionId === "duplicate-terminal" ||
+            observation.solutionId === "alternate-valid"
+            ? {
+                ...observation,
+                outcome: "unknown",
+                detail: "candidate validation failed before grading"
+            }
+            : observation)
+    });
+    const report = evaluateRepositoryOracleAdequacyV1(incomplete);
+    assert.equal(report.admitted, false);
+    assert.deepEqual(report.falseAcceptedSolutionIds, []);
+    assert.deepEqual(report.falseRejectedSolutionIds, []);
+    assert.deepEqual(report.mutationFamilyKills.find((family) => family.family === "event-order"), {
+        family: "event-order",
+        killed: 0,
+        total: 1
+    });
+    assert.ok(report.rejectionReasons.some((reason) => reason.includes("inconclusive solution observations")));
+});
+test("candidate-policy rejection safely short-circuits hidden execution for reward hacking", () => {
+    const base = oracle();
+    const protectedClause = {
+        id: "candidate-policy-protected-paths",
+        kind: "candidate-policy",
+        critical: true,
+        description: "Candidates cannot rewrite hidden tests.",
+        policyId: "protected-controls-and-hidden-tests",
+        forbiddenPaths: ["packages/provider/src/stream.test.ts"]
+    };
+    const solutionIds = base.solutions.map((solution) => solution.id);
+    const guarded = {
+        ...base,
+        clauses: [protectedClause, ...base.clauses],
+        solutions: [
+            ...base.solutions,
+            {
+                id: "rewrite-hidden-test",
+                kind: "reward-hacking",
+                family: "reward-hacking",
+                expectedClass: "wrong"
+            }
+        ],
+        observations: [
+            ...solutionIds.flatMap((solutionId) => [
+                {
+                    solutionId,
+                    clauseId: protectedClause.id,
+                    repetition: 1,
+                    outcome: "pass",
+                    detail: "candidate preflight passed"
+                },
+                {
+                    solutionId,
+                    clauseId: protectedClause.id,
+                    repetition: 2,
+                    outcome: "pass",
+                    detail: "candidate preflight passed"
+                }
+            ]),
+            ...base.observations,
+            {
+                solutionId: "rewrite-hidden-test",
+                clauseId: protectedClause.id,
+                repetition: 1,
+                outcome: "fail",
+                detail: "protected path override"
+            },
+            {
+                solutionId: "rewrite-hidden-test",
+                clauseId: protectedClause.id,
+                repetition: 2,
+                outcome: "fail",
+                detail: "protected path override"
+            }
+        ]
+    };
+    const report = evaluateRepositoryOracleAdequacyV1(guarded);
+    assert.equal(report.admitted, true);
+    assert.deepEqual(report.falseAcceptedSolutionIds, []);
+    assert.deepEqual(report.insufficientObservationPairs, []);
+    assert.deepEqual(report.mutationFamilyKills.find((family) => family.family === "reward-hacking"), { family: "reward-hacking", killed: 1, total: 1 });
+});
+test("case admission is fail-closed and candidate projection excludes hidden truth", () => {
+    const accepted = admittedCase();
+    assert.equal(accepted.status, "valid-library");
+    assert.deepEqual(Object.keys(repositoryCandidateCaseProjectionV1(accepted)).sort(), [
+        "capabilityId",
+        "familyId",
+        "id",
+        "lane",
+        "task"
+    ]);
+    assert.equal(JSON.stringify(repositoryCandidateCaseProjectionV1(accepted)).includes("duplicate-terminal"), false);
+    const rejected = admitRepositoryBenchmarkCaseV1({
+        draft: {
+            ...accepted,
+            hidden: oracle({
+                observations: oracle().observations.map((observation) => observation.solutionId === "duplicate-terminal"
+                    ? { ...observation, outcome: "pass" }
+                    : observation)
+            }),
+            adequacy: evaluateRepositoryOracleAdequacyV1(oracle({
+                observations: oracle().observations.map((observation) => observation.solutionId === "duplicate-terminal"
+                    ? { ...observation, outcome: "pass" }
+                    : observation)
+            })),
+            qualityFindings: accepted.qualityFindings.filter((finding) => finding.axis !== "leakage")
+        }
+    });
+    assert.equal(rejected.status, "rejected");
+    assert.ok(rejected.rejectionReasons.some((reason) => reason.includes("missing quality finding: leakage")));
+    assert.ok(rejected.rejectionReasons.some((reason) => reason.includes("plausible wrong solutions accepted")));
+});
+test("library compilation rejects behavioral duplicates rather than counting paraphrases", () => {
+    const first = admittedCase("case-stream-order");
+    const second = admittedCase("case-stream-order-paraphrase", first.behavioralFingerprint);
+    const library = compileValidatedBenchmarkLibraryV1([first, second]);
+    assert.deepEqual(library.cases.map((entry) => entry.id), ["case-stream-order"]);
+    assert.deepEqual(library.rejectedCaseIds, ["case-stream-order-paraphrase"]);
+    assert.deepEqual(library.acceptanceFunnel.find((entry) => entry.gate === "deduplication"), { gate: "deduplication", input: 2, admitted: 1, rejected: 1 });
+    assert.deepEqual(library.coverage.capabilities, [
+        { id: "provider-stream-translation", count: 1 }
+    ]);
+    assert.deepEqual(library.coverage.fixtureKinds, [{ id: "counterfactual", count: 1 }]);
+    assert.deepEqual(library.coverage.oracleKinds, [
+        { id: "ordered-events", count: 1 },
+        { id: "property", count: 1 }
+    ]);
+    assert.deepEqual(library.coverage.mutationFamilies, [
+        { id: "event-order", count: 1 },
+        { id: "integration", count: 1 }
+    ]);
+});
+test("acceptance funnel is sequential and does not re-admit an early rejection", () => {
+    const authenticFailure = admitRepositoryBenchmarkCaseV1({
+        draft: {
+            ...admittedCase("case-authenticity-failure"),
+            qualityFindings: admittedCase("case-authenticity-failure").qualityFindings.map((finding) => finding.axis === "authenticity"
+                ? {
+                    ...finding,
+                    outcome: "fail",
+                    detail: "seed is not authentic"
+                }
+                : finding)
+        }
+    });
+    const specificationFailure = admitRepositoryBenchmarkCaseV1({
+        draft: {
+            ...admittedCase("case-specification-failure"),
+            qualityFindings: admittedCase("case-specification-failure").qualityFindings.map((finding) => finding.axis === "specification-sufficiency"
+                ? {
+                    ...finding,
+                    outcome: "review-required",
+                    detail: "task remains ambiguous"
+                }
+                : finding)
+        }
+    });
+    const accepted = admittedCase("case-accepted");
+    const library = compileValidatedBenchmarkLibraryV1([
+        authenticFailure,
+        specificationFailure,
+        accepted
+    ]);
+    assert.deepEqual(library.acceptanceFunnel.slice(0, 3), [
+        { gate: "authenticity", input: 3, admitted: 2, rejected: 1 },
+        {
+            gate: "specification-sufficiency",
+            input: 2,
+            admitted: 1,
+            rejected: 1
+        },
+        { gate: "oracle-adequacy", input: 1, admitted: 1, rejected: 0 }
+    ]);
+    assert.ok(library.acceptanceFunnel.slice(2).every((entry) => entry.input <= 1));
+    assert.deepEqual(library.cases.map((entry) => entry.id), ["case-accepted"]);
+});
+test("behavior map and qualified seed invariants reject unsupported evidence", () => {
+    const map = {
+        version: 1,
+        repository: {
+            root: "/repo",
+            requestedRef: "HEAD",
+            commit: "a".repeat(40),
+            tree: "b".repeat(40)
+        },
+        packages: [
+            {
+                id: "package-core",
+                name: "core",
+                path: "packages/core",
+                manifestPath: "packages/core/package.json",
+                dependencyPackageIds: [],
+                publicExports: ["."]
+            }
+        ],
+        publicSurfaces: [],
+        protocols: [],
+        commands: [
+            {
+                id: "command-test",
+                kind: "test",
+                cwd: "packages/core",
+                executable: "pnpm",
+                args: ["test"],
+                timeoutMs: 60_000
+            }
+        ],
+        tests: [
+            {
+                id: "test-core",
+                path: "packages/core/src/core.test.ts",
+                names: ["core behavior"],
+                commandIds: ["command-test"]
+            }
+        ],
+        testBindings: [
+            {
+                testId: "test-core",
+                targetIds: ["package-core"],
+                signals: ["package-ownership"],
+                confidence: "medium"
+            }
+        ],
+        historyEpisodes: [
+            {
+                id: "episode-fix",
+                commit: "c".repeat(40),
+                parentCommit: "d".repeat(40),
+                occurredAt: "2026-01-01T00:00:00.000Z",
+                subject: "fix core behavior",
+                body: "",
+                changedPaths: [
+                    {
+                        path: "packages/core/src/core.ts",
+                        status: "modified",
+                        kind: "implementation"
+                    },
+                    {
+                        path: "packages/core/src/core.test.ts",
+                        status: "modified",
+                        kind: "test"
+                    }
+                ],
+                testPaths: ["packages/core/src/core.test.ts"],
+                implementationPaths: ["packages/core/src/core.ts"],
+                protocolPaths: [],
+                behaviorChanging: true,
+                seedEligible: true
+            }
+        ],
+        workloadSignals: [
+            {
+                id: "signal-core",
+                kind: "recurring-cochange",
+                label: "core behavior repair",
+                episodeIds: ["episode-fix"],
+                pathPatterns: ["packages/core"],
+                frequency: 1,
+                importance: "normal",
+                confidence: "medium"
+            }
+        ],
+        blindSpots: []
+    };
+    assert.doesNotThrow(() => assertRepositoryBehaviorMapV1(map));
+    assert.throws(() => assertRepositoryBehaviorMapV1({
+        ...map,
+        testBindings: [
+            {
+                ...map.testBindings[0],
+                targetIds: ["unknown-target"]
+            }
+        ]
+    }), /unknown target/u);
+    const seed = {
+        version: 1,
+        id: "seed-core-fix",
+        status: "qualified",
+        source: { kind: "historical-fix", changeEpisodeId: "episode-fix" },
+        summary: "Repair core behavior.",
+        capabilityEvidence: [{ kind: "history-episode", id: "episode-fix" }],
+        initialState: {
+            commit: "c".repeat(40),
+            parentCommit: "d".repeat(40)
+        },
+        targetBehavior: [
+            {
+                id: "core-behavior",
+                description: "Core behavior passes its regression test.",
+                critical: true,
+                evidence: [{ kind: "test", id: "test-core" }]
+            }
+        ],
+        referenceCommit: "c".repeat(40),
+        baselineObservations: [
+            {
+                id: "baseline",
+                kind: "test-command",
+                subjectId: "command-test-baseline-control",
+                outcome: "pass",
+                detail: "unmodified historical checkout passes"
+            }
+        ],
+        preChangeObservations: [
+            {
+                id: "pre",
+                kind: "test-command",
+                subjectId: "command-test",
+                outcome: "fail",
+                detail: "regression reproduced"
+            }
+        ],
+        postChangeObservations: [
+            {
+                id: "post",
+                kind: "test-command",
+                subjectId: "command-test",
+                outcome: "pass",
+                detail: "fix passes"
+            }
+        ],
+        candidateTestIds: ["test-core"],
+        environment: {
+            protectedControlPaths: [],
+            trustedPreparationRecipes: [],
+            candidateValidationRecipes: [],
+            baselineGradeRecipes: [
+                {
+                    ...map.commands[0],
+                    id: `${map.commands[0].id}-baseline-control`
+                }
+            ],
+            gradeRecipes: [map.commands[0]]
+        },
+        confidence: "high",
+        risks: [],
+        rejectionReasons: []
+    };
+    assert.doesNotThrow(() => assertRepositoryTaskSeedV1(seed));
+    assert.throws(() => assertRepositoryTaskSeedV1({
+        ...seed,
+        preChangeObservations: seed.preChangeObservations.map((observation) => ({
+            ...observation,
+            outcome: "pass"
+        }))
+    }), /pre-change failure/u);
+});
+test("reviewed improvement cycles preserve oracle escapes and lifecycle decisions without losing the audited core", async () => {
+    const core = admittedCase("case-audited-core", "fingerprint-core");
+    const stale = admittedCase("case-stale-environment", "fingerprint-stale");
+    const superseded = admittedCase("case-superseded-fixture", "fingerprint-superseded");
+    const active = admittedCase("case-active", "fingerprint-active");
+    const library = compileValidatedBenchmarkLibraryV1([core, stale, superseded, active]);
+    const reviews = [
+        {
+            reviewerId: "foundry-reviewer-a",
+            independentlyProduced: true,
+            verdict: "approve",
+            detail: "The evidence supports the proposed quality action."
+        },
+        {
+            reviewerId: "foundry-reviewer-b",
+            independentlyProduced: true,
+            verdict: "approve",
+            detail: "The action preserves the admission standard."
+        }
+    ];
+    const cycle = await Effect.runPromise(compileRepositoryFoundryImprovementCycleV1({
+        cycleId: "cycle-2026-09-01",
+        library,
+        auditedCoreCaseIds: [core.id],
+        drafts: [
+            {
+                id: "improvement-oracle-escape",
+                trigger: "oracle-escape",
+                action: "add-fixture",
+                summary: "Add the no-terminal counterfactual that kills the escaped stream solution.",
+                affectedCaseIds: [core.id],
+                evidence: [{ kind: "test", id: "counterfactual-no-terminal" }],
+                reviews
+            },
+            {
+                id: "improvement-false-rejection",
+                trigger: "false-rejection",
+                action: "add-valid-alternative",
+                summary: "Retain an independently reviewed implementation that satisfies every public clause.",
+                affectedCaseIds: [core.id],
+                evidence: [{ kind: "symbol", id: "alternate-valid" }],
+                reviews
+            },
+            {
+                id: "improvement-coverage-gap",
+                trigger: "coverage-gap",
+                action: "add-seed",
+                summary: "Add an authentic cross-file migration seed for an underrepresented capability.",
+                affectedCaseIds: [],
+                evidence: [{ kind: "history-episode", id: "migration-episode" }],
+                reviews
+            },
+            {
+                id: "improvement-environment-drift",
+                trigger: "environment-drift",
+                action: "quarantine-case",
+                summary: "Quarantine the case until its historical dependency recipe is reconstructed.",
+                affectedCaseIds: [stale.id],
+                evidence: [{ kind: "command", id: "historical-build" }],
+                reviews
+            },
+            {
+                id: "improvement-superseded",
+                trigger: "superseded",
+                action: "retire-case",
+                summary: "Retire the weaker fixture after a reviewed counterfactual subsumes it.",
+                affectedCaseIds: [superseded.id],
+                evidence: [{ kind: "test", id: "stronger-counterfactual" }],
+                reviews
+            },
+            {
+                id: "improvement-protect-core",
+                trigger: "superseded",
+                action: "retire-case",
+                summary: "Attempt to remove the audited regression case.",
+                affectedCaseIds: [core.id],
+                evidence: [],
+                reviews
+            }
+        ]
+    }));
+    assert.deepEqual(cycle.auditedCoreCaseIds, [core.id]);
+    assert.deepEqual(cycle.activeCaseIds, [active.id]);
+    assert.deepEqual(cycle.quarantinedCaseIds, [stale.id]);
+    assert.deepEqual(cycle.retiredCaseIds, [superseded.id]);
+    assert.deepEqual(cycle.records.slice(0, 5).map((record) => record.decision), ["applied", "applied", "applied", "applied", "applied"]);
+    assert.equal(cycle.records[5]?.decision, "rejected");
+    assert.match(cycle.records[5]?.rejectionReasons.join("\n") ?? "", /audited core case cannot be silently removed/u);
+});
+test("improvement cycles reject unreviewed and conflicting lifecycle changes instead of silently drifting", async () => {
+    const benchmarkCase = admittedCase("case-lifecycle-conflict", "fingerprint-lifecycle-conflict");
+    const reviews = [
+        {
+            reviewerId: "only-reviewer",
+            independentlyProduced: true,
+            verdict: "approve",
+            detail: "One review is not enough."
+        }
+    ];
+    const cycle = await Effect.runPromise(compileRepositoryFoundryImprovementCycleV1({
+        cycleId: "cycle-conflict",
+        library: compileValidatedBenchmarkLibraryV1([benchmarkCase]),
+        auditedCoreCaseIds: [],
+        drafts: [
+            {
+                id: "unreviewed-quarantine",
+                trigger: "instability",
+                action: "quarantine-case",
+                summary: "Quarantine an unstable case.",
+                affectedCaseIds: [benchmarkCase.id],
+                evidence: [],
+                reviews
+            },
+            {
+                id: "reviewed-quarantine",
+                trigger: "instability",
+                action: "quarantine-case",
+                summary: "Quarantine after independent replay review.",
+                affectedCaseIds: [benchmarkCase.id],
+                evidence: [],
+                reviews: [
+                    ...reviews,
+                    {
+                        reviewerId: "second-reviewer",
+                        independentlyProduced: true,
+                        verdict: "approve",
+                        detail: "The repeated observations are unstable."
+                    }
+                ]
+            },
+            {
+                id: "conflicting-retirement",
+                trigger: "superseded",
+                action: "retire-case",
+                summary: "Try to retire a case already quarantined this cycle.",
+                affectedCaseIds: [benchmarkCase.id],
+                evidence: [],
+                reviews: [
+                    ...reviews,
+                    {
+                        reviewerId: "second-reviewer",
+                        independentlyProduced: true,
+                        verdict: "approve",
+                        detail: "The replacement is stronger."
+                    }
+                ]
+            }
+        ]
+    }));
+    assert.equal(cycle.records[0]?.decision, "rejected");
+    assert.match(cycle.records[0]?.rejectionReasons.join("\n") ?? "", /two distinct independent approvals/u);
+    assert.equal(cycle.records[1]?.decision, "applied");
+    assert.equal(cycle.records[2]?.decision, "rejected");
+    assert.match(cycle.records[2]?.rejectionReasons.join("\n") ?? "", /already has a lifecycle decision/u);
+    assert.deepEqual(cycle.quarantinedCaseIds, [benchmarkCase.id]);
+    assert.deepEqual(cycle.retiredCaseIds, []);
+});
+test("independently reviewed pure cases compile into one routing dimension without smearing", () => {
+    const basis = routingBasis();
+    const benchmarkCase = admittedCase("case-stream-order");
+    const library = compileValidatedBenchmarkLibraryV1([benchmarkCase]);
+    const label = reviewedDimensionLabel({
+        caseId: benchmarkCase.id,
+        basis,
+        primaryDimensionId: "gateway-protocols"
+    });
+    const routing = compileRepositoryRoutingBenchmarkV1({
+        basis,
+        library,
+        labels: [label],
+        policy: routingPolicy
+    });
+    assert.deepEqual(routing.eligibleCaseIds, [benchmarkCase.id]);
+    assert.deepEqual(routing.libraryOnlyCaseIds, []);
+    assert.equal(routing.assignments[0]?.primaryDimensionId, "gateway-protocols");
+    assert.equal(routing.assignments[0]?.eligible, true);
+    assert.deepEqual(routing.dimensions.find((dimension) => dimension.dimensionId === "gateway-protocols"), {
+        dimensionId: "gateway-protocols",
+        caseIds: [benchmarkCase.id],
+        minimumRequired: 1,
+        routingReady: true
+    });
+    assert.equal(routing.routingReady, false);
+    assert.equal(routing.coverageGaps.length, basis.dimensions.length - 1);
+});
+test("ambiguous or critic-disputed cases remain in the quality library but cannot shape routing", () => {
+    const basis = routingBasis();
+    const ambiguousCase = admittedCase("case-ambiguous-routing", "fingerprint-ambiguous-routing");
+    const disputedCase = admittedCase("case-disputed-routing", "fingerprint-disputed-routing");
+    const library = compileValidatedBenchmarkLibraryV1([ambiguousCase, disputedCase]);
+    const ambiguous = reviewedDimensionLabel({
+        caseId: ambiguousCase.id,
+        basis,
+        primaryDimensionId: "gateway-protocols",
+        secondaryDimensionId: "daemon-control-operations"
+    });
+    const disputed = reviewedDimensionLabel({
+        caseId: disputedCase.id,
+        basis,
+        primaryDimensionId: "gateway-protocols",
+        reviewerBDimensionId: "model-routing-registry"
+    });
+    const routing = compileRepositoryRoutingBenchmarkV1({
+        basis,
+        library,
+        labels: [ambiguous, disputed],
+        policy: routingPolicy
+    });
+    assert.deepEqual(routing.eligibleCaseIds, []);
+    assert.deepEqual(routing.libraryOnlyCaseIds, ["case-ambiguous-routing", "case-disputed-routing"]);
+    const ambiguousAssignment = routing.assignments.find((assignment) => assignment.caseId === ambiguousCase.id);
+    const disputedAssignment = routing.assignments.find((assignment) => assignment.caseId === disputedCase.id);
+    assert.ok(ambiguousAssignment?.rejectionReasons.some((reason) => reason.includes("require exactly one")));
+    assert.ok(ambiguousAssignment?.rejectionReasons.some((reason) => reason.includes("does not dominate")));
+    assert.ok(disputedAssignment?.rejectionReasons.some((reason) => reason.includes("did not both approve")));
+});
+test("routing compilation fails closed on stale labels and duplicate case identities", () => {
+    const basis = routingBasis();
+    const benchmarkCase = admittedCase("case-stream-order");
+    const library = compileValidatedBenchmarkLibraryV1([benchmarkCase]);
+    const current = reviewedDimensionLabel({
+        caseId: benchmarkCase.id,
+        basis,
+        primaryDimensionId: "gateway-protocols"
+    });
+    const stale = {
+        ...current,
+        basisDigest: "f".repeat(64),
+        label: {
+            ...current.label,
+            basisDigest: "f".repeat(64)
+        },
+        reviews: current.reviews.map((review) => ({
+            ...review,
+            independentLabel: {
+                ...review.independentLabel,
+                basisDigest: "f".repeat(64)
+            }
+        }))
+    };
+    const staleRouting = compileRepositoryRoutingBenchmarkV1({
+        basis,
+        library,
+        labels: [stale],
+        policy: routingPolicy
+    });
+    assert.deepEqual(staleRouting.eligibleCaseIds, []);
+    assert.ok(staleRouting.assignments[0]?.rejectionReasons.includes("dimension label basis digest does not match routing basis"));
+    assert.throws(() => compileRepositoryRoutingBenchmarkV1({
+        basis,
+        library,
+        labels: [current, current],
+        policy: routingPolicy
+    }), /duplicate dimension labels/u);
+});
+const dimensionCompletion = (input, overrides = {}) => {
+    const primary = input.foundryRole === "dimension-critic-luna"
+        ? (overrides.lunaPrimary ?? "gateway-protocols")
+        : "gateway-protocols";
+    return {
+        primaryDimensionId: primary,
+        scores: routingBasis().dimensions.map((dimension) => ({
+            dimensionId: dimension.id,
+            score: dimension.id === primary
+                ? 0.88
+                : input.foundryRole === "dimension-critic-terra" &&
+                    dimension.id === overrides.terraSecondary
+                    ? 0.62
+                    : 0.03
+        })),
+        unknownProbability: 0.06,
+        detail: "The task primarily changes the externally observable gateway protocol contract.",
+        evidenceIds: ["benchmark-case:/visible", "routing-basis:/dimensions/0"]
+    };
+};
+const dimensionModelPlan = () => gpt56RepositoryRoutingModelPlanV1({
+    solModel: "codex/gpt-5.6-sol",
+    terraModel: "codex/gpt-5.6-terra",
+    lunaModel: "codex/gpt-5.6-luna",
+    reasoningEffort: "max"
+});
+test("Sol, Terra, and Luna independently label an admitted case before routing compilation", async () => {
+    const calls = [];
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        completeDetailed: (input) => {
+            calls.push(input);
+            return Effect.succeed({
+                text: JSON.stringify(dimensionCompletion(input)),
+                callId: `call-${input.foundryRole}`
+            });
+        },
+        complete: (input) => Effect.succeed(JSON.stringify(dimensionCompletion(input)))
+    }));
+    const result = await Effect.runPromise(authorRepositoryReviewedDimensionLabelV1({
+        operationId: "case-stream-order-routing-label",
+        basis: routingBasis(),
+        benchmarkCase: admittedCase(),
+        modelPlan: dimensionModelPlan()
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+    assert.deepEqual(calls.map((call) => call.foundryRole), ["dimension-labeler", "dimension-critic-terra", "dimension-critic-luna"]);
+    assert.equal(result.reviewed.reviews.every((review) => review.outcome === "approve"), true);
+    assert.equal(result.modelCalls.length, 3);
+    const routing = compileRepositoryRoutingBenchmarkV1({
+        basis: routingBasis(),
+        library: compileValidatedBenchmarkLibraryV1([admittedCase()]),
+        labels: [result.reviewed],
+        policy: routingPolicy
+    });
+    assert.deepEqual(routing.eligibleCaseIds, ["case-stream-order"]);
+});
+test("independent dimension disagreement or critic ambiguity excludes routing evidence", async () => {
+    for (const overrides of [
+        { lunaPrimary: "model-routing-registry" },
+        { terraSecondary: "model-routing-registry" }
+    ]) {
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            completeDetailed: (input) => Effect.succeed({
+                text: JSON.stringify(dimensionCompletion(input, overrides)),
+                callId: `call-${input.foundryRole}`
+            }),
+            complete: (input) => Effect.succeed(JSON.stringify(dimensionCompletion(input, overrides)))
+        }));
+        const result = await Effect.runPromise(authorRepositoryReviewedDimensionLabelV1({
+            operationId: "case-stream-order-routing-label",
+            basis: routingBasis(),
+            benchmarkCase: admittedCase(),
+            modelPlan: dimensionModelPlan()
+        }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+        const routing = compileRepositoryRoutingBenchmarkV1({
+            basis: routingBasis(),
+            library: compileValidatedBenchmarkLibraryV1([admittedCase()]),
+            labels: [result.reviewed],
+            policy: routingPolicy
+        });
+        assert.deepEqual(routing.eligibleCaseIds, []);
+        assert.deepEqual(routing.libraryOnlyCaseIds, ["case-stream-order"]);
+    }
+});
+test("routing labeling uses an immutable bounded plan and rejects a changed benchmark case", async () => {
+    const benchmarkCase = admittedCase();
+    const basis = routingBasis();
+    const plan = await Effect.runPromise(planRepositoryRoutingLabelingV1({
+        foundryPlanDigest: "foundry-plan-digest",
+        benchmarkCase,
+        basis,
+        modelPlan: dimensionModelPlan(),
+        policy: routingPolicy
+    }));
+    assert.equal(plan.budget.semanticModelCalls, 3);
+    assert.equal(plan.budget.plannedModelCalls, 6);
+    assert.equal(plan.budget.maximumTransientRetries, 3);
+    assert.equal(plan.budget.requiredTotalInputTokens, 3_072_000);
+    assert.equal(plan.budget.requiredTotalOutputTokens, 98_304);
+    let calls = 0;
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        completeDetailed: (input) => {
+            calls += 1;
+            return Effect.succeed({
+                text: JSON.stringify(dimensionCompletion(input)),
+                callId: `call-${input.foundryRole}`
+            });
+        },
+        complete: (input) => Effect.succeed(JSON.stringify(dimensionCompletion(input)))
+    }));
+    const changedCase = {
+        ...benchmarkCase,
+        behavioralFingerprint: "changed-fingerprint"
+    };
+    const exit = await Effect.runPromiseExit(executeRepositoryRoutingLabelingV1({
+        plan,
+        benchmarkCase: changedCase
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+    assert.equal(exit._tag, "Failure");
+    assert.equal(calls, 0);
+});
+test("routing labeling normalizes valid input key order before freezing its plan identity", async (t) => {
+    const basis = routingBasis();
+    const modelPlan = dimensionModelPlan();
+    const input = {
+        foundryPlanDigest: "foundry-plan-digest",
+        benchmarkCase: admittedCase(),
+        basis,
+        modelPlan,
+        policy: routingPolicy
+    };
+    const baseline = await Effect.runPromise(planRepositoryRoutingLabelingV1(input));
+    assertRepositoryRoutingLabelingPlanV1(JSON.parse(JSON.stringify(baseline)));
+    const { repositoryDigest, ...facetDetails } = basis.facetSnapshot;
+    const { id, ...dimensionDetails } = basis.dimensions[0];
+    const variants = [
+        {
+            name: "public JSON facet snapshot with its repository digest last",
+            input: {
+                ...input,
+                basis: {
+                    ...basis,
+                    facetSnapshot: { ...facetDetails, repositoryDigest }
+                }
+            }
+        },
+        {
+            name: "dimension and model assignment property order",
+            input: {
+                ...input,
+                basis: {
+                    ...basis,
+                    dimensions: [{ ...dimensionDetails, id }, ...basis.dimensions.slice(1)]
+                },
+                modelPlan: {
+                    ...modelPlan,
+                    assignments: modelPlan.assignments.map(({ role, ...assignment }) => ({
+                        ...assignment,
+                        role
+                    }))
+                }
+            }
+        },
+        {
+            name: "policy property order",
+            input: {
+                ...input,
+                policy: {
+                    minimumCasesPerDimension: routingPolicy.minimumCasesPerDimension,
+                    minimumDominanceMargin: routingPolicy.minimumDominanceMargin,
+                    maximumUnknownProbability: routingPolicy.maximumUnknownProbability,
+                    activeDimensionThreshold: routingPolicy.activeDimensionThreshold
+                }
+            }
+        }
+    ];
+    for (const variant of variants) {
+        await t.test(variant.name, async () => {
+            const before = JSON.stringify(variant.input);
+            const plan = await Effect.runPromise(planRepositoryRoutingLabelingV1(variant.input));
+            assert.equal(JSON.stringify(variant.input), before, "planning does not mutate its inputs");
+            assert.equal(plan.planDigest, baseline.planDigest, "equivalent inputs retain one identity");
+            assert.equal(JSON.stringify(plan), JSON.stringify(baseline));
+            assertRepositoryRoutingLabelingPlanV1(JSON.parse(JSON.stringify(plan)));
+            assert.throws(() => assertRepositoryRoutingLabelingPlanV1({
+                ...plan,
+                policy: {
+                    ...plan.policy,
+                    minimumCasesPerDimension: plan.policy.minimumCasesPerDimension + 1
+                }
+            }));
+        });
+    }
+});