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

package/dist/project-workflow.js

@@ -1,13 +1,17 @@
 import { assertDecompositionResult, assertPublishedRoutingActivation, assertRoutingObjectivePolicy, isForbiddenEvalModel } from "@velum-labs/routekit-eval-contracts";
 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, scopedExpectedCalls, summarizeEvalRunLedger } from "./project-contracts.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) {
@@ -92,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":
@@ -157,15 +161,18 @@ const sameLedger = (left, right) => left.expectedCalls === right.expectedCalls &
     left.knownOutputTokens === right.knownOutputTokens &&
     left.unknownTokenMeasurements === right.unknownTokenMeasurements &&
     left.knownPricedSubtotalUsd === right.knownPricedSubtotalUsd &&
-    left.unpricedCalls === right.unpricedCalls;
-const validateQualifiedReport = (state, plan, proposal, report) => {
-    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");
+    left.unpricedCalls === right.unpricedCalls &&
+    left.subscriptionUnitCalls === right.subscriptionUnitCalls;
+const validateQualifiedReport = (state, plan, proposal, report, costService) => Effect.gen(function* () {
+    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();
@@ -285,30 +292,60 @@ const validateQualifiedReport = (state, plan, proposal, report) => {
                 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 = summarizeEvalRunLedger(report.comparisons, expected.expectedCallCount, qualification?.decomposition.observations ?? []);
+    const ledger = yield* summarizeEvalRunLedger(report.comparisons, expected.expectedCallCount, costService, qualification?.decomposition.observations ?? [], plan.classifierModel);
     if (ledger.observedCalls !== expected.expectedCallCount ||
         ledger.observedCandidateRows !== expected.expectedCandidateCalls ||
         !sameLedger(ledger, report.ledger)) {
         throw new Error("qualification ledger does not match the completed evidence");
     }
-};
+});
 const parseObjective = (state, answer) => Effect.gen(function* () {
     const text = yield* nonEmptyAnswer(state, answer);
     const json = yield* Effect.try({
@@ -512,8 +549,26 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
     const artifacts = yield* EvalProjectArtifacts;
     const inspector = yield* EvalRepositoryInspector;
     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),
@@ -522,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 &&
@@ -532,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 {
@@ -697,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);
@@ -743,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
@@ -757,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);
@@ -768,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,
@@ -790,7 +870,7 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
         yield* store.save(root, next);
         return yield* statusOf(root, next);
     });
-    const createPlan = (repositoryRoot, scope) => Effect.gen(function* () {
+    const createPlan = (repositoryRoot, scope, repetitions = 1) => Effect.gen(function* () {
         const root = resolveRoot(repositoryRoot);
         const state = yield* loadRequired(root);
         if (state.stage !== "ready" && state.stage !== "qualified") {
@@ -798,13 +878,24 @@ 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");
         }
+        if (!Number.isSafeInteger(repetitions) || repetitions < 1) {
+            return yield* transitionError(state.stage, "eval repetitions N must be at least 1");
+        }
         if (scope === "full") {
             const shortSuite = proposal.suites.find((suite) => suite.cases.length < 20);
             if (shortSuite !== undefined ||
@@ -817,16 +908,22 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
         }
         const selectedCaseIds = proposal.suites.map((suite) => ({
             dimensionId: suite.dimensionId,
-            caseIds: suite.cases
+            caseIds: Array.from({ length: repetitions }, (_, repetition) => suite.cases
                 .slice(0, scope === "pilot" ? 5 : undefined)
-                .map((testCase) => testCase.id)
+                .map((testCase) => repetitions === 1
+                ? testCase.id
+                : `${testCase.id}#${String(repetition + 1)}`)).flat()
         }));
-        const selectedDecompositionCaseIds = proposal.decompositionBenchmark.cases
+        const selectedDecompositionCaseIds = Array.from({ length: repetitions }, (_, repetition) => proposal.decompositionBenchmark.cases
             .slice(0, scope === "pilot" ? 5 : undefined)
-            .map((testCase) => testCase.id);
-        const selectedCompositionCaseIds = proposal.compositionSuite.cases
+            .map((testCase) => repetitions === 1
+            ? testCase.id
+            : `${testCase.id}#${String(repetition + 1)}`)).flat();
+        const selectedCompositionCaseIds = Array.from({ length: repetitions }, (_, repetition) => proposal.compositionSuite.cases
             .slice(0, scope === "pilot" ? 5 : undefined)
-            .map((testCase) => testCase.id);
+            .map((testCase) => repetitions === 1
+            ? testCase.id
+            : `${testCase.id}#${String(repetition + 1)}`)).flat();
         const expected = scopedExpectedCalls({
             candidateModels: proposal.candidateModels,
             selectedCaseIds,
@@ -840,6 +937,7 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             projectRevision: state.revision,
             createdAt: yield* isoNow,
             scope,
+            repetitions,
             basisDigest: state.basisDigest,
             evaluationDigest: state.evaluationDigest,
             candidateModels: state.configuration.candidateModels,
@@ -855,7 +953,15 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             selectedDecompositionCaseIds,
             selectedCompositionCaseIds,
             maximumOutputTokens: Math.max(proposal.compositionSuite.maximumOutputTokens, ...proposal.suites.map((suite) => suite.maximumOutputTokens)),
-            ...expected
+            ...expected,
+            costEstimate: yield* estimateEvalPlanCost({
+                candidateModels: state.configuration.candidateModels,
+                candidateReasoningEfforts: state.configuration.candidateReasoningEfforts,
+                classifierModel: state.configuration.classifierModel,
+                judgeModel: state.configuration.judgeModel,
+                maximumOutputTokens: Math.max(proposal.compositionSuite.maximumOutputTokens, ...proposal.suites.map((suite) => suite.maximumOutputTokens)),
+                ...expected
+            }, costService)
         };
         yield* artifacts.materializePlanSuites(root, plan, proposal);
         yield* artifacts.savePlan(root, plan);
@@ -877,6 +983,9 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             plan.evaluationDigest !== state.evaluationDigest ||
             !sameStrings(plan.candidateModels, state.configuration.candidateModels) ||
             !sameReasoningEfforts(plan.candidateReasoningEfforts, state.configuration.candidateReasoningEfforts) ||
+            (plan.costEstimate !== undefined &&
+                JSON.stringify(plan.costEstimate) !==
+                    JSON.stringify(yield* estimateEvalPlanCost(plan, costService))) ||
             plan.classifierModel !== state.configuration.classifierModel ||
             plan.authorModel !== state.configuration.authorModel ||
             plan.judgeModel !== state.configuration.judgeModel) {
@@ -888,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();
@@ -923,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);
@@ -940,10 +1058,7 @@ export const makeEvalProjectWorkflow = Effect.gen(function* () {
             (plan.scope === "pilot" && report.status !== "completed")) {
             return yield* transitionError(state.stage, "only full plans may qualify routing activation; pilot plans are completed diagnostics");
         }
-        yield* Effect.try({
-            try: () => validateQualifiedReport(state, plan, proposal, report),
-            catch: (cause) => transitionError(state.stage, cause instanceof Error ? cause.message : "qualification report is invalid")
-        });
+        yield* validateQualifiedReport(state, plan, proposal, report, costService).pipe(Effect.catchDefect((cause) => Effect.fail(transitionError(state.stage, cause instanceof Error ? cause.message : "qualification report is invalid"))));
         const reportPath = yield* artifacts.saveRunReport(root, report);
         const common = {
             version: state.version,
@@ -982,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");
+        }
+    }
+}