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

package/dist/repository-language-model-protocol.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+/** Required roles in every v1 plan. Opt-in reviews must not change legacy budgets. */
+export declare const REPOSITORY_FOUNDRY_MODEL_ROLES: readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner"];
+export declare const RepositoryFoundryModelRoleV1: Schema.Literals<readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner", "oracle-critic"]>;
+export type RepositoryFoundryModelRoleV1 = typeof RepositoryFoundryModelRoleV1.Type;
+export declare const RepositoryFoundryReasoningEffortV1: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+export type RepositoryFoundryReasoningEffortV1 = typeof RepositoryFoundryReasoningEffortV1.Type;
+export declare const RepositoryFoundryModelAssignmentV1: Schema.Struct<{
+    readonly role: Schema.Literals<readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner", "oracle-critic"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+}>;
+export type RepositoryFoundryModelAssignmentV1 = typeof RepositoryFoundryModelAssignmentV1.Type;
+export declare const RepositoryFoundryModelPlanV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly assignments: Schema.$Array<Schema.Struct<{
+        readonly role: Schema.Literals<readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner", "oracle-critic"]>;
+        readonly model: Schema.String;
+        readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+    }>>;
+}>;
+export type RepositoryFoundryModelPlanV1 = typeof RepositoryFoundryModelPlanV1.Type;
+export declare const RepositoryFoundryModelCallV1: Schema.Struct<{
+    readonly operationId: Schema.String;
+    readonly role: Schema.Literals<readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner", "oracle-critic"]>;
+    readonly model: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+    readonly callId: Schema.optionalKey<Schema.String>;
+}>;
+export type RepositoryFoundryModelCallV1 = typeof RepositoryFoundryModelCallV1.Type;
+export declare function assertRepositoryFoundryModelPlanV1(value: unknown): asserts value is RepositoryFoundryModelPlanV1;
+export declare function repositoryFoundryModelAssignmentV1(plan: RepositoryFoundryModelPlanV1, role: RepositoryFoundryModelRoleV1): RepositoryFoundryModelAssignmentV1;
+export declare function repositoryFoundryModelPlanV1(input: {
+    readonly primaryModel: string;
+    readonly criticAModel?: string;
+    readonly criticBModel?: string;
+    readonly reviewerModel?: string;
+    readonly oracleCriticModel?: string;
+    readonly primaryReasoningEffort?: RepositoryFoundryReasoningEffortV1;
+    readonly reviewReasoningEffort?: RepositoryFoundryReasoningEffortV1;
+}): RepositoryFoundryModelPlanV1;
+/** Retained for callers with existing GPT-5.6 generation configurations. */
+export declare const gpt56RepositoryFoundryModelPlanV1: typeof repositoryFoundryModelPlanV1;

package/dist/repository-language-model-protocol.js

@@ -0,0 +1,146 @@
+import { assertExplicitEvalModel } from "@velum-labs/routekit-eval-contracts";
+import { Schema } from "effect";
+/** Required roles in every v1 plan. Opt-in reviews must not change legacy budgets. */
+export const REPOSITORY_FOUNDRY_MODEL_ROLES = [
+    "repository-analyst",
+    "specification-writer",
+    "specification-critic-a",
+    "specification-critic-b",
+    "trajectory-designer",
+    "trajectory-critic",
+    "oracle-designer",
+    "valid-solution-generator-a",
+    "valid-solution-generator-b",
+    "adversary",
+    "solution-critic-a",
+    "solution-critic-b",
+    "held-out-adversary",
+    "held-out-solution-critic-a",
+    "held-out-solution-critic-b",
+    "quality-reviewer",
+    "hill-climb-planner"
+];
+export const RepositoryFoundryModelRoleV1 = Schema.Literals([
+    ...REPOSITORY_FOUNDRY_MODEL_ROLES,
+    "oracle-critic"
+]);
+export const RepositoryFoundryReasoningEffortV1 = Schema.Literals([
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+    "ultra"
+]);
+export const RepositoryFoundryModelAssignmentV1 = Schema.Struct({
+    role: RepositoryFoundryModelRoleV1,
+    model: Schema.String,
+    reasoningEffort: RepositoryFoundryReasoningEffortV1
+});
+export const RepositoryFoundryModelPlanV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    assignments: Schema.Array(RepositoryFoundryModelAssignmentV1)
+});
+export const RepositoryFoundryModelCallV1 = Schema.Struct({
+    operationId: Schema.String,
+    role: RepositoryFoundryModelRoleV1,
+    model: Schema.String,
+    reasoningEffort: RepositoryFoundryReasoningEffortV1,
+    callId: Schema.optionalKey(Schema.String)
+});
+const FORBIDDEN_MODEL_ALIASES = new Set(["auto", "default", "router"]);
+const PRIMARY_REASONING_ROLES = new Set([
+    "repository-analyst",
+    "specification-writer",
+    "trajectory-designer",
+    "oracle-designer",
+    "valid-solution-generator-a",
+    "valid-solution-generator-b",
+    "adversary",
+    "held-out-adversary",
+    "hill-climb-planner"
+]);
+export function assertRepositoryFoundryModelPlanV1(value) {
+    const plan = Schema.decodeUnknownSync(RepositoryFoundryModelPlanV1)(value);
+    const byRole = new Map(plan.assignments.map((assignment) => [assignment.role, assignment]));
+    if (plan.assignments.length < REPOSITORY_FOUNDRY_MODEL_ROLES.length ||
+        plan.assignments.length > REPOSITORY_FOUNDRY_MODEL_ROLES.length + 1 ||
+        byRole.size !== plan.assignments.length ||
+        REPOSITORY_FOUNDRY_MODEL_ROLES.some((role) => !byRole.has(role))) {
+        throw new Error("repository foundry model plan requires exactly one assignment for every generation role");
+    }
+    for (const assignment of plan.assignments) {
+        assertExplicitEvalModel(assignment.model, "author");
+        if (assignment.model
+            .toLowerCase()
+            .split("/")
+            .some((segment) => FORBIDDEN_MODEL_ALIASES.has(segment))) {
+            throw new Error(`repository foundry role ${assignment.role} must use a concrete provider/model id, not alias ${JSON.stringify(assignment.model)}`);
+        }
+        if (PRIMARY_REASONING_ROLES.has(assignment.role) &&
+            (assignment.reasoningEffort === "low" || assignment.reasoningEffort === "medium")) {
+            throw new Error(`repository foundry primary reasoning role ${assignment.role} requires high or stronger reasoning`);
+        }
+    }
+}
+export function repositoryFoundryModelAssignmentV1(plan, role) {
+    assertRepositoryFoundryModelPlanV1(plan);
+    const assignment = plan.assignments.find((candidate) => candidate.role === role);
+    if (assignment === undefined) {
+        throw new Error(`repository foundry model role is unassigned: ${role}`);
+    }
+    return assignment;
+}
+export function repositoryFoundryModelPlanV1(input) {
+    const primaryReasoningEffort = input.primaryReasoningEffort ?? "high";
+    const reviewReasoningEffort = input.reviewReasoningEffort ?? "high";
+    const modelFor = (role) => {
+        if (role === "specification-critic-a" ||
+            role === "solution-critic-a" ||
+            role === "held-out-solution-critic-a") {
+            return input.criticAModel ?? input.primaryModel;
+        }
+        if (role === "specification-critic-b" ||
+            role === "trajectory-critic" ||
+            role === "solution-critic-b" ||
+            role === "held-out-solution-critic-b") {
+            return input.criticBModel ?? input.primaryModel;
+        }
+        if (role === "quality-reviewer") {
+            return input.reviewerModel ?? input.primaryModel;
+        }
+        return input.primaryModel;
+    };
+    const plan = {
+        version: 1,
+        assignments: [
+            ...REPOSITORY_FOUNDRY_MODEL_ROLES.map((role) => ({
+                role,
+                model: modelFor(role),
+                reasoningEffort: role === "specification-critic-a" ||
+                    role === "specification-critic-b" ||
+                    role === "trajectory-critic" ||
+                    role === "solution-critic-a" ||
+                    role === "solution-critic-b" ||
+                    role === "held-out-solution-critic-a" ||
+                    role === "held-out-solution-critic-b" ||
+                    role === "quality-reviewer"
+                    ? reviewReasoningEffort
+                    : primaryReasoningEffort
+            })),
+            ...(input.oracleCriticModel === undefined
+                ? []
+                : [
+                    {
+                        role: "oracle-critic",
+                        model: input.oracleCriticModel,
+                        reasoningEffort: reviewReasoningEffort
+                    }
+                ])
+        ]
+    };
+    assertRepositoryFoundryModelPlanV1(plan);
+    return plan;
+}
+/** Retained for callers with existing GPT-5.6 generation configurations. */
+export const gpt56RepositoryFoundryModelPlanV1 = repositoryFoundryModelPlanV1;

package/dist/repository-oracle-coverage-protocol.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+import type { RepositoryHiddenFixtureSuiteV1 } from "./repository-fixture-protocol.js";
+export declare const RepositoryOracleCoverageReviewV1: Schema.Struct<{
+    readonly verdict: Schema.Literals<readonly ["approve", "revise"]>;
+    readonly detail: Schema.String;
+    readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["covered", "gap", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly counterexample: Schema.String;
+        readonly assertionEvidence: Schema.$Array<Schema.Struct<{
+            readonly fixtureId: Schema.String;
+            readonly excerpt: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type RepositoryOracleCoverageReviewV1 = typeof RepositoryOracleCoverageReviewV1.Type;
+export declare function assertRepositoryOracleCoverageReviewV1(review: RepositoryOracleCoverageReviewV1, scopeIds: readonly string[], suite: RepositoryHiddenFixtureSuiteV1): void;

package/dist/repository-oracle-coverage-protocol.js

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+import { RepositoryFoundryError } from "./errors.js";
+export const RepositoryOracleCoverageReviewV1 = Schema.Struct({
+    verdict: Schema.Literals(["approve", "revise"]),
+    detail: Schema.String,
+    scopeCoverage: Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        outcome: Schema.Literals(["covered", "gap", "uncertain"]),
+        detail: Schema.String,
+        counterexample: Schema.String,
+        assertionEvidence: Schema.Array(Schema.Struct({ fixtureId: Schema.String, excerpt: Schema.String }))
+    }))
+});
+export function assertRepositoryOracleCoverageReviewV1(review, scopeIds, suite) {
+    const expected = new Set(scopeIds);
+    const ids = review.scopeCoverage.map((entry) => entry.scopeId);
+    const covered = review.scopeCoverage.every((entry) => entry.outcome === "covered");
+    if (expected.size === 0 ||
+        expected.size !== scopeIds.length ||
+        review.detail.trim().length === 0 ||
+        ids.length !== expected.size ||
+        new Set(ids).size !== ids.length ||
+        ids.some((id) => !expected.has(id)) ||
+        (review.verdict === "approve") !== covered ||
+        review.scopeCoverage.some((entry) => entry.detail.trim().length === 0 ||
+            (entry.outcome === "covered"
+                ? entry.counterexample.trim().length !== 0 || entry.assertionEvidence.length === 0
+                : entry.counterexample.trim().length === 0) ||
+            entry.assertionEvidence.some((evidence) => evidence.excerpt.trim().length < 8 ||
+                evidence.excerpt.length > 5000 ||
+                !suite.fixtures.some((fixture) => fixture.id === evidence.fixtureId) ||
+                !suite.overlays.some((overlay) => overlay.fixtureIds.includes(evidence.fixtureId) &&
+                    overlay.content.includes(evidence.excerpt))))) {
+        throw new RepositoryFoundryError({
+            operation: "compile-reviewed-case",
+            detail: "oracle coverage review must assess every frozen scope clause with concrete current assertion evidence or an actionable counterexample"
+        });
+    }
+}

package/dist/repository-oracle-execution-binding.d.ts

@@ -0,0 +1,27 @@
+import type { RepositoryExecutableSolutionV1, RepositoryHistoricalOracleInputV1 } from "./repository-execution-protocol.js";
+/**
+ * Scientific execution identity, shared by fresh execution, continuation and
+ * archived reconstruction. Scheduling, cache objects and callbacks are not
+ * executable inputs. Patch bodies are: public solution metadata cannot bind them.
+ */
+export declare const repositoryOracleExecutionBindingV1: (input: RepositoryHistoricalOracleInputV1) => {
+    executionBindingDigest: string;
+    solutions: RepositoryExecutableSolutionV1[];
+    solutionMetadata: {
+        id: string;
+        kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+        family: string;
+        expectedClass: "valid" | "wrong";
+        commit: string;
+    }[];
+    hiddenTestOverlays: {
+        path: string;
+        sourceCommit: string;
+    }[];
+    protectedControlOverlays: {
+        path: string;
+        sourceCommit: string;
+    }[];
+    structuralClauses: readonly import("./repository-execution-protocol.js").RepositoryStructuralOracleClauseV1[];
+    repetitions: number;
+};

package/dist/repository-oracle-execution-binding.js

@@ -0,0 +1,59 @@
+import { pipelineDigestV2 } from "./case-pipeline-protocol-v2.js";
+/**
+ * Scientific execution identity, shared by fresh execution, continuation and
+ * archived reconstruction. Scheduling, cache objects and callbacks are not
+ * executable inputs. Patch bodies are: public solution metadata cannot bind them.
+ */
+export const repositoryOracleExecutionBindingV1 = (input) => {
+    const referenceCommit = input.seed.referenceCommit;
+    if (referenceCommit === undefined)
+        throw new Error("historical oracle execution binding requires a reference commit");
+    const solutions = [
+        {
+            id: "historical-reference",
+            kind: "historical-reference",
+            family: "reference",
+            expectedClass: "valid",
+            commit: referenceCommit
+        },
+        {
+            id: "historical-defect",
+            kind: "historical-defect",
+            family: "historical-defect",
+            expectedClass: "wrong",
+            commit: input.seed.initialState.commit
+        },
+        ...input.additionalSolutions
+    ];
+    const hiddenTestOverlays = input.seed.capabilityEvidence
+        .filter((evidence) => evidence.kind === "test" && evidence.path !== undefined)
+        .map((evidence) => ({ path: evidence.path, sourceCommit: referenceCommit }));
+    const protectedControlOverlays = input.seed.environment.protectedControlPaths.map((path) => ({
+        path,
+        sourceCommit: referenceCommit
+    }));
+    const structuralClauses = input.structuralClauses ?? [];
+    const repetitions = Math.max(1, Math.min(input.repetitions ?? 2, 5));
+    const executionBindingDigest = pipelineDigestV2({
+        version: 1,
+        caseId: input.caseId,
+        environment: input.seed.environment,
+        hiddenTestOverlays,
+        protectedControlOverlays,
+        hiddenFixtureSuite: input.hiddenFixtureSuite ?? null,
+        structuralClauses,
+        solutions,
+        repetitions
+    });
+    return {
+        executionBindingDigest,
+        solutions,
+        solutionMetadata: solutions.map(({ id, kind, family, expectedClass, commit }) => ({
+            id, kind, family, expectedClass, commit
+        })),
+        hiddenTestOverlays,
+        protectedControlOverlays,
+        structuralClauses,
+        repetitions
+    };
+};

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

@@ -0,0 +1,230 @@
+import { Schema } from "effect";
+export declare const RepositoryOracleClauseV1: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"candidate-policy">;
+    readonly policyId: Schema.String;
+    readonly forbiddenPaths: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"test-command">;
+    readonly recipeId: Schema.String;
+    readonly expectedExitCode: Schema.Finite;
+    readonly fixtureIds: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"json-field">;
+    readonly pointer: Schema.String;
+    readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+    readonly expectedJson: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"ordered-events">;
+    readonly eventTypes: Schema.$Array<Schema.String>;
+    readonly terminalEvent: Schema.optionalKey<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"property">;
+    readonly propertyId: Schema.String;
+    readonly fixtureIds: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"differential">;
+    readonly implementationIds: Schema.$Array<Schema.String>;
+    readonly fixtureIds: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"architecture">;
+    readonly ruleId: Schema.String;
+    readonly expectedPaths: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"transformation-completeness">;
+    readonly ruleId: Schema.String;
+    readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+    readonly requiredNewPaths: Schema.$Array<Schema.String>;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"semantic-residual">;
+    readonly criterion: Schema.String;
+    readonly id: Schema.String;
+    readonly critical: Schema.Boolean;
+    readonly description: Schema.String;
+}>]>;
+export type RepositoryOracleClauseV1 = typeof RepositoryOracleClauseV1.Type;
+export declare const RepositoryReferenceSolutionV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+    readonly family: Schema.String;
+    readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    readonly commit: Schema.optionalKey<Schema.String>;
+}>;
+export type RepositoryReferenceSolutionV1 = typeof RepositoryReferenceSolutionV1.Type;
+export declare const RepositoryOracleObservationV1: Schema.Struct<{
+    readonly solutionId: Schema.String;
+    readonly clauseId: Schema.String;
+    readonly repetition: Schema.Finite;
+    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+    readonly detail: Schema.String;
+    readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+}>;
+export type RepositoryOracleObservationV1 = typeof RepositoryOracleObservationV1.Type;
+export declare const RepositoryHiddenOracleV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+    /** Host binding includes executable patches and environment, not only public solution metadata. */
+    readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+    /** Planned repetition count, including repetitions not yet present in a continuation. */
+    readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+    readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"historical-regression">;
+        readonly expectationMode: Schema.Literal<"changes">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"boundary">;
+        readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"counterfactual">;
+        readonly expectationMode: Schema.Literal<"changes">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"metamorphic">;
+        readonly expectationMode: Schema.Literal<"preserved">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>]>>;
+    readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"candidate-policy">;
+        readonly policyId: Schema.String;
+        readonly forbiddenPaths: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"test-command">;
+        readonly recipeId: Schema.String;
+        readonly expectedExitCode: Schema.Finite;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"json-field">;
+        readonly pointer: Schema.String;
+        readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+        readonly expectedJson: Schema.optionalKey<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ordered-events">;
+        readonly eventTypes: Schema.$Array<Schema.String>;
+        readonly terminalEvent: Schema.optionalKey<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"property">;
+        readonly propertyId: Schema.String;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"differential">;
+        readonly implementationIds: Schema.$Array<Schema.String>;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"architecture">;
+        readonly ruleId: Schema.String;
+        readonly expectedPaths: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"transformation-completeness">;
+        readonly ruleId: Schema.String;
+        readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+        readonly requiredNewPaths: Schema.$Array<Schema.String>;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"semantic-residual">;
+        readonly criterion: Schema.String;
+        readonly id: Schema.String;
+        readonly critical: Schema.Boolean;
+        readonly description: Schema.String;
+    }>]>>;
+    readonly solutions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        readonly commit: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly observations: Schema.$Array<Schema.Struct<{
+        readonly solutionId: Schema.String;
+        readonly clauseId: Schema.String;
+        readonly repetition: Schema.Finite;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+        readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+    }>>;
+    readonly knownLimitations: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryHiddenOracleV1 = typeof RepositoryHiddenOracleV1.Type;
+export declare const RepositoryOracleAdequacyReportV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly admitted: Schema.Boolean;
+    readonly validSolutionCount: Schema.Finite;
+    readonly wrongSolutionCount: Schema.Finite;
+    readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+    readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+    readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+    readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+    readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+    readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+        readonly family: Schema.String;
+        readonly killed: Schema.Finite;
+        readonly total: Schema.Finite;
+    }>>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryOracleAdequacyReportV1 = typeof RepositoryOracleAdequacyReportV1.Type;
+export declare function assertRepositoryHiddenOracleV1(value: unknown): asserts value is RepositoryHiddenOracleV1;