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

package/dist/services/case-generation/service.d.ts

@@ -0,0 +1,619 @@
+import { Context, Effect, Layer, Schema } from "effect";
+import { type RepositorySolutionEditSourceV1 } from "../../adapters/repository-solution-edits.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+import type { RepositoryBenchmarkCaseV1, RepositoryCandidateVisibleTaskV1 } from "../../repository-benchmark-protocol.js";
+import type { RepositoryFoundryModelCallV1, RepositoryFoundryModelPlanV1 } from "../../repository-language-model-protocol.js";
+import type { RepositoryOracleCoverageReviewV1 } from "../../repository-oracle-coverage-protocol.js";
+import type { RepositoryHiddenOracleV1, RepositoryOracleAdequacyReportV1, RepositoryOracleObservationV1 } from "../../repository-oracle-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { type RepositoryTrajectoryPolicyV1 as RepositoryTrajectoryPolicy } from "../../repository-trajectory-protocol.js";
+import { type RepositoryModelAuthoredCaseSpecificationV1 } from "../case-authoring/service.js";
+import { RepositoryFoundryLanguageModel, type RepositoryFoundryStructuredGenerationV1 } from "../language-model/service.js";
+import { type RepositoryExecutableSolutionV1 } from "../oracle-builder/service.js";
+import { type RepositoryOracleCoverageWitnessRevisionV1, type RepositoryOracleCoverageWitnessV1 } from "../oracle-coverage-witness/service.js";
+import { type RepositoryTrajectoryPolicyReviewV1, type RepositoryTrajectoryRevisionAttemptV1 } from "../trajectory-policy/service.js";
+declare const FixtureProposal: Schema.Struct<{
+    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 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 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 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 testPath: Schema.String;
+    }>]>>;
+    readonly overlays: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+    }>>;
+    readonly knownLimitations: Schema.$Array<Schema.String>;
+    readonly scopeCoverage: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["covered", "unsupported", "contradictory", "uncertain"]>;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+        readonly detail: Schema.String;
+    }>>>;
+}>;
+export type RepositoryFixtureProposalV1 = typeof FixtureProposal.Type;
+declare const SolutionProposal: Schema.Struct<{
+    readonly solutions: Schema.$Array<Schema.Struct<{
+        readonly fileOverrides: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>>;
+        readonly id: Schema.String;
+        readonly family: Schema.String;
+        readonly kind: Schema.Literals<readonly ["independent-valid", "simplified-valid", "behavior-preserving-valid", "mutation", "model-near-miss", "reward-hacking"]>;
+    }>>;
+}>;
+export type RepositorySolutionProposalV1 = typeof SolutionProposal.Type;
+declare const QualityReview: Schema.Struct<{
+    readonly verdict: Schema.Literals<readonly ["approve", "reject"]>;
+    readonly detail: Schema.String;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly axis: Schema.Literals<readonly ["specification", "oracle", "valid-solution-independence", "development-adversaries", "held-out-adversaries", "trajectory"]>;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail"]>;
+        readonly detail: Schema.String;
+        readonly evidenceIds: Schema.$Array<Schema.String>;
+    }>>;
+    readonly coverageGaps: Schema.$Array<Schema.String>;
+    readonly correlatedAssumptions: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryGenerationQualityReviewV1 = typeof QualityReview.Type;
+declare const SolutionReviewProposal: Schema.Struct<{
+    readonly reviews: Schema.$Array<Schema.Struct<{
+        readonly solutionId: Schema.String;
+        readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+declare const ValidControlIndependenceReview: Schema.Struct<{
+    readonly outcome: Schema.Literals<readonly ["independent", "correlated", "uncertain"]>;
+    readonly detail: Schema.String;
+    readonly implementations: Schema.$Array<Schema.Struct<{
+        readonly solutionId: Schema.String;
+        readonly mechanism: Schema.String;
+        readonly sourcePaths: Schema.$Array<Schema.String>;
+    }>>;
+    readonly correlatedFeatures: Schema.$Array<Schema.Literals<readonly ["renaming-or-formatting", "helper-extraction", "equivalent-control-flow", "same-behavioral-mechanism", "insufficient-evidence"]>>;
+}>;
+export type RepositorySolutionReviewProposalV1 = typeof SolutionReviewProposal.Type & {
+    readonly implementationIndependence?: typeof ValidControlIndependenceReview.Type;
+};
+declare const HillClimbProposal: Schema.Struct<{
+    readonly rationale: Schema.String;
+    readonly targetedFalseAcceptIds: Schema.$Array<Schema.String>;
+    readonly targetedFalseRejectIds: Schema.$Array<Schema.String>;
+    readonly targetedInconclusiveIds: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly fixtureProposal: Schema.Struct<{
+        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 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 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 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 testPath: Schema.String;
+        }>]>>;
+        readonly overlays: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+        }>>;
+        readonly knownLimitations: Schema.$Array<Schema.String>;
+        readonly scopeCoverage: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly scopeId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["covered", "unsupported", "contradictory", "uncertain"]>;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly detail: Schema.String;
+        }>>>;
+    }>;
+}>;
+export type RepositoryHillClimbProposalV1 = typeof HillClimbProposal.Type;
+export type RepositoryHillClimbAttemptV1 = {
+    readonly sequence: number;
+    readonly beforeAdequacy: RepositoryOracleAdequacyReportV1;
+    readonly proposal: RepositoryHillClimbProposalV1;
+    readonly candidateAdequacy?: RepositoryOracleAdequacyReportV1;
+    readonly candidateFixtureProposal?: RepositoryFixtureProposalV1;
+    readonly candidateObservations?: readonly RepositoryOracleObservationV1[];
+    readonly referencePreflight?: {
+        readonly status: "passed" | "rejected";
+        readonly detail?: string;
+        readonly diagnostics?: unknown;
+    };
+    readonly coverageWitnessRevalidation?: {
+        readonly status: "passed" | "rejected";
+        readonly revisions: readonly RepositoryOracleCoverageWitnessRevisionV1[];
+    };
+    readonly decision: "accepted" | "rejected";
+    readonly rejectionReasons: readonly string[];
+    readonly afterAdequacy: RepositoryOracleAdequacyReportV1;
+};
+export type RepositoryGeneratedCaseResultV1 = {
+    readonly version: 1;
+    readonly authored: RepositoryModelAuthoredCaseSpecificationV1;
+    readonly sourceContext?: {
+        readonly initialCommit: string;
+        readonly referenceCommit: string;
+        readonly initialSupportingPaths: readonly string[];
+        readonly referenceSupportingPaths: readonly string[];
+    };
+    readonly initialFixtureProposal: RepositoryFixtureProposalV1;
+    readonly fixtureProposal: RepositoryFixtureProposalV1;
+    readonly oracleCoverageReviews?: readonly {
+        readonly phase: "initial" | "before-freeze";
+        readonly revision: number;
+        readonly review: RepositoryOracleCoverageReviewV1;
+        /** Host evidence resolves fixed hypotheses; the original model verdict is retained. */
+        readonly executionAssessment?: {
+            readonly kind: "resolved-by-execution";
+            readonly witnesses: readonly RepositoryOracleCoverageWitnessV1[];
+        };
+    }[];
+    readonly oracleCoverageWitnessRevisions?: readonly {
+        readonly sequence: number;
+        readonly decision: "accepted" | "rejected";
+        readonly revisions: readonly RepositoryOracleCoverageWitnessRevisionV1[];
+    }[];
+    readonly trajectoryPolicy: RepositoryTrajectoryPolicy;
+    readonly trajectoryPolicyReview: RepositoryTrajectoryPolicyReviewV1;
+    readonly trajectoryRevisionAttempts: readonly RepositoryTrajectoryRevisionAttemptV1[];
+    readonly validSolutionProposal: RepositorySolutionProposalV1;
+    readonly adversaryProposal: RepositorySolutionProposalV1;
+    readonly solutionReviews: readonly [
+        RepositorySolutionReviewProposalV1,
+        RepositorySolutionReviewProposalV1
+    ];
+    readonly heldOutAdversaryProposal: RepositorySolutionProposalV1;
+    readonly heldOutSolutionReviews: readonly [
+        RepositorySolutionReviewProposalV1,
+        RepositorySolutionReviewProposalV1
+    ];
+    readonly heldOutAdequacy: RepositoryOracleAdequacyReportV1;
+    readonly heldOutOracle?: RepositoryHiddenOracleV1;
+    readonly qualityReview: RepositoryGenerationQualityReviewV1;
+    readonly weakAdequacy: RepositoryOracleAdequacyReportV1;
+    readonly hillClimbAttempts: readonly RepositoryHillClimbAttemptV1[];
+    readonly benchmarkCase: RepositoryBenchmarkCaseV1;
+    readonly modelCalls: readonly RepositoryFoundryModelCallV1[];
+};
+export type RepositoryGeneratedCaseCheckpointV1 = {
+    readonly version: 1;
+    readonly kind: "pending-quality-review";
+    readonly validControlReviewVersion?: 2;
+    readonly reviewInputVersion?: 2;
+    readonly specificationContractFactsVersion?: 1;
+    readonly repositoryRoot: string;
+    readonly operationId: string;
+    readonly modelPlan: RepositoryFoundryModelPlanV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly requiresReplayValidation: boolean;
+    readonly generation: Omit<RepositoryGeneratedCaseResultV1, "qualityReview" | "heldOutOracle"> & {
+        readonly heldOutOracle: RepositoryHiddenOracleV1;
+    };
+    readonly qualityReviewInput: Readonly<Record<string, unknown>>;
+    readonly sourceBases: readonly string[];
+};
+/** Bind accepted public facts to the actual final writer and two critic calls. */
+export declare function assertRepositorySpecificationContractFactsEvidenceV1(authored: RepositoryModelAuthoredCaseSpecificationV1): void;
+export type RepositorySemanticReviewRoleV1 = "solution-critic-a" | "solution-critic-b";
+/** Source-only production critic input. Expected labels are never projected here. */
+export type RepositorySemanticReviewInputV1 = {
+    readonly role: RepositorySemanticReviewRoleV1;
+    readonly modelContext: Readonly<Record<string, unknown>>;
+    readonly visible: RepositoryCandidateVisibleTaskV1;
+    readonly targetBehavior: RepositoryTaskSeedV1["targetBehavior"];
+    readonly preChangeSources: readonly {
+        readonly path: string;
+        readonly content: string;
+    }[];
+    readonly solutions: readonly Pick<RepositoryExecutableSolutionV1, "id" | "family" | "fileOverrides">[];
+    /** Generation provenance, not adjudicated correctness labels. */
+    readonly comparisonSolutionIds: readonly string[];
+    readonly validControlReviewVersion?: 1 | 2;
+};
+/**
+ * One preparation boundary for generation, repair, and prospective calibration.
+ * Preserve the legacy packet property order, prompt, and schema when no policy
+ * marker is present; calibration must measure this operation, not a copied prompt.
+ */
+export declare const prepareRepositorySemanticReviewV1: (input: RepositorySemanticReviewInputV1) => {
+    role: RepositorySemanticReviewRoleV1;
+    instructions: string;
+    input: {
+        implementationComparison?: {
+            solutionIds: string[];
+        } | undefined;
+        visible: {
+            readonly lane: "request";
+            readonly id: string;
+            readonly request: {
+                readonly endpoint: "chat" | "responses" | "anthropic";
+                readonly method: "POST";
+                readonly path: string;
+                readonly headers: readonly {
+                    readonly name: string;
+                    readonly value: string;
+                }[];
+                readonly bodyJson: string;
+            };
+        } | {
+            readonly lane: "repository-agent";
+            readonly id: string;
+            readonly requestText: string;
+            readonly checkoutCommit: string;
+            readonly allowedTools: readonly ("test" | "read" | "search" | "edit" | "shell")[];
+            readonly constraints: readonly string[];
+        };
+        targetBehavior: readonly {
+            readonly id: string;
+            readonly description: string;
+            readonly critical: boolean;
+            readonly evidence: readonly {
+                readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+                readonly id: string;
+                readonly path?: string | undefined;
+            }[];
+        }[];
+        preChangeSources: readonly {
+            readonly path: string;
+            readonly content: string;
+        }[];
+        solutions: {
+            id: string;
+            family: string;
+            fileOverrides: readonly import("../../repository-execution-protocol.js").RepositoryCommandFileOverrideV1[] | undefined;
+        }[];
+    };
+    schemaName: string;
+    outputSchema: Schema.Codec<RepositorySolutionReviewProposalV1, RepositorySolutionReviewProposalV1, never, never>;
+    maximumOutputTokens: number;
+};
+export declare const executeRepositorySemanticReviewV1: (input: {
+    readonly modelPlan: RepositoryFoundryModelPlanV1;
+    readonly operationId: string;
+    readonly prepared: ReturnType<typeof prepareRepositorySemanticReviewV1>;
+}) => Effect.Effect<RepositoryFoundryStructuredGenerationV1<RepositorySolutionReviewProposalV1>, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+/** Model-attested coverage and identifier integrity, not proof of assertion semantics. */
+export declare const assertRepositoryFixtureScopeCoverageV1: (proposal: RepositoryFixtureProposalV1, scope: readonly {
+    readonly id: string;
+}[] | undefined) => void;
+type RepositorySolutionGenerationRequestV1 = {
+    readonly plan: RepositoryFoundryModelPlanV1;
+    readonly role: "valid-solution-generator-a" | "valid-solution-generator-b" | "adversary" | "held-out-adversary";
+    readonly operationId: string;
+    readonly instructions: string;
+    readonly input: unknown;
+    readonly schemaName: string;
+    readonly maximumOutputTokens: number;
+};
+export declare const generateRepositorySolutionProposalV1: (input: {
+    readonly request: RepositorySolutionGenerationRequestV1;
+    readonly initialCommit: string;
+    readonly editSources: readonly RepositorySolutionEditSourceV1[];
+    readonly allowedSolutionPaths: ReadonlySet<string>;
+    readonly allowedRewardHackingPaths: ReadonlySet<string>;
+}) => Effect.Effect<{
+    value: {
+        readonly solutions: readonly {
+            readonly fileOverrides: readonly {
+                readonly path: string;
+                readonly content: string;
+            }[];
+            readonly id: string;
+            readonly family: string;
+            readonly kind: "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "mutation" | "model-near-miss" | "reward-hacking";
+        }[];
+    };
+    call: {
+        readonly reasoningEffort: "high" | "medium" | "low" | "xhigh" | "max" | "ultra";
+        readonly role: "oracle-critic" | "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";
+        readonly model: string;
+        readonly operationId: string;
+        readonly callId?: string | undefined;
+    };
+    rawProposal: {
+        readonly solutions: readonly {
+            readonly fileOverrides: readonly ({
+                readonly path: string;
+                readonly content: string;
+            } | {
+                readonly path: string;
+                readonly edits: readonly {
+                    readonly search: string;
+                    readonly replace: string;
+                }[];
+            })[];
+            readonly id: string;
+            readonly family: string;
+            readonly kind: "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "mutation" | "model-near-miss" | "reward-hacking";
+        }[];
+    };
+}, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+/** Eligibility is a necessary population bound; execution must still prove every semantic kill. */
+export declare const assertRepositorySemanticControlPopulationV1: (solutions: readonly RepositoryExecutableSolutionV1[], protectedControlPaths: readonly string[]) => void;
+type RepositoryValidControlPairFindingV1 = {
+    readonly code: string;
+    readonly detail: string;
+};
+export declare const assertIndependentValidSolutionPairV1: (left: readonly RepositoryExecutableSolutionV1[], right: readonly RepositoryExecutableSolutionV1[], preChangeSources: readonly {
+    readonly path: string;
+    readonly content: string;
+}[], validControlReviewVersion?: 1 | 2) => void;
+export declare const assertHeldOutAdversaryNoveltyV1: (development: readonly RepositoryExecutableSolutionV1[], heldOut: readonly RepositoryExecutableSolutionV1[], preChangeSources?: readonly {
+    readonly path: string;
+    readonly content: string;
+}[]) => void;
+export declare const validateRepositoryGenerationQualityReviewV1: (proposal: RepositoryGenerationQualityReviewV1, evidenceInventory: readonly string[]) => void;
+/** Critic prose is private evidence. Only this fixed vocabulary can reach either solver. */
+export declare const repositorySemanticReviewIndependenceFindingsV1: (proposal: RepositorySolutionReviewProposalV1, validSolutions: readonly Pick<RepositoryExecutableSolutionV1, "id" | "fileOverrides">[], reviewer: string, validControlReviewVersion?: 1 | 2, criticInput?: Readonly<Record<string, unknown>>) => readonly RepositoryValidControlPairFindingV1[];
+/**
+ * Allows a fresh oracle proposal for repeated, complete test-body evidence errors.
+ * The original outcomes remain unknown. Mixed outcomes and operational failures
+ * are not admitted to this repair path.
+ */
+export declare const repairableRepositoryFixtureEvidenceV1: (oracle: RepositoryHiddenOracleV1, adequacy: RepositoryOracleAdequacyReportV1) => {
+    solutionId: string;
+    clauseId: string;
+    fixtureIds: readonly string[];
+    observations: RepositoryHiddenOracleV1["observations"];
+}[];
+export type CaseGenerationShape = {
+    readonly reviewSemanticSolutions: (input: Parameters<typeof executeRepositorySemanticReviewV1>[0]) => Effect.Effect<RepositoryFoundryStructuredGenerationV1<RepositorySolutionReviewProposalV1>, RepositoryFoundryError>;
+    readonly generateHistorical: (input: {
+        readonly repositoryRoot: string;
+        readonly operationId: string;
+        readonly caseId: string;
+        readonly requestedDimension?: string;
+        readonly validControlRegenerationSequence?: number;
+        readonly validControlReviewVersion?: 1 | 2;
+        readonly dependencyContextVersion?: 1 | 2;
+        readonly oracleCoverageWitnessVersion?: 1 | 2;
+        readonly oracleCoverageWitnessRepairVersion?: 1;
+        readonly oracleRepairFeedbackVersion?: 1;
+        readonly reviewInputVersion?: 2;
+        readonly specificationContractFactsVersion?: 1;
+        readonly map: RepositoryBehaviorMapV1;
+        readonly seed: RepositoryTaskSeedV1;
+        readonly modelPlan: RepositoryFoundryModelPlanV1;
+        readonly oracleRepetitions?: number;
+        readonly oracleConcurrency?: number;
+        readonly maximumHillClimbAttempts?: number;
+        readonly maximumSpecificationRevisions?: number;
+        readonly maximumOracleCoverageRevisions?: number;
+        readonly maximumFixtureRepairAttempts?: number;
+    }) => Effect.Effect<RepositoryGeneratedCaseResultV1, RepositoryFoundryError>;
+};
+declare const CaseGeneration_base: Context.ServiceClass<CaseGeneration, "@velum-labs/routekit-eval-setup/CaseGeneration", CaseGenerationShape>;
+export declare class CaseGeneration extends CaseGeneration_base {
+}
+export declare const generateHistoricalRepositoryCaseV1: (input: {
+    readonly repositoryRoot: string;
+    readonly operationId: string;
+    readonly caseId: string;
+    readonly requestedDimension?: string;
+    readonly validControlRegenerationSequence?: number;
+    readonly validControlReviewVersion?: 1 | 2;
+    readonly dependencyContextVersion?: 1 | 2;
+    readonly oracleCoverageWitnessVersion?: 1 | 2;
+    readonly oracleCoverageWitnessRepairVersion?: 1;
+    readonly oracleRepairFeedbackVersion?: 1;
+    readonly reviewInputVersion?: 2;
+    readonly specificationContractFactsVersion?: 1;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly modelPlan: RepositoryFoundryModelPlanV1;
+    readonly oracleRepetitions?: number;
+    readonly oracleConcurrency?: number;
+    readonly maximumHillClimbAttempts?: number;
+    readonly maximumSpecificationRevisions?: number;
+    readonly maximumOracleCoverageRevisions?: number;
+    readonly maximumFixtureRepairAttempts?: number;
+}) => Effect.Effect<{
+    qualityReview: {
+        readonly verdict: "approve" | "reject";
+        readonly detail: string;
+        readonly findings: readonly {
+            readonly axis: "oracle" | "specification" | "valid-solution-independence" | "development-adversaries" | "held-out-adversaries" | "trajectory";
+            readonly outcome: "pass" | "fail";
+            readonly detail: string;
+            readonly evidenceIds: readonly string[];
+        }[];
+        readonly coverageGaps: readonly string[];
+        readonly correlatedAssumptions: readonly string[];
+    };
+    modelCalls: {
+        readonly reasoningEffort: "high" | "medium" | "low" | "xhigh" | "max" | "ultra";
+        readonly role: "oracle-critic" | "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";
+        readonly model: string;
+        readonly operationId: string;
+        readonly callId?: string | undefined;
+    }[];
+    version: 1;
+    trajectoryPolicy: RepositoryTrajectoryPolicy;
+    authored: RepositoryModelAuthoredCaseSpecificationV1;
+    benchmarkCase: RepositoryBenchmarkCaseV1;
+    weakAdequacy: RepositoryOracleAdequacyReportV1;
+    fixtureProposal: RepositoryFixtureProposalV1;
+    sourceContext?: {
+        readonly initialCommit: string;
+        readonly referenceCommit: string;
+        readonly initialSupportingPaths: readonly string[];
+        readonly referenceSupportingPaths: readonly string[];
+    };
+    initialFixtureProposal: RepositoryFixtureProposalV1;
+    oracleCoverageReviews?: readonly {
+        readonly phase: "initial" | "before-freeze";
+        readonly revision: number;
+        readonly review: RepositoryOracleCoverageReviewV1;
+        /** Host evidence resolves fixed hypotheses; the original model verdict is retained. */
+        readonly executionAssessment?: {
+            readonly kind: "resolved-by-execution";
+            readonly witnesses: readonly RepositoryOracleCoverageWitnessV1[];
+        };
+    }[];
+    oracleCoverageWitnessRevisions?: readonly {
+        readonly sequence: number;
+        readonly decision: "accepted" | "rejected";
+        readonly revisions: readonly RepositoryOracleCoverageWitnessRevisionV1[];
+    }[];
+    trajectoryPolicyReview: RepositoryTrajectoryPolicyReviewV1;
+    trajectoryRevisionAttempts: readonly RepositoryTrajectoryRevisionAttemptV1[];
+    validSolutionProposal: RepositorySolutionProposalV1;
+    adversaryProposal: RepositorySolutionProposalV1;
+    solutionReviews: readonly [RepositorySolutionReviewProposalV1, RepositorySolutionReviewProposalV1];
+    heldOutAdversaryProposal: RepositorySolutionProposalV1;
+    heldOutSolutionReviews: readonly [RepositorySolutionReviewProposalV1, RepositorySolutionReviewProposalV1];
+    heldOutAdequacy: RepositoryOracleAdequacyReportV1;
+    hillClimbAttempts: readonly RepositoryHillClimbAttemptV1[];
+    heldOutOracle: RepositoryHiddenOracleV1;
+}, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+export declare const reconstructRepositoryGeneratedCaseCheckpointV1: (input: {
+    readonly repositoryRoot: string;
+    readonly operationId: string;
+    readonly caseId: string;
+    readonly requestedDimension?: string;
+    readonly validControlRegenerationSequence?: number;
+    readonly validControlReviewVersion?: 1 | 2;
+    readonly dependencyContextVersion?: 1 | 2;
+    readonly oracleCoverageWitnessVersion?: 1 | 2;
+    readonly oracleCoverageWitnessRepairVersion?: 1;
+    readonly oracleRepairFeedbackVersion?: 1;
+    readonly reviewInputVersion?: 2;
+    readonly specificationContractFactsVersion?: 1;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly modelPlan: RepositoryFoundryModelPlanV1;
+    readonly oracleRepetitions?: number;
+    readonly oracleConcurrency?: number;
+    readonly maximumHillClimbAttempts?: number;
+    readonly maximumSpecificationRevisions?: number;
+    readonly maximumOracleCoverageRevisions?: number;
+    readonly maximumFixtureRepairAttempts?: number;
+}) => Effect.Effect<RepositoryGeneratedCaseCheckpointV1, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+/** Pure sizing of the full frozen review request, including wire wrapping and schema. */
+export declare const prepareRepositoryCaseQualityReviewV1: (input: {
+    readonly checkpoint: Pick<RepositoryGeneratedCaseCheckpointV1, "modelPlan" | "operationId" | "validControlReviewVersion" | "reviewInputVersion" | "qualityReviewInput" | "sourceBases">;
+    readonly operationId?: string;
+    readonly reviewInputVersion?: 2;
+}) => {
+    evidence: import("../../adapters/repository-review-evidence.js").RepositoryReviewEvidenceV1;
+    instructions: string;
+    requestBytes: number;
+    requestByteLimit: number;
+} | {
+    evidence: import("../../adapters/repository-review-evidence.js").RepositoryReviewEvidenceV2;
+    instructions: string;
+    requestBytes: number;
+    requestByteLimit: number;
+};
+export declare const reviewRepositoryGeneratedCaseCheckpointV1: (input: {
+    readonly checkpoint: RepositoryGeneratedCaseCheckpointV1;
+    readonly operationId?: string;
+    readonly reviewInputVersion?: 2;
+}) => Effect.Effect<{
+    qualityReview: {
+        readonly verdict: "approve" | "reject";
+        readonly detail: string;
+        readonly findings: readonly {
+            readonly axis: "oracle" | "specification" | "valid-solution-independence" | "development-adversaries" | "held-out-adversaries" | "trajectory";
+            readonly outcome: "pass" | "fail";
+            readonly detail: string;
+            readonly evidenceIds: readonly string[];
+        }[];
+        readonly coverageGaps: readonly string[];
+        readonly correlatedAssumptions: readonly string[];
+    };
+    modelCalls: {
+        readonly reasoningEffort: "high" | "medium" | "low" | "xhigh" | "max" | "ultra";
+        readonly role: "oracle-critic" | "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";
+        readonly model: string;
+        readonly operationId: string;
+        readonly callId?: string | undefined;
+    }[];
+    version: 1;
+    trajectoryPolicy: RepositoryTrajectoryPolicy;
+    authored: RepositoryModelAuthoredCaseSpecificationV1;
+    benchmarkCase: RepositoryBenchmarkCaseV1;
+    weakAdequacy: RepositoryOracleAdequacyReportV1;
+    fixtureProposal: RepositoryFixtureProposalV1;
+    sourceContext?: {
+        readonly initialCommit: string;
+        readonly referenceCommit: string;
+        readonly initialSupportingPaths: readonly string[];
+        readonly referenceSupportingPaths: readonly string[];
+    };
+    initialFixtureProposal: RepositoryFixtureProposalV1;
+    oracleCoverageReviews?: readonly {
+        readonly phase: "initial" | "before-freeze";
+        readonly revision: number;
+        readonly review: RepositoryOracleCoverageReviewV1;
+        /** Host evidence resolves fixed hypotheses; the original model verdict is retained. */
+        readonly executionAssessment?: {
+            readonly kind: "resolved-by-execution";
+            readonly witnesses: readonly RepositoryOracleCoverageWitnessV1[];
+        };
+    }[];
+    oracleCoverageWitnessRevisions?: readonly {
+        readonly sequence: number;
+        readonly decision: "accepted" | "rejected";
+        readonly revisions: readonly RepositoryOracleCoverageWitnessRevisionV1[];
+    }[];
+    trajectoryPolicyReview: RepositoryTrajectoryPolicyReviewV1;
+    trajectoryRevisionAttempts: readonly RepositoryTrajectoryRevisionAttemptV1[];
+    validSolutionProposal: RepositorySolutionProposalV1;
+    adversaryProposal: RepositorySolutionProposalV1;
+    solutionReviews: readonly [RepositorySolutionReviewProposalV1, RepositorySolutionReviewProposalV1];
+    heldOutAdversaryProposal: RepositorySolutionProposalV1;
+    heldOutSolutionReviews: readonly [RepositorySolutionReviewProposalV1, RepositorySolutionReviewProposalV1];
+    heldOutAdequacy: RepositoryOracleAdequacyReportV1;
+    hillClimbAttempts: readonly RepositoryHillClimbAttemptV1[];
+    heldOutOracle: RepositoryHiddenOracleV1;
+}, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+export declare const makeCaseGeneration: Effect.Effect<CaseGenerationShape, never, RepositoryFoundryLanguageModel>;
+export declare const CaseGenerationLive: Layer.Layer<CaseGeneration, never, RepositoryFoundryLanguageModel>;
+export {};