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

package/dist/repository-oracle-protocol.js

@@ -0,0 +1,156 @@
+import { Schema } from "effect";
+import { RepositoryOracleFixtureV1 } from "./repository-fixture-protocol.js";
+const OracleClauseCommon = {
+    id: Schema.String,
+    critical: Schema.Boolean,
+    description: Schema.String
+};
+export const RepositoryOracleClauseV1 = Schema.Union([
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("candidate-policy"),
+        policyId: Schema.String,
+        forbiddenPaths: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("test-command"),
+        recipeId: Schema.String,
+        expectedExitCode: Schema.Finite,
+        fixtureIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("json-field"),
+        pointer: Schema.String,
+        operator: Schema.Literals(["equals", "present", "absent"]),
+        expectedJson: Schema.optionalKey(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("ordered-events"),
+        eventTypes: Schema.Array(Schema.String),
+        terminalEvent: Schema.optionalKey(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("property"),
+        propertyId: Schema.String,
+        fixtureIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("differential"),
+        implementationIds: Schema.Array(Schema.String),
+        fixtureIds: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("architecture"),
+        ruleId: Schema.String,
+        expectedPaths: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("transformation-completeness"),
+        ruleId: Schema.String,
+        forbiddenLegacyPaths: Schema.Array(Schema.String),
+        requiredNewPaths: Schema.Array(Schema.String)
+    }),
+    Schema.Struct({
+        ...OracleClauseCommon,
+        kind: Schema.Literal("semantic-residual"),
+        criterion: Schema.String
+    })
+]);
+export const RepositoryReferenceSolutionV1 = Schema.Struct({
+    id: Schema.String,
+    kind: Schema.Literals([
+        "historical-reference",
+        "independent-valid",
+        "simplified-valid",
+        "behavior-preserving-valid",
+        "historical-defect",
+        "mutation",
+        "model-near-miss",
+        "reward-hacking"
+    ]),
+    family: Schema.String,
+    expectedClass: Schema.Literals(["valid", "wrong"]),
+    commit: Schema.optionalKey(Schema.String)
+});
+export const RepositoryOracleObservationV1 = Schema.Struct({
+    solutionId: Schema.String,
+    clauseId: Schema.String,
+    repetition: Schema.Finite,
+    outcome: Schema.Literals(["pass", "fail", "unknown"]),
+    detail: Schema.String,
+    inconclusiveReason: Schema.optionalKey(Schema.Literal("unattributed-test-failure"))
+});
+export const RepositoryHiddenOracleV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    caseId: Schema.String,
+    hardFailurePolicy: Schema.Literal("any-critical-hard-clause-fails"),
+    /** Host binding includes executable patches and environment, not only public solution metadata. */
+    executionBindingDigest: Schema.optionalKey(Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/u))),
+    /** Planned repetition count, including repetitions not yet present in a continuation. */
+    executionRepetitions: Schema.optionalKey(Schema.Finite.check(Schema.makeFilter((value) => Number.isInteger(value) && value >= 1 && value <= 5
+        ? undefined
+        : "execution repetitions must be an integer from 1 to 5"))),
+    fixtures: Schema.Array(RepositoryOracleFixtureV1),
+    clauses: Schema.Array(RepositoryOracleClauseV1),
+    solutions: Schema.Array(RepositoryReferenceSolutionV1),
+    observations: Schema.Array(RepositoryOracleObservationV1),
+    knownLimitations: Schema.Array(Schema.String)
+});
+export const RepositoryOracleAdequacyReportV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    caseId: Schema.String,
+    admitted: Schema.Boolean,
+    validSolutionCount: Schema.Finite,
+    wrongSolutionCount: Schema.Finite,
+    falseRejectedSolutionIds: Schema.Array(Schema.String),
+    falseAcceptedSolutionIds: Schema.Array(Schema.String),
+    unstableSolutionIds: Schema.Array(Schema.String),
+    unobservedClauseIds: Schema.Array(Schema.String),
+    insufficientObservationPairs: Schema.Array(Schema.String),
+    mutationFamilyKills: Schema.Array(Schema.Struct({
+        family: Schema.String,
+        killed: Schema.Finite,
+        total: Schema.Finite
+    })),
+    rejectionReasons: Schema.Array(Schema.String)
+});
+export function assertRepositoryHiddenOracleV1(value) {
+    const oracle = Schema.decodeUnknownSync(RepositoryHiddenOracleV1)(value);
+    if (oracle.caseId.trim().length === 0 ||
+        oracle.clauses.length === 0 ||
+        !oracle.clauses.some((clause) => clause.critical)) {
+        throw new Error("repository hidden oracle requires a case id and critical hard clause");
+    }
+    const clauseIds = new Set(oracle.clauses.map((clause) => clause.id));
+    const fixtureIds = new Set(oracle.fixtures.map((fixture) => fixture.id));
+    const solutionIds = new Set(oracle.solutions.map((solution) => solution.id));
+    if (clauseIds.size !== oracle.clauses.length || solutionIds.size !== oracle.solutions.length) {
+        throw new Error("repository hidden oracle ids must be unique");
+    }
+    if (!oracle.solutions.some((solution) => solution.expectedClass === "valid") ||
+        !oracle.solutions.some((solution) => solution.expectedClass === "wrong")) {
+        throw new Error("repository hidden oracle requires valid and wrong solution populations");
+    }
+    for (const observation of oracle.observations) {
+        if (!solutionIds.has(observation.solutionId) ||
+            !clauseIds.has(observation.clauseId) ||
+            !Number.isInteger(observation.repetition) ||
+            observation.repetition < 1 ||
+            (observation.inconclusiveReason !== undefined && observation.outcome !== "unknown")) {
+            throw new Error("repository hidden oracle observation refers to an unknown solution or clause");
+        }
+    }
+    for (const clause of oracle.clauses) {
+        if (clause.kind === "test-command" &&
+            clause.fixtureIds.some((fixtureId) => !fixtureIds.has(fixtureId))) {
+            throw new Error("repository hidden oracle test clause refers to an unknown fixture");
+        }
+    }
+}

package/dist/repository-oracle-scope-policy.d.ts

@@ -0,0 +1,22 @@
+import type { OracleCheckpointV1, SpecCheckpointV1 } from "./case-pipeline-protocol.js";
+import type { RepositoryHiddenOracleV1, RepositoryOracleClauseV1, RepositoryOracleObservationV1 } from "./repository-oracle-protocol.js";
+/** Shared executed-evidence policy for tournament repair and final admission. */
+export declare const repositoryOracleRepeatedRowsV1: (rows: readonly RepositoryOracleObservationV1[], repetitions: number) => boolean;
+export declare const repositoryOracleAttributedSemanticFailureV1: (row: RepositoryOracleObservationV1, clause: RepositoryOracleClauseV1) => boolean;
+/**
+ * Resolve every grounded scope through the author's persisted fixture mapping
+ * and repeated execution. The mapping is advisory until these observations
+ * prove it: every scope needs a reference-passing fixture with compatible
+ * metadata, and changed scopes additionally need the same fixture to reject
+ * the pinned historical defect through attributed assertion evidence.
+ */
+export declare const evaluateRepositoryOracleScopeCoverageV1: (input: {
+    readonly spec: SpecCheckpointV1;
+    readonly oracleCheckpoint: OracleCheckpointV1;
+    readonly oracle: RepositoryHiddenOracleV1;
+    readonly repetitions: number;
+    readonly label: string;
+}) => {
+    readonly reasons: readonly string[];
+    readonly unresolvedScopeIds: readonly string[];
+};

package/dist/repository-oracle-scope-policy.js

@@ -0,0 +1,92 @@
+/** Shared executed-evidence policy for tournament repair and final admission. */
+export const repositoryOracleRepeatedRowsV1 = (rows, repetitions) => rows.length === repetitions &&
+    new Set(rows.map(({ repetition }) => repetition)).size === repetitions &&
+    rows.every(({ repetition }) => Number.isSafeInteger(repetition) && repetition >= 1 && repetition <= repetitions);
+export const repositoryOracleAttributedSemanticFailureV1 = (row, clause) => clause.kind === "test-command" &&
+    row.outcome === "fail" &&
+    row.detail.includes("stage=grade") &&
+    row.detail.includes("gradeExecuted=true") &&
+    row.detail.includes("timeout=false") &&
+    row.detail.includes("exit=1") &&
+    row.detail.includes("assertionFailures=") &&
+    !row.detail.includes("output=truncated");
+const fixtureClauseOf = (oracle, fixtureId) => oracle.clauses.find((clause) => clause.kind === "test-command" && clause.critical && clause.fixtureIds.includes(fixtureId));
+const repeatedFixturePass = (input) => {
+    const rows = input.oracle.observations.filter((row) => row.solutionId === input.solutionId && row.clauseId === input.clauseId);
+    return (repositoryOracleRepeatedRowsV1(rows, input.repetitions) &&
+        rows.every((row) => row.outcome === "pass" &&
+            row.detail.includes("stage=grade") &&
+            row.detail.includes("gradeExecuted=true") &&
+            row.detail.includes("timeout=false") &&
+            row.detail.includes("exit=0") &&
+            !row.detail.includes("output=truncated")));
+};
+const repeatedFixtureKill = (input) => {
+    const rows = input.oracle.observations.filter((row) => row.solutionId === input.solutionId && row.clauseId === input.clause.id);
+    return (repositoryOracleRepeatedRowsV1(rows, input.repetitions) &&
+        rows.every((row) => repositoryOracleAttributedSemanticFailureV1(row, input.clause)));
+};
+/**
+ * Resolve every grounded scope through the author's persisted fixture mapping
+ * and repeated execution. The mapping is advisory until these observations
+ * prove it: every scope needs a reference-passing fixture with compatible
+ * metadata, and changed scopes additionally need the same fixture to reject
+ * the pinned historical defect through attributed assertion evidence.
+ */
+export const evaluateRepositoryOracleScopeCoverageV1 = (input) => {
+    const reasons = [];
+    const unresolvedScopeIds = new Set();
+    const expectedScopeIds = new Set(input.spec.scope.map(({ id }) => id));
+    const submittedScopeIds = input.oracleCheckpoint.scopeCoverage.map(({ scopeId }) => scopeId);
+    if (submittedScopeIds.length !== input.spec.scope.length ||
+        new Set(submittedScopeIds).size !== submittedScopeIds.length ||
+        submittedScopeIds.some((scopeId) => !expectedScopeIds.has(scopeId))) {
+        reasons.push(`${input.label}: scope fixture mapping must contain every grounded scope exactly once`);
+    }
+    const coverageByScope = new Map(input.oracleCheckpoint.scopeCoverage.map((coverage) => [coverage.scopeId, coverage]));
+    const mappingValid = reasons.length === 0;
+    for (const scope of input.spec.scope) {
+        unresolvedScopeIds.add(scope.id);
+        const coverage = coverageByScope.get(scope.id);
+        if (coverage === undefined || coverage.fixtureIds.length === 0) {
+            reasons.push(`${input.label}: grounded scope ${scope.id} has no mapped executable fixture`);
+            continue;
+        }
+        if (new Set(coverage.fixtureIds).size !== coverage.fixtureIds.length) {
+            reasons.push(`${input.label}: grounded scope ${scope.id} has duplicate fixture mappings`);
+            continue;
+        }
+        const resolved = coverage.fixtureIds.some((fixtureId) => {
+            const fixture = input.oracle.fixtures.find(({ id }) => id === fixtureId);
+            const clause = fixtureClauseOf(input.oracle, fixtureId);
+            if (fixture === undefined ||
+                (scope.kind === "changed" && fixture.expectationMode !== "changes") ||
+                clause === undefined) {
+                return false;
+            }
+            const referencePassed = repeatedFixturePass({
+                oracle: input.oracle,
+                clauseId: clause.id,
+                solutionId: "historical-reference",
+                repetitions: input.repetitions
+            });
+            if (!referencePassed)
+                return false;
+            return (scope.kind === "preserved" ||
+                repeatedFixtureKill({
+                    oracle: input.oracle,
+                    clause,
+                    solutionId: "historical-defect",
+                    repetitions: input.repetitions
+                }));
+        });
+        if (resolved && mappingValid)
+            unresolvedScopeIds.delete(scope.id);
+        if (!resolved) {
+            reasons.push(scope.kind === "changed"
+                ? `${input.label}: changed scope ${scope.id} lacks one mapped changes fixture with repeated historical-reference passes and attributed historical-defect failures`
+                : `${input.label}: preserved scope ${scope.id} lacks one mapped fixture with repeated historical-reference passes`);
+        }
+    }
+    return { reasons, unresolvedScopeIds: [...unresolvedScopeIds].sort() };
+};

package/dist/repository-quality-policy.d.ts

@@ -0,0 +1,15 @@
+import type { RepositoryBenchmarkCaseV1, RepositoryValidatedBenchmarkLibraryV1 } from "./repository-benchmark-protocol.js";
+import { type RepositoryHiddenOracleV1, type RepositoryOracleAdequacyReportV1 } from "./repository-oracle-protocol.js";
+/** Partial execution is measurable progress, but never a completed control verdict. */
+export declare const repositoryOracleSolutionObservationsCompleteV1: (oracle: RepositoryHiddenOracleV1, solutionId: string) => boolean;
+export declare function evaluateRepositoryOracleAdequacyV1(oracle: RepositoryHiddenOracleV1): RepositoryOracleAdequacyReportV1;
+export declare function repositoryBehavioralFingerprintV1(input: {
+    readonly capabilityId: string;
+    readonly familyId: string;
+    readonly behaviorClauses: readonly string[];
+    readonly oracle: RepositoryHiddenOracleV1;
+}): string;
+export declare function admitRepositoryBenchmarkCaseV1(input: {
+    readonly draft: Omit<RepositoryBenchmarkCaseV1, "status" | "rejectionReasons">;
+}): RepositoryBenchmarkCaseV1;
+export declare function compileValidatedBenchmarkLibraryV1(cases: readonly RepositoryBenchmarkCaseV1[]): RepositoryValidatedBenchmarkLibraryV1;

package/dist/repository-quality-policy.js

@@ -0,0 +1,357 @@
+import { createHash } from "node:crypto";
+import { assertRepositoryHiddenOracleV1 } from "./repository-oracle-protocol.js";
+const HARD_FINDING_AXES = new Set([
+    "authenticity",
+    "specification-sufficiency",
+    "oracle-adequacy",
+    "stability",
+    "distinctness",
+    "realism",
+    "leakage",
+    "triviality"
+]);
+const completeRepetitions = (oracle, observations) => {
+    // Older whole-solution checkpoints did not retain the plan cardinality.
+    // Infer their already-observed cardinality, never lower the scientific minimum.
+    const required = Math.max(2, oracle.executionRepetitions ??
+        oracle.observations.reduce((maximum, row) => Math.max(maximum, row.repetition), 2));
+    return observations.length === required &&
+        new Set(observations.map((row) => row.repetition)).size === required &&
+        observations.every((row) => Number.isInteger(row.repetition) &&
+            row.repetition >= 1 && row.repetition <= required);
+};
+/** Partial execution is measurable progress, but never a completed control verdict. */
+export const repositoryOracleSolutionObservationsCompleteV1 = (oracle, solutionId) => {
+    if (rejectedByCandidatePolicy(oracle, solutionId))
+        return true;
+    const clauses = oracle.clauses.filter((clause) => clause.critical && clause.kind !== "semantic-residual");
+    return clauses.length > 0 && clauses.every((clause) => {
+        const rows = oracle.observations.filter((row) => row.solutionId === solutionId && row.clauseId === clause.id);
+        return completeRepetitions(oracle, rows) && rows.every((row) => row.outcome !== "unknown");
+    });
+};
+const solutionPasses = (oracle, solutionId) => {
+    const criticalClauseIds = new Set(oracle.clauses
+        .filter((clause) => clause.critical && clause.kind !== "semantic-residual")
+        .map((clause) => clause.id));
+    if (criticalClauseIds.size === 0)
+        return false;
+    return [...criticalClauseIds].every((clauseId) => {
+        const observations = oracle.observations.filter((observation) => observation.solutionId === solutionId &&
+            observation.clauseId === clauseId);
+        return (completeRepetitions(oracle, observations) &&
+            observations.every((observation) => observation.outcome === "pass"));
+    });
+};
+const unstableSolutions = (oracle) => {
+    const unstable = new Set();
+    for (const solution of oracle.solutions) {
+        for (const clause of oracle.clauses.filter((entry) => entry.critical && entry.kind !== "semantic-residual")) {
+            const outcomes = new Set(oracle.observations
+                .filter((observation) => observation.solutionId === solution.id &&
+                observation.clauseId === clause.id)
+                .map((observation) => observation.outcome));
+            if (outcomes.size > 1 || outcomes.has("unknown")) {
+                unstable.add(solution.id);
+            }
+        }
+    }
+    return [...unstable].sort();
+};
+const rejectedByCandidatePolicy = (oracle, solutionId) => oracle.clauses
+    .filter((clause) => clause.critical && clause.kind === "candidate-policy")
+    .some((clause) => {
+    const observations = oracle.observations.filter((observation) => observation.solutionId === solutionId &&
+        observation.clauseId === clause.id);
+    return (completeRepetitions(oracle, observations) &&
+        observations.every((observation) => observation.outcome === "fail"));
+});
+const solutionHasObservedFailure = (oracle, solutionId) => oracle.clauses.some((clause) => clause.critical &&
+    clause.kind !== "semantic-residual" &&
+    oracle.observations.some((observation) => observation.solutionId === solutionId &&
+        observation.clauseId === clause.id &&
+        observation.outcome === "fail"));
+const solutionIsConclusivelyRejected = (oracle, solutionId) => {
+    if (rejectedByCandidatePolicy(oracle, solutionId))
+        return true;
+    if (!solutionHasObservedFailure(oracle, solutionId))
+        return false;
+    return oracle.clauses
+        .filter((clause) => clause.critical && clause.kind !== "semantic-residual")
+        .every((clause) => {
+        const observations = oracle.observations.filter((observation) => observation.solutionId === solutionId && observation.clauseId === clause.id);
+        return (completeRepetitions(oracle, observations) &&
+            !observations.some((observation) => observation.outcome === "unknown") &&
+            new Set(observations.map((observation) => observation.outcome)).size === 1);
+    });
+};
+export function evaluateRepositoryOracleAdequacyV1(oracle) {
+    assertRepositoryHiddenOracleV1(oracle);
+    const valid = oracle.solutions.filter((solution) => solution.expectedClass === "valid");
+    const wrong = oracle.solutions.filter((solution) => solution.expectedClass === "wrong");
+    const falseRejectedSolutionIds = valid
+        .filter((solution) => solutionHasObservedFailure(oracle, solution.id))
+        .map((solution) => solution.id)
+        .sort();
+    const falseAcceptedSolutionIds = wrong
+        .filter((solution) => solutionPasses(oracle, solution.id))
+        .map((solution) => solution.id)
+        .sort();
+    const unstableSolutionIds = unstableSolutions(oracle);
+    const inconclusiveSolutionIds = [
+        ...new Set(oracle.observations
+            .filter((observation) => observation.outcome === "unknown" &&
+            oracle.clauses.some((clause) => clause.id === observation.clauseId &&
+                clause.critical &&
+                clause.kind !== "semantic-residual"))
+            .map((observation) => observation.solutionId))
+    ].sort();
+    const observedClauseIds = new Set(oracle.observations.map((observation) => observation.clauseId));
+    const unobservedClauseIds = oracle.clauses
+        .filter((clause) => clause.critical &&
+        clause.kind !== "semantic-residual" &&
+        !observedClauseIds.has(clause.id))
+        .map((clause) => clause.id)
+        .sort();
+    const insufficientObservationPairs = oracle.solutions.flatMap((solution) => rejectedByCandidatePolicy(oracle, solution.id)
+        ? []
+        : oracle.clauses
+            .filter((clause) => clause.critical && clause.kind !== "semantic-residual")
+            .flatMap((clause) => {
+            const observations = oracle.observations.filter((observation) => observation.solutionId === solution.id &&
+                observation.clauseId === clause.id);
+            return completeRepetitions(oracle, observations)
+                ? []
+                : [`${solution.id}/${clause.id}`];
+        }));
+    const families = [...new Set(wrong.map((solution) => solution.family))].sort();
+    const mutationFamilyKills = families.map((family) => {
+        const members = wrong.filter((solution) => solution.family === family);
+        return {
+            family,
+            killed: members.filter((solution) => solutionIsConclusivelyRejected(oracle, solution.id)).length,
+            total: members.length
+        };
+    });
+    const rejectionReasons = [
+        ...(falseRejectedSolutionIds.length === 0
+            ? []
+            : [
+                `known valid solutions rejected: ${falseRejectedSolutionIds.join(", ")}`
+            ]),
+        ...(falseAcceptedSolutionIds.length === 0
+            ? []
+            : [
+                `plausible wrong solutions accepted: ${falseAcceptedSolutionIds.join(", ")}`
+            ]),
+        ...(unstableSolutionIds.length === 0
+            ? []
+            : [`unstable solution observations: ${unstableSolutionIds.join(", ")}`]),
+        ...(inconclusiveSolutionIds.length === 0
+            ? []
+            : [`inconclusive solution observations: ${inconclusiveSolutionIds.join(", ")}`]),
+        ...(unobservedClauseIds.length === 0
+            ? []
+            : [`critical clauses unobserved: ${unobservedClauseIds.join(", ")}`]),
+        ...(insufficientObservationPairs.length === 0
+            ? []
+            : [
+                `critical solution/clause pairs need repeated observations: ${insufficientObservationPairs.join(", ")}`
+            ]),
+        ...mutationFamilyKills
+            .filter((family) => family.killed !== family.total)
+            .map((family) => `mutation family ${JSON.stringify(family.family)} killed ${String(family.killed)}/${String(family.total)}`)
+    ];
+    return {
+        version: 1,
+        caseId: oracle.caseId,
+        admitted: rejectionReasons.length === 0,
+        validSolutionCount: valid.length,
+        wrongSolutionCount: wrong.length,
+        falseRejectedSolutionIds,
+        falseAcceptedSolutionIds,
+        unstableSolutionIds,
+        unobservedClauseIds,
+        insufficientObservationPairs,
+        mutationFamilyKills,
+        rejectionReasons
+    };
+}
+const normalize = (value) => value
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/\b[0-9a-f]{7,64}\b/gu, "<digest>")
+    .replace(/\b\d+\b/gu, "<number>")
+    .replace(/\s+/gu, " ")
+    .trim();
+export function repositoryBehavioralFingerprintV1(input) {
+    const semantic = {
+        capabilityId: normalize(input.capabilityId),
+        familyId: normalize(input.familyId),
+        behaviorClauses: [...new Set(input.behaviorClauses.map(normalize))].sort(),
+        oracleClauses: input.oracle.clauses
+            .filter((clause) => clause.kind !== "semantic-residual")
+            .map((clause) => ({
+            kind: clause.kind,
+            critical: clause.critical,
+            description: normalize(clause.description)
+        }))
+            .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))
+    };
+    return createHash("sha256").update(JSON.stringify(semantic)).digest("hex");
+}
+export function admitRepositoryBenchmarkCaseV1(input) {
+    const { draft } = input;
+    const seenAxes = new Set(draft.qualityFindings.map((finding) => finding.axis));
+    const missingAxes = [...HARD_FINDING_AXES].filter((axis) => !seenAxes.has(axis));
+    const failed = draft.qualityFindings.filter((finding) => HARD_FINDING_AXES.has(finding.axis) && finding.outcome !== "pass");
+    const evidenceUnlinked = draft.qualityFindings.filter((finding) => HARD_FINDING_AXES.has(finding.axis) &&
+        finding.outcome === "pass" &&
+        (finding.evidenceIds.length === 0 ||
+            finding.evidenceIds.some((evidenceId) => evidenceId.trim().length === 0)));
+    const rejectionReasons = [
+        ...(draft.hidden.caseId === draft.id
+            ? []
+            : ["hidden oracle case id does not match benchmark case"]),
+        ...(draft.visible.id === draft.id
+            ? []
+            : ["visible task id does not match benchmark case"]),
+        ...(draft.visible.lane === draft.lane
+            ? []
+            : ["visible task lane does not match benchmark case"]),
+        ...missingAxes.map((axis) => `missing quality finding: ${axis}`),
+        ...failed.map((finding) => `${finding.axis} ${finding.outcome}: ${finding.detail}`),
+        ...evidenceUnlinked.map((finding) => `${finding.axis} pass is not linked to concrete evidence ids`),
+        ...draft.adequacy.rejectionReasons
+    ];
+    return {
+        ...draft,
+        status: rejectionReasons.length === 0 ? "valid-library" : "rejected",
+        rejectionReasons
+    };
+}
+const QUALITY_GATES = [
+    "authenticity",
+    "specification-sufficiency",
+    "oracle-adequacy",
+    "stability",
+    "distinctness",
+    "leakage",
+    "realism",
+    "triviality",
+    "case-integrity",
+    "deduplication"
+];
+const counts = (values) => [...values.reduce((accumulator, value) => {
+        accumulator.set(value, (accumulator.get(value) ?? 0) + 1);
+        return accumulator;
+    }, new Map())]
+    .sort((left, right) => left[0].localeCompare(right[0]))
+    .map(([id, count]) => ({ id, count }));
+const packageRoot = (path) => {
+    const parts = path.split("/");
+    return parts.length >= 2 &&
+        (parts[0] === "packages" || parts[0] === "apps")
+        ? parts.slice(0, 2).join("/")
+        : undefined;
+};
+export function compileValidatedBenchmarkLibraryV1(cases) {
+    let active = [...cases];
+    const rejectedByPipeline = new Map();
+    const acceptanceFunnel = [];
+    for (const gate of QUALITY_GATES) {
+        const input = active.length;
+        if (gate === "deduplication") {
+            const byFingerprint = new Map();
+            for (const benchmarkCase of active) {
+                const matching = byFingerprint.get(benchmarkCase.behavioralFingerprint) ?? [];
+                matching.push(benchmarkCase);
+                byFingerprint.set(benchmarkCase.behavioralFingerprint, matching);
+            }
+            const duplicateLoserIds = new Set();
+            for (const matching of byFingerprint.values()) {
+                if (matching.length < 2)
+                    continue;
+                const ordered = [...matching].sort((left, right) => left.hidden.knownLimitations.length -
+                    right.hidden.knownLimitations.length ||
+                    left.id.localeCompare(right.id));
+                for (const duplicate of ordered.slice(1)) {
+                    duplicateLoserIds.add(duplicate.id);
+                    rejectedByPipeline.set(duplicate.id, "semantic duplicate behavioral fingerprint");
+                }
+            }
+            active = active.filter((benchmarkCase) => !duplicateLoserIds.has(benchmarkCase.id));
+        }
+        else if (gate === "case-integrity") {
+            const failed = active.filter((benchmarkCase) => benchmarkCase.status !== "valid-library");
+            for (const benchmarkCase of failed) {
+                rejectedByPipeline.set(benchmarkCase.id, "case failed invariant admission");
+            }
+            active = active.filter((benchmarkCase) => benchmarkCase.status === "valid-library");
+        }
+        else {
+            const failed = active.filter((benchmarkCase) => {
+                const quality = benchmarkCase.qualityFindings.find((finding) => finding.axis === gate);
+                return quality === undefined || quality.outcome !== "pass";
+            });
+            for (const benchmarkCase of failed) {
+                rejectedByPipeline.set(benchmarkCase.id, `case failed sequential quality gate ${gate}`);
+            }
+            const failedIds = new Set(failed.map((benchmarkCase) => benchmarkCase.id));
+            active = active.filter((benchmarkCase) => !failedIds.has(benchmarkCase.id));
+        }
+        acceptanceFunnel.push({
+            gate,
+            input,
+            admitted: active.length,
+            rejected: input - active.length
+        });
+    }
+    const acceptedIds = new Set(active.map((benchmarkCase) => benchmarkCase.id));
+    const normalized = cases.map((benchmarkCase) => {
+        if (acceptedIds.has(benchmarkCase.id))
+            return benchmarkCase;
+        const pipelineReason = rejectedByPipeline.get(benchmarkCase.id);
+        if (pipelineReason === undefined ||
+            benchmarkCase.rejectionReasons.includes(pipelineReason)) {
+            return benchmarkCase;
+        }
+        return {
+            ...benchmarkCase,
+            status: "rejected",
+            rejectionReasons: [...benchmarkCase.rejectionReasons, pipelineReason]
+        };
+    });
+    const coverage = {
+        capabilities: counts(active.map((benchmarkCase) => benchmarkCase.capabilityId)),
+        families: counts(active.map((benchmarkCase) => benchmarkCase.familyId)),
+        lanes: counts(active.map((benchmarkCase) => benchmarkCase.lane)),
+        packages: counts(active.flatMap((benchmarkCase) => [
+            ...benchmarkCase.qualityFindings.flatMap((finding) => finding.evidence.flatMap((evidence) => {
+                const root = evidence.path === undefined
+                    ? undefined
+                    : packageRoot(evidence.path);
+                return root === undefined ? [] : [root];
+            })),
+            ...benchmarkCase.hidden.fixtures.flatMap((fixture) => {
+                const root = packageRoot(fixture.testPath);
+                return root === undefined ? [] : [root];
+            })
+        ])),
+        oracleKinds: counts(active.flatMap((benchmarkCase) => benchmarkCase.hidden.clauses.map((clause) => clause.kind))),
+        fixtureKinds: counts(active.flatMap((benchmarkCase) => benchmarkCase.hidden.fixtures.map((fixture) => fixture.kind))),
+        mutationFamilies: counts(active.flatMap((benchmarkCase) => benchmarkCase.hidden.solutions
+            .filter((solution) => solution.expectedClass === "wrong")
+            .map((solution) => solution.family)))
+    };
+    return {
+        version: 1,
+        cases: active,
+        rejectedCaseIds: normalized
+            .filter((benchmarkCase) => benchmarkCase.status === "rejected")
+            .map((benchmarkCase) => benchmarkCase.id)
+            .sort(),
+        acceptanceFunnel,
+        coverage
+    };
+}