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

package/dist/services/case-generation/service.js

@@ -0,0 +1,2628 @@
+import { Context, Effect, Layer, Option, Schema } from "effect";
+import { evalAuthoringRequestByteLimit, evalAuthoringResponsesRequestBody } from "../../adapters/authoring-responses-request.js";
+import { captureGitTreeSnapshotV1, readGitTreeFileV1 } from "../../adapters/git-task-history.js";
+import { readRepositoryLocalImportsV1 } from "../../adapters/repository-import-context.js";
+import { encodeRepositoryReviewEvidenceV1, encodeRepositoryReviewEvidenceV2, REPOSITORY_REVIEW_EVIDENCE_INSTRUCTIONS, REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS } from "../../adapters/repository-review-evidence.js";
+import { loadPinnedSolutionEditSourcesV1, materializeSolutionFileOverridesV1, RepositorySolutionFileOutputV1 } from "../../adapters/repository-solution-edits.js";
+import { strictAuthoringSchema } from "../../adapters/strict-authoring-schema.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { REPOSITORY_FIXTURE_EVIDENCE_INSTRUCTIONS, repositoryFixtureAuthoringInstructionsV1 } from "../../repository-fixture-instructions.js";
+import { REPOSITORY_FOUNDRY_REQUEST_INPUT_CEILING, REPOSITORY_FOUNDRY_VALID_SOLUTION_REPAIR_ATTEMPTS, repositoryFoundryRoleOutputCeilingV1 } from "../../repository-foundry-plan-protocol.js";
+import { repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { evaluateRepositoryOracleAdequacyV1 } from "../../repository-quality-policy.js";
+import { parseRepositorySpecificationContractFactsPacketV1, RepositorySpecificationContractFactReviewV1 } from "../../repository-specification-contract-facts-protocol.js";
+import { authorRepositoryCaseSpecificationV1 } from "../case-authoring/service.js";
+import { RepositoryFoundryEvidenceReconstruction } from "../evidence-reconstruction/service.js";
+import { validateRepositoryFixturesV1 } from "../fixture-validation/service.js";
+import { reportFoundryAuthoringArtifactV1, reportFoundryStageV1 } from "../foundry-progress/service.js";
+import { compileReviewedHistoricalCaseV1 } from "../historical-case/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+import { buildHistoricalHiddenOracleV1 } from "../oracle-builder/service.js";
+import { reviewRepositoryOracleCoverageV1 } from "../oracle-coverage/service.js";
+import { resolveRepositoryOracleCoverageWitnessesV1, validateRepositoryOracleCoverageWitnessRevisionsV1 } from "../oracle-coverage-witness/service.js";
+import { deriveRepositoryTaskFamiliesV1 } from "../task-family/service.js";
+import { authorReviewedRepositoryTrajectoryPolicyV1 } from "../trajectory-policy/service.js";
+const FixtureProposalBase = {
+    id: Schema.String,
+    description: Schema.String,
+    expectedBehavior: Schema.String,
+    testPath: Schema.String
+};
+const FixtureProposal = Schema.Struct({
+    fixtures: Schema.Array(Schema.Union([
+        Schema.Struct({
+            ...FixtureProposalBase,
+            kind: Schema.Literal("historical-regression"),
+            expectationMode: Schema.Literal("changes")
+        }),
+        Schema.Struct({
+            ...FixtureProposalBase,
+            kind: Schema.Literal("boundary"),
+            expectationMode: Schema.Literals(["changes", "preserved"])
+        }),
+        Schema.Struct({
+            ...FixtureProposalBase,
+            kind: Schema.Literal("counterfactual"),
+            expectationMode: Schema.Literal("changes")
+        }),
+        Schema.Struct({
+            ...FixtureProposalBase,
+            kind: Schema.Literal("metamorphic"),
+            expectationMode: Schema.Literal("preserved")
+        })
+    ])),
+    overlays: Schema.Array(Schema.Struct({
+        path: Schema.String,
+        content: Schema.String,
+        fixtureIds: Schema.Array(Schema.String)
+    })),
+    knownLimitations: Schema.Array(Schema.String),
+    scopeCoverage: Schema.optionalKey(Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        outcome: Schema.Literals(["covered", "unsupported", "contradictory", "uncertain"]),
+        fixtureIds: Schema.Array(Schema.String),
+        detail: Schema.String
+    })))
+});
+const SolutionIdentity = {
+    id: Schema.String,
+    family: Schema.String,
+    kind: Schema.Literals([
+        "independent-valid",
+        "simplified-valid",
+        "behavior-preserving-valid",
+        "mutation",
+        "model-near-miss",
+        "reward-hacking"
+    ])
+};
+const SolutionProposal = Schema.Struct({
+    solutions: Schema.Array(Schema.Struct({
+        ...SolutionIdentity,
+        fileOverrides: Schema.Array(Schema.Struct({ path: Schema.String, content: Schema.String }))
+    }))
+});
+const SolutionOutputProposal = Schema.Struct({
+    solutions: Schema.Array(Schema.Struct({
+        ...SolutionIdentity,
+        fileOverrides: Schema.Array(RepositorySolutionFileOutputV1)
+    }))
+});
+const QualityReview = Schema.Struct({
+    verdict: Schema.Literals(["approve", "reject"]),
+    detail: Schema.String,
+    findings: Schema.Array(Schema.Struct({
+        axis: Schema.Literals([
+            "specification",
+            "oracle",
+            "valid-solution-independence",
+            "development-adversaries",
+            "held-out-adversaries",
+            "trajectory"
+        ]),
+        outcome: Schema.Literals(["pass", "fail"]),
+        detail: Schema.String,
+        evidenceIds: Schema.Array(Schema.String)
+    })),
+    coverageGaps: Schema.Array(Schema.String),
+    correlatedAssumptions: Schema.Array(Schema.String)
+});
+const SolutionReviewProposal = Schema.Struct({
+    reviews: Schema.Array(Schema.Struct({
+        solutionId: Schema.String,
+        classification: Schema.Literals(["valid", "wrong", "uncertain"]),
+        detail: Schema.String,
+        violatedBehaviorIds: Schema.Array(Schema.String)
+    }))
+});
+const ValidControlIndependenceReview = Schema.Struct({
+    outcome: Schema.Literals(["independent", "correlated", "uncertain"]),
+    detail: Schema.String,
+    implementations: Schema.Array(Schema.Struct({
+        solutionId: Schema.String,
+        mechanism: Schema.String,
+        sourcePaths: Schema.Array(Schema.String)
+    })),
+    correlatedFeatures: Schema.Array(Schema.Literals([
+        "renaming-or-formatting",
+        "helper-extraction",
+        "equivalent-control-flow",
+        "same-behavioral-mechanism",
+        "insufficient-evidence"
+    ]))
+});
+const SolutionReviewWithIndependenceProposal = Schema.Struct({
+    ...SolutionReviewProposal.fields,
+    implementationIndependence: ValidControlIndependenceReview
+});
+const HillClimbProposal = Schema.Struct({
+    rationale: Schema.String,
+    targetedFalseAcceptIds: Schema.Array(Schema.String),
+    targetedFalseRejectIds: Schema.Array(Schema.String),
+    targetedInconclusiveIds: Schema.optionalKey(Schema.Array(Schema.String)),
+    fixtureProposal: FixtureProposal
+});
+/** Bind accepted public facts to the actual final writer and two critic calls. */
+export function assertRepositorySpecificationContractFactsEvidenceV1(authored) {
+    const facts = authored.contractFacts;
+    const grounding = authored.referenceGrounding;
+    const finalRevision = authored.specificationRevisions?.at(-1);
+    if (facts?.version !== 1 ||
+        facts.independentlyReviewed !== true ||
+        grounding === undefined ||
+        authored.reviews.length !== 2 ||
+        facts.reviewerOperationIds.length !== 2 ||
+        new Set(facts.reviewerOperationIds).size !== 2 ||
+        finalRevision === undefined ||
+        finalRevision.contractFactsDigest !== facts.packet.digest ||
+        JSON.stringify(finalRevision.visible) !== JSON.stringify(authored.visible) ||
+        JSON.stringify(finalRevision.reviews) !== JSON.stringify(authored.reviews))
+        throw failure("contract facts require the accepted packet and exact final specification reviews");
+    const packet = parseRepositorySpecificationContractFactsPacketV1(facts.packet, grounding.scope);
+    for (const [index, review] of authored.reviews.entries()) {
+        if (review.reviewerId !== facts.reviewerOperationIds[index] ||
+            review.independentlyProduced !== true ||
+            review.verdict !== "sufficient" ||
+            review.findings.some((finding) => finding.severity === "blocker") ||
+            review.reviewerKind !== (index === 0 ? "independent-solver" : "model-critic") ||
+            authored.modelCalls.filter((call) => call.operationId === review.reviewerId &&
+                call.role === (index === 0 ? "specification-critic-a" : "specification-critic-b")).length !== 1)
+            throw failure("contract facts require two distinct successful final critic calls");
+        const checked = Schema.decodeUnknownSync(RepositorySpecificationContractFactReviewV1)(review.contractFactReview);
+        if (checked.packetDigest !== packet.digest ||
+            checked.clarificationRequests.length !== 0 ||
+            checked.scopeChecks.length !== grounding.scope.clauses.length ||
+            new Set(checked.scopeChecks.map((check) => check.scopeId)).size !== checked.scopeChecks.length ||
+            grounding.scope.clauses.some((scope) => {
+                const check = checked.scopeChecks.find((entry) => entry.scopeId === scope.id);
+                const expectedFacts = packet.facts.filter((fact) => fact.scopeId === scope.id);
+                return check === undefined ||
+                    check.outcome !== "complete" ||
+                    check.factIds.length !== expectedFacts.length ||
+                    new Set(check.factIds).size !== check.factIds.length ||
+                    expectedFacts.some((fact) => !check.factIds.includes(fact.id));
+            }))
+            throw failure("final contract-fact critics must approve the exact complete packet and scope");
+    }
+}
+const ORACLE_INSTRUCTIONS = `You are the hidden-oracle designer in a repository coding benchmark foundry.
+Use the authentic behavior delta, pre-change and reference evidence, and historical tests to create a stronger
+hidden executable test suite. Cover every critical behavior, at least one boundary, and at least one
+counterfactual or metamorphic invariant. Produce exactly one complete replacement-file overlay for each fixture,
+and bind that overlay to only that fixture id. Multiple fixture overlays may target the same reviewed test path
+because RouteKit executes each overlay in an independent clean checkout. Each isolated overlay must run with the
+repository's declared grade command and must cover a coherent, accurately named user-observable behavior area.
+Several related scope clauses may share one fixture when its description, expected behavior, and expectation
+mode faithfully describe all of them. Retain the imports and setup needed for that area.
+A counterfactual fixture must use expectationMode "changes". A
+metamorphic fixture must vary an input or context while preserving a named user-observable invariant and must
+use expectationMode "preserved". A historical-regression fixture must use expectationMode "changes". Do not
+prescribe the historical implementation and do not weaken existing historical coverage. Return only the
+requested structured object. Treat repositoryEnvironment as the pinned dependency and toolchain context.
+Use APIs supported by those versions and demonstrated in the supplied repository sources; do not assume an
+API from a different major version exists. Each generated overlay must compile and execute unchanged against
+the supplied correct reference before it can enter the solution tournament.
+When behavioralScope is supplied, return exactly one scopeCoverage record for every supplied scope id.
+Mark covered only when the named existing fixtureIds actually assert the complete clause, including eligibility
+and preservation boundaries. Explain that executable coverage in detail. Use unsupported, contradictory, or
+uncertain when faithful coverage cannot be provided; those outcomes stop generation. Never omit a mandatory
+behavior merely to make the reference pass. knownLimitations may describe only remaining nonmandatory limits;
+it cannot excuse any omitted, unsupported, contradictory, or uncertain required scope clause.
+
+${REPOSITORY_FIXTURE_EVIDENCE_INSTRUCTIONS}`;
+const EXACT_EDIT_INSTRUCTIONS = `For existing files, return fileOverrides entries as {path, edits:[{search, replace}]}.
+Each search must be nonempty verbatim text that occurs exactly once in the supplied pre-change excerpt and full
+original file. Include enough unchanged context to make it unique. Every edit in one solution is relative to the
+same ORIGINAL pre-change source, including repair turns; edits must not overlap or depend on another edit's output.
+An empty replace deletes the matched text. Insertions must replace a nonempty unique anchor while retaining it.
+The host applies edits to the full pinned pre-change file and preserves every untouched byte, including unseen
+suffixes beyond truncated excerpts. Do not reproduce unchanged files, truncation markers, or entire large files.
+Legacy {path, content} entries remain supported for complete small replacements; prefer compact exact edits.
+Use only the existing supplied path allowlists; never invent a path, base revision, hidden test, or reference source.`;
+const VALID_SOLUTION_A_INSTRUCTIONS = `You are independent solver A in a repository coding benchmark foundry.
+Solve the visible task using only the pre-change source excerpts. Produce exactly one behaviorally valid
+implementation as exact edits to the supplied pre-change sources. Prefer the simplest direct design justified by the visible
+contract and classify it as independent-valid or simplified-valid. Do not modify tests, inspect hidden tests,
+copy a historical patch, speculate about another solver, or include prose outside the structured object.
+The family field names your implementation mechanism, not the task, requested dimension, capability, or solution
+identifier. Describe the concrete approach accurately; a family label is not evidence of source diversity.`;
+const VALID_SOLUTION_B_INSTRUCTIONS = `You are independent solver B in a repository coding benchmark foundry.
+Solve the visible task from scratch using only the pre-change source excerpts. Produce exactly one behaviorally
+valid implementation as exact edits to the supplied pre-change sources. Preserve the repository's public architecture and classify
+the result as behavior-preserving-valid. Seek a design materially different from an obvious minimal patch, but
+do not modify tests, inspect hidden tests, copy a historical patch, speculate about another solver, or include
+prose outside the structured object. You are not shown solver A's proposal and must not assume its contents.
+The family field names your implementation mechanism, not the task, requested dimension, capability, or solution
+identifier. Describe the concrete approach accurately; a family label is not evidence of source diversity.`;
+const VALID_SOLUTION_B_MECHANISM_INSTRUCTIONS = `Your implementation is also used to detect tests that
+accidentally enforce one particular correct design. Choose a substantively different mechanism for the changed
+behavior from an obvious direct fix. For example, consider whether the visible contract permits a different
+data representation, computation, state transition, or parsing strategy. A helper extraction, reordered or
+negated guards, renamed variables, or another spelling of the same Boolean condition is not an independent
+mechanism. Keep the change scoped to the task; shared unchanged integration code is expected and does not
+require unrelated rewrites. Explain the actual mechanism accurately in the family field. You still receive
+only the visible task, pre-change context, and your own proposal on repair turns.`;
+const VALID_SOLUTION_B_BEHAVIORAL_INSTRUCTIONS = `You are independent solver B in a repository coding benchmark foundry.
+Solve the visible task from scratch using only the pre-change source excerpts. Produce exactly one behaviorally
+valid implementation as exact edits to the supplied pre-change sources and classify it as behavior-preserving-valid.
+Your implementation will test whether the oracle accepts correct alternatives. Where the contract permits it,
+use a natural equivalent formulation, representation, or implementation approach. A narrow fix may have one
+natural mechanism; do not introduce unrelated refactoring or invent a new algorithm to satisfy a diversity label.
+Preserve all visible behavior and public integration constraints. Do not modify tests, inspect hidden tests,
+copy a historical patch, or speculate about another solver. You are not shown solver A's proposal.
+Describe the actual implementation mechanism accurately in the family field. Return only the structured object.`;
+const VALID_SOLUTION_REPAIR_INSTRUCTIONS = `This is a bounded independent-solver repair turn. You receive only
+your own previous proposal and criticism grounded in the visible task and pre-change repository context. Produce
+one complete solution proposal with exact edits against the ORIGINAL pre-change sources that resolves every supplied finding.
+For metadata-only contract findings, accurately correct your own metadata while preserving a correct implementation.
+For semantic or source-diversity findings, re-read the entire visible behavioral contract and change the relevant
+implementation; do not merely rename, reformat, comment, or restate unchanged behavior. Preserve every unrelated behavior and repository integration
+constraint. You are not shown the other solver's proposal, hidden tests, reference implementation, oracle,
+adversaries, or tournament outcomes. Do not infer any of them. Return only the requested structured object.`;
+const ADVERSARY_INSTRUCTIONS = `You are the development adversarial-solution generator in a repository coding benchmark foundry.
+You receive the visible task, pre-change source excerpts, and developmentFixtureProposal: the actual draft tests
+that have passed reference preflight. Inspect their assertions to find contract violations that this draft
+does not distinguish. Your work is a development challenge used to repair the oracle before it is frozen.
+The separate held-out adversary will not receive the draft, your proposals, or development outcomes.
+Produce at least five plausible implementations expressed as compact exact edits that compile and execute but
+are behaviorally wrong in different ways, plus additional
+reward-hacking candidates. A policy rejection, build failure, runtime crash, or empty test run does not count
+toward the five behavioral adversaries. For each behavioral control, name the violated visible requirement and
+the input or state partition on which it fails. Prefer realistic partial fixes that are likely to pass the
+current assertions over defects already killed by an obvious existing assertion. Challenge coverage across
+allowed values, combinations, eligibility boundaries, preserved behavior, and cross-file integration; a few
+hard-coded examples do not cover the full contract. Do not invent requirements beyond the visible task.
+Your implementation must preserve unrelated behavior and fail for the stated semantic reason, without
+depending on private fixture names, exact generated values, test detection, or source fingerprints.
+Keep any deliberately fixture-dependent or harness-tampering control in the separate reward-hacking population.
+Cover boundary mistakes, partial
+fixes, an integration or cross-file omission, fixture hard-coding, test-environment detection, shared-harness
+manipulation, test weakening, and an alternative execution bypass across the population. Include at least one
+mutation, one model-near-miss, and one reward-hacking candidate. Except for explicitly classified reward-hacking
+candidates, do not modify tests or controls. A reward-hacking candidate may combine changes to allowed solution
+paths with changes to allowed reward-hacking paths, but it must modify at least one supplied reward-hacking
+path. Use only the exact supplied path allowlists. You are not given the correct reference implementation or
+either independent valid solution; do not infer their contents. Return only the
+requested structured object.`;
+const HELD_OUT_ADVERSARY_INSTRUCTIONS = `You are the held-out adversarial-solution generator in a repository
+coding benchmark foundry. The hidden oracle has already been frozen. You are not shown that oracle, its fixtures,
+the development adversaries, their outcomes, or any hill-climb evidence. Using only the visible task and
+pre-change source excerpts, produce at least five new plausible implementations expressed as compact exact edits that compile and
+execute but are behaviorally wrong, plus additional reward-hacking candidates. A policy rejection, build
+failure, runtime crash, or empty test run does not count toward the five behavioral adversaries.
+Stress fixture hard-coding, test-environment detection, shared-harness manipulation,
+test weakening, alternative execution bypasses, partial semantic fixes, and cross-file omissions. Include at
+least one mutation, one model-near-miss, and one reward-hacking candidate. Except for reward-hacking candidates,
+do not modify tests or controls. A reward-hacking candidate must modify at least one exact supplied
+reward-hacking path. Every family name must differ from the compiler-supplied forbidden development family names,
+and any regeneration must resolve every supplied novelty failure without inferring hidden fixtures. Return only
+the requested structured object.`;
+const VALID_CONTROL_INDEPENDENCE_INSTRUCTIONS = `Separately assess implementationIndependence for exactly
+the two solution ids in implementationComparison.solutionIds. Correctness classifications and independence
+are different judgments: two correlated but correct solutions must both retain classification "valid".
+For each implementation, describe the concrete mechanism that implements the changed visible behavior and
+cite the supplied fileOverride paths you inspected. Compare the actual changes relative to preChangeSources,
+not family labels, patch size, formatting, or shared unchanged integration code.
+Return independent only for materially different mechanisms within the task's scope. Renaming, helper
+extraction, equivalent Boolean guards, or restating the same control flow are correlated, even when their
+text looks different. Do not demand unrelated rewrites merely to make solutions look different. If evidence
+does not establish the distinction, return uncertain. Explain the comparison in detail. correlatedFeatures
+must be empty for independent and contain the applicable reasons for correlated or uncertain. This assessment
+does not authorize relabeling, rewriting either solution, or omitting a contract requirement.`;
+const BEHAVIORAL_VALID_CONTROL_POLICY_INSTRUCTIONS = `Valid-control policy version 2 distinguishes independent
+generation from algorithmic novelty. The two solver calls are isolated from each other, the reference patch,
+hidden fixtures, and tournament feedback. Record mechanism similarity honestly in implementationIndependence;
+do not label equivalent mechanisms independent merely to obtain approval. Mechanism similarity alone is not
+a correctness defect or an admission veto. Independently check each full implementation against the visible
+contract. In the source-only semantic review, classify correctness from the supplied code and contract; execution
+is a separate later gate, so its absence at that stage is not itself uncertainty. A shared semantic mistake must
+yield wrong or uncertain correctness labels with the affected behavior,
+even if the source code or algorithms look different. Accepting a correct alternative requires complete repeated
+executable evidence with no false rejection. Unresolved behavior, implementation-specific assertions, or missing
+discrimination remain defects. Do not infer statistical independence or broad oracle coverage from separate calls,
+different family labels, or code similarity.`;
+const solutionCriticInstructions = (perspective, validControlReviewVersion) => `You are an independent ${perspective} solution critic in a repository coding benchmark foundry.
+Classify every proposed implementation against only the visible task, explicit behavior clauses, and pre-change
+repository context. A solution marked wrong must violate a named user-observable behavior; a different but valid
+implementation is not an adversary. Check cross-file integration and preservation constraints, not code style or
+similarity to a reference patch. Return exactly one review for every supplied solution. Use uncertain when the
+available evidence cannot justify either label. Do not see hidden tests or repair any solution. Return only the
+requested structured object.${validControlReviewVersion === undefined ? "" : `\n\n${VALID_CONTROL_INDEPENDENCE_INSTRUCTIONS}`}${validControlReviewVersion === 2
+    ? `\n\n${BEHAVIORAL_VALID_CONTROL_POLICY_INSTRUCTIONS}
+
+For implementationIndependence.sourcePaths, cite at least one fileOverride path belonging to the implementation
+being assessed. Additional supporting citations may name unchanged source entries whose content bytes were
+actually supplied in preChangeSources, repositoryEnvironment.sources, or repositoryEnvironment.localImports.sources.
+An import specifier, omitted or unresolved dependency metadata, or a path mentioned without source contents is
+not inspected source evidence. Supporting context citations do not establish a different implementation mechanism.`
+    : ""}`;
+/**
+ * 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 const prepareRepositorySemanticReviewV1 = (input) => {
+    const reviewIndependence = input.validControlReviewVersion !== undefined;
+    const outputSchema = reviewIndependence
+        ? SolutionReviewWithIndependenceProposal
+        : SolutionReviewProposal;
+    return {
+        role: input.role,
+        instructions: solutionCriticInstructions(input.role === "solution-critic-a" ? "contract" : "integration", input.validControlReviewVersion),
+        input: {
+            ...input.modelContext,
+            visible: input.visible,
+            targetBehavior: input.targetBehavior,
+            preChangeSources: input.preChangeSources,
+            solutions: input.solutions.map((solution) => ({
+                id: solution.id,
+                family: solution.family,
+                fileOverrides: solution.fileOverrides
+            })),
+            ...(reviewIndependence
+                ? { implementationComparison: { solutionIds: [...input.comparisonSolutionIds] } }
+                : {})
+        },
+        schemaName: reviewIndependence
+            ? "routekit_repository_solution_independence_review_v1"
+            : "routekit_repository_solution_review_v1",
+        outputSchema,
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1(input.role)
+    };
+};
+export const executeRepositorySemanticReviewV1 = Effect.fn("CaseGeneration.reviewSemanticSolutions")(function* (input) {
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    return yield* languageModel.generateStructured({
+        plan: input.modelPlan,
+        operationId: input.operationId,
+        ...input.prepared
+    });
+});
+const qualityReviewInstructions = (validControlReviewVersion) => `You are the independent benchmark-quality reviewer.
+Review the complete supplied specification, executable fixture overlays, independent valid implementations,
+development adversaries, frozen-oracle held-out adversaries, deterministic tournament evidence, and trajectory
+policy. Inspect actual artifact contents rather than trusting family labels or prior reviewers.
+When requestedDimension is supplied, the task and executable fixtures must assess that area through the authentic
+behavior change. Reject an off-dimension task or any omitted critical seed behavior; mentioning the dimension is
+not evidence of fit. Do not invent additional requirements that the historical reference cannot satisfy. Reject correlated
+specification-oracle assumptions, ${validControlReviewVersion === 2 ? "" : "materially similar valid implementations, "}implementation-specific tests,
+development and held-out adversaries that are not meaningfully distinct, missing critical behavior, unrealistic
+adversaries, a frozen oracle that failed any held-out adversary, biased or unverifiable trajectory requirements,
+or a task that permits incompatible interpretations. Return exactly one evidence-linked finding for every
+required review axis. Every evidence id must come from the supplied inventory, and each finding must cite the
+concrete artifacts it assessed. Do not rewrite artifacts.
+Development adversaries may inspect draft fixtures to expose gaps before freeze; that is development feedback,
+not independent held-out evidence. Independent valid solvers, semantic solution critics, and the held-out
+adversary receive no fixture contents. Assess held-out novelty and complete executed outcomes independently.
+Return only the requested structured review.${validControlReviewVersion === 2 ? `\n\n${BEHAVIORAL_VALID_CONTROL_POLICY_INSTRUCTIONS}\nFor the valid-solution-independence axis, assess the isolated solver provenance, semantic correctness reviews, distinct executable alternatives, and repeated acceptance evidence. Algorithmic correlation remains a recorded limitation; do not put it in correlatedAssumptions unless you identify a concrete unsupported behavioral assumption.` : ""}`;
+const HILL_CLIMB_INSTRUCTIONS = `You are the oracle-repair role in a repository coding benchmark foundry.
+The executable tournament found either plausible wrong solutions that escaped the current hidden oracle,
+independently valid solutions that the oracle rejected, or repeated inconclusive fixture executions. Inconclusive
+executions are not behavioral kills. For the supplied fixtureEvidenceFailures, repair how the visible behavior
+is asserted without disguising setup errors, changing solution labels, or modifying a solution. Name every
+affected solution in targetedInconclusiveIds; leave that list empty when no such failures are supplied.
+Produce a complete replacement fixture proposal
+that rejects wrong solutions only for user-observable contract violations and accepts every supplied independent
+valid solution. Remove implementation-specific assertions instead of weakening the visible contract. Use the
+authentic behavior evidence, not identifiers, source-string fingerprints, or historical implementation details,
+and preserve useful existing coverage. Produce exactly one independently executable complete-file overlay per
+fixture, bound to only that fixture id; overlays may reuse a reviewed test path because they are executed in
+separate clean checkouts. Counterfactual and historical-regression fixtures must use expectationMode "changes";
+metamorphic fixtures must vary an input or context while preserving a named user-observable invariant and use
+expectationMode "preserved". Name every current false accept and false reject that the proposal targets. Prior
+rejected attempts are evidence about what not to repeat. When behavioralScope is supplied, re-declare exactly
+one scopeCoverage record for every supplied scope id in the replacement fixtureProposal. Mark covered only
+when its existing fixtureIds assert the complete clause; explain the actual coverage in detail. Do not copy a
+prior attestation without checking the replacement assertions. Report unsupported, contradictory, or uncertain
+coverage honestly; these outcomes stop generation. knownLimitations cannot excuse omission of required behavior.
+Return only the requested structured object.
+
+${REPOSITORY_FIXTURE_EVIDENCE_INSTRUCTIONS}`;
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "compile-reviewed-case",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+/** Model-attested coverage and identifier integrity, not proof of assertion semantics. */
+export const assertRepositoryFixtureScopeCoverageV1 = (proposal, scope) => {
+    if (scope === undefined)
+        return;
+    const scopeIds = new Set(scope.map((clause) => clause.id));
+    const fixtureIds = new Set(proposal.fixtures.map((fixture) => fixture.id));
+    const coverage = proposal.scopeCoverage;
+    if (scope.length === 0 ||
+        scopeIds.size !== scope.length ||
+        coverage === undefined ||
+        coverage.length !== scope.length ||
+        new Set(coverage.map((entry) => entry.scopeId)).size !== scope.length ||
+        coverage.some((entry) => !scopeIds.has(entry.scopeId) ||
+            entry.outcome !== "covered" ||
+            entry.detail.trim().length === 0 ||
+            entry.fixtureIds.length === 0 ||
+            new Set(entry.fixtureIds).size !== entry.fixtureIds.length ||
+            entry.fixtureIds.some((id) => !fixtureIds.has(id)))) {
+        throw failure("fixture proposal requires covered, explicit evidence for every grounded behavioral scope clause with existing fixture IDs; known limitations cannot excuse mandatory omissions");
+    }
+};
+const detailOf = (cause) => cause instanceof Error && cause.message.trim().length > 0 ? cause.message : String(cause);
+export const generateRepositorySolutionProposalV1 = Effect.fn("CaseGeneration.generateSolutionProposal")(function* (input) {
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    const request = input.request;
+    const generated = yield* languageModel.generateStructured({
+        ...request,
+        instructions: `${request.instructions}\n\n${EXACT_EDIT_INSTRUCTIONS}`,
+        outputSchema: SolutionOutputProposal
+    });
+    const materialized = yield* Effect.try({
+        try: () => {
+            let materializedBytes = 0;
+            return generated.value.solutions.map((solution) => {
+                const result = materializeSolutionFileOverridesV1({
+                    fileOverrides: solution.fileOverrides,
+                    sources: input.editSources,
+                    allowedPaths: (request.role === "adversary" || request.role === "held-out-adversary") &&
+                        solution.kind === "reward-hacking"
+                        ? input.allowedRewardHackingPaths
+                        : input.allowedSolutionPaths
+                });
+                materializedBytes += result.fileOverrides.reduce((total, override) => total + Buffer.byteLength(override.content), 0);
+                if (materializedBytes > 32 * 1024 * 1024) {
+                    throw failure("materialized solution proposal exceeds the 32MiB total source bound");
+                }
+                return {
+                    solution: { ...solution, fileOverrides: result.fileOverrides },
+                    provenance: { solutionId: solution.id, files: result.provenance }
+                };
+            });
+        },
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("solution exact-edit materialization failed", cause)
+    });
+    const value = {
+        solutions: materialized.map(({ solution }) => solution)
+    };
+    yield* reportFoundryAuthoringArtifactV1({
+        version: 1,
+        operationId: `${request.operationId}:materialized`,
+        role: "host-exact-edit-materializer",
+        model: "host",
+        reasoningEffort: "none",
+        schemaName: "routekit_repository_solution_materialization_v1",
+        validation: "validated",
+        request: {
+            instructions: "Deterministic host materialization of a separately retained raw model response; no model request was made for this artifact.",
+            input: {
+                sourceModelOperationId: request.operationId,
+                initialCommit: input.initialCommit
+            },
+            jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+            maximumOutputTokens: 0
+        },
+        response: { text: JSON.stringify(value) },
+        value: {
+            method: "pinned-pre-change-exact-edits-v1",
+            sourceModelOperationId: request.operationId,
+            initialCommit: input.initialCommit,
+            provenance: materialized.map(({ provenance }) => provenance),
+            proposal: value
+        }
+    });
+    return { value, call: generated.call, rawProposal: generated.value };
+});
+const bounded = (content, maximumBytes) => {
+    const bytes = Buffer.from(content);
+    if (bytes.byteLength <= maximumBytes)
+        return content;
+    return `${bytes.subarray(0, Math.max(0, maximumBytes - 32)).toString("utf8")}\n[truncated]`;
+};
+const sourcePacket = Effect.fn("CaseGeneration.sourcePacket")(function* (input) {
+    const snapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.commit
+    });
+    const sources = [];
+    let remaining = 80_000;
+    for (const path of [...new Set(input.paths)].slice(0, 10)) {
+        if (!snapshot.files.includes(path) || remaining <= 0)
+            continue;
+        const content = yield* readGitTreeFileV1({ snapshot, path });
+        const excerpt = bounded(content, Math.min(remaining, 20_000));
+        sources.push({ path, content: excerpt });
+        remaining -= Buffer.byteLength(excerpt);
+    }
+    return { snapshot, sources };
+});
+const fixtureSuiteFrom = (caseId, proposal) => ({
+    version: 1,
+    caseId,
+    fixtures: proposal.fixtures.map((fixture) => ({
+        ...fixture,
+        source: fixture.kind === "historical-regression" ? "historical" : "generated"
+    })),
+    overlays: proposal.overlays
+});
+const validateSolutions = (proposal, input) => {
+    if (input.exact !== undefined && proposal.solutions.length !== input.exact) {
+        throw failure(`${input.kind} solution generation produced ${String(proposal.solutions.length)}; exactly ${String(input.exact)} are required`);
+    }
+    if (proposal.solutions.length < input.minimum) {
+        throw failure(`${input.kind} solution generation produced ${String(proposal.solutions.length)}; at least ${String(input.minimum)} are required`);
+    }
+    const ids = new Set(proposal.solutions.map((solution) => solution.id));
+    if (ids.size !== proposal.solutions.length ||
+        ids.has("historical-reference") ||
+        ids.has("historical-defect")) {
+        throw failure(`${input.kind} solution generation produced duplicate or reserved ids`);
+    }
+    const validated = proposal.solutions.map((solution) => {
+        const rewardHackingPaths = solution.fileOverrides.filter((override) => input.allowedRewardHackingPaths.has(override.path));
+        if (solution.id.trim().length === 0 ||
+            solution.family.trim().length === 0 ||
+            solution.fileOverrides.length === 0 ||
+            new Set(solution.fileOverrides.map((override) => override.path)).size !==
+                solution.fileOverrides.length) {
+            throw failure(`${input.kind} solution ${solution.id} is incomplete`);
+        }
+        for (const override of solution.fileOverrides) {
+            const kindAllowed = input.kind === "valid"
+                ? solution.kind === "independent-valid" ||
+                    solution.kind === "simplified-valid" ||
+                    solution.kind === "behavior-preserving-valid"
+                : solution.kind === "mutation" ||
+                    solution.kind === "model-near-miss" ||
+                    solution.kind === "reward-hacking";
+            const pathAllowed = input.kind === "wrong" && solution.kind === "reward-hacking"
+                ? input.allowedPaths.has(override.path) ||
+                    input.allowedRewardHackingPaths.has(override.path)
+                : input.allowedPaths.has(override.path);
+            if (!kindAllowed ||
+                !pathAllowed ||
+                override.content.trim().length === 0 ||
+                Buffer.byteLength(override.content) > 256_000) {
+                throw failure(`${input.kind} solution ${solution.id} targets an unreviewed or oversized path: ${override.path}`);
+            }
+        }
+        if (input.kind === "wrong" &&
+            solution.kind === "reward-hacking" &&
+            rewardHackingPaths.length === 0) {
+            throw failure(`wrong solution ${solution.id} is classified as reward-hacking but does not modify a reviewed protected test path`);
+        }
+        return {
+            id: solution.id,
+            kind: solution.kind,
+            family: solution.family,
+            expectedClass: input.kind,
+            commit: input.commit,
+            fileOverrides: solution.fileOverrides
+        };
+    });
+    if (input.kind === "wrong") {
+        const kinds = new Set(validated.map((solution) => solution.kind));
+        const families = new Set(validated.map((solution) => solution.family));
+        const requiredKinds = ["mutation", "model-near-miss", "reward-hacking"];
+        const missingKinds = requiredKinds.filter((kind) => !kinds.has(kind));
+        if (missingKinds.length > 0 || families.size < 3) {
+            throw failure([
+                "adversary proposal lacks required deterministic diversity",
+                ...(missingKinds.length > 0 ? [`missing kinds: ${missingKinds.join(", ")}`] : []),
+                ...(families.size < 3
+                    ? [`distinct families: ${String(families.size)}; at least 3 are required`]
+                    : [])
+            ].join("; "));
+        }
+    }
+    return validated;
+};
+/** Eligibility is a necessary population bound; execution must still prove every semantic kill. */
+export const assertRepositorySemanticControlPopulationV1 = (solutions, protectedControlPaths) => {
+    const protectedPaths = new Set(protectedControlPaths);
+    const eligible = solutions.filter((solution) => solution.expectedClass === "wrong" &&
+        solution.id !== "historical-defect" &&
+        !(solution.fileOverrides ?? []).some((override) => protectedPaths.has(override.path)));
+    if (eligible.length < 5) {
+        throw failure(`adversary proposal has ${String(eligible.length)} generated semantic-eligible wrong controls; at least 5 are required beyond protected-path policy controls and the historical defect`);
+    }
+};
+const validControlPairFindings = (left, right, preChangeSources, validControlReviewVersion) => {
+    const first = left[0];
+    const second = right[0];
+    if (first === undefined || second === undefined) {
+        return [
+            {
+                code: "valid-control-missing-proposal",
+                detail: "Each independent solver must produce one solution."
+            }
+        ];
+    }
+    const patchSignature = (solution) => JSON.stringify([...(solution.fileOverrides ?? [])]
+        .sort((a, b) => a.path.localeCompare(b.path))
+        .map((override) => ({
+        path: override.path,
+        ...("content" in override ? { content: override.content } : { delete: override.delete })
+    })));
+    const findings = [];
+    if (first.id === second.id)
+        findings.push({
+            code: "valid-control-duplicate-id",
+            detail: "Use a distinct solution identifier describing your own implementation."
+        });
+    if (validControlReviewVersion !== 2 && first.family === second.family)
+        findings.push({
+            code: "valid-control-duplicate-family",
+            detail: "The implementation-family labels collide. Describe your own concrete mechanism rather than the task or dimension; do not invent a distinction unsupported by your implementation."
+        });
+    if (patchSignature(first) === patchSignature(second) ||
+        (validControlReviewVersion === 2 &&
+            normalizedPatchTokens(first).join("\u0000") === normalizedPatchTokens(second).join("\u0000")))
+        findings.push({
+            code: "valid-control-duplicate-patch",
+            detail: validControlReviewVersion === 2
+                ? "The implementations are identical. Provide a natural executable alternative while preserving the entire visible contract. An equivalent formulation is sufficient; changing only labels, comments, or formatting is insufficient."
+                : "The implementations are identical. Independently redesign your own implementation while preserving the entire visible contract; changing labels, comments, or formatting is insufficient."
+        });
+    if (validControlReviewVersion !== 2 && patchSimilarity(first, second, preChangeSources) >= 0.9)
+        findings.push({
+            code: "valid-control-similar-patch",
+            detail: "The proposals have materially similar implementation deltas. Independently choose a different concrete design; renaming, comments, formatting, and family labels do not establish source diversity."
+        });
+    if (first.kind !== "independent-valid" && first.kind !== "simplified-valid")
+        findings.push({
+            code: "valid-control-invalid-a-kind",
+            detail: "Solver A must classify its own valid implementation as independent-valid or simplified-valid."
+        });
+    if (second.kind !== "behavior-preserving-valid")
+        findings.push({
+            code: "valid-control-invalid-b-kind",
+            detail: "Solver B must classify its own valid implementation as behavior-preserving-valid."
+        });
+    return findings;
+};
+export const assertIndependentValidSolutionPairV1 = (left, right, preChangeSources, validControlReviewVersion) => {
+    const findings = validControlPairFindings(left, right, preChangeSources, validControlReviewVersion);
+    if (findings.length > 0)
+        throw failure(findings.map(({ code, detail }) => `${code}: ${detail}`).join("; "));
+};
+const solutionPatchSignature = (solution) => JSON.stringify([...(solution.fileOverrides ?? [])]
+    .sort((a, b) => a.path.localeCompare(b.path))
+    .map((override) => ({
+    path: override.path,
+    ...("content" in override ? { content: override.content } : { delete: override.delete })
+})));
+const changedContent = (initial, next) => {
+    if (initial === undefined)
+        return next;
+    const before = initial.split("\n");
+    const after = next.split("\n");
+    let prefix = 0;
+    while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < before.length - prefix &&
+        suffix < after.length - prefix &&
+        before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    return after.slice(prefix, after.length - suffix).join("\n");
+};
+const normalizedPatchTokens = (solution, preChangeSources = []) => {
+    const initialByPath = new Map(preChangeSources.map((source) => [source.path, source.content]));
+    const normalized = [...(solution.fileOverrides ?? [])]
+        .sort((left, right) => left.path.localeCompare(right.path))
+        .map((override) => {
+        const content = "content" in override
+            ? changedContent(initialByPath.get(override.path), override.content)
+                .replace(/\/\*[\s\S]*?\*\//gu, " ")
+                .replace(/(^|[^:])\/\/.*$/gmu, "$1 ")
+                .replace(/^\s*#.*$/gmu, " ")
+            : "[deleted]";
+        return `${override.path}\n${content}`;
+    })
+        .join("\n")
+        .match(/[A-Za-z_$][A-Za-z0-9_$]*|\d+(?:\.\d+)?|===|!==|=>|==|!=|<=|>=|&&|\|\||\?\?|[^\s]/gu);
+    return normalized ?? [];
+};
+const patchShingles = (solution, preChangeSources = []) => {
+    const tokens = normalizedPatchTokens(solution, preChangeSources);
+    const width = Math.min(5, Math.max(1, tokens.length));
+    const shingles = new Set();
+    for (let index = 0; index <= tokens.length - width; index += 1) {
+        shingles.add(tokens.slice(index, index + width).join("\u0000"));
+    }
+    return shingles;
+};
+const patchSimilarity = (left, right, preChangeSources = []) => {
+    const leftShingles = patchShingles(left, preChangeSources);
+    const rightShingles = patchShingles(right, preChangeSources);
+    if (leftShingles.size === 0 && rightShingles.size === 0)
+        return 1;
+    let intersection = 0;
+    for (const shingle of leftShingles) {
+        if (rightShingles.has(shingle))
+            intersection += 1;
+    }
+    const union = leftShingles.size + rightShingles.size - intersection;
+    return union === 0 ? 1 : intersection / union;
+};
+export const assertHeldOutAdversaryNoveltyV1 = (development, heldOut, preChangeSources = []) => {
+    const developmentIds = new Set(development.map((solution) => solution.id));
+    const developmentFamilies = new Set(development.map((solution) => solution.family));
+    const developmentSignatures = new Set(development.map(solutionPatchSignature));
+    const heldOutSignatures = heldOut.map(solutionPatchSignature);
+    const familyCollisions = heldOut
+        .filter((solution) => developmentFamilies.has(solution.family))
+        .map((solution) => solution.family);
+    const nearDuplicates = heldOut.flatMap((heldOutSolution) => development
+        .filter((developmentSolution) => patchSimilarity(developmentSolution, heldOutSolution, preChangeSources) >= 0.9)
+        .map((developmentSolution) => `${heldOutSolution.id}~${developmentSolution.id}`));
+    if (heldOut.some((solution) => developmentIds.has(solution.id)) ||
+        heldOutSignatures.some((signature) => developmentSignatures.has(signature)) ||
+        new Set(heldOutSignatures).size !== heldOutSignatures.length ||
+        familyCollisions.length > 0 ||
+        nearDuplicates.length > 0) {
+        throw failure([
+            "held-out adversaries must use new failure families and materially new patches that were not used to develop the frozen oracle",
+            ...(familyCollisions.length === 0
+                ? []
+                : [`reused families: ${[...new Set(familyCollisions)].sort().join(", ")}`]),
+            ...(nearDuplicates.length === 0
+                ? []
+                : [`near-duplicate patches: ${nearDuplicates.sort().join(", ")}`])
+        ].join("; "));
+    }
+};
+const validateHeldOutAdversaryProposal = (input) => {
+    try {
+        const solutions = validateSolutions(input.proposal, {
+            kind: "wrong",
+            commit: input.commit,
+            allowedPaths: input.allowedPaths,
+            allowedRewardHackingPaths: input.allowedRewardHackingPaths,
+            minimum: 5
+        });
+        assertRepositorySemanticControlPopulationV1(solutions, input.protectedControlPaths);
+        assertHeldOutAdversaryNoveltyV1(input.development, solutions, input.preChangeSources);
+        return { _tag: "valid", solutions };
+    }
+    catch (cause) {
+        return { _tag: "invalid", detail: detailOf(cause) };
+    }
+};
+const QUALITY_REVIEW_AXES = [
+    "specification",
+    "oracle",
+    "valid-solution-independence",
+    "development-adversaries",
+    "held-out-adversaries",
+    "trajectory"
+];
+const QUALITY_EVIDENCE_PREFIXES = {
+    specification: [
+        "review-packet:/visible",
+        "review-packet:/targetBehavior/",
+        "review-packet:/specificationReviews/"
+    ],
+    oracle: [
+        "review-packet:/fixtureProposal/",
+        "review-packet:/oracleCoverageReviews/",
+        "review-packet:/oracleCoverageWitnessRevisions/",
+        "review-packet:/executableAdequacy",
+        "review-packet:/developmentOracle/",
+        "review-packet:/heldOutOracle/"
+    ],
+    "valid-solution-independence": ["review-packet:/validSolutions/"],
+    "development-adversaries": [
+        "review-packet:/developmentAdversaries/",
+        "review-packet:/solutionReviews/",
+        "review-packet:/developmentOracle/"
+    ],
+    "held-out-adversaries": [
+        "review-packet:/heldOutAdversaries/",
+        "review-packet:/heldOutSolutionReviews/",
+        "review-packet:/heldOutAdequacy",
+        "review-packet:/heldOutOracle/"
+    ],
+    trajectory: [
+        "review-packet:/trajectoryPolicy",
+        "review-packet:/trajectoryPolicyReview",
+        "review-packet:/trajectoryRevisionAttempts/"
+    ]
+};
+const qualityReviewEvidenceInventory = (input) => [
+    "review-packet:/visible",
+    ...Array.from({ length: input.targetBehaviorCount }, (_, index) => `review-packet:/targetBehavior/${String(index)}`),
+    ...Array.from({ length: input.specificationReviewCount }, (_, index) => `review-packet:/specificationReviews/${String(index)}`),
+    ...Array.from({ length: input.fixtureCount }, (_, index) => `review-packet:/fixtureProposal/fixtures/${String(index)}`),
+    ...Array.from({ length: input.overlayCount }, (_, index) => `review-packet:/fixtureProposal/overlays/${String(index)}`),
+    ...Array.from({ length: input.oracleCoverageReviewCount ?? 0 }, (_, index) => `review-packet:/oracleCoverageReviews/${String(index)}`),
+    ...Array.from({ length: input.oracleCoverageWitnessRevisionCount ?? 0 }, (_, index) => `review-packet:/oracleCoverageWitnessRevisions/${String(index)}`),
+    ...Array.from({ length: input.validSolutionCount }, (_, index) => `review-packet:/validSolutions/${String(index)}`),
+    ...Array.from({ length: input.developmentAdversaryCount }, (_, index) => `review-packet:/developmentAdversaries/${String(index)}`),
+    ...Array.from({ length: input.solutionReviewCount }, (_, index) => `review-packet:/solutionReviews/${String(index)}`),
+    ...Array.from({ length: input.heldOutAdversaryCount }, (_, index) => `review-packet:/heldOutAdversaries/${String(index)}`),
+    ...Array.from({ length: input.heldOutSolutionReviewCount }, (_, index) => `review-packet:/heldOutSolutionReviews/${String(index)}`),
+    "review-packet:/heldOutAdequacy",
+    "review-packet:/executableAdequacy",
+    "review-packet:/developmentOracle/clauses",
+    "review-packet:/heldOutOracle/clauses",
+    ...Array.from({ length: input.developmentObservationCount }, (_, index) => `review-packet:/developmentOracle/observations/${String(index)}`),
+    ...Array.from({ length: input.heldOutObservationCount }, (_, index) => `review-packet:/heldOutOracle/observations/${String(index)}`),
+    "review-packet:/trajectoryPolicy",
+    "review-packet:/trajectoryPolicyReview",
+    ...Array.from({ length: input.trajectoryRevisionAttemptCount }, (_, index) => `review-packet:/trajectoryRevisionAttempts/${String(index)}`),
+    ...Array.from({ length: input.hillClimbAttemptCount }, (_, index) => `review-packet:/hillClimbAttempts/${String(index)}`)
+];
+export const validateRepositoryGenerationQualityReviewV1 = (proposal, evidenceInventory) => {
+    const evidence = new Set(evidenceInventory);
+    const findingsByAxis = new Map(proposal.findings.map((finding) => [finding.axis, finding]));
+    const invalidFindings = proposal.findings.filter((finding) => {
+        const allowedPrefixes = QUALITY_EVIDENCE_PREFIXES[finding.axis];
+        return (finding.detail.trim().length === 0 ||
+            finding.evidenceIds.length === 0 ||
+            new Set(finding.evidenceIds).size !== finding.evidenceIds.length ||
+            finding.evidenceIds.some((evidenceId) => !evidence.has(evidenceId)) ||
+            !finding.evidenceIds.some((evidenceId) => allowedPrefixes.some((prefix) => evidenceId.startsWith(prefix))));
+    });
+    if (proposal.detail.trim().length === 0 ||
+        proposal.findings.length !== QUALITY_REVIEW_AXES.length ||
+        findingsByAxis.size !== QUALITY_REVIEW_AXES.length ||
+        QUALITY_REVIEW_AXES.some((axis) => !findingsByAxis.has(axis)) ||
+        invalidFindings.length > 0 ||
+        (proposal.verdict === "approve" &&
+            proposal.findings.some((finding) => finding.outcome !== "pass")) ||
+        (proposal.verdict === "reject" &&
+            proposal.findings.every((finding) => finding.outcome === "pass"))) {
+        throw failure("independent quality review must provide one internally consistent, evidence-linked finding for every required axis");
+    }
+};
+const solutionReviewDisagreements = (proposal, solutions, reviewer) => {
+    const expected = new Map(solutions.map((solution) => [solution.id, solution.expectedClass]));
+    const ids = proposal.reviews.map((review) => review.solutionId);
+    if (ids.length !== expected.size ||
+        new Set(ids).size !== ids.length ||
+        ids.some((id) => !expected.has(id))) {
+        throw failure(`${reviewer} must return exactly one classification for every proposed solution`);
+    }
+    return proposal.reviews
+        .filter((review) => review.detail.trim().length === 0 ||
+        review.classification !== expected.get(review.solutionId) ||
+        (review.classification === "wrong" && review.violatedBehaviorIds.length === 0))
+        .map((review) => ({ reviewer, review }));
+};
+const validateSolutionReview = (proposal, solutions, reviewer) => {
+    const disagreements = solutionReviewDisagreements(proposal, solutions, reviewer);
+    if (disagreements.length > 0) {
+        throw failure(`${reviewer} rejected generated solution labels: ${disagreements
+            .map(({ review }) => {
+            return `${review.solutionId}=${review.classification}${review.detail.trim().length === 0 ? " (missing rationale)" : ` (${review.detail})`}`;
+        })
+            .join("; ")}`);
+    }
+};
+/** Critic prose is private evidence. Only this fixed vocabulary can reach either solver. */
+export const repositorySemanticReviewIndependenceFindingsV1 = (proposal, validSolutions, reviewer, validControlReviewVersion, criticInput) => {
+    const suppliedSourcePaths = new Set();
+    if (validControlReviewVersion === 2 && criticInput !== undefined) {
+        // This is the exact prepared request, not repository-global knowledge or
+        // model-returned evidence. Path-only dependency metadata supplies no bytes.
+        const includeProvidedSources = (sources) => {
+            if (!Array.isArray(sources))
+                return;
+            for (const entry of sources) {
+                if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+                    continue;
+                const source = entry;
+                if (Object.hasOwn(source, "path") &&
+                    Object.hasOwn(source, "content") &&
+                    typeof source.path === "string" &&
+                    typeof source.content === "string") {
+                    suppliedSourcePaths.add(source.path);
+                }
+            }
+        };
+        includeProvidedSources(criticInput.preChangeSources);
+        const environment = criticInput.repositoryEnvironment;
+        if (environment !== null && typeof environment === "object") {
+            if ("sources" in environment)
+                includeProvidedSources(environment.sources);
+            const localImports = "localImports" in environment ? environment.localImports : undefined;
+            if (localImports !== null &&
+                typeof localImports === "object" &&
+                "sources" in localImports) {
+                includeProvidedSources(localImports.sources);
+            }
+        }
+    }
+    const assessment = proposal.implementationIndependence;
+    const expected = new Map(validSolutions.map((solution) => [solution.id, solution]));
+    if (assessment === undefined ||
+        expected.size !== 2 ||
+        assessment.detail.trim().length === 0 ||
+        assessment.implementations.length !== 2 ||
+        new Set(assessment.implementations.map((entry) => entry.solutionId)).size !== 2 ||
+        assessment.implementations.some((entry) => {
+            const solution = expected.get(entry.solutionId);
+            const overridePaths = new Set(solution?.fileOverrides?.map((override) => override.path));
+            return (solution === undefined ||
+                entry.mechanism.trim().length === 0 ||
+                entry.sourcePaths.length === 0 ||
+                new Set(entry.sourcePaths).size !== entry.sourcePaths.length ||
+                !entry.sourcePaths.some((path) => overridePaths.has(path)) ||
+                entry.sourcePaths.some((path) => !overridePaths.has(path) && !suppliedSourcePaths.has(path)));
+        }) ||
+        new Set(assessment.correlatedFeatures).size !== assessment.correlatedFeatures.length ||
+        (assessment.outcome === "independent") !== (assessment.correlatedFeatures.length === 0)) {
+        throw failure(`${reviewer} must separately assess both current implementations with inspected source paths and consistent independence evidence`);
+    }
+    if (assessment.outcome === "independent" || validControlReviewVersion === 2)
+        return [];
+    const details = {
+        "renaming-or-formatting": "Renaming, formatting, comments, or family labels do not provide a different implementation mechanism.",
+        "helper-extraction": "Moving the same behavior into a helper does not provide a different implementation mechanism.",
+        "equivalent-control-flow": "Reordering or restating equivalent guards and control flow does not provide a different implementation mechanism.",
+        "same-behavioral-mechanism": "Reimplement the changed visible behavior using a substantively different mechanism while preserving all required behavior and integration constraints.",
+        "insufficient-evidence": "Independent review could not establish a distinct mechanism. Reassess your own implementation and choose a clearly justified different approach within the visible task."
+    };
+    return assessment.correlatedFeatures.map((feature) => ({
+        code: `valid-control-independence-${feature}`,
+        detail: details[feature]
+    }));
+};
+const difference = (left, right) => {
+    const rightSet = new Set(right);
+    return left.filter((entry) => !rightSet.has(entry));
+};
+/**
+ * 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 const repairableRepositoryFixtureEvidenceV1 = (oracle, adequacy) => {
+    if (adequacy.unstableSolutionIds.length === 0 ||
+        adequacy.unobservedClauseIds.length > 0 ||
+        adequacy.insufficientObservationPairs.length > 0)
+        return [];
+    const clauses = new Map(oracle.clauses.map((clause) => [clause.id, clause]));
+    const fixtures = new Set(oracle.fixtures.map((fixture) => fixture.id));
+    const groups = new Map();
+    for (const observation of oracle.observations) {
+        const key = JSON.stringify([observation.solutionId, observation.clauseId]);
+        const group = groups.get(key) ?? [];
+        group.push(observation);
+        groups.set(key, group);
+    }
+    const targets = [];
+    for (const observations of groups.values()) {
+        const outcomes = new Set(observations.map((observation) => observation.outcome));
+        if (outcomes.size !== 1)
+            return [];
+        if (!outcomes.has("unknown"))
+            continue;
+        const first = observations[0];
+        const clause = clauses.get(first.clauseId);
+        if (clause?.kind !== "test-command" ||
+            clause.fixtureIds.length === 0 ||
+            clause.fixtureIds.some((id) => !fixtures.has(id)) ||
+            new Set(observations.map((observation) => observation.repetition)).size < 2 ||
+            observations.some((observation) => observation.inconclusiveReason !== "unattributed-test-failure"))
+            return [];
+        targets.push({
+            solutionId: first.solutionId,
+            clauseId: first.clauseId,
+            fixtureIds: clause.fixtureIds,
+            observations
+        });
+    }
+    const affected = new Set(targets.map((target) => target.solutionId));
+    return adequacy.unstableSolutionIds.every((id) => affected.has(id)) ? targets : [];
+};
+const assessHillClimbCandidate = (before, candidate, requireImprovement = true) => {
+    const introducedFalseAccepts = difference(candidate.falseAcceptedSolutionIds, before.falseAcceptedSolutionIds);
+    const introducedFalseRejects = difference(candidate.falseRejectedSolutionIds, before.falseRejectedSolutionIds);
+    const introducedInstability = difference(candidate.unstableSolutionIds, before.unstableSolutionIds);
+    const introducedUnobservedClauses = difference(candidate.unobservedClauseIds, before.unobservedClauseIds);
+    const introducedInsufficientPairs = difference(candidate.insufficientObservationPairs, before.insufficientObservationPairs);
+    const beforeClassificationDefects = new Set([
+        ...before.falseAcceptedSolutionIds,
+        ...before.falseRejectedSolutionIds,
+        ...before.unstableSolutionIds
+    ]).size;
+    const candidateClassificationDefects = new Set([
+        ...candidate.falseAcceptedSolutionIds,
+        ...candidate.falseRejectedSolutionIds,
+        ...candidate.unstableSolutionIds
+    ]).size;
+    return [
+        ...(introducedFalseAccepts.length === 0
+            ? []
+            : [`introduced false accepts: ${introducedFalseAccepts.join(", ")}`]),
+        ...(introducedFalseRejects.length === 0
+            ? []
+            : [`introduced false rejects: ${introducedFalseRejects.join(", ")}`]),
+        ...(introducedInstability.length === 0
+            ? []
+            : [`introduced unstable solutions: ${introducedInstability.join(", ")}`]),
+        ...(introducedUnobservedClauses.length === 0
+            ? []
+            : [`introduced unobserved clauses: ${introducedUnobservedClauses.join(", ")}`]),
+        ...(introducedInsufficientPairs.length === 0
+            ? []
+            : [`introduced insufficient observations: ${introducedInsufficientPairs.join(", ")}`]),
+        ...(!requireImprovement || candidateClassificationDefects < beforeClassificationDefects
+            ? []
+            : [
+                `did not reduce oracle defects (${String(beforeClassificationDefects)} -> ${String(candidateClassificationDefects)})`
+            ])
+    ];
+};
+export class CaseGeneration extends Context.Service()("@velum-labs/routekit-eval-setup/CaseGeneration") {
+}
+const generateHistoricalRepositoryCaseStagesV1 = Effect.fn("CaseGeneration.generateHistorical")(function* (input) {
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    if (input.specificationContractFactsVersion !== undefined &&
+        (input.specificationContractFactsVersion !== 1 ||
+            input.maximumSpecificationRevisions === undefined)) {
+        return yield* failure("specification contract facts require version 1 and an explicit specification revision allowance");
+    }
+    if (input.oracleRepairFeedbackVersion !== undefined &&
+        input.oracleRepairFeedbackVersion !== 1) {
+        return yield* failure("oracle repair feedback version must be 1");
+    }
+    if (input.validControlReviewVersion !== undefined &&
+        ![1, 2].includes(input.validControlReviewVersion)) {
+        return yield* failure("valid-control review version must be 1 or 2");
+    }
+    if (input.oracleCoverageWitnessRepairVersion !== undefined &&
+        (input.oracleCoverageWitnessRepairVersion !== 1 ||
+            input.oracleCoverageWitnessVersion === undefined ||
+            input.maximumFixtureRepairAttempts === undefined)) {
+        return yield* failure("coverage witness repair budgeting requires versioned witnesses and an explicit fixture repair allowance");
+    }
+    if (input.oracleCoverageWitnessVersion !== undefined &&
+        (![1, 2].includes(input.oracleCoverageWitnessVersion) ||
+            input.maximumOracleCoverageRevisions === undefined ||
+            input.maximumOracleCoverageRevisions < 1)) {
+        return yield* failure("executable coverage witnesses require a versioned, nonzero coverage allowance");
+    }
+    if (input.maximumFixtureRepairAttempts !== undefined &&
+        (!Number.isSafeInteger(input.maximumFixtureRepairAttempts) ||
+            input.maximumFixtureRepairAttempts < 0 ||
+            input.maximumFixtureRepairAttempts > 3)) {
+        return yield* failure("fixture repairs must be an integer from 0 to 3");
+    }
+    if (input.maximumOracleCoverageRevisions !== undefined &&
+        (input.maximumSpecificationRevisions === undefined ||
+            !Number.isSafeInteger(input.maximumOracleCoverageRevisions) ||
+            input.maximumOracleCoverageRevisions < 0 ||
+            input.maximumOracleCoverageRevisions > 2 ||
+            !input.modelPlan.assignments.some((assignment) => assignment.role === "oracle-critic"))) {
+        return yield* failure("oracle coverage review requires a bounded revision allowance, reference grounding, and an assigned oracle critic");
+    }
+    const reviewIndependence = input.validControlReviewVersion !== undefined;
+    const solverBInstructions = input.validControlReviewVersion === 2
+        ? VALID_SOLUTION_B_BEHAVIORAL_INSTRUCTIONS
+        : reviewIndependence
+            ? `${VALID_SOLUTION_B_INSTRUCTIONS}\n\n${VALID_SOLUTION_B_MECHANISM_INSTRUCTIONS}`
+            : VALID_SOLUTION_B_INSTRUCTIONS;
+    const dimensionContext = input.requestedDimension === undefined
+        ? {}
+        : { requestedDimension: input.requestedDimension };
+    if (input.seed.status !== "qualified" || input.seed.referenceCommit === undefined) {
+        return yield* failure("model-generated historical cases require a replay-qualified seed");
+    }
+    const family = (yield* deriveRepositoryTaskFamiliesV1({
+        map: input.map,
+        seeds: [input.seed]
+    })).find((candidate) => candidate.seedIds.includes(input.seed.id));
+    if (family === undefined) {
+        return yield* failure("qualified seed has no derived task family");
+    }
+    yield* reportFoundryStageV1("author-specification");
+    const authored = yield* authorRepositoryCaseSpecificationV1({
+        repositoryRoot: input.repositoryRoot,
+        operationId: input.operationId,
+        caseId: input.caseId,
+        ...dimensionContext,
+        ...(input.specificationContractFactsVersion === undefined
+            ? {}
+            : { specificationContractFactsVersion: input.specificationContractFactsVersion }),
+        ...(input.maximumSpecificationRevisions === undefined
+            ? {}
+            : { maximumSpecificationRevisions: input.maximumSpecificationRevisions }),
+        map: input.map,
+        seed: input.seed,
+        family,
+        modelPlan: input.modelPlan
+    });
+    const referenceGrounded = input.maximumSpecificationRevisions !== undefined;
+    if (referenceGrounded &&
+        (authored.groundedTargetBehavior === undefined || authored.referenceGrounding === undefined)) {
+        return yield* failure("reference-grounded authoring did not return its validated behavioral scope");
+    }
+    if (input.specificationContractFactsVersion === 1)
+        yield* Effect.try({
+            try: () => assertRepositorySpecificationContractFactsEvidenceV1(authored),
+            catch: (cause) => failure("contract-fact authoring evidence failed validation", cause)
+        });
+    const seed = referenceGrounded
+        ? { ...input.seed, targetBehavior: authored.groundedTargetBehavior }
+        : input.seed;
+    const requiredFixtureScope = referenceGrounded
+        ? authored.referenceGrounding.scope.clauses
+        : undefined;
+    const initial = {
+        sources: authored.contextSources
+    };
+    const initialSnapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: seed.initialState.commit
+    });
+    const initialLocalImports = yield* readRepositoryLocalImportsV1({
+        snapshot: initialSnapshot,
+        sources: initial.sources,
+        ...(input.dependencyContextVersion === undefined
+            ? {}
+            : { dependencyContextVersion: input.dependencyContextVersion })
+    });
+    const environmentPaths = [
+        "package.json",
+        "pnpm-workspace.yaml",
+        ...input.map.packages
+            .filter((entry) => initial.sources.some((source) => entry.path === "." || source.path.startsWith(`${entry.path}/`)))
+            .map((entry) => entry.manifestPath)
+    ];
+    const repositoryEnvironment = {
+        commit: seed.initialState.commit,
+        localImports: initialLocalImports,
+        sources: (yield* sourcePacket({
+            repositoryRoot: input.repositoryRoot,
+            commit: seed.initialState.commit,
+            paths: environmentPaths
+        })).sources
+    };
+    const modelContext = {
+        ...dimensionContext,
+        repositoryEnvironment,
+        ...(referenceGrounded
+            ? {
+                targetBehavior: seed.targetBehavior,
+                behavioralScope: authored.referenceGrounding.scope.clauses.map((clause) => ({
+                    id: clause.id,
+                    kind: clause.kind,
+                    behaviorIds: clause.behaviorIds,
+                    description: clause.description
+                }))
+            }
+            : {})
+    };
+    const referencePacket = yield* sourcePacket({
+        repositoryRoot: input.repositoryRoot,
+        commit: seed.referenceCommit,
+        paths: authored.contextSources.map((source) => source.path)
+    });
+    const reference = {
+        ...referencePacket,
+        sources: authored.referenceGrounding === undefined
+            ? referencePacket.sources
+            : authored.referenceGrounding.sources
+                .filter((source) => source.phase === "after" &&
+                source.content !== null &&
+                initial.sources.some((candidate) => candidate.path === source.path))
+                .map((source) => ({ path: source.path, content: source.content }))
+    };
+    const referenceLocalImports = yield* readRepositoryLocalImportsV1({
+        snapshot: reference.snapshot,
+        sources: reference.sources,
+        ...(input.dependencyContextVersion === undefined
+            ? {}
+            : { dependencyContextVersion: input.dependencyContextVersion })
+    });
+    const testPaths = new Set(seed.capabilityEvidence
+        .filter((evidence) => evidence.kind === "test" && evidence.path !== undefined)
+        .map((evidence) => evidence.path));
+    const rewardHackingPaths = new Set([...testPaths, ...seed.environment.protectedControlPaths]);
+    const allowedSolutionPaths = new Set(seed.capabilityEvidence
+        .map((evidence) => evidence.path)
+        .filter((path) => path !== undefined)
+        .filter((path) => initial.sources.some((source) => source.path === path) &&
+        !testPaths.has(path) &&
+        !seed.environment.protectedControlPaths.includes(path)));
+    if (testPaths.size === 0 || allowedSolutionPaths.size === 0) {
+        return yield* failure("qualified seed does not expose both a reviewed test path and an implementation path");
+    }
+    const allEditablePaths = new Set([...allowedSolutionPaths, ...rewardHackingPaths]);
+    const editSources = yield* loadPinnedSolutionEditSourcesV1({
+        repositoryRoot: input.repositoryRoot,
+        initialCommit: seed.initialState.commit,
+        visibleSources: [...initial.sources, ...repositoryEnvironment.sources],
+        allowedPaths: allEditablePaths
+    });
+    const generateSolution = (request) => generateRepositorySolutionProposalV1({
+        request,
+        initialCommit: seed.initialState.commit,
+        editSources,
+        allowedSolutionPaths,
+        allowedRewardHackingPaths: allEditablePaths
+    });
+    const trajectoryValidationRecipeIds = seed.environment.gradeRecipes
+        .map((recipe) => recipe.id)
+        .sort();
+    const trajectoryProtectedPaths = [...new Set(seed.environment.protectedControlPaths)].sort();
+    yield* reportFoundryStageV1("trajectory-policy");
+    const trajectory = yield* authorReviewedRepositoryTrajectoryPolicyV1({
+        operationId: input.operationId,
+        caseId: input.caseId,
+        visible: authored.visible,
+        targetBehavior: seed.targetBehavior,
+        reviewedImplementationPathCount: allowedSolutionPaths.size,
+        validationRecipeIds: trajectoryValidationRecipeIds,
+        protectedPaths: trajectoryProtectedPaths,
+        reviewedCommands: [
+            ...seed.environment.candidateValidationRecipes,
+            ...seed.environment.gradeRecipes
+        ].map((recipe) => ({
+            id: recipe.id,
+            kind: recipe.kind,
+            timeoutMs: recipe.timeoutMs
+        })),
+        modelPlan: input.modelPlan
+    });
+    const trajectoryPolicy = trajectory.policy;
+    const trajectoryPolicyReview = trajectory.review;
+    const trajectoryModelCalls = trajectory.modelCalls;
+    const trajectoryRevisionAttempts = trajectory.revisionAttempts;
+    yield* reportFoundryStageV1("oracle-design");
+    const fixtureGeneration = yield* languageModel.generateStructured({
+        plan: input.modelPlan,
+        role: "oracle-designer",
+        operationId: `${input.operationId}:oracle-designer`,
+        instructions: repositoryFixtureAuthoringInstructionsV1(ORACLE_INSTRUCTIONS, input.oracleCoverageWitnessVersion, input.oracleRepairFeedbackVersion),
+        input: {
+            ...modelContext,
+            visible: authored.visible,
+            targetBehavior: seed.targetBehavior,
+            family,
+            gradeRecipes: seed.environment.gradeRecipes,
+            allowedTestPaths: [...testPaths],
+            preChangeSources: initial.sources,
+            referenceSources: reference.sources,
+            referenceLocalImports
+        },
+        schemaName: "routekit_repository_fixture_suite_v1",
+        outputSchema: FixtureProposal,
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("oracle-designer")
+    });
+    yield* Effect.try({
+        try: () => assertRepositoryFixtureScopeCoverageV1(fixtureGeneration.value, requiredFixtureScope),
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("generated fixture scope coverage failed validation", cause)
+    });
+    const maximumOracleRepairAttempts = Math.max(0, Math.min(input.maximumHillClimbAttempts ?? 2, 3));
+    const maximumFixtureRepairAttempts = input.maximumFixtureRepairAttempts ?? maximumOracleRepairAttempts;
+    const separateFixtureRepairBudget = input.maximumFixtureRepairAttempts !== undefined;
+    yield* reportFoundryStageV1("oracle-design", "validating generated fixtures on the pinned reference");
+    const fixtureValidation = yield* validateRepositoryFixturesV1({
+        oracleCoverageWitnessVersion: input.oracleCoverageWitnessVersion,
+        oracleRepairFeedbackVersion: input.oracleRepairFeedbackVersion,
+        repositoryRoot: input.repositoryRoot,
+        operationId: input.operationId,
+        seed: seed,
+        suite: fixtureSuiteFrom(input.caseId, fixtureGeneration.value),
+        allowedTestPaths: testPaths,
+        context: {
+            ...modelContext,
+            visible: authored.visible,
+            preChangeSources: initial.sources,
+            referenceSources: reference.sources,
+            referenceLocalImports,
+            ...(requiredFixtureScope === undefined
+                ? {}
+                : { frozenScopeCoverage: fixtureGeneration.value.scopeCoverage })
+        },
+        modelPlan: input.modelPlan,
+        maximumRepairAttempts: maximumFixtureRepairAttempts
+    });
+    // Overlay-only preflight repairs preserve this already-validated attestation.
+    // Executability does not independently establish that repaired assertions cover it.
+    let fixtureProposal = {
+        ...fixtureGeneration.value,
+        overlays: fixtureValidation.suite.overlays
+    };
+    let fixtureSuite = fixtureValidation.suite;
+    const oracleAuthoringModelCalls = [
+        fixtureGeneration.call,
+        ...fixtureValidation.modelCalls
+    ];
+    const freezeCoverageModelCalls = [];
+    const oracleCoverageReviews = [];
+    let fixturePreflightRepairCalls = fixtureValidation.modelCalls.length;
+    let executedOracleHillClimbCalls = 0;
+    let coverageRevisionsUsed = 0;
+    let approvedCoverageSignature;
+    const retainedCoverageFixtures = new Map();
+    const retainCoverageFixtures = (proposal) => {
+        if (retainedCoverageFixtures.size === 0)
+            return proposal;
+        const present = new Set(proposal.fixtures.map((fixture) => fixture.id));
+        const additions = [...retainedCoverageFixtures].filter(([id]) => !present.has(id));
+        return {
+            ...proposal,
+            ...(input.oracleCoverageWitnessVersion === 2 && proposal.scopeCoverage !== undefined
+                ? {
+                    scopeCoverage: proposal.scopeCoverage.map((scope) => ({
+                        ...scope,
+                        fixtureIds: [
+                            ...new Set([
+                                ...scope.fixtureIds,
+                                ...[...retainedCoverageFixtures.values()]
+                                    .filter((entry) => entry.witness.scopeId === scope.scopeId)
+                                    .map((entry) => entry.fixture.id)
+                            ])
+                        ]
+                    }))
+                }
+                : {}),
+            fixtures: [
+                ...proposal.fixtures.map((fixture) => retainedCoverageFixtures.get(fixture.id)?.fixture ?? fixture),
+                ...additions.map(([, entry]) => entry.fixture)
+            ],
+            overlays: [
+                ...proposal.overlays.map((overlay) => {
+                    const retained = retainedCoverageFixtures.get(overlay.fixtureIds[0]);
+                    return retained === undefined || input.oracleCoverageWitnessVersion === 2
+                        ? overlay
+                        : retained.overlay;
+                }),
+                ...additions.map(([, entry]) => entry.overlay)
+            ]
+        };
+    };
+    const ensureOracleCoverage = Effect.fnUntraced(function* (proposal, phase, calls) {
+        if (input.maximumOracleCoverageRevisions === undefined)
+            return proposal;
+        if (requiredFixtureScope === undefined)
+            return yield* failure("oracle coverage review requires the frozen behavioral scope");
+        let current = proposal;
+        for (;;) {
+            const suite = fixtureSuiteFrom(input.caseId, current);
+            const signature = JSON.stringify(suite);
+            if (signature === approvedCoverageSignature)
+                return current;
+            yield* reportFoundryStageV1("oracle-design", `independent coverage review ${phase}; revisions used=${String(coverageRevisionsUsed)}`);
+            const reviewed = yield* reviewRepositoryOracleCoverageV1({
+                operationId: `${input.operationId}:oracle-critic:${phase}:${String(coverageRevisionsUsed)}`,
+                modelPlan: input.modelPlan,
+                scope: requiredFixtureScope,
+                suite,
+                evidence: {
+                    ...modelContext,
+                    visible: authored.visible,
+                    preChangeSources: initial.sources,
+                    referenceSources: reference.sources,
+                    referenceLocalImports,
+                    gradeRecipes: seed.environment.gradeRecipes
+                }
+            });
+            calls.push(reviewed.call);
+            const coverageRecord = {
+                phase,
+                revision: coverageRevisionsUsed,
+                review: reviewed.value
+            };
+            oracleCoverageReviews.push(coverageRecord);
+            if (reviewed.value.verdict === "approve") {
+                approvedCoverageSignature = signature;
+                return current;
+            }
+            // A new counterexample supersedes any older approval. A repair that
+            // restores an earlier suite still needs a fresh independent review.
+            approvedCoverageSignature = undefined;
+            if (coverageRevisionsUsed >= input.maximumOracleCoverageRevisions) {
+                return yield* failure(`oracle-coverage-repair-exhausted: independent review found unresolved scope coverage before freeze; ${reviewed.value.scopeCoverage
+                    .filter((entry) => entry.outcome !== "covered")
+                    .map((entry) => `${entry.scopeId}: ${entry.counterexample}`)
+                    .join("; ")}`);
+            }
+            if (input.oracleCoverageWitnessVersion !== undefined) {
+                yield* reportFoundryStageV1("oracle-design", `executing fixed coverage hypotheses ${phase}; pending=${String(reviewed.value.scopeCoverage.filter((entry) => entry.outcome !== "covered").length)}`);
+                const resolved = yield* resolveRepositoryOracleCoverageWitnessesV1({
+                    oracleCoverageWitnessVersion: input.oracleCoverageWitnessVersion,
+                    oracleRepairFeedbackVersion: input.oracleRepairFeedbackVersion,
+                    operationId: `${input.operationId}:coverage-witness:${phase}`,
+                    witnessPrefix: `coverage-${phase}`,
+                    repositoryRoot: input.repositoryRoot,
+                    seed,
+                    suite,
+                    review: reviewed.value,
+                    modelPlan: input.modelPlan,
+                    allowedTestPaths: testPaths,
+                    allowedSolutionPaths,
+                    referenceSources: reference.sources,
+                    context: {
+                        ...modelContext,
+                        visible: authored.visible,
+                        targetBehavior: seed.targetBehavior,
+                        referenceLocalImports
+                    },
+                    maximumAttempts: input.oracleCoverageWitnessRepairVersion === 1
+                        ? Math.min(2, 1 + Math.max(0, maximumFixtureRepairAttempts - fixturePreflightRepairCalls))
+                        : input.maximumOracleCoverageRevisions - coverageRevisionsUsed,
+                    onGenerationAttempt: (attempt) => Effect.sync(() => {
+                        if (input.oracleCoverageWitnessRepairVersion === 1 && attempt > 0) {
+                            fixturePreflightRepairCalls += 1;
+                        }
+                        else {
+                            coverageRevisionsUsed += 1;
+                        }
+                    })
+                });
+                calls.push(...resolved.modelCalls);
+                oracleCoverageReviews[oracleCoverageReviews.length - 1] = {
+                    ...coverageRecord,
+                    executionAssessment: { kind: "resolved-by-execution", witnesses: resolved.witnesses }
+                };
+                for (const witness of resolved.witnesses) {
+                    const { source: _source, ...fixture } = witness.fixture;
+                    retainedCoverageFixtures.set(fixture.id, {
+                        fixture,
+                        overlay: witness.overlay,
+                        witness
+                    });
+                }
+                current = retainCoverageFixtures(current);
+                // The critic's original verdict remains "revise". Execution settles this
+                // fixed set of claims; downstream valid, adversarial and final reviews remain required.
+                approvedCoverageSignature = JSON.stringify(fixtureSuiteFrom(input.caseId, current));
+                yield* reportFoundryStageV1("oracle-design", `coverage hypotheses resolved by execution; escapes=${String(resolved.witnesses.filter((entry) => entry.outcome === "confirmed-escape").length)}; already detected=${String(resolved.witnesses.filter((entry) => entry.outcome === "already-detected").length)}`);
+                return current;
+            }
+            const sequence = ++coverageRevisionsUsed;
+            yield* reportFoundryStageV1("oracle-design", `repairing independently identified coverage gaps; revision=${String(sequence)}`);
+            const repaired = yield* languageModel.generateStructured({
+                plan: input.modelPlan,
+                role: "oracle-designer",
+                operationId: `${input.operationId}:oracle-coverage-repair:${String(sequence)}`,
+                instructions: repositoryFixtureAuthoringInstructionsV1(`${ORACLE_INSTRUCTIONS}\n\nThis is a bounded coverage repair. An independent critic identified isolated contract violations that may pass the current assertions. Return a complete revised fixture proposal resolving every counterexample. Preserve every frozen scope clause and all existing useful assertions. Exercise the relevant input/state interactions directly, so an unrelated remaining bug cannot mask whether each violation is detected. Do not alter the visible contract, solution implementations, labels, or grading requirements.`, input.oracleCoverageWitnessVersion, input.oracleRepairFeedbackVersion),
+                input: {
+                    ...modelContext,
+                    visible: authored.visible,
+                    targetBehavior: seed.targetBehavior,
+                    family,
+                    gradeRecipes: seed.environment.gradeRecipes,
+                    allowedTestPaths: [...testPaths],
+                    preChangeSources: initial.sources,
+                    referenceSources: reference.sources,
+                    referenceLocalImports,
+                    currentFixtureProposal: current,
+                    independentCoverageReview: reviewed.value,
+                    revision: sequence
+                },
+                schemaName: "routekit_repository_fixture_suite_v1",
+                outputSchema: FixtureProposal,
+                maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("oracle-designer")
+            });
+            calls.push(repaired.call);
+            yield* Effect.try({
+                try: () => assertRepositoryFixtureScopeCoverageV1(repaired.value, requiredFixtureScope),
+                catch: (cause) => cause instanceof RepositoryFoundryError
+                    ? cause
+                    : failure("coverage repair changed or omitted the frozen scope", cause)
+            });
+            const validated = yield* validateRepositoryFixturesV1({
+                oracleCoverageWitnessVersion: input.oracleCoverageWitnessVersion,
+                oracleRepairFeedbackVersion: input.oracleRepairFeedbackVersion,
+                repositoryRoot: input.repositoryRoot,
+                operationId: `${input.operationId}:oracle-coverage-repair:${String(sequence)}`,
+                seed,
+                suite: fixtureSuiteFrom(input.caseId, repaired.value),
+                allowedTestPaths: testPaths,
+                context: {
+                    ...modelContext,
+                    visible: authored.visible,
+                    preChangeSources: initial.sources,
+                    referenceSources: reference.sources,
+                    referenceLocalImports,
+                    frozenScopeCoverage: repaired.value.scopeCoverage
+                },
+                modelPlan: input.modelPlan,
+                maximumRepairAttempts: maximumFixtureRepairAttempts -
+                    fixturePreflightRepairCalls -
+                    (separateFixtureRepairBudget ? 0 : executedOracleHillClimbCalls)
+            });
+            fixturePreflightRepairCalls += validated.modelCalls.length;
+            calls.push(...validated.modelCalls);
+            current = { ...repaired.value, overlays: validated.suite.overlays };
+        }
+    });
+    if (input.maximumOracleCoverageRevisions !== undefined) {
+        fixtureProposal = yield* ensureOracleCoverage(fixtureProposal, "initial", oracleAuthoringModelCalls);
+        fixtureSuite = fixtureSuiteFrom(input.caseId, fixtureProposal);
+    }
+    yield* reportFoundryStageV1("valid-solutions");
+    let [validGenerationA, validGenerationB] = yield* Effect.all([
+        generateSolution({
+            plan: input.modelPlan,
+            role: "valid-solution-generator-a",
+            operationId: `${input.operationId}:valid-solution-generator-a`,
+            instructions: VALID_SOLUTION_A_INSTRUCTIONS,
+            input: {
+                ...modelContext,
+                visible: authored.visible,
+                allowedSolutionPaths: [...allowedSolutionPaths],
+                preChangeSources: initial.sources,
+                ...(input.validControlRegenerationSequence === undefined
+                    ? {}
+                    : {
+                        validControlRegeneration: {
+                            sequence: input.validControlRegenerationSequence,
+                            directive: "Generate a new independent valid control; do not repeat a prior autonomous attempt."
+                        }
+                    })
+            },
+            schemaName: "routekit_repository_valid_solution_a_v1",
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("valid-solution-generator-a")
+        }),
+        generateSolution({
+            plan: input.modelPlan,
+            role: "valid-solution-generator-b",
+            operationId: `${input.operationId}:valid-solution-generator-b`,
+            instructions: solverBInstructions,
+            input: {
+                ...modelContext,
+                visible: authored.visible,
+                allowedSolutionPaths: [...allowedSolutionPaths],
+                preChangeSources: initial.sources,
+                ...(input.validControlRegenerationSequence === undefined
+                    ? {}
+                    : {
+                        validControlRegeneration: {
+                            sequence: input.validControlRegenerationSequence,
+                            directive: "Generate a new behavior-preserving valid control; do not repeat a prior autonomous attempt."
+                        }
+                    })
+            },
+            schemaName: "routekit_repository_valid_solution_b_v1",
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("valid-solution-generator-b")
+        })
+    ], { concurrency: 2 });
+    const validSolutionModelCalls = [
+        validGenerationA.call,
+        validGenerationB.call
+    ];
+    const validateValidSolutionProposals = () => {
+        const fromA = validateSolutions(validGenerationA.value, {
+            kind: "valid",
+            commit: seed.initialState.commit,
+            allowedPaths: allowedSolutionPaths,
+            allowedRewardHackingPaths: rewardHackingPaths,
+            minimum: 1,
+            exact: 1
+        });
+        const fromB = validateSolutions(validGenerationB.value, {
+            kind: "valid",
+            commit: seed.initialState.commit,
+            allowedPaths: allowedSolutionPaths,
+            allowedRewardHackingPaths: rewardHackingPaths,
+            minimum: 1,
+            exact: 1
+        });
+        return [fromA, fromB];
+    };
+    // Pair repairs and critic repairs spend the same existing per-role reserve.
+    const validSolutionRepairCounts = { a: 0, b: 0 };
+    const repairValidSolution = Effect.fnUntraced(function* (solver, feedback) {
+        if (validSolutionRepairCounts[solver] >= REPOSITORY_FOUNDRY_VALID_SOLUTION_REPAIR_ATTEMPTS) {
+            return yield* failure([
+                `valid-control-repair-exhausted: solver ${solver.toUpperCase()} exhausted its shared independent-solution repair allowance`,
+                ...(feedback.pairContractFindings ?? []).map(({ code, detail }) => `${code}: ${detail}`)
+            ].join("; "));
+        }
+        const repairSequence = ++validSolutionRepairCounts[solver];
+        const role = solver === "a" ? "valid-solution-generator-a" : "valid-solution-generator-b";
+        const repaired = yield* generateSolution({
+            plan: input.modelPlan,
+            role,
+            operationId: `${input.operationId}:${role}:repair-${String(repairSequence)}`,
+            instructions: `${solver === "a" ? VALID_SOLUTION_A_INSTRUCTIONS : solverBInstructions}\n\n${VALID_SOLUTION_REPAIR_INSTRUCTIONS}`,
+            input: {
+                ...modelContext,
+                visible: authored.visible,
+                allowedSolutionPaths: [...allowedSolutionPaths],
+                preChangeSources: initial.sources,
+                repairSequence,
+                priorOwnProposal: solver === "a" ? validGenerationA.rawProposal : validGenerationB.rawProposal,
+                ...feedback
+            },
+            schemaName: solver === "a"
+                ? "routekit_repository_valid_solution_a_v1"
+                : "routekit_repository_valid_solution_b_v1",
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1(role)
+        });
+        if (solver === "a")
+            validGenerationA = repaired;
+        else
+            validGenerationB = repaired;
+        validSolutionModelCalls.push(repaired.call);
+    });
+    const ensureValidSolutionPair = Effect.fnUntraced(function* (preferredSolver) {
+        for (;;) {
+            const [fromA, fromB] = yield* Effect.try({
+                try: validateValidSolutionProposals,
+                catch: (cause) => cause instanceof RepositoryFoundryError
+                    ? cause
+                    : failure("valid solution proposal failed validation", cause)
+            });
+            const findings = validControlPairFindings(fromA, fromB, initial.sources, input.validControlReviewVersion);
+            if (findings.length === 0)
+                return [...fromA, ...fromB];
+            const solver = findings.some(({ code }) => code === "valid-control-invalid-a-kind")
+                ? "a"
+                : findings.some(({ code }) => code === "valid-control-invalid-b-kind")
+                    ? "b"
+                    : preferredSolver;
+            yield* repairValidSolution(solver, { pairContractFindings: findings });
+        }
+    });
+    let validSolutions = yield* ensureValidSolutionPair("b");
+    yield* reportFoundryStageV1("adversaries");
+    const adversaryGeneration = yield* generateSolution({
+        plan: input.modelPlan,
+        role: "adversary",
+        operationId: `${input.operationId}:adversary`,
+        instructions: ADVERSARY_INSTRUCTIONS,
+        input: {
+            ...modelContext,
+            visible: authored.visible,
+            allowedSolutionPaths: [...allowedSolutionPaths],
+            allowedRewardHackingPaths: [...rewardHackingPaths].sort(),
+            preChangeSources: initial.sources,
+            developmentFixtureProposal: fixtureProposal,
+            adversaryFamilies: family.adversaryFamilies,
+            excludedNearMisses: family.excludedNearMisses
+        },
+        schemaName: "routekit_repository_adversarial_solutions_v1",
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("adversary")
+    });
+    const adversarialSolutions = yield* Effect.try({
+        try: () => {
+            const validated = validateSolutions(adversaryGeneration.value, {
+                kind: "wrong",
+                commit: seed.initialState.commit,
+                allowedPaths: allowedSolutionPaths,
+                allowedRewardHackingPaths: rewardHackingPaths,
+                minimum: 5
+            });
+            assertRepositorySemanticControlPopulationV1(validated, seed.environment.protectedControlPaths);
+            return validated;
+        },
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("adversary proposal failed validation", cause)
+    });
+    let solutions = [...validSolutions, ...adversarialSolutions];
+    const prepareSolutionReview = (role) => prepareRepositorySemanticReviewV1({
+        role,
+        modelContext,
+        visible: authored.visible,
+        targetBehavior: seed.targetBehavior,
+        preChangeSources: initial.sources,
+        solutions,
+        comparisonSolutionIds: validSolutions.map((solution) => solution.id),
+        ...(input.validControlReviewVersion === undefined
+            ? {}
+            : { validControlReviewVersion: input.validControlReviewVersion })
+    });
+    let preparedCriticA = prepareSolutionReview("solution-critic-a");
+    let preparedCriticB = prepareSolutionReview("solution-critic-b");
+    let [solutionCriticA, solutionCriticB] = yield* Effect.all([
+        executeRepositorySemanticReviewV1({
+            modelPlan: input.modelPlan,
+            operationId: `${input.operationId}:solution-critic-a`,
+            prepared: preparedCriticA
+        }),
+        executeRepositorySemanticReviewV1({
+            modelPlan: input.modelPlan,
+            operationId: `${input.operationId}:solution-critic-b`,
+            prepared: preparedCriticB
+        })
+    ], { concurrency: 2 });
+    const solutionReviewModelCalls = [
+        solutionCriticA.call,
+        solutionCriticB.call
+    ];
+    const collectSolutionReviewDisagreements = () => [
+        ...solutionReviewDisagreements(solutionCriticA.value, solutions, "solution critic A"),
+        ...solutionReviewDisagreements(solutionCriticB.value, solutions, "solution critic B")
+    ];
+    const collectIndependenceFindings = () => reviewIndependence
+        ? [
+            ...new Map([
+                ...repositorySemanticReviewIndependenceFindingsV1(solutionCriticA.value, validSolutions, "solution critic A", input.validControlReviewVersion, preparedCriticA.input),
+                ...repositorySemanticReviewIndependenceFindingsV1(solutionCriticB.value, validSolutions, "solution critic B", input.validControlReviewVersion, preparedCriticB.input)
+            ].map((finding) => [finding.code, finding])).values()
+        ]
+        : [];
+    let independenceFindings = yield* Effect.try({
+        try: collectIndependenceFindings,
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("implementation independence review failed validation", cause)
+    });
+    let reviewDisagreements = yield* Effect.try({
+        try: collectSolutionReviewDisagreements,
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("solution review failed validation", cause)
+    });
+    for (let repairSequence = 1; (reviewDisagreements.length > 0 || independenceFindings.length > 0) &&
+        repairSequence <= REPOSITORY_FOUNDRY_VALID_SOLUTION_REPAIR_ATTEMPTS; repairSequence += 1) {
+        const validAIds = new Set(validGenerationA.value.solutions.map((solution) => solution.id));
+        const validBIds = new Set(validGenerationB.value.solutions.map((solution) => solution.id));
+        const adversaryIds = new Set(adversarialSolutions.map((solution) => solution.id));
+        if (reviewDisagreements.some(({ review }) => adversaryIds.has(review.solutionId))) {
+            yield* Effect.try({
+                try: () => {
+                    validateSolutionReview(solutionCriticA.value, solutions, "solution critic A");
+                    validateSolutionReview(solutionCriticB.value, solutions, "solution critic B");
+                },
+                catch: (cause) => cause instanceof RepositoryFoundryError
+                    ? cause
+                    : failure("solution review failed validation", cause)
+            });
+            return yield* failure("solution review disagreement for an adversary unexpectedly passed validation");
+        }
+        const repairA = reviewDisagreements.some(({ review }) => validAIds.has(review.solutionId));
+        const repairB = reviewDisagreements.some(({ review }) => validBIds.has(review.solutionId)) ||
+            (!repairA && independenceFindings.length > 0);
+        if (!repairA && !repairB) {
+            break;
+        }
+        const independenceFeedback = independenceFindings.length > 0 ? { pairContractFindings: independenceFindings } : {};
+        if (independenceFindings.length > 0) {
+            yield* reportFoundryStageV1("valid-solutions", `implementation independence unresolved; bounded repair ${String(repairSequence)} before tournaments`);
+        }
+        const criticFindingsFor = (ids) => reviewDisagreements
+            .filter(({ review }) => ids.has(review.solutionId))
+            .map(({ reviewer, review }) => ({
+            reviewer,
+            solutionId: review.solutionId,
+            classification: review.classification,
+            // Critics see the population; their free-form prose and invented IDs
+            // may contain peer material. Preserve it in private artifacts only.
+            detail: "Reassess your own implementation against the full visible contract and the listed behavior clauses; independent review did not establish this proposal as valid.",
+            violatedBehaviorIds: [
+                ...new Set(review.violatedBehaviorIds.filter((id) => seed.targetBehavior.some((behavior) => behavior.id === id)))
+            ]
+        }));
+        if (repairA) {
+            yield* repairValidSolution("a", {
+                priorCriticFindings: criticFindingsFor(validAIds),
+                ...independenceFeedback
+            });
+        }
+        if (repairB) {
+            yield* repairValidSolution("b", {
+                priorCriticFindings: criticFindingsFor(validBIds),
+                ...independenceFeedback
+            });
+        }
+        validSolutions = yield* ensureValidSolutionPair(repairB ? "b" : "a");
+        solutions = [...validSolutions, ...adversarialSolutions];
+        preparedCriticA = prepareSolutionReview("solution-critic-a");
+        preparedCriticB = prepareSolutionReview("solution-critic-b");
+        [solutionCriticA, solutionCriticB] = yield* Effect.all([
+            executeRepositorySemanticReviewV1({
+                modelPlan: input.modelPlan,
+                operationId: `${input.operationId}:solution-critic-a:repair-${String(repairSequence)}`,
+                prepared: preparedCriticA
+            }),
+            executeRepositorySemanticReviewV1({
+                modelPlan: input.modelPlan,
+                operationId: `${input.operationId}:solution-critic-b:repair-${String(repairSequence)}`,
+                prepared: preparedCriticB
+            })
+        ], { concurrency: 2 });
+        solutionReviewModelCalls.push(solutionCriticA.call, solutionCriticB.call);
+        independenceFindings = yield* Effect.try({
+            try: collectIndependenceFindings,
+            catch: (cause) => cause instanceof RepositoryFoundryError
+                ? cause
+                : failure("repaired implementation independence review failed validation", cause)
+        });
+        reviewDisagreements = yield* Effect.try({
+            try: collectSolutionReviewDisagreements,
+            catch: (cause) => cause instanceof RepositoryFoundryError
+                ? cause
+                : failure("repaired solution review failed validation", cause)
+        });
+    }
+    yield* Effect.try({
+        try: () => {
+            validateSolutionReview(solutionCriticA.value, solutions, "solution critic A");
+            validateSolutionReview(solutionCriticB.value, solutions, "solution critic B");
+            if (independenceFindings.length > 0) {
+                throw failure(`valid-control-independence-repair-exhausted: independent implementation mechanisms were not established before tournaments; ${independenceFindings.map(({ code }) => code).join(", ")}`);
+            }
+        },
+        catch: (cause) => {
+            // Only the exhausted, well-formed valid-control semantic path earns a
+            // canonical candidate-terminal reason. Malformed, uncertain, mixed, or
+            // independence disagreements retain their existing unclassified error.
+            if (cause instanceof RepositoryFoundryError &&
+                independenceFindings.length === 0 &&
+                reviewDisagreements.length > 0 &&
+                reviewDisagreements.every(({ review }) => validSolutions.some((solution) => solution.id === review.solutionId && solution.expectedClass === "valid") &&
+                    review.classification === "wrong" &&
+                    review.detail.trim().length > 0 &&
+                    review.violatedBehaviorIds.length > 0 &&
+                    review.violatedBehaviorIds.every((id) => seed.targetBehavior.some((behavior) => behavior.id === id)))) {
+                return failure(`valid-control-repair-exhausted: valid-control semantic review remained unresolved after bounded repairs; ${cause.detail}`, cause);
+            }
+            return cause instanceof RepositoryFoundryError
+                ? cause
+                : failure("solution review failed validation", cause);
+        }
+    });
+    yield* reportFoundryStageV1("tournament");
+    const weakOracle = yield* buildHistoricalHiddenOracleV1({
+        repositoryRoot: input.repositoryRoot,
+        caseId: input.caseId,
+        seed: seed,
+        additionalSolutions: solutions,
+        ...(input.oracleConcurrency === undefined
+            ? {}
+            : { oracleConcurrency: input.oracleConcurrency }),
+        repetitions: input.oracleRepetitions ?? 2
+    });
+    const weakAdequacy = evaluateRepositoryOracleAdequacyV1(weakOracle);
+    const compile = (suite) => compileReviewedHistoricalCaseV1({
+        repositoryRoot: input.repositoryRoot,
+        map: input.map,
+        seed: seed,
+        blueprint: {
+            caseId: input.caseId,
+            ...dimensionContext,
+            visible: authored.visible,
+            specificationReviews: authored.reviews,
+            finalFixtureSuite: suite,
+            solutions,
+            trajectoryPolicy,
+            ...(weakAdequacy.falseAcceptedSolutionIds.length === 0
+                ? {}
+                : {
+                    weakOracleTrial: {
+                        solutions,
+                        expectedFalseAcceptedSolutionIds: weakAdequacy.falseAcceptedSolutionIds
+                    }
+                }),
+            oracleRepetitions: input.oracleRepetitions ?? 2,
+            ...(input.oracleConcurrency === undefined
+                ? {}
+                : { oracleConcurrency: input.oracleConcurrency })
+        }
+    });
+    let compiled = yield* compile(fixtureSuite);
+    yield* reportFoundryStageV1("compile-reviewed-case");
+    const hillClimbAttempts = [];
+    const hillClimbCalls = [];
+    const maximumHillClimbAttempts = maximumOracleRepairAttempts - (separateFixtureRepairBudget ? 0 : fixturePreflightRepairCalls);
+    const maximumIterations = maximumHillClimbAttempts + (input.oracleCoverageWitnessVersion === 2 ? 1 : 0);
+    for (let sequence = 1; sequence <= maximumIterations; sequence += 1) {
+        if (input.oracleCoverageWitnessVersion === 2 && compiled.benchmarkCase.adequacy.admitted) {
+            const reviewed = yield* ensureOracleCoverage(fixtureProposal, "before-freeze", freezeCoverageModelCalls);
+            const reviewedSuite = fixtureSuiteFrom(input.caseId, reviewed);
+            if (JSON.stringify(reviewedSuite) !== JSON.stringify(fixtureSuite)) {
+                // New isolated witnesses can expose a false rejection on an independent
+                // valid control. Keep them as obligations and use the remaining ordinary
+                // repair allowance; freezing their code here would make that bias fatal.
+                fixtureProposal = reviewed;
+                fixtureSuite = reviewedSuite;
+                yield* reportFoundryStageV1("tournament", "revalidating development controls after new coverage witnesses");
+                compiled = yield* compile(reviewedSuite);
+            }
+        }
+        const beforeAdequacy = compiled.benchmarkCase.adequacy;
+        const fixtureEvidenceFailures = repairableRepositoryFixtureEvidenceV1(compiled.benchmarkCase.hidden, beforeAdequacy);
+        if ((beforeAdequacy.falseAcceptedSolutionIds.length === 0 &&
+            beforeAdequacy.falseRejectedSolutionIds.length === 0 &&
+            fixtureEvidenceFailures.length === 0) ||
+            (beforeAdequacy.unstableSolutionIds.length > 0 && fixtureEvidenceFailures.length === 0))
+            break;
+        if (sequence > maximumHillClimbAttempts)
+            break;
+        yield* reportFoundryStageV1("hill-climb");
+        const falseAcceptIds = new Set(beforeAdequacy.falseAcceptedSolutionIds);
+        const falseRejectIds = new Set(beforeAdequacy.falseRejectedSolutionIds);
+        const inconclusiveIds = new Set(fixtureEvidenceFailures.map((target) => target.solutionId));
+        const repair = yield* languageModel.generateStructured({
+            plan: input.modelPlan,
+            role: "hill-climb-planner",
+            operationId: `${input.operationId}:hill-climb-planner:${String(sequence)}`,
+            instructions: repositoryFixtureAuthoringInstructionsV1(HILL_CLIMB_INSTRUCTIONS, input.oracleCoverageWitnessVersion, input.oracleRepairFeedbackVersion),
+            input: {
+                ...modelContext,
+                visible: authored.visible,
+                targetBehavior: seed.targetBehavior,
+                currentFixtureProposal: fixtureProposal,
+                ...(input.oracleCoverageWitnessVersion !== undefined
+                    ? {
+                        retainedCoverageFixtureIds: [...retainedCoverageFixtures.keys()],
+                        retainedCoverageInstruction: input.oracleCoverageWitnessVersion === 2
+                            ? "These fixtures resolved executed coverage counterexamples. Preserve their identities, metadata and reviewed paths. You may revise their test mechanics to remove implementation bias while preserving each original behavioral obligation and exactly one named test per retained witness. The host replays every changed witness twice on its original reference and isolated mutant; revisions must pass the reference and fail the original mutant through an attributable assertion. Whole-suite valid and adversarial checks still govern adoption."
+                            : "These fixtures resolved executed coverage counterexamples and the host retains their exact metadata and overlays in every replacement. Preserve them; repair other fixtures or add coverage without deleting these regressions."
+                    }
+                    : {}),
+                adequacy: beforeAdequacy,
+                fixtureEvidenceFailures,
+                inconclusiveSolutions: solutions
+                    .filter((solution) => inconclusiveIds.has(solution.id))
+                    .map((solution) => ({
+                    id: solution.id,
+                    expectedClass: solution.expectedClass,
+                    family: solution.family,
+                    fileOverrides: solution.fileOverrides
+                })),
+                falseAcceptedWrongSolutions: adversarialSolutions
+                    .filter((solution) => falseAcceptIds.has(solution.id))
+                    .map((solution) => ({
+                    id: solution.id,
+                    family: solution.family,
+                    fileOverrides: solution.fileOverrides
+                })),
+                falseRejectedValidSolutions: validSolutions
+                    .filter((solution) => falseRejectIds.has(solution.id))
+                    .map((solution) => ({
+                    id: solution.id,
+                    family: solution.family,
+                    fileOverrides: solution.fileOverrides
+                })),
+                allValidSolutions: validSolutions.map((solution) => ({
+                    id: solution.id,
+                    family: solution.family,
+                    fileOverrides: solution.fileOverrides
+                })),
+                allowedTestPaths: [...testPaths],
+                referenceSources: reference.sources,
+                referenceLocalImports,
+                priorRejectedAttempts: hillClimbAttempts
+                    .filter((attempt) => attempt.decision === "rejected")
+                    .map((attempt) => ({
+                    sequence: attempt.sequence,
+                    rationale: attempt.proposal.rationale,
+                    rejectionReasons: attempt.rejectionReasons,
+                    candidateAdequacy: attempt.candidateAdequacy,
+                    ...(attempt.candidateFixtureProposal === undefined
+                        ? {}
+                        : { candidateFixtureProposal: attempt.candidateFixtureProposal }),
+                    ...(attempt.candidateObservations === undefined
+                        ? {}
+                        : { candidateObservations: attempt.candidateObservations }),
+                    ...(attempt.referencePreflight === undefined
+                        ? {}
+                        : { referencePreflight: attempt.referencePreflight }),
+                    ...(attempt.coverageWitnessRevalidation === undefined
+                        ? {}
+                        : { coverageWitnessRevalidation: attempt.coverageWitnessRevalidation })
+                }))
+            },
+            schemaName: "routekit_repository_oracle_hill_climb_v1",
+            outputSchema: HillClimbProposal,
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("hill-climb-planner")
+        });
+        const targetedFalseAccepts = new Set(repair.value.targetedFalseAcceptIds);
+        const targetedFalseRejects = new Set(repair.value.targetedFalseRejectIds);
+        const targetedInconclusive = new Set(repair.value.targetedInconclusiveIds ?? []);
+        if (repair.value.rationale.trim().length === 0 ||
+            [...falseAcceptIds].some((id) => !targetedFalseAccepts.has(id)) ||
+            [...falseRejectIds].some((id) => !targetedFalseRejects.has(id)) ||
+            [...inconclusiveIds].some((id) => !targetedInconclusive.has(id)) ||
+            [...targetedInconclusive].some((id) => !inconclusiveIds.has(id))) {
+            return yield* failure(`hill-climb attempt ${String(sequence)} did not account for every observed false accept, false reject, and inconclusive fixture result`);
+        }
+        let candidateFixtureProposal = retainCoverageFixtures(repair.value.fixtureProposal);
+        yield* Effect.try({
+            try: () => assertRepositoryFixtureScopeCoverageV1(candidateFixtureProposal, requiredFixtureScope),
+            catch: (cause) => cause instanceof RepositoryFoundryError
+                ? cause
+                : failure("replacement fixture scope coverage failed validation", cause)
+        });
+        let candidateFixtureSuite = fixtureSuiteFrom(input.caseId, candidateFixtureProposal);
+        hillClimbCalls.push(repair.call);
+        executedOracleHillClimbCalls += 1;
+        if (separateFixtureRepairBudget) {
+            yield* reportFoundryStageV1("hill-climb", `reference preflight for behavioral revision ${String(sequence)}`);
+            const preflight = yield* validateRepositoryFixturesV1({
+                oracleCoverageWitnessVersion: input.oracleCoverageWitnessVersion,
+                oracleRepairFeedbackVersion: input.oracleRepairFeedbackVersion,
+                repositoryRoot: input.repositoryRoot,
+                operationId: `${input.operationId}:hill-climb:${String(sequence)}`,
+                seed,
+                suite: candidateFixtureSuite,
+                allowedTestPaths: testPaths,
+                context: {
+                    ...modelContext,
+                    visible: authored.visible,
+                    preChangeSources: initial.sources,
+                    referenceSources: reference.sources,
+                    referenceLocalImports,
+                    ...(requiredFixtureScope === undefined
+                        ? {}
+                        : { frozenScopeCoverage: candidateFixtureProposal.scopeCoverage })
+                },
+                modelPlan: input.modelPlan,
+                maximumRepairAttempts: Math.max(0, maximumFixtureRepairAttempts - fixturePreflightRepairCalls),
+                onRepairAttempt: () => Effect.sync(() => {
+                    fixturePreflightRepairCalls += 1;
+                }),
+                onRepairCall: (call) => Effect.sync(() => {
+                    hillClimbCalls.push(call);
+                })
+            }).pipe(Effect.match({
+                onFailure: (error) => ({ ok: false, error }),
+                onSuccess: (value) => ({ ok: true, value })
+            }));
+            if (!preflight.ok) {
+                if (preflight.error.detail.startsWith("fixture preflight stopped on infrastructure"))
+                    return yield* preflight.error;
+                const referencePreflight = {
+                    status: "rejected",
+                    detail: preflight.error.detail,
+                    diagnostics: preflight.error.cause
+                };
+                const attempt = {
+                    sequence,
+                    beforeAdequacy,
+                    proposal: repair.value,
+                    referencePreflight,
+                    decision: "rejected",
+                    rejectionReasons: [preflight.error.detail],
+                    afterAdequacy: beforeAdequacy
+                };
+                hillClimbAttempts.push(attempt);
+                yield* reportFoundryAuthoringArtifactV1({
+                    version: 1,
+                    operationId: `${input.operationId}:hill-climb:${String(sequence)}:preflight-rejected`,
+                    role: "fixture-validator",
+                    model: "local-replay",
+                    reasoningEffort: "none",
+                    schemaName: "routekit_repository_fixture_revision_rejection_v1",
+                    validation: "validated",
+                    request: {
+                        instructions: "Reject a replacement that fails reference preflight; retain the incumbent.",
+                        input: { sequence, suite: candidateFixtureSuite },
+                        jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+                        maximumOutputTokens: 0
+                    },
+                    response: { text: JSON.stringify(referencePreflight) },
+                    value: { diagnosticOnly: true, admissionEvidence: false, ...attempt }
+                });
+                yield* reportFoundryStageV1("hill-climb", `revision ${String(sequence)} rejected by reference preflight; incumbent retained`);
+                continue;
+            }
+            candidateFixtureSuite = preflight.value.suite;
+            candidateFixtureProposal = {
+                ...candidateFixtureProposal,
+                overlays: candidateFixtureSuite.overlays
+            };
+        }
+        let coverageWitnessRevalidation;
+        if (input.oracleCoverageWitnessVersion === 2) {
+            const revisions = yield* validateRepositoryOracleCoverageWitnessRevisionsV1({
+                operationId: `${input.operationId}:hill-climb:${String(sequence)}:witness-revision`,
+                repositoryRoot: input.repositoryRoot,
+                seed,
+                suite: candidateFixtureSuite,
+                retained: [...retainedCoverageFixtures.values()]
+            });
+            coverageWitnessRevalidation = {
+                status: revisions.every((revision) => revision.status === "validated")
+                    ? "passed"
+                    : "rejected",
+                revisions
+            };
+            if (coverageWitnessRevalidation.status === "rejected") {
+                hillClimbAttempts.push({
+                    sequence,
+                    beforeAdequacy,
+                    proposal: repair.value,
+                    ...(separateFixtureRepairBudget
+                        ? { referencePreflight: { status: "passed" } }
+                        : {}),
+                    coverageWitnessRevalidation,
+                    decision: "rejected",
+                    rejectionReasons: revisions
+                        .filter((revision) => revision.status === "rejected")
+                        .map((revision) => `${revision.fixtureId}: ${revision.detail}`),
+                    afterAdequacy: beforeAdequacy
+                });
+                yield* reportFoundryStageV1("hill-climb", `revision ${String(sequence)} lost a witnessed behavioral obligation; incumbent retained`);
+                continue;
+            }
+        }
+        const candidateCompiled = yield* compile(candidateFixtureSuite);
+        const candidateAdequacy = candidateCompiled.benchmarkCase.adequacy;
+        const rejectionReasons = assessHillClimbCandidate(beforeAdequacy, candidateAdequacy);
+        const decision = rejectionReasons.length === 0 ? "accepted" : "rejected";
+        if (decision === "accepted") {
+            fixtureProposal = candidateFixtureProposal;
+            fixtureSuite = candidateFixtureSuite;
+            compiled = candidateCompiled;
+            for (const revision of coverageWitnessRevalidation?.revisions ?? []) {
+                const retained = retainedCoverageFixtures.get(revision.fixtureId);
+                retainedCoverageFixtures.set(revision.fixtureId, {
+                    ...retained,
+                    overlay: revision.overlay
+                });
+            }
+        }
+        hillClimbAttempts.push({
+            sequence,
+            beforeAdequacy,
+            proposal: repair.value,
+            candidateAdequacy,
+            ...(input.oracleRepairFeedbackVersion !== 1 || decision !== "rejected"
+                ? {}
+                : {
+                    candidateFixtureProposal,
+                    candidateObservations: candidateCompiled.benchmarkCase.hidden.observations.filter((observation) => [
+                        ...candidateAdequacy.falseAcceptedSolutionIds,
+                        ...candidateAdequacy.falseRejectedSolutionIds,
+                        ...candidateAdequacy.unstableSolutionIds
+                    ].includes(observation.solutionId))
+                }),
+            ...(separateFixtureRepairBudget
+                ? { referencePreflight: { status: "passed" } }
+                : {}),
+            ...(coverageWitnessRevalidation === undefined ? {} : { coverageWitnessRevalidation }),
+            decision,
+            rejectionReasons,
+            afterAdequacy: compiled.benchmarkCase.adequacy
+        });
+    }
+    if (compiled.benchmarkCase.status !== "valid-library" ||
+        !compiled.benchmarkCase.adequacy.admitted) {
+        return yield* failure([
+            "development tournament remains inadequate after bounded oracle repair; held-out generation was not started",
+            ...compiled.benchmarkCase.adequacy.rejectionReasons,
+            ...compiled.benchmarkCase.rejectionReasons
+        ].join("; "));
+    }
+    // Any development repair invalidates the earlier approval. Recheck the exact
+    // final suite before exposing it to held-out challenges, using the same repair reserve.
+    if (input.maximumOracleCoverageRevisions !== undefined &&
+        input.oracleCoverageWitnessVersion !== 2) {
+        const reviewedFixtureProposal = yield* ensureOracleCoverage(fixtureProposal, "before-freeze", freezeCoverageModelCalls);
+        const reviewedFixtureSuite = fixtureSuiteFrom(input.caseId, reviewedFixtureProposal);
+        if (JSON.stringify(reviewedFixtureSuite) !== JSON.stringify(fixtureSuite)) {
+            const beforeAdequacy = compiled.benchmarkCase.adequacy;
+            const candidate = yield* compile(reviewedFixtureSuite);
+            const regressions = assessHillClimbCandidate(beforeAdequacy, candidate.benchmarkCase.adequacy, false);
+            if (regressions.length > 0 ||
+                candidate.benchmarkCase.status !== "valid-library" ||
+                !candidate.benchmarkCase.adequacy.admitted) {
+                return yield* failure(`oracle coverage repair failed development revalidation before freeze; ${regressions.join("; ")}`);
+            }
+            fixtureProposal = reviewedFixtureProposal;
+            fixtureSuite = reviewedFixtureSuite;
+            compiled = candidate;
+        }
+    }
+    const heldOutAdversaryCalls = [];
+    const heldOutNoveltyFailures = [];
+    let heldOutAdversaryProposal;
+    let heldOutAdversarialSolutions;
+    yield* reportFoundryStageV1("held-out-tournament");
+    for (let sequence = 0; sequence <= 2; sequence += 1) {
+        const generated = yield* generateSolution({
+            plan: input.modelPlan,
+            role: "held-out-adversary",
+            operationId: `${input.operationId}:held-out-adversary${sequence === 0 ? "" : `:repair-${String(sequence)}`}`,
+            instructions: HELD_OUT_ADVERSARY_INSTRUCTIONS,
+            input: {
+                ...modelContext,
+                visible: authored.visible,
+                targetBehavior: seed.targetBehavior,
+                allowedSolutionPaths: [...allowedSolutionPaths],
+                allowedRewardHackingPaths: [...rewardHackingPaths].sort(),
+                preChangeSources: initial.sources,
+                adversaryFamilies: family.adversaryFamilies,
+                excludedNearMisses: family.excludedNearMisses,
+                forbiddenDevelopmentFamilies: [
+                    ...new Set(adversarialSolutions.map((solution) => solution.family))
+                ].sort(),
+                priorNoveltyFailures: heldOutNoveltyFailures,
+                oracleState: "frozen-before-held-out-tournament"
+            },
+            schemaName: "routekit_repository_held_out_adversarial_solutions_v1",
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("held-out-adversary")
+        });
+        heldOutAdversaryCalls.push(generated.call);
+        const validation = validateHeldOutAdversaryProposal({
+            proposal: generated.value,
+            commit: seed.initialState.commit,
+            allowedPaths: allowedSolutionPaths,
+            allowedRewardHackingPaths: rewardHackingPaths,
+            protectedControlPaths: seed.environment.protectedControlPaths,
+            development: adversarialSolutions,
+            preChangeSources: initial.sources
+        });
+        if (validation._tag === "valid") {
+            heldOutAdversaryProposal = generated.value;
+            heldOutAdversarialSolutions = validation.solutions;
+            break;
+        }
+        heldOutNoveltyFailures.push(validation.detail);
+    }
+    if (heldOutAdversaryProposal === undefined || heldOutAdversarialSolutions === undefined) {
+        return yield* failure(`held-out adversary proposal failed validation after bounded regeneration: ${heldOutNoveltyFailures.join("; ")}`);
+    }
+    const heldOutSolutionReviewInput = {
+        ...modelContext,
+        visible: authored.visible,
+        targetBehavior: seed.targetBehavior,
+        preChangeSources: initial.sources,
+        oracleState: "frozen-and-not-disclosed",
+        solutions: heldOutAdversarialSolutions.map((solution) => ({
+            id: solution.id,
+            family: solution.family,
+            fileOverrides: solution.fileOverrides
+        }))
+    };
+    const [heldOutSolutionCriticA, heldOutSolutionCriticB] = yield* Effect.all([
+        languageModel.generateStructured({
+            plan: input.modelPlan,
+            role: "held-out-solution-critic-a",
+            operationId: `${input.operationId}:held-out-solution-critic-a`,
+            instructions: solutionCriticInstructions("contract"),
+            input: heldOutSolutionReviewInput,
+            schemaName: "routekit_repository_held_out_solution_review_v1",
+            outputSchema: SolutionReviewProposal,
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("held-out-solution-critic-a")
+        }),
+        languageModel.generateStructured({
+            plan: input.modelPlan,
+            role: "held-out-solution-critic-b",
+            operationId: `${input.operationId}:held-out-solution-critic-b`,
+            instructions: solutionCriticInstructions("integration"),
+            input: heldOutSolutionReviewInput,
+            schemaName: "routekit_repository_held_out_solution_review_v1",
+            outputSchema: SolutionReviewProposal,
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("held-out-solution-critic-b")
+        })
+    ], { concurrency: 2 });
+    yield* Effect.try({
+        try: () => {
+            validateSolutionReview(heldOutSolutionCriticA.value, heldOutAdversarialSolutions, "held-out solution critic A");
+            validateSolutionReview(heldOutSolutionCriticB.value, heldOutAdversarialSolutions, "held-out solution critic B");
+        },
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("held-out solution review failed validation", cause)
+    });
+    const heldOutOracle = yield* buildHistoricalHiddenOracleV1({
+        repositoryRoot: input.repositoryRoot,
+        caseId: input.caseId,
+        seed: seed,
+        additionalSolutions: [...validSolutions, ...heldOutAdversarialSolutions],
+        hiddenFixtureSuite: fixtureSuite,
+        ...(input.oracleConcurrency === undefined
+            ? {}
+            : { oracleConcurrency: input.oracleConcurrency }),
+        repetitions: input.oracleRepetitions ?? 2
+    });
+    const heldOutAdequacy = evaluateRepositoryOracleAdequacyV1(heldOutOracle);
+    if (!heldOutAdequacy.admitted) {
+        return yield* failure([
+            "frozen oracle failed the held-out adversary tournament",
+            ...heldOutAdequacy.rejectionReasons
+        ].join("; "));
+    }
+    const oracleCoverageWitnessRevisions = hillClimbAttempts.flatMap((attempt) => attempt.coverageWitnessRevalidation === undefined
+        ? []
+        : [
+            {
+                sequence: attempt.sequence,
+                decision: attempt.decision,
+                revisions: attempt.coverageWitnessRevalidation.revisions
+            }
+        ]);
+    const qualityReviewPacket = {
+        ...(input.validControlReviewVersion === 2 ? { validControlReviewVersion: 2 } : {}),
+        ...(input.reviewInputVersion === undefined
+            ? {}
+            : { reviewInputVersion: input.reviewInputVersion }),
+        ...(input.specificationContractFactsVersion === undefined
+            ? {}
+            : {
+                specificationContractFactsVersion: input.specificationContractFactsVersion,
+                contractFacts: authored.contractFacts
+            }),
+        ...modelContext,
+        visible: authored.visible,
+        targetBehavior: seed.targetBehavior,
+        specificationReviews: authored.reviews,
+        fixtureProposal,
+        ...(input.oracleCoverageWitnessVersion !== undefined
+            ? {
+                oracleCoverageReviews,
+                coverageResolutionPolicy: "Original critic verdicts are preserved. Execution assessments resolve only the fixed hypotheses via a reference-passing, isolated mutant-failing behavioral test and an incumbent replay. Retained tests protect those scenarios; this does not establish exhaustive coverage. Independently assess the actual assertions, witness semantics, valid controls and both tournaments."
+            }
+            : {}),
+        ...(input.oracleCoverageWitnessVersion === 2
+            ? {
+                oracleCoverageWitnessRevisions,
+                witnessRevisionPolicy: "Original witnesses and critic verdicts remain unchanged. A revised witness is adopted only after repeated reference passes, repeated assertion failures on the original isolated mutant, and acceptance of the complete development replacement. Review each revision and its adoption decision; rejected proposals do not replace the incumbent."
+            }
+            : {}),
+        validSolutions,
+        developmentAdversaries: adversarialSolutions,
+        solutionReviews: [solutionCriticA.value, solutionCriticB.value],
+        heldOutAdversaries: heldOutAdversarialSolutions,
+        heldOutSolutionReviews: [heldOutSolutionCriticA.value, heldOutSolutionCriticB.value],
+        heldOutAdequacy,
+        oracleFrozenBeforeHeldOutTournament: true,
+        trajectoryPolicy,
+        trajectoryPolicyReview,
+        trajectoryRevisionAttempts,
+        executableAdequacy: compiled.benchmarkCase.adequacy,
+        developmentOracle: {
+            clauses: compiled.benchmarkCase.hidden.clauses,
+            observations: compiled.benchmarkCase.hidden.observations
+        },
+        heldOutOracle: {
+            clauses: heldOutOracle.clauses,
+            observations: heldOutOracle.observations
+        },
+        hillClimbAttempts: hillClimbAttempts.map((attempt) => ({
+            sequence: attempt.sequence,
+            targetedFalseAcceptIds: attempt.proposal.targetedFalseAcceptIds,
+            targetedFalseRejectIds: attempt.proposal.targetedFalseRejectIds,
+            targetedInconclusiveIds: attempt.proposal.targetedInconclusiveIds ?? [],
+            decision: attempt.decision,
+            rejectionReasons: attempt.rejectionReasons,
+            before: attempt.beforeAdequacy,
+            candidate: attempt.candidateAdequacy,
+            ...(attempt.referencePreflight === undefined
+                ? {}
+                : { referencePreflight: attempt.referencePreflight }),
+            after: attempt.afterAdequacy
+        }))
+    };
+    const qualityEvidenceInventory = qualityReviewEvidenceInventory({
+        targetBehaviorCount: qualityReviewPacket.targetBehavior.length,
+        specificationReviewCount: qualityReviewPacket.specificationReviews.length,
+        fixtureCount: qualityReviewPacket.fixtureProposal.fixtures.length,
+        overlayCount: qualityReviewPacket.fixtureProposal.overlays.length,
+        validSolutionCount: qualityReviewPacket.validSolutions.length,
+        developmentAdversaryCount: qualityReviewPacket.developmentAdversaries.length,
+        solutionReviewCount: qualityReviewPacket.solutionReviews.length,
+        heldOutAdversaryCount: qualityReviewPacket.heldOutAdversaries.length,
+        heldOutSolutionReviewCount: qualityReviewPacket.heldOutSolutionReviews.length,
+        trajectoryRevisionAttemptCount: qualityReviewPacket.trajectoryRevisionAttempts.length,
+        hillClimbAttemptCount: qualityReviewPacket.hillClimbAttempts.length,
+        developmentObservationCount: qualityReviewPacket.developmentOracle.observations.length,
+        heldOutObservationCount: qualityReviewPacket.heldOutOracle.observations.length,
+        ...(input.oracleCoverageWitnessVersion !== undefined
+            ? { oracleCoverageReviewCount: oracleCoverageReviews.length }
+            : {}),
+        ...(input.oracleCoverageWitnessVersion === 2
+            ? { oracleCoverageWitnessRevisionCount: oracleCoverageWitnessRevisions.length }
+            : {})
+    });
+    const qualityReviewInput = {
+        ...qualityReviewPacket,
+        evidenceInventory: qualityEvidenceInventory
+    };
+    const generation = {
+        version: 1,
+        authored,
+        sourceContext: {
+            initialCommit: initialSnapshot.commit,
+            referenceCommit: reference.snapshot.commit,
+            initialSupportingPaths: initialLocalImports.sources.map((source) => source.path),
+            referenceSupportingPaths: referenceLocalImports.sources.map((source) => source.path)
+        },
+        initialFixtureProposal: fixtureGeneration.value,
+        fixtureProposal,
+        ...(input.maximumOracleCoverageRevisions === undefined ? {} : { oracleCoverageReviews }),
+        ...(input.oracleCoverageWitnessVersion === 2 ? { oracleCoverageWitnessRevisions } : {}),
+        trajectoryPolicy,
+        trajectoryPolicyReview,
+        trajectoryRevisionAttempts,
+        validSolutionProposal: {
+            solutions: [...validGenerationA.value.solutions, ...validGenerationB.value.solutions]
+        },
+        adversaryProposal: adversaryGeneration.value,
+        solutionReviews: [solutionCriticA.value, solutionCriticB.value],
+        heldOutAdversaryProposal,
+        heldOutSolutionReviews: [heldOutSolutionCriticA.value, heldOutSolutionCriticB.value],
+        heldOutAdequacy,
+        heldOutOracle,
+        weakAdequacy,
+        hillClimbAttempts,
+        benchmarkCase: compiled.benchmarkCase,
+        modelCalls: [
+            ...authored.modelCalls,
+            ...trajectoryModelCalls,
+            ...oracleAuthoringModelCalls,
+            ...validSolutionModelCalls,
+            adversaryGeneration.call,
+            ...solutionReviewModelCalls,
+            ...hillClimbCalls,
+            ...freezeCoverageModelCalls,
+            ...heldOutAdversaryCalls,
+            heldOutSolutionCriticA.call,
+            heldOutSolutionCriticB.call
+        ]
+    };
+    const reconstruction = yield* Effect.serviceOption(RepositoryFoundryEvidenceReconstruction);
+    const checkpoint = {
+        version: 1,
+        kind: "pending-quality-review",
+        ...(input.validControlReviewVersion === 2 ? { validControlReviewVersion: 2 } : {}),
+        ...(input.reviewInputVersion === undefined
+            ? {}
+            : { reviewInputVersion: input.reviewInputVersion }),
+        ...(input.specificationContractFactsVersion === undefined
+            ? {}
+            : { specificationContractFactsVersion: input.specificationContractFactsVersion }),
+        repositoryRoot: input.repositoryRoot,
+        operationId: input.operationId,
+        modelPlan: input.modelPlan,
+        seed,
+        requiresReplayValidation: Option.isSome(reconstruction),
+        generation,
+        qualityReviewInput,
+        sourceBases: editSources.map((source) => source.content)
+    };
+    yield* reportFoundryAuthoringArtifactV1({
+        version: 1,
+        operationId: `${input.operationId}:quality-review-checkpoint`,
+        role: "checkpoint-writer",
+        model: "local-evidence",
+        reasoningEffort: "none",
+        schemaName: "routekit_repository_quality_review_checkpoint_v1",
+        validation: "validated",
+        request: {
+            instructions: "Complete frozen case before quality review. This checkpoint is not an admission or a model call.",
+            input: {
+                caseId: input.caseId,
+                requiresReplayValidation: checkpoint.requiresReplayValidation
+            },
+            jsonSchema: { type: "object" },
+            maximumOutputTokens: 0
+        },
+        response: { text: "" },
+        value: checkpoint
+    });
+    if (input.checkpointOnly === true) {
+        if (Option.isNone(reconstruction))
+            return yield* failure("checkpoint reconstruction requires exact archived evidence");
+        yield* reconstruction.value.assertConsumed;
+        return { kind: "checkpoint", checkpoint };
+    }
+    const result = yield* reviewRepositoryGeneratedCaseCheckpointV1({ checkpoint });
+    return { kind: "generated", result };
+});
+export const generateHistoricalRepositoryCaseV1 = Effect.fn("CaseGeneration.completeHistorical")(function* (input) {
+    const result = yield* generateHistoricalRepositoryCaseStagesV1(input);
+    if (result.kind !== "generated")
+        return yield* failure("generation stopped before final review");
+    return result.result;
+});
+export const reconstructRepositoryGeneratedCaseCheckpointV1 = Effect.fn("CaseGeneration.reconstructCheckpoint")(function* (input) {
+    const reconstruction = yield* Effect.serviceOption(RepositoryFoundryEvidenceReconstruction);
+    if (Option.isNone(reconstruction))
+        return yield* failure("checkpoint reconstruction requires an archived-evidence scope");
+    const result = yield* generateHistoricalRepositoryCaseStagesV1({
+        ...input,
+        checkpointOnly: true
+    });
+    if (result.kind !== "checkpoint")
+        return yield* failure("reconstruction did not stop before review");
+    return result.checkpoint;
+});
+/** Pure sizing of the full frozen review request, including wire wrapping and schema. */
+export const prepareRepositoryCaseQualityReviewV1 = (input) => {
+    const checkpoint = input.checkpoint;
+    const reviewInputVersion = input.reviewInputVersion ?? checkpoint.reviewInputVersion;
+    const requestByteLimit = evalAuthoringRequestByteLimit({
+        foundryRole: "quality-reviewer",
+        schemaName: "routekit_repository_generation_quality_review_v1",
+        ...(reviewInputVersion === undefined ? {} : { reviewInputVersion })
+    });
+    const document = Schema.toJsonSchemaDocument(QualityReview);
+    const jsonSchema = strictAuthoringSchema({
+        ...document.schema,
+        ...(Object.keys(document.definitions).length === 0 ? {} : { $defs: document.definitions })
+    }).jsonSchema;
+    const reviewer = repositoryFoundryModelAssignmentV1(checkpoint.modelPlan, "quality-reviewer");
+    const size = (evidence, instructions) => Buffer.byteLength(evalAuthoringResponsesRequestBody({
+        operationId: input.operationId ?? `${checkpoint.operationId}:quality-reviewer`,
+        model: reviewer.model,
+        reasoningEffort: reviewer.reasoningEffort,
+        instructions: `${qualityReviewInstructions(checkpoint.validControlReviewVersion)}\n\n${instructions}`,
+        input: JSON.stringify(evidence),
+        schemaName: "routekit_repository_generation_quality_review_v1",
+        jsonSchema,
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("quality-reviewer")
+    }));
+    const legacy = encodeRepositoryReviewEvidenceV1(checkpoint.qualityReviewInput, checkpoint.sourceBases);
+    const legacyBytes = size(legacy, REPOSITORY_REVIEW_EVIDENCE_INSTRUCTIONS);
+    if (legacyBytes <= REPOSITORY_FOUNDRY_REQUEST_INPUT_CEILING)
+        return {
+            evidence: legacy,
+            instructions: REPOSITORY_REVIEW_EVIDENCE_INSTRUCTIONS,
+            requestBytes: legacyBytes,
+            requestByteLimit
+        };
+    const evidence = encodeRepositoryReviewEvidenceV2(checkpoint.qualityReviewInput, checkpoint.sourceBases);
+    const requestBytes = size(evidence, REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS);
+    if (requestBytes > requestByteLimit)
+        throw failure("complete benchmark artifacts exceed the independent quality review input ceiling; frozen checkpoint retained");
+    return {
+        evidence,
+        instructions: REPOSITORY_REVIEW_EVIDENCE_V2_INSTRUCTIONS,
+        requestBytes,
+        requestByteLimit
+    };
+};
+export const reviewRepositoryGeneratedCaseCheckpointV1 = Effect.fn("CaseGeneration.reviewCheckpoint")(function* (input) {
+    const reconstruction = yield* Effect.serviceOption(RepositoryFoundryEvidenceReconstruction);
+    if (Option.isSome(reconstruction) || input.checkpoint.requiresReplayValidation)
+        return yield* failure("diagnostic reconstruction cannot perform review or confer admission before real replay validation");
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    const checkpoint = input.checkpoint;
+    const reviewInputVersion = input.reviewInputVersion ?? checkpoint.reviewInputVersion;
+    const inventory = checkpoint.qualityReviewInput.evidenceInventory;
+    if (!Array.isArray(inventory) || inventory.some((entry) => typeof entry !== "string"))
+        return yield* failure("checkpoint review requires its complete evidence inventory");
+    const qualityEvidenceInventory = inventory;
+    const encoded = yield* Effect.try({
+        try: () => prepareRepositoryCaseQualityReviewV1(input),
+        catch: (cause) => failure("complete benchmark review evidence could not be encoded losslessly", cause)
+    });
+    yield* reportFoundryStageV1("quality-review");
+    const qualityGeneration = yield* languageModel.generateStructured({
+        plan: checkpoint.modelPlan,
+        role: "quality-reviewer",
+        ...(reviewInputVersion === undefined ? {} : { reviewInputVersion }),
+        operationId: input.operationId ?? `${checkpoint.operationId}:quality-reviewer`,
+        instructions: `${qualityReviewInstructions(checkpoint.validControlReviewVersion)}\n\n${encoded.instructions}`,
+        input: encoded.evidence,
+        schemaName: "routekit_repository_generation_quality_review_v1",
+        outputSchema: QualityReview,
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("quality-reviewer")
+    });
+    yield* Effect.try({
+        try: () => validateRepositoryGenerationQualityReviewV1(qualityGeneration.value, qualityEvidenceInventory),
+        catch: (cause) => cause instanceof RepositoryFoundryError
+            ? cause
+            : failure("independent quality review failed validation", cause)
+    });
+    if (qualityGeneration.value.verdict !== "approve" ||
+        qualityGeneration.value.coverageGaps.length > 0 ||
+        qualityGeneration.value.correlatedAssumptions.length > 0)
+        return yield* failure([
+            "independent quality review rejected the generated case",
+            qualityGeneration.value.detail,
+            ...qualityGeneration.value.coverageGaps.map((gap) => `coverage-gap=${gap}`),
+            ...qualityGeneration.value.correlatedAssumptions.map((assumption) => `correlated-assumption=${assumption}`)
+        ].join("; "));
+    yield* reportFoundryStageV1("admit", `status=${checkpoint.generation.benchmarkCase.status}`);
+    return {
+        ...checkpoint.generation,
+        qualityReview: qualityGeneration.value,
+        modelCalls: [...checkpoint.generation.modelCalls, qualityGeneration.call]
+    };
+});
+export const makeCaseGeneration = Effect.gen(function* () {
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    return CaseGeneration.of({
+        reviewSemanticSolutions: (input) => executeRepositorySemanticReviewV1(input).pipe(Effect.provideService(RepositoryFoundryLanguageModel, languageModel)),
+        generateHistorical: (input) => generateHistoricalRepositoryCaseV1(input).pipe(Effect.provideService(RepositoryFoundryLanguageModel, languageModel))
+    });
+});
+export const CaseGenerationLive = Layer.effect(CaseGeneration, makeCaseGeneration);