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

package/dist/project-store.js

@@ -14,6 +14,7 @@ const storeFailure = (operation, path, cause) => new EvalProjectStoreError({
 export const makeFileEvalProjectStore = Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
     const paths = yield* Path.Path;
+    const platform = yield* Effect.context();
     const projectPath = (root) => paths.join(paths.resolve(root), ".routekit", "evals", PROJECT_FILE);
     const loadDocument = (repositoryRoot) => Effect.gen(function* () {
         const root = yield* fs
@@ -45,7 +46,7 @@ export const makeFileEvalProjectStore = Effect.gen(function* () {
             .pipe(Effect.mapError((cause) => storeFailure("creating", directory, cause)));
         yield* writeFileAtomicEffect(target, `${JSON.stringify(state, null, 2)}\n`, {
             mode: 0o600
-        }).pipe(Effect.mapError((cause) => storeFailure("committing", target, cause)), Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, paths));
+        }).pipe(Effect.mapError((cause) => storeFailure("committing", target, cause)), Effect.provide(platform));
     });
     return EvalProjectStore.of({
         loadDocument,

package/dist/project-workflow.d.ts

@@ -1,5 +1,5 @@
 import { CostService } from "@velum-labs/routekit-registry";
-import { Context, Effect, Layer, Path } from "effect";
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
 import type { EvalProjectArtifactError, EvalSetupInspectionError } from "./errors.js";
 import { EvalDimensionContrastError, type EvalModelCatalogError, type EvalProjectStoreError, EvalProjectTransitionError } from "./errors.js";
 import { EvalRepositoryInspector } from "./inspection.js";
@@ -29,6 +29,6 @@ export type EvalProjectWorkflowShape = {
 declare const EvalProjectWorkflow_base: Context.ServiceClass<EvalProjectWorkflow, "@velum-labs/routekit-eval-setup/EvalProjectWorkflow", EvalProjectWorkflowShape>;
 export declare class EvalProjectWorkflow extends EvalProjectWorkflow_base {
 }
-export declare const makeEvalProjectWorkflow: Effect.Effect<EvalProjectWorkflowShape, never, EvalProjectArtifacts | Path.Path | EvalProjectStore | EvalRepositoryInspector | EvalModelCatalog | CostService>;
-export declare const EvalProjectWorkflowLive: Layer.Layer<EvalProjectWorkflow, never, EvalProjectArtifacts | Path.Path | EvalProjectStore | EvalRepositoryInspector | EvalModelCatalog | CostService>;
+export declare const makeEvalProjectWorkflow: Effect.Effect<EvalProjectWorkflowShape, never, EvalProjectArtifacts | Path.Path | FileSystem.FileSystem | EvalRepositoryInspector | EvalProjectStore | EvalModelCatalog | CostService>;
+export declare const EvalProjectWorkflowLive: Layer.Layer<EvalProjectWorkflow, never, EvalProjectArtifacts | Path.Path | FileSystem.FileSystem | EvalRepositoryInspector | EvalProjectStore | EvalModelCatalog | CostService>;
 export {};

package/dist/project-workflow.js

@@ -2,13 +2,16 @@ import { assertDecompositionResult, assertPublishedRoutingActivation, assertRout
 import { RoutingActivationConstraints, RoutingObjectivePolicy } from "@velum-labs/routekit-eval-contracts";
 import { CostService } from "@velum-labs/routekit-registry";
 import { Clock, Context, Effect, Layer, Path, Schema } from "effect";
+import { assertCurrentEvaluationEvidence } from "./adapters/evaluation-evidence-freshness.js";
 import { EvalDimensionContrastError, EvalProjectTransitionError } from "./errors.js";
+import { EVAL_STRUCTURE_POLICY_VERSION, assertEvaluationStructure, evaluationStructureReportDigest } from "./evaluation-structure-policy.js";
 import { EvalRepositoryInspector } from "./inspection.js";
 import { candidateReasoningEffortFromAnswer } from "./model-selection.js";
 import { EvalProjectArtifacts, evaluationProposalDigest, routingBasisDigest } from "./project-artifacts.js";
 import { EVAL_PROJECT_VERSION, estimateEvalPlanCost, scopedExpectedCalls, summarizeEvalRunLedger } from "./project-contracts.js";
 import { EvalProjectStore } from "./project-store.js";
 import { EvalModelCatalog } from "./services/model-catalog/service.js";
+import { assertEvalRunCanFail } from "./eval-event-log.js";
 const isoNow = Effect.map(Clock.currentTimeMillis, (millis) => new Date(millis).toISOString());
 const questionForProgress = (progress) => {
     switch (progress._tag) {
@@ -93,7 +96,7 @@ const nextAction = (state, artifacts) => {
                 ? "propose-evaluations"
                 : "approve-evaluations";
         case "ready":
-            return "run";
+            return artifacts.evaluationsApproved ? "run" : "approve-evaluations";
         case "running":
             return "none";
         case "qualified":
@@ -161,13 +164,15 @@ const sameLedger = (left, right) => left.expectedCalls === right.expectedCalls &
     left.unpricedCalls === right.unpricedCalls &&
     left.subscriptionUnitCalls === right.subscriptionUnitCalls;
 const validateQualifiedReport = (state, plan, proposal, report, costService) => Effect.gen(function* () {
-    assertPublishedRoutingActivation(report.activation, {
-        dimensionIds: plan.selectedCaseIds.map((entry) => entry.dimensionId)
-    });
-    if (report.activation.basisDigest !== state.basisDigest ||
-        report.activation.classifierModel !== state.configuration.classifierModel ||
-        !sameStrings(report.activation.candidateModels, plan.candidateModels)) {
-        throw new Error("published activation does not match the immutable execution plan");
+    if (report.status === "passed") {
+        assertPublishedRoutingActivation(report.activation, {
+            dimensionIds: plan.selectedCaseIds.map((entry) => entry.dimensionId)
+        });
+        if (report.activation.basisDigest !== state.basisDigest ||
+            report.activation.classifierModel !== state.configuration.classifierModel ||
+            !sameStrings(report.activation.candidateModels, plan.candidateModels)) {
+            throw new Error("published activation does not match the immutable execution plan");
+        }
     }
     const expectedDimensions = new Map(plan.selectedCaseIds.map((entry) => [entry.dimensionId, new Set(entry.caseIds)]));
     const comparisons = new Map();
@@ -287,21 +292,51 @@ const validateQualifiedReport = (state, plan, proposal, report, costService) =>
                 observedCompositionCases.size !== 0 ||
                 qualification.composition.comparableCases !== 0 ||
                 qualification.composition.agreeingCases !== 0 ||
+                qualification.composition.winnerAgreement !== undefined ||
+                qualification.composition.conclusion !== "inconclusive" ||
+                qualification.composition.publishable ||
                 qualification.composition.cases.length !== 0) {
                 throw new Error("composition qualification summary does not meet the reviewed threshold");
             }
         }
         else if (qualification.composition.expectedCases !== expectedCompositionCases.size ||
             observedCompositionCases.size !== expectedCompositionCases.size ||
-            qualification.composition.comparableCases < 1 ||
             qualification.composition.agreeingCases !==
                 qualification.composition.cases.filter((result) => result.passed).length ||
-            Math.abs(qualification.composition.winnerAgreement -
-                qualification.composition.agreeingCases / qualification.composition.comparableCases) > 1e-6 ||
-            qualification.composition.winnerAgreement <
-                proposal.compositionSuite.minimumWinnerAgreement) {
+            qualification.composition.comparableCases !==
+                qualification.composition.cases.filter((result) => result.comparable).length ||
+            qualification.composition.cases.some((result) => result.comparable !==
+                (result.predictedWinner !== null &&
+                    result.observedWinner !== null &&
+                    result.predictedScoreGap >= proposal.compositionSuite.minimumWinnerScoreGap &&
+                    result.observedScoreGap >= proposal.compositionSuite.minimumWinnerScoreGap) ||
+                result.passed !==
+                    (result.comparable && result.predictedWinner === result.observedWinner))) {
             throw new Error("composition qualification summary does not meet the reviewed threshold");
         }
+        if (expectedCompositionCases.size > 0) {
+            const comparableCases = qualification.composition.comparableCases;
+            const expectedAgreement = comparableCases === 0
+                ? undefined
+                : qualification.composition.agreeingCases / comparableCases;
+            const meetsThreshold = expectedAgreement !== undefined &&
+                expectedAgreement >= proposal.compositionSuite.minimumWinnerAgreement;
+            if ((expectedAgreement === undefined
+                ? qualification.composition.winnerAgreement !== undefined
+                : qualification.composition.winnerAgreement === undefined ||
+                    Math.abs(qualification.composition.winnerAgreement - expectedAgreement) > 1e-6) ||
+                qualification.composition.conclusion !==
+                    (expectedAgreement === undefined
+                        ? "inconclusive"
+                        : meetsThreshold
+                            ? "passed"
+                            : "failed") ||
+                qualification.composition.publishable !==
+                    (plan.scope === "full" && meetsThreshold) ||
+                (plan.scope === "full" && !meetsThreshold)) {
+                throw new Error("composition qualification summary does not meet the reviewed threshold");
+            }
+        }
     }
     const expected = scopedExpectedCalls(plan);
     const ledger = yield* summarizeEvalRunLedger(report.comparisons, expected.expectedCallCount, costService, qualification?.decomposition.observations ?? [], plan.classifierModel);
@@ -516,7 +551,24 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
     const modelCatalog = yield* EvalModelCatalog;
     const costService = yield* CostService;
     const paths = yield* Path.Path;
+    const platform = yield* Effect.context();
     const resolveRoot = (repositoryRoot) => paths.resolve(repositoryRoot);
+    const evaluationStructureFor = (root, state, proposal) => Effect.gen(function* () {
+        const report = yield* Effect.try({
+            try: () => assertEvaluationStructure({
+                proposal,
+                sourceInventory: state.sourceInventory
+            }),
+            catch: (cause) => transitionError(state.stage, cause instanceof Error
+                ? cause.message
+                : "evaluation proposal failed structure validation")
+        });
+        yield* assertCurrentEvaluationEvidence({
+            repositoryRoot: root,
+            evidenceSources: proposal.evidenceSources ?? []
+        }).pipe(Effect.provide(platform), Effect.mapError((cause) => transitionError(state.stage, cause.message)));
+        return report;
+    });
     const statusOf = (root, state) => Effect.gen(function* () {
         const [basis, basisApproval, evaluations, evaluationsApproval, plans] = yield* Effect.all([
             artifacts.loadBasisProposal(root),
@@ -525,6 +577,15 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             artifacts.loadEvaluationsApproval(root),
             artifacts.listPlans(root)
         ]);
+        const structureReport = evaluations === undefined
+            ? undefined
+            : yield* evaluationStructureFor(root, state, evaluations).pipe(Effect.match({
+                onFailure: () => undefined,
+                onSuccess: (report) => report
+            }));
+        const structureReportDigest = structureReport === undefined
+            ? undefined
+            : evaluationStructureReportDigest(structureReport);
         const artifactStatus = {
             ...(basis === undefined ? {} : { basisProposalDigest: basis.basisDigest }),
             basisApproved: basis !== undefined &&
@@ -535,7 +596,10 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
                 : { evaluationProposalDigest: evaluations.evaluationDigest }),
             evaluationsApproved: evaluations !== undefined &&
                 evaluationsApproval?.kind === "evaluations" &&
-                evaluationsApproval.digest === evaluations.evaluationDigest,
+                evaluationsApproval.digest === evaluations.evaluationDigest &&
+                evaluationsApproval.structurePolicyVersion ===
+                    EVAL_STRUCTURE_POLICY_VERSION &&
+                evaluationsApproval.structureReportDigest === structureReportDigest,
             plans
         };
         return {
@@ -700,7 +764,9 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
     const proposeEvaluations = (repositoryRoot, input) => Effect.gen(function* () {
         const root = resolveRoot(repositoryRoot);
         const state = yield* loadRequired(root);
-        if (state.stage !== "evaluations-review") {
+        if (state.stage !== "evaluations-review" &&
+            state.stage !== "ready" &&
+            state.stage !== "qualified") {
             return yield* transitionError(state.stage, "dimension evaluations can only be proposed after routing-basis approval");
         }
         const basis = yield* artifacts.loadBasisProposal(root);
@@ -746,6 +812,9 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
                     candidateReasoningEfforts: state.configuration.candidateReasoningEfforts
                 }),
             judgeModel: state.configuration.judgeModel,
+            ...(input.evidenceSources === undefined
+                ? {}
+                : { evidenceSources: input.evidenceSources }),
             suites: input.suites,
             decompositionBenchmark: input.decompositionBenchmark,
             compositionSuite: input.compositionSuite
@@ -760,7 +829,9 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
     const approveEvaluations = (repositoryRoot, expectedDigest) => Effect.gen(function* () {
         const root = resolveRoot(repositoryRoot);
         const state = yield* loadRequired(root);
-        if (state.stage !== "evaluations-review") {
+        if (state.stage !== "evaluations-review" &&
+            state.stage !== "ready" &&
+            state.stage !== "qualified") {
             return yield* transitionError(state.stage, "dimension evaluations are not awaiting approval");
         }
         const proposal = yield* artifacts.loadEvaluationProposal(root);
@@ -771,13 +842,19 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             proposal.basisDigest !== state.basisDigest) {
             return yield* transitionError(state.stage, "evaluation proposal changed after review; approve its current digest");
         }
+        const structureReport = yield* evaluationStructureFor(root, state, proposal);
         const now = yield* isoNow;
         yield* artifacts.saveEvaluationsApproval(root, {
             version: EVAL_PROJECT_VERSION,
             kind: "evaluations",
             digest: proposal.evaluationDigest,
-            approvedAt: now
+            approvedAt: now,
+            structurePolicyVersion: EVAL_STRUCTURE_POLICY_VERSION,
+            structureReportDigest: evaluationStructureReportDigest(structureReport)
         });
+        if (state.stage !== "evaluations-review") {
+            return yield* statusOf(root, state);
+        }
         const next = {
             version: state.version,
             projectId: state.projectId,
@@ -801,9 +878,17 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
         }
         const proposal = yield* artifacts.loadEvaluationProposal(root);
         const approval = yield* artifacts.loadEvaluationsApproval(root);
+        const structureReport = proposal === undefined
+            ? undefined
+            : yield* evaluationStructureFor(root, state, proposal);
         if (proposal === undefined ||
             approval?.kind !== "evaluations" ||
             approval.digest !== proposal.evaluationDigest ||
+            approval.structurePolicyVersion !== EVAL_STRUCTURE_POLICY_VERSION ||
+            approval.structureReportDigest !==
+                (structureReport === undefined
+                    ? undefined
+                    : evaluationStructureReportDigest(structureReport)) ||
             proposal.evaluationDigest !== state.evaluationDigest ||
             proposal.basisDigest !== state.basisDigest) {
             return yield* transitionError(state.stage, "approved evaluation artifacts are stale");
@@ -912,6 +997,15 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             proposal.basisDigest !== plan.basisDigest) {
             return yield* transitionError(state.stage, "the approved evaluation proposal for the execution plan is missing or stale");
         }
+        const approval = yield* artifacts.loadEvaluationsApproval(root);
+        const structureReport = yield* evaluationStructureFor(root, state, proposal);
+        if (approval?.kind !== "evaluations" ||
+            approval.digest !== proposal.evaluationDigest ||
+            approval.structurePolicyVersion !== EVAL_STRUCTURE_POLICY_VERSION ||
+            approval.structureReportDigest !==
+                evaluationStructureReportDigest(structureReport)) {
+            return yield* transitionError(state.stage, "the evaluation approval is stale under the current structure policy");
+        }
         yield* artifacts.materializePlanSuites(root, plan, proposal, "rematerialize");
         const now = yield* isoNow;
         const runId = crypto.randomUUID();
@@ -947,7 +1041,7 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
         if ((report.target.kind === "configured"
             ? !report.cleanup.sessionOpened || !report.cleanup.sessionClosed
             : report.cleanup.sessionOpened || report.cleanup.sessionClosed) ||
-            report.activation.basisDigest !== state.basisDigest) {
+            (report.status === "passed" && report.activation.basisDigest !== state.basisDigest)) {
             return yield* transitionError(state.stage, "a run cannot qualify before session cleanup and activation validation complete");
         }
         const plan = yield* artifacts.loadPlan(root, state.planId);
@@ -1003,6 +1097,10 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             report.evaluationDigest !== state.evaluationDigest) {
             return yield* transitionError(state.stage, "failure report does not match the active run");
         }
+        yield* Effect.try({
+            try: () => assertEvalRunCanFail(report.events ?? []),
+            catch: (cause) => transitionError(state.stage, cause instanceof Error ? cause.message : "failure report has no terminal event")
+        });
         yield* artifacts.saveRunReport(root, report);
         const next = {
             version: state.version,

package/dist/repository-adversary-protocol.d.ts

@@ -0,0 +1,64 @@
+import { Schema } from "effect";
+export declare const RepositoryAdversaryMutationOperatorV1: Schema.Literals<readonly ["condition-negation", "boundary-operator", "partial-output-drop", "cross-file-omission"]>;
+export type RepositoryAdversaryMutationOperatorV1 = typeof RepositoryAdversaryMutationOperatorV1.Type;
+export declare const RepositoryAdversaryValidationObservationV1: Schema.Struct<{
+    readonly repetition: Schema.Finite;
+    readonly outcome: Schema.Literals<readonly ["pass", "fail"]>;
+    readonly detail: Schema.String;
+}>;
+export type RepositoryAdversaryValidationObservationV1 = typeof RepositoryAdversaryValidationObservationV1.Type;
+export declare const RepositoryAdversaryCandidateV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly id: Schema.String;
+    readonly solutionId: Schema.String;
+    readonly family: Schema.String;
+    readonly operator: Schema.Literals<readonly ["condition-negation", "boundary-operator", "partial-output-drop", "cross-file-omission"]>;
+    readonly sourcePath: Schema.String;
+    readonly relatedPaths: Schema.$Array<Schema.String>;
+    readonly sourceCommit: Schema.String;
+    readonly originalSnippet: Schema.String;
+    readonly mutatedSnippet: Schema.String;
+    readonly validationRecipeId: Schema.String;
+    readonly compilationStatus: Schema.Literals<readonly ["passed", "failed"]>;
+    readonly validationObservations: Schema.$Array<Schema.Struct<{
+        readonly repetition: Schema.Finite;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail"]>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryAdversaryCandidateV1 = typeof RepositoryAdversaryCandidateV1.Type;
+export declare const RepositoryAdversaryGenerationReportV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly seedId: Schema.String;
+    readonly generationCoverage: Schema.Struct<{
+        readonly implementationPathCount: Schema.Finite;
+        readonly changedPathCount: Schema.Finite;
+        readonly generatedCrossFileCandidateCount: Schema.Finite;
+        readonly omittedCrossFileCandidateCount: Schema.Finite;
+    }>;
+    readonly candidates: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly id: Schema.String;
+        readonly solutionId: Schema.String;
+        readonly family: Schema.String;
+        readonly operator: Schema.Literals<readonly ["condition-negation", "boundary-operator", "partial-output-drop", "cross-file-omission"]>;
+        readonly sourcePath: Schema.String;
+        readonly relatedPaths: Schema.$Array<Schema.String>;
+        readonly sourceCommit: Schema.String;
+        readonly originalSnippet: Schema.String;
+        readonly mutatedSnippet: Schema.String;
+        readonly validationRecipeId: Schema.String;
+        readonly compilationStatus: Schema.Literals<readonly ["passed", "failed"]>;
+        readonly validationObservations: Schema.$Array<Schema.Struct<{
+            readonly repetition: Schema.Finite;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>>;
+    readonly admittedCandidateIds: Schema.$Array<Schema.String>;
+    readonly rejectedCandidateIds: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryAdversaryGenerationReportV1 = typeof RepositoryAdversaryGenerationReportV1.Type;
+export declare function assertRepositoryAdversaryGenerationReportV1(value: unknown): asserts value is RepositoryAdversaryGenerationReportV1;

package/dist/repository-adversary-protocol.js

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+export const RepositoryAdversaryMutationOperatorV1 = Schema.Literals([
+    "condition-negation",
+    "boundary-operator",
+    "partial-output-drop",
+    "cross-file-omission"
+]);
+export const RepositoryAdversaryValidationObservationV1 = Schema.Struct({
+    repetition: Schema.Finite,
+    outcome: Schema.Literals(["pass", "fail"]),
+    detail: Schema.String
+});
+export const RepositoryAdversaryCandidateV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    id: Schema.String,
+    solutionId: Schema.String,
+    family: Schema.String,
+    operator: RepositoryAdversaryMutationOperatorV1,
+    sourcePath: Schema.String,
+    relatedPaths: Schema.Array(Schema.String),
+    sourceCommit: Schema.String,
+    originalSnippet: Schema.String,
+    mutatedSnippet: Schema.String,
+    validationRecipeId: Schema.String,
+    compilationStatus: Schema.Literals(["passed", "failed"]),
+    validationObservations: Schema.Array(RepositoryAdversaryValidationObservationV1),
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export const RepositoryAdversaryGenerationReportV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    seedId: Schema.String,
+    generationCoverage: Schema.Struct({
+        implementationPathCount: Schema.Finite,
+        changedPathCount: Schema.Finite,
+        generatedCrossFileCandidateCount: Schema.Finite,
+        omittedCrossFileCandidateCount: Schema.Finite
+    }),
+    candidates: Schema.Array(RepositoryAdversaryCandidateV1),
+    admittedCandidateIds: Schema.Array(Schema.String),
+    rejectedCandidateIds: Schema.Array(Schema.String)
+});
+export function assertRepositoryAdversaryGenerationReportV1(value) {
+    const report = Schema.decodeUnknownSync(RepositoryAdversaryGenerationReportV1)(value);
+    const candidateIds = new Set(report.candidates.map((candidate) => candidate.id));
+    const solutionIds = new Set(report.candidates.map((candidate) => candidate.solutionId));
+    const crossFileCandidateCount = report.candidates.filter((candidate) => candidate.operator === "cross-file-omission").length;
+    if (candidateIds.size !== report.candidates.length ||
+        solutionIds.size !== report.candidates.length) {
+        throw new Error("repository adversary candidate ids must be unique");
+    }
+    if (!Number.isInteger(report.generationCoverage.implementationPathCount) ||
+        !Number.isInteger(report.generationCoverage.changedPathCount) ||
+        !Number.isInteger(report.generationCoverage.generatedCrossFileCandidateCount) ||
+        !Number.isInteger(report.generationCoverage.omittedCrossFileCandidateCount) ||
+        report.generationCoverage.implementationPathCount < 0 ||
+        report.generationCoverage.changedPathCount < 0 ||
+        report.generationCoverage.generatedCrossFileCandidateCount < 0 ||
+        report.generationCoverage.omittedCrossFileCandidateCount < 0 ||
+        report.generationCoverage.changedPathCount >
+            report.generationCoverage.implementationPathCount ||
+        report.generationCoverage.generatedCrossFileCandidateCount !==
+            crossFileCandidateCount ||
+        (report.generationCoverage.changedPathCount >= 2
+            ? report.generationCoverage.generatedCrossFileCandidateCount +
+                report.generationCoverage.omittedCrossFileCandidateCount !==
+                report.generationCoverage.changedPathCount
+            : report.generationCoverage.generatedCrossFileCandidateCount !== 0 ||
+                report.generationCoverage.omittedCrossFileCandidateCount !== 0)) {
+        throw new Error("repository adversary generation coverage must account for every eligible cross-file path");
+    }
+    const classified = new Set([
+        ...report.admittedCandidateIds,
+        ...report.rejectedCandidateIds
+    ]);
+    if (classified.size !== report.candidates.length ||
+        [...classified].some((id) => !candidateIds.has(id))) {
+        throw new Error("every repository adversary candidate must be classified exactly once");
+    }
+    for (const candidate of report.candidates) {
+        if (new Set(candidate.relatedPaths).size !== candidate.relatedPaths.length ||
+            candidate.relatedPaths.includes(candidate.sourcePath) ||
+            (candidate.operator === "cross-file-omission"
+                ? candidate.relatedPaths.length === 0
+                : candidate.relatedPaths.length !== 0)) {
+            throw new Error("repository adversary related paths must identify only the coupled files for cross-file mutations");
+        }
+        if (candidate.validationObservations.length < 2 ||
+            candidate.validationObservations.some((observation) => !Number.isInteger(observation.repetition) ||
+                observation.repetition < 1)) {
+            throw new Error("repository adversary candidates require repeated validation observations");
+        }
+        const passed = candidate.validationObservations.every((observation) => observation.outcome === "pass");
+        if ((candidate.compilationStatus === "passed") !== passed ||
+            (candidate.compilationStatus === "passed") !==
+                report.admittedCandidateIds.includes(candidate.id) ||
+            (candidate.compilationStatus === "failed") !==
+                report.rejectedCandidateIds.includes(candidate.id)) {
+            throw new Error("repository adversary classification must match compilation observations");
+        }
+        if (candidate.compilationStatus === "passed" &&
+            candidate.rejectionReasons.length > 0) {
+            throw new Error("admitted repository adversaries cannot have rejection reasons");
+        }
+    }
+}