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

package/dist/test/repository-specification-contract-checkpoint.test.js

@@ -0,0 +1,228 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { parseRepositorySpecificationContractFactsProposalV1, repositorySpecificationContractFactsPacketV1, repositorySpecificationContractFactsScopeV1 } from "../repository-specification-contract-facts-protocol.js";
+import { assertRepositorySpecificationContractFactsEvidenceV1 } from "../services/case-generation/service.js";
+// Pure saved-evidence boundary fixture. The packet compiler is real; the model
+// calls and judgments are synthetic and confer no semantic or admission proof.
+const acceptedEvidence = () => {
+    const evidence = [{ sourceId: "after-fixture", startLine: 1, endLine: 1 }];
+    const frozenScope = {
+        clauses: [{
+                id: "lower-bound",
+                kind: "changed",
+                behaviorIds: ["clamp-range"],
+                description: "Preserve the numeric range and repair its lower boundary.",
+                evidence
+            }],
+        unresolvedQuestions: []
+    };
+    const proposal = parseRepositorySpecificationContractFactsProposalV1({
+        version: 1,
+        facts: [{
+                id: "negative-input",
+                scopeId: "lower-bound",
+                kind: "behavior",
+                statement: "Numeric values below zero produce zero.",
+                evidence
+            }]
+    });
+    const scope = repositorySpecificationContractFactsScopeV1(frozenScope, proposal);
+    const packet = repositorySpecificationContractFactsPacketV1(scope, proposal);
+    const visible = {
+        lane: "repository-agent",
+        id: "synthetic-fact-case",
+        requestText: scope.clauses[0].description,
+        checkoutCommit: "before-fixture",
+        allowedTools: ["read", "edit", "test"],
+        constraints: ["Preserve unrelated behavior."]
+    };
+    const reviewerOperationIds = [
+        "synthetic-facts:specification-critic-a",
+        "synthetic-facts:specification-critic-b"
+    ];
+    const reviews = reviewerOperationIds.map((reviewerId, index) => ({
+        reviewerId,
+        reviewerKind: index === 0 ? "independent-solver" : "model-critic",
+        independentlyProduced: true,
+        verdict: "sufficient",
+        detail: "Synthetic complete review of the exact saved packet.",
+        findings: [],
+        contractFactReview: {
+            packetDigest: packet.digest,
+            scopeChecks: [{
+                    scopeId: "lower-bound",
+                    factIds: ["negative-input"],
+                    outcome: "complete",
+                    detail: "The supplied numeric boundary is explicit.",
+                    evidence: index === 0 ? [] : evidence
+                }],
+            clarificationRequests: []
+        }
+    }));
+    return {
+        version: 1,
+        caseId: visible.id,
+        analysis: {
+            summary: "Synthetic lower-bound scope.",
+            userObservableBehaviors: ["Negative values produce zero."],
+            constraints: [],
+            risks: [],
+            relevantPaths: [],
+            referenceScope: frozenScope
+        },
+        contextSources: [],
+        visible,
+        reviews,
+        modelCalls: [
+            {
+                operationId: "synthetic-facts:repository-analyst",
+                role: "repository-analyst",
+                model: "offline/analyst",
+                reasoningEffort: "high"
+            },
+            {
+                operationId: "synthetic-facts:specification-writer",
+                role: "specification-writer",
+                model: "offline/writer",
+                reasoningEffort: "high"
+            },
+            ...reviewerOperationIds.map((operationId, index) => ({
+                operationId,
+                role: index === 0 ? "specification-critic-a" : "specification-critic-b",
+                model: `offline/critic-${index}`,
+                reasoningEffort: "high"
+            }))
+        ],
+        contractFacts: {
+            version: 1,
+            packet,
+            independentlyReviewed: true,
+            reviewerOperationIds,
+            history: [{
+                    sequence: 0,
+                    packetDigest: packet.digest,
+                    analystOperationId: "synthetic-facts:repository-analyst",
+                    clarificationRequestIds: []
+                }]
+        },
+        referenceGrounding: {
+            beforeCommit: "before-fixture",
+            referenceCommit: "after-fixture",
+            sources: [],
+            scope
+        },
+        groundedTargetBehavior: [{
+                id: "clamp-range",
+                description: scope.clauses[0].description,
+                critical: true,
+                evidence: []
+            }],
+        specificationRevisions: [{
+                sequence: 0,
+                visible,
+                reviews,
+                rejectionReasons: [],
+                contractFactsDigest: packet.digest
+            }]
+    };
+};
+const withFinalReviews = (authored, reviews) => ({
+    ...authored,
+    reviews,
+    specificationRevisions: [{
+            ...authored.specificationRevisions[0],
+            reviews
+        }]
+});
+test("saved contract facts bind the final rendered scope and both actual independent reviews", () => {
+    const authored = acceptedEvidence();
+    assertRepositorySpecificationContractFactsEvidenceV1(authored);
+    const detached = JSON.parse(JSON.stringify(authored));
+    assertRepositorySpecificationContractFactsEvidenceV1(detached);
+    assert.deepEqual(detached, authored, "validation does not rewrite archived evidence");
+    assert.notEqual(authored.analysis.referenceScope?.clauses[0]?.description, authored.referenceGrounding?.scope.clauses[0]?.description, "the packet is bound to the final rendered scope, not the analyst's original description");
+});
+test("a saved accepted flag cannot replace missing or stale final packet/reviewer evidence", () => {
+    const authored = acceptedEvidence();
+    const accepted = authored.contractFacts;
+    for (const invalid of [
+        { ...authored, contractFacts: undefined },
+        { ...authored, specificationRevisions: undefined },
+        {
+            ...authored,
+            specificationRevisions: [{
+                    ...authored.specificationRevisions[0],
+                    contractFactsDigest: "0".repeat(64)
+                }]
+        },
+        { ...authored, referenceGrounding: undefined },
+        { ...authored, modelCalls: authored.modelCalls.filter((call) => call.role !== "specification-critic-b") },
+        { ...authored, visible: { ...authored.visible, requestText: "A different final request." } },
+        {
+            ...authored,
+            contractFacts: {
+                ...accepted,
+                reviewerOperationIds: [accepted.reviewerOperationIds[0], accepted.reviewerOperationIds[0]]
+            }
+        },
+        {
+            ...authored,
+            contractFacts: {
+                ...accepted,
+                reviewerOperationIds: ["synthetic-replacement:specification-critic-a", accepted.reviewerOperationIds[1]]
+            }
+        },
+        {
+            ...authored,
+            contractFacts: { ...accepted, packet: { ...accepted.packet, digest: "0".repeat(64) } }
+        },
+        {
+            ...authored,
+            referenceGrounding: {
+                ...authored.referenceGrounding,
+                scope: authored.analysis.referenceScope
+            }
+        }
+    ]) {
+        assert.throws(() => assertRepositorySpecificationContractFactsEvidenceV1(invalid));
+    }
+});
+test("matching archived review copies must still approve this complete packet without pending questions", () => {
+    const authored = acceptedEvidence();
+    for (const first of [
+        { ...authored.reviews[0], independentlyProduced: false },
+        { ...authored.reviews[0], verdict: "insufficient" },
+        {
+            ...authored.reviews[0],
+            contractFactReview: { ...authored.reviews[0].contractFactReview, packetDigest: "0".repeat(64) }
+        },
+        {
+            ...authored.reviews[0],
+            contractFactReview: { ...authored.reviews[0].contractFactReview, scopeChecks: [] }
+        },
+        {
+            ...authored.reviews[0],
+            contractFactReview: {
+                ...authored.reviews[0].contractFactReview,
+                scopeChecks: [{
+                        ...authored.reviews[0].contractFactReview.scopeChecks[0],
+                        factIds: []
+                    }]
+            }
+        },
+        {
+            ...authored.reviews[0],
+            contractFactReview: {
+                ...authored.reviews[0].contractFactReview,
+                clarificationRequests: [{
+                        scopeId: "lower-bound",
+                        factIds: ["negative-input"],
+                        reason: "missing-boundary",
+                        question: "Is the negative boundary complete?"
+                    }]
+            }
+        }
+    ]) {
+        assert.throws(() => assertRepositorySpecificationContractFactsEvidenceV1(withFinalReviews(authored, [first, authored.reviews[1]])));
+    }
+});

package/dist/test/repository-specification-contract-facts.test.d.ts

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

package/dist/test/repository-specification-contract-facts.test.js

@@ -0,0 +1,177 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Schema } from "effect";
+import { parseRepositorySpecificationContractFactsPacketV1, parseRepositorySpecificationContractFactsProposalV1, renderRepositorySpecificationContractFactV1, RepositorySpecificationContractFactsProposalV1, repositorySpecificationContractFactsPacketV1, repositorySpecificationContractFactsScopeV1, repositorySpecificationPublicContractFactV1 } from "../repository-specification-contract-facts-protocol.js";
+const references = [
+    { sourceId: "before-source", startLine: 1, endLine: 1 },
+    { sourceId: "after-source", startLine: 2, endLine: 3 }
+];
+const scope = {
+    clauses: [
+        {
+            id: "response-policy",
+            kind: "changed",
+            behaviorIds: ["response-normalization"],
+            description: "Normalize eligible responses and preserve ineligible responses.",
+            evidence: references
+        }
+    ],
+    unresolvedQuestions: []
+};
+const raw = () => ({
+    version: 1,
+    facts: [
+        {
+            id: "response-types",
+            scopeId: "response-policy",
+            kind: "closed-set",
+            subject: "response types selected for normalization",
+            appliesWhen: "the request is non-streaming",
+            members: ["event-stream", "event-records"],
+            outsideBehavior: "Preserve the original response.",
+            evidence: references.map((entry) => ({ ...entry }))
+        }
+    ]
+});
+const prepared = () => {
+    const proposal = parseRepositorySpecificationContractFactsProposalV1(raw());
+    const finalScope = repositorySpecificationContractFactsScopeV1(scope, proposal);
+    const packet = repositorySpecificationContractFactsPacketV1(finalScope, proposal);
+    return { proposal, finalScope, packet };
+};
+test("marked fact schemas reject excess fields before a public projection can hide them", () => {
+    for (const value of [
+        { ...raw(), confidence: "approved" },
+        { ...raw(), facts: [{ ...raw().facts[0], privateSource: "not an allowed field" }] },
+        {
+            ...raw(),
+            facts: [
+                {
+                    ...raw().facts[0],
+                    evidence: [{ ...references[0], sourceText: "not an allowed field" }]
+                }
+            ]
+        }
+    ]) {
+        assert.throws(() => parseRepositorySpecificationContractFactsProposalV1(value));
+        // The schema itself is strict, including use by the language-model owner
+        // whose general decode call does not supply onExcessProperty explicitly.
+        assert.throws(() => Schema.decodeUnknownSync(RepositorySpecificationContractFactsProposalV1)(value));
+    }
+});
+test("public facts are positively projected and deterministically rendered without provenance", () => {
+    const { proposal, finalScope, packet } = prepared();
+    const privateFact = {
+        ...proposal.facts[0],
+        privateAnswer: "PRIVATE-DATA",
+        evidence: references
+    };
+    const projected = repositorySpecificationPublicContractFactV1(privateFact);
+    assert.deepEqual(projected, packet.facts[0]);
+    const publicText = JSON.stringify(packet);
+    for (const privateValue of ["PRIVATE-DATA", "before-source", "after-source", '"evidence"']) {
+        assert.equal(publicText.includes(privateValue), false);
+    }
+    const rendered = renderRepositorySpecificationContractFactV1(packet.facts[0]);
+    assert.ok(rendered.includes('"event-stream", "event-records"'));
+    assert.ok(rendered.includes("Outside this set: Preserve the original response."));
+    assert.ok(finalScope.clauses[0].description.includes(rendered));
+    assert.equal(scope.clauses[0].description.includes(rendered), false);
+    assert.deepEqual(finalScope.clauses[0].behaviorIds, scope.clauses[0].behaviorIds);
+    assert.deepEqual(finalScope.unresolvedQuestions, scope.unresolvedQuestions);
+    assert.ok(Object.isFrozen(packet));
+    assert.ok(Object.isFrozen(packet.facts));
+    assert.ok(Object.isFrozen(packet.facts[0]));
+});
+test("packet roundtrip binds final rendered scope, facts, and both digests", () => {
+    const { packet, finalScope } = prepared();
+    const loaded = parseRepositorySpecificationContractFactsPacketV1(JSON.parse(JSON.stringify(packet)), finalScope);
+    assert.deepEqual(loaded, packet);
+    assert.notEqual(loaded, packet);
+    assert.throws(() => parseRepositorySpecificationContractFactsPacketV1(packet, scope));
+    for (const changed of [
+        { ...packet, digest: "0".repeat(64) },
+        { ...packet, scopeDigest: "0".repeat(64) },
+        { ...packet, facts: [] },
+        { ...packet, privateEvidence: references },
+        {
+            ...packet,
+            facts: [{ ...packet.facts[0], outsideBehavior: "Discard all other responses." }]
+        }
+    ]) {
+        assert.throws(() => parseRepositorySpecificationContractFactsPacketV1(changed, finalScope));
+    }
+    assert.throws(() => parseRepositorySpecificationContractFactsPacketV1(packet, {
+        ...finalScope,
+        clauses: [{ ...finalScope.clauses[0], behaviorIds: ["another-behavior"] }]
+    }));
+});
+test("fact bounds refuse duplicates, partial closed sets, invalid evidence, and unknown scopes", () => {
+    const original = raw();
+    for (const facts of [
+        [],
+        [original.facts[0], original.facts[0]],
+        [{ ...original.facts[0], members: [] }],
+        [{ ...original.facts[0], members: ["same", "same"] }],
+        [{ ...original.facts[0], members: Array.from({ length: 129 }, (_, i) => `member-${String(i)}`) }],
+        [{ ...original.facts[0], outsideBehavior: "" }],
+        [{ ...original.facts[0], appliesWhen: "x".repeat(2_001) }],
+        [{ ...original.facts[0], evidence: [] }],
+        [{ ...original.facts[0], evidence: [{ ...references[0], startLine: 0 }] }],
+        [{ ...original.facts[0], evidence: [{ ...references[0], endLine: 0.5 }] }],
+        [{ ...original.facts[0], subject: "private-contract-fact-question-0-1" }]
+    ]) {
+        assert.throws(() => parseRepositorySpecificationContractFactsProposalV1({ version: 1, facts }));
+    }
+    const unknownScope = parseRepositorySpecificationContractFactsProposalV1({
+        version: 1,
+        facts: [{ ...original.facts[0], scopeId: "unrelated-scope" }]
+    });
+    assert.throws(() => repositorySpecificationContractFactsScopeV1(scope, unknownScope));
+});
+test("eligibility and behavior facts render both boundary outcomes without implementation syntax", () => {
+    const proposal = parseRepositorySpecificationContractFactsProposalV1({
+        version: 1,
+        facts: [
+            {
+                id: "eligibility",
+                scopeId: "response-policy",
+                kind: "eligibility",
+                condition: "the response is an event stream",
+                whenEligible: "Normalize its completed payload.",
+                whenIneligible: "Preserve the response body.",
+                evidence: references
+            },
+            {
+                id: "preservation",
+                scopeId: "response-policy",
+                kind: "behavior",
+                statement: "Preserve response status codes.",
+                evidence: references
+            }
+        ]
+    });
+    const rendered = proposal.facts
+        .map(repositorySpecificationPublicContractFactV1)
+        .map(renderRepositorySpecificationContractFactV1);
+    assert.ok(rendered[0].includes("When eligible: Normalize its completed payload."));
+    assert.ok(rendered[0].includes("When ineligible: Preserve the response body."));
+    assert.equal(rendered[1], "For this task: Preserve response status codes.");
+});
+test("oversize public contract packets fail without dropping or truncating facts", () => {
+    const proposal = parseRepositorySpecificationContractFactsProposalV1({
+        version: 1,
+        facts: Array.from({ length: 32 }, (_, index) => ({
+            id: `behavior-${String(index)}`,
+            scopeId: "response-policy",
+            kind: "behavior",
+            statement: "p".repeat(1_500),
+            evidence: references
+        }))
+    });
+    const finalScope = repositorySpecificationContractFactsScopeV1(scope, proposal);
+    assert.equal(proposal.facts.length, 32);
+    assert.throws(() => repositorySpecificationContractFactsPacketV1(finalScope, proposal), /32768 bytes/u);
+    assert.equal(proposal.facts.length, 32);
+    assert.equal(proposal.facts[31].kind, "behavior");
+});

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

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

package/dist/test/repository-trajectory-authoring.test.js

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { Effect, Layer } from "effect";
+import { EvalAuthoringTransport } from "../project-authoring.js";
+import { gpt56RepositoryFoundryModelPlanV1 } from "../repository-language-model-protocol.js";
+import { RepositoryFoundryLanguageModelLive } from "../services/language-model/service.js";
+import { authorReviewedRepositoryTrajectoryPolicyV1 } from "../services/trajectory-policy/service.js";
+const plan = () => gpt56RepositoryFoundryModelPlanV1({
+    primaryModel: "codex/gpt-5.6-sol",
+    criticAModel: "codex/gpt-5.6-terra",
+    criticBModel: "codex/gpt-5.6-luna",
+    reviewerModel: "codex/gpt-5.6-terra",
+    primaryReasoningEffort: "max",
+    reviewReasoningEffort: "max"
+});
+const proposal = (repaired) => ({
+    thresholds: {
+        maximumToolCalls: 28,
+        maximumFailedToolCalls: 6,
+        maximumRepeatedFailedActions: 2
+    },
+    rationale: repaired
+        ? "The numeric ceilings allow proportionate exploration and debugging; only compiler-owned requirements are normative."
+        : "The numeric ceilings allow debugging, but visible test changes must be legitimate and non-weakening."
+});
+const completion = (input, approveRepairSequence = 1) => {
+    const repairSequence = Number(input.operationId.match(/:repair-(\d+)$/u)?.[1] ?? "0");
+    if (input.foundryRole === "trajectory-designer") {
+        return proposal(repairSequence > 0);
+    }
+    if (input.foundryRole === "trajectory-critic") {
+        if (repairSequence < approveRepairSequence) {
+            return {
+                verdict: "reject",
+                detail: "The rationale introduces an unverifiable visible-test legitimacy rule.",
+                unverifiableRequirements: [
+                    "Visible test changes must be legitimate and non-weakening."
+                ],
+                styleBiases: []
+            };
+        }
+        return {
+            verdict: "approve",
+            detail: "The replacement rationale only explains numeric headroom and every normative gate is mechanical.",
+            unverifiableRequirements: [],
+            styleBiases: []
+        };
+    }
+    throw new Error(`unexpected role ${String(input.foundryRole)}`);
+};
+const run = async (rejectRepair = false) => {
+    const calls = [];
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        completeDetailed: (input) => {
+            calls.push(input);
+            return Effect.succeed({
+                text: JSON.stringify(completion(input, rejectRepair ? Number.POSITIVE_INFINITY : 1)),
+                callId: `call-${input.operationId}`
+            });
+        },
+        complete: (input) => Effect.succeed(JSON.stringify(completion(input, rejectRepair ? Number.POSITIVE_INFINITY : 1)))
+    }));
+    const effect = authorReviewedRepositoryTrajectoryPolicyV1({
+        operationId: "trajectory-case",
+        caseId: "case-gateway-stream",
+        visible: {
+            lane: "repository-agent",
+            id: "case-gateway-stream",
+            requestText: "Preserve terminal stream ordering without dropping usage.",
+            checkoutCommit: "a".repeat(40),
+            allowedTools: ["read", "search", "edit", "shell", "test"],
+            constraints: ["Preserve the external wire contract."]
+        },
+        targetBehavior: [
+            {
+                id: "terminal-order",
+                description: "Exactly one terminal event is emitted after all output and usage events.",
+                critical: true,
+                evidence: [{ kind: "test", id: "stream-test", path: "src/stream.test.ts" }]
+            }
+        ],
+        reviewedImplementationPathCount: 2,
+        validationRecipeIds: ["command-test-stream"],
+        protectedPaths: ["test/hidden-control.ts"],
+        reviewedCommands: [
+            {
+                id: "command-test-stream",
+                kind: "test",
+                timeoutMs: 30_000
+            }
+        ],
+        modelPlan: plan()
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))));
+    return { calls, effect };
+};
+test("trajectory authoring repairs an unverifiable rationale and requires a fresh independent review", async () => {
+    const { calls, effect } = await run();
+    const result = await Effect.runPromise(effect);
+    assert.deepEqual(calls.map((call) => `${String(call.foundryRole)}:${call.operationId}`), [
+        "trajectory-designer:trajectory-case:trajectory-designer",
+        "trajectory-critic:trajectory-case:trajectory-critic",
+        "trajectory-designer:trajectory-case:trajectory-designer:repair-1",
+        "trajectory-critic:trajectory-case:trajectory-critic:repair-1"
+    ]);
+    assert.equal(result.review.verdict, "approve");
+    assert.equal(result.revisionAttempts.length, 1);
+    assert.equal(result.revisionAttempts[0]?.beforeReview.verdict, "reject");
+    assert.equal(result.revisionAttempts[0]?.candidateReview.verdict, "approve");
+    assert.equal(result.revisionAttempts[0]?.decision, "accepted");
+    assert.equal(result.modelCalls.length, 4);
+    assert.equal(result.policy.requirements.passingValidationAfterLastMutation, true);
+    assert.equal(result.policy.requirements.noProtectedPathMutations, true);
+});
+test("trajectory authoring fails closed when the repaired policy is still unverifiable", async () => {
+    const { calls, effect } = await run(true);
+    const exit = await Effect.runPromiseExit(effect);
+    assert.equal(exit._tag, "Failure");
+    assert.equal(calls.length, 6);
+    if (exit._tag === "Failure") {
+        assert.match(String(exit.cause), /trajectory policy failed validation/u);
+        assert.match(String(exit.cause), /unverifiable/u);
+    }
+});
+test("trajectory authoring uses a second independently reviewed repair when the first remains biased", async () => {
+    const calls = [];
+    const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+        completeDetailed: (input) => {
+            calls.push(input);
+            return Effect.succeed({
+                text: JSON.stringify(completion(input, 2)),
+                callId: `call-${input.operationId}`
+            });
+        },
+        complete: (input) => {
+            calls.push(input);
+            return Effect.succeed(JSON.stringify(completion(input, 2)));
+        }
+    }));
+    const effect = authorReviewedRepositoryTrajectoryPolicyV1({
+        operationId: "trajectory-case",
+        caseId: "case-gateway-stream",
+        visible: {
+            lane: "repository-agent",
+            id: "case-gateway-stream",
+            requestText: "Preserve terminal stream ordering without dropping usage.",
+            checkoutCommit: "a".repeat(40),
+            allowedTools: ["read", "search", "edit", "shell", "test"],
+            constraints: ["Preserve the external wire contract."]
+        },
+        targetBehavior: [
+            {
+                id: "terminal-order",
+                description: "Exactly one terminal event is emitted after all output and usage events.",
+                critical: true,
+                evidence: [{ kind: "test", id: "stream-test", path: "src/stream.test.ts" }]
+            }
+        ],
+        reviewedImplementationPathCount: 2,
+        validationRecipeIds: ["command-test-stream"],
+        protectedPaths: ["test/hidden-control.ts"],
+        reviewedCommands: [
+            {
+                id: "command-test-stream",
+                kind: "test",
+                timeoutMs: 30_000
+            }
+        ],
+        modelPlan: plan()
+    }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))));
+    const result = await Effect.runPromise(effect);
+    assert.equal(result.review.verdict, "approve");
+    assert.equal(result.revisionAttempts.length, 2);
+    assert.equal(result.revisionAttempts[0]?.decision, "rejected");
+    assert.equal(result.revisionAttempts[1]?.decision, "accepted");
+    assert.equal(calls.length, 6);
+});

package/dist/test/repository-valid-control-plan.test.d.ts

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

package/dist/test/repository-valid-control-plan.test.js

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { assertRepositoryFoundryGenerationPlanV1, repositoryFoundryGenerationBudgetV1, repositoryFoundryGenerationPlanDigestV1 } from "../repository-foundry-plan-protocol.js";
+import { repositoryFoundryModelPlanV1 } from "../repository-language-model-protocol.js";
+test("valid-control review is pinned without changing legacy plans or the model-call budget", () => {
+    const unsignedPlan = (validControlReviewVersion) => ({
+        version: 1,
+        repository: { root: "/repo", requestedRef: "HEAD", commit: "commit", tree: "tree" },
+        caseId: "legacy-case",
+        ...(validControlReviewVersion === undefined ? {} : { validControlReviewVersion }),
+        seedId: "seed",
+        initialCommit: "initial",
+        referenceCommit: "reference",
+        modelPlan: repositoryFoundryModelPlanV1({ primaryModel: "codex/gpt-6-astra" }),
+        qualification: { batches: 2, repetitionsPerBatch: 2, oracleRepetitions: 2 },
+        budget: repositoryFoundryGenerationBudgetV1(2)
+    });
+    const unsigned = unsignedPlan();
+    const legacy = { ...unsigned, planDigest: repositoryFoundryGenerationPlanDigestV1(unsigned) };
+    assert.equal(legacy.planDigest, "357e58c2853e4379791e3d1c5b9475993a65c371684c8f6a6f4c69400f1d2994");
+    assertRepositoryFoundryGenerationPlanV1(legacy);
+    const reviewedUnsigned = unsignedPlan(1);
+    const reviewed = {
+        ...reviewedUnsigned,
+        planDigest: repositoryFoundryGenerationPlanDigestV1(reviewedUnsigned)
+    };
+    assertRepositoryFoundryGenerationPlanV1(reviewed);
+    assert.notEqual(reviewed.planDigest, legacy.planDigest);
+    assert.deepEqual(reviewed.budget, legacy.budget);
+    assert.throws(() => assertRepositoryFoundryGenerationPlanV1({ ...legacy, validControlReviewVersion: 1 }), /digest/u);
+    const { validControlReviewVersion: _version, ...stripped } = reviewed;
+    assert.throws(() => assertRepositoryFoundryGenerationPlanV1(stripped), /digest/u);
+    assert.throws(() => assertRepositoryFoundryGenerationPlanV1({ ...reviewed, validControlReviewVersion: 2 }));
+    const behavioralUnsigned = unsignedPlan(2);
+    const behavioral = {
+        ...behavioralUnsigned,
+        planDigest: repositoryFoundryGenerationPlanDigestV1(behavioralUnsigned)
+    };
+    assertRepositoryFoundryGenerationPlanV1(behavioral);
+    assert.notEqual(behavioral.planDigest, reviewed.planDigest);
+    assert.notEqual(behavioral.planDigest, legacy.planDigest);
+    assert.deepEqual(behavioral.budget, legacy.budget);
+    assert.throws(() => assertRepositoryFoundryGenerationPlanV1({ ...behavioral, validControlReviewVersion: 1 }));
+    assert.throws(() => assertRepositoryFoundryGenerationPlanV1({ ...behavioral, validControlReviewVersion: 3 }));
+});

package/dist/test/repository-vitest-phase.test.d.ts

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