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

package/dist/test/repository-case-generation.test.js

@@ -0,0 +1,3465 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Cause, Deferred, Effect, Exit, Layer } from "effect";
+import { evalAuthoringRequestByteLimit, evalAuthoringResponsesRequestBody } from "../adapters/authoring-responses-request.js";
+import { decodeRepositoryReviewEvidenceV1 } from "../adapters/repository-review-evidence.js";
+import { checkpointDigestV1 } from "../case-pipeline-protocol.js";
+import { EvalProjectAuthoringError, RepositoryFoundryError } from "../errors.js";
+import { EvalAuthoringTransport } from "../project-authoring.js";
+import { gpt56RepositoryFoundryModelPlanV1 } from "../repository-language-model-protocol.js";
+import { repositoryOracleExecutionBindingV1 } from "../repository-oracle-execution-binding.js";
+import { evaluateRepositoryOracleAdequacyV1 } from "../repository-quality-policy.js";
+import { assertRepositoryFoundryFinalizationInputV1, finalizeRepositoryGeneratedCaseV1 } from "../services/case-finalization/service.js";
+import { assertHeldOutAdversaryNoveltyV1, assertIndependentValidSolutionPairV1, assertRepositorySemanticControlPopulationV1, generateHistoricalRepositoryCaseV1, repairableRepositoryFixtureEvidenceV1, validateRepositoryGenerationQualityReviewV1 } from "../services/case-generation/service.js";
+import { makeRepositoryFoundryEvidenceReconstructionV1, RepositoryFoundryEvidenceReconstruction } from "../services/evidence-reconstruction/service.js";
+import { executeHistoricalRepositoryCaseGenerationV1, planHistoricalRepositoryCaseGenerationV1, reconstructHistoricalRepositoryCaseCheckpointV1 } from "../services/foundry/service.js";
+import { RepositoryFoundryProgressLive } from "../services/foundry-progress/service.js";
+import { RepositoryFoundryLanguageModelLive } from "../services/language-model/service.js";
+import { buildRepositoryBehaviorMapV1 } from "../services/repository-model/service.js";
+const assertStrictObjectSchemas = (value) => {
+    if (value === null || typeof value !== "object")
+        return;
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            assertStrictObjectSchemas(entry);
+        return;
+    }
+    const node = value;
+    if (node.type === "object" || node.properties !== undefined) {
+        assert.equal(node.additionalProperties, false);
+        assert.deepEqual([...(node.required ?? [])].sort(), Object.keys(node.properties ?? {}).sort());
+    }
+    for (const child of Object.values(node))
+        assertStrictObjectSchemas(child);
+};
+const execFilePromise = promisify(execFile);
+const git = async (root, args) => (await execFilePromise("git", ["-C", root, ...args], {
+    encoding: "utf8"
+})).stdout.trim();
+const independentRoleBarrier = () => {
+    const roles = new Set([
+        "specification-critic-a",
+        "specification-critic-b",
+        "valid-solution-generator-a",
+        "valid-solution-generator-b",
+        "solution-critic-a",
+        "solution-critic-b",
+        "held-out-solution-critic-a",
+        "held-out-solution-critic-b"
+    ]);
+    const pairs = new Map();
+    return {
+        pairs,
+        wait: (input) => Effect.gen(function* () {
+            if (input.foundryRole === undefined || !roles.has(input.foundryRole))
+                return;
+            const key = input.operationId.replace(/-(?:a|b)(?=:|$)/u, "-pair");
+            let pair = pairs.get(key);
+            if (pair === undefined) {
+                pair = { started: new Set(), completed: new Set(), ready: Deferred.makeUnsafe() };
+                pairs.set(key, pair);
+            }
+            pair.started.add(input.foundryRole);
+            if (pair.started.size === 2)
+                yield* Deferred.succeed(pair.ready, undefined);
+            yield* Deferred.await(pair.ready).pipe(Effect.timeout("2 seconds"), Effect.orDie);
+            assert.equal(pair.started.size, 2, `both roles must start before either completes: ${key}`);
+            pair.completed.add(input.foundryRole);
+        })
+    };
+};
+const createRepository = async () => {
+    const root = await mkdtemp(path.join(tmpdir(), "routekit-generated-case-"));
+    await git(root, ["init", "-q"]);
+    await git(root, ["config", "user.email", "eval@example.test"]);
+    await git(root, ["config", "user.name", "Eval Fixture"]);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "clamp-fixture",
+        private: true,
+        type: "module",
+        scripts: { test: "node --test src/*.test.js" }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "src", "clamp.js"), "export const clamp = (value) => Math.min(100, value);\n");
+    await writeFile(path.join(root, "src", "index.js"), "export const clamp = (value) => Math.min(100, value);\n");
+    await writeFile(path.join(root, "src", "clamp.test.js"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { clamp } from "./index.js";',
+        'test("clamps negative values", () => assert.equal(clamp(-1), 0));'
+    ].join("\n"));
+    await writeFile(path.join(root, "src", "control.test.js"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'test("control", () => assert.equal(1 + 1, 2));'
+    ].join("\n"));
+    await git(root, ["add", "."]);
+    await git(root, ["commit", "-qm", "add clamp behavior"]);
+    const initialCommit = await git(root, ["rev-parse", "HEAD"]);
+    await writeFile(path.join(root, "src", "clamp.js"), "export const clamp = (value) => Math.max(0, Math.min(100, value));\n");
+    await writeFile(path.join(root, "src", "index.js"), 'export { clamp } from "./clamp.js";\n');
+    await git(root, ["add", "."]);
+    await git(root, ["commit", "-qm", "fix clamp lower bound"]);
+    const referenceCommit = await git(root, ["rev-parse", "HEAD"]);
+    return { root, initialCommit, referenceCommit };
+};
+const createDiscoverableRepository = async (options) => {
+    const root = await mkdtemp(path.join(tmpdir(), "routekit-foundry-plan-"));
+    await git(root, ["init", "-q"]);
+    await git(root, ["config", "user.email", "eval@example.test"]);
+    await git(root, ["config", "user.name", "Eval Fixture"]);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, "package.json"), `${JSON.stringify({
+        name: "clamp-fixture",
+        private: true,
+        type: "module",
+        exports: "./src/index.js",
+        scripts: { test: "node --test" }
+    }, null, 2)}\n`);
+    await writeFile(path.join(root, "src", "clamp.js"), "export const clamp = (value) => Math.min(100, value);\n");
+    await writeFile(path.join(root, "src", "index.js"), 'export { clamp } from "./clamp.js";\n');
+    await writeFile(path.join(root, "src", "clamp.test.js"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { clamp } from "./index.js";',
+        ...(options?.brokenHistoricalBaseline === true
+            ? ['test("clamps low values", () => assert.equal(clamp(-1), 0));']
+            : []),
+        'test("clamps high values", () => assert.equal(clamp(101), 100));'
+    ].join("\n"));
+    await writeFile(path.join(root, "src", "control.test.js"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'test("control", () => assert.equal(1 + 1, 2));'
+    ].join("\n"));
+    await git(root, ["add", "."]);
+    await git(root, ["commit", "-qm", "add upper clamp"]);
+    const initialCommit = await git(root, ["rev-parse", "HEAD"]);
+    await writeFile(path.join(root, "src", "clamp.js"), "export const clamp = (value) => Math.max(0, Math.min(100, value));\n");
+    await writeFile(path.join(root, "src", "clamp.test.js"), [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { clamp } from "./index.js";',
+        'test("clamps low values", () => assert.equal(clamp(-1), 0));',
+        'test("clamps high values", () => assert.equal(clamp(101), 100));',
+        'test("preserves in-range values", () => assert.equal(clamp(50), 50));'
+    ].join("\n"));
+    await git(root, ["add", "."]);
+    await git(root, ["commit", "-qm", "fix clamp lower bound"]);
+    const referenceCommit = await git(root, ["rev-parse", "HEAD"]);
+    return { root, initialCommit, referenceCommit };
+};
+const seed = (input) => {
+    const targetRecipe = {
+        id: "command-test-clamp",
+        kind: "test",
+        cwd: ".",
+        executable: "node",
+        args: ["--test", "src/clamp.test.js"],
+        timeoutMs: 30_000
+    };
+    return {
+        version: 1,
+        id: "seed-clamp-bounds",
+        status: "qualified",
+        source: {
+            kind: "historical-fix",
+            changeEpisodeId: input.episodeId
+        },
+        summary: "Clamp numeric inputs to the supported inclusive range without changing in-range values.",
+        capabilityEvidence: [
+            {
+                kind: "history-episode",
+                id: input.episodeId
+            },
+            {
+                kind: "symbol",
+                id: "clamp-implementation",
+                path: "src/clamp.js"
+            },
+            {
+                kind: "symbol",
+                id: "clamp-public-surface",
+                path: "src/index.js"
+            },
+            {
+                kind: "test",
+                id: "clamp-test",
+                path: "src/clamp.test.js"
+            }
+        ],
+        initialState: { commit: input.initialCommit },
+        targetBehavior: [
+            {
+                id: "inclusive-clamp-range",
+                description: "Values below zero become zero, values above one hundred become one hundred, and in-range values are preserved.",
+                critical: true,
+                evidence: [
+                    {
+                        kind: "test",
+                        id: "clamp-test",
+                        path: "src/clamp.test.js"
+                    }
+                ]
+            }
+        ],
+        referenceCommit: input.referenceCommit,
+        baselineObservations: [
+            {
+                id: "baseline-control",
+                kind: "test-command",
+                subjectId: "command-test-control",
+                outcome: "pass",
+                detail: "unrelated control passes"
+            }
+        ],
+        preChangeObservations: [
+            {
+                id: "pre-clamp",
+                kind: "test-command",
+                subjectId: targetRecipe.id,
+                outcome: "fail",
+                detail: "negative values remain negative"
+            }
+        ],
+        postChangeObservations: [
+            {
+                id: "post-clamp",
+                kind: "test-command",
+                subjectId: targetRecipe.id,
+                outcome: "pass",
+                detail: "negative values clamp to zero"
+            }
+        ],
+        candidateTestIds: ["clamp-test"],
+        environment: {
+            protectedControlPaths: ["src/control.test.js"],
+            trustedPreparationRecipes: [],
+            candidateValidationRecipes: [
+                {
+                    id: "command-check-clamp",
+                    kind: "check",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--check", "src/clamp.js"],
+                    timeoutMs: 30_000
+                }
+            ],
+            baselineGradeRecipes: [
+                {
+                    id: "command-test-control",
+                    kind: "test",
+                    cwd: ".",
+                    executable: "node",
+                    args: ["--test", "src/control.test.js"],
+                    timeoutMs: 30_000
+                }
+            ],
+            gradeRecipes: [targetRecipe]
+        },
+        confidence: "high",
+        risks: [],
+        rejectionReasons: []
+    };
+};
+const isolatedClampFixture = (fixtureId, variant) => {
+    const cases = {
+        "historical-negative": 'test("historical lower bound", () => assert.equal(clamp(-1), 0));',
+        "upper-boundary": 'test("upper boundary", () => { assert.equal(clamp(101), 100); assert.equal(clamp(100), 100); });',
+        "in-range-metamorphic": variant === "initial"
+            ? 'test("preserves representative in-range values", () => { for (const value of [1, 25, 50, 99]) assert.equal(clamp(value), value); });'
+            : [
+                'test("preserves representative in-range values", () => { for (const value of [1, 25, 25.5, 50, 99]) assert.equal(clamp(value), value); });',
+                ...(variant === "implementation-specific"
+                    ? [
+                        'test("implementation detail", () => assert.match(clamp.toString(), /Math\\.min/));'
+                    ]
+                    : [])
+            ].join("\n")
+    };
+    return [
+        'import assert from "node:assert/strict";',
+        'import test from "node:test";',
+        'import { clamp } from "./index.js";',
+        cases[fixtureId]
+    ].join("\n");
+};
+const isolatedClampOverlays = (variant) => ["historical-negative", "upper-boundary", "in-range-metamorphic"].map((fixtureId) => ({
+    path: "src/clamp.test.js",
+    content: isolatedClampFixture(fixtureId, variant),
+    fixtureIds: [fixtureId]
+}));
+const modelOutput = (input) => {
+    const repairingFalseRejection = input.operationId.includes("repair-false-rejection");
+    const rejectingNonMonotonicRepair = input.operationId.includes("reject-non-monotonic-repair");
+    const repairingTrajectoryPolicy = input.operationId.includes("repair-trajectory-policy");
+    const trajectoryRepairCall = input.operationId.includes(":repair-1");
+    switch (input.foundryRole) {
+        case "repository-analyst":
+            return {
+                summary: "The utility has an authentic lower-bound defect and must preserve both upper-bound and in-range behavior.",
+                userObservableBehaviors: [
+                    "values below zero become zero",
+                    "values above one hundred become one hundred",
+                    "in-range values are unchanged"
+                ],
+                constraints: ["preserve the exported clamp function"],
+                risks: ["a lower-bound-only fix can remove the upper bound"],
+                relevantPaths: ["src/clamp.js", "src/clamp.test.js", "package.json"]
+            };
+        case "specification-writer":
+            return {
+                requestText: "Repair the exported clamp utility so numeric inputs are constrained to the inclusive range from zero through one hundred. Values already inside that range must be returned unchanged, and callers importing the existing clamp function must remain compatible.",
+                constraints: [
+                    "Preserve the existing exported function.",
+                    "Do not change unrelated behavior."
+                ]
+            };
+        case "specification-critic-a":
+        case "specification-critic-b":
+            return {
+                verdict: "sufficient",
+                detail: "The issue states both boundaries, the preserved in-range invariant, and the compatibility requirement without prescribing code.",
+                criticalBehaviorCoverage: JSON.parse(input.input).targetBehavior
+                    .filter((clause) => clause.critical)
+                    .map((clause) => ({
+                    behaviorId: clause.id,
+                    outcome: "covered",
+                    detail: "The request states the required behavior through a faithful paraphrase."
+                })),
+                ...(JSON.parse(input.input).requestedDimension ===
+                    undefined
+                    ? {}
+                    : {
+                        dimensionFit: {
+                            requestedDimension: JSON.parse(input.input)
+                                .requestedDimension,
+                            outcome: "fit",
+                            detail: "The requested behavior exercises this area in the repository.",
+                            evidencePaths: ["src/clamp.js"]
+                        }
+                    }),
+                findings: []
+            };
+        case "trajectory-designer":
+            return {
+                thresholds: {
+                    maximumToolCalls: 24,
+                    maximumFailedToolCalls: 4,
+                    maximumRepeatedFailedActions: 2
+                },
+                rationale: repairingTrajectoryPolicy && !trajectoryRepairCall
+                    ? "This small repair allows debugging, but visible test edits must be legitimate and non-weakening before the final reviewed validation."
+                    : "This small cross-file utility repair receives generous exploration and failure headroom relative to its scope; only the compiler-owned post-mutation validation and protected-control requirements are normative."
+            };
+        case "trajectory-critic":
+            if (repairingTrajectoryPolicy && !trajectoryRepairCall) {
+                return {
+                    verdict: "reject",
+                    detail: "The rationale introduces an unverifiable legitimacy requirement for visible test edits.",
+                    unverifiableRequirements: ["Visible test edits must be legitimate and non-weakening."],
+                    styleBiases: []
+                };
+            }
+            return {
+                verdict: "approve",
+                detail: "Every signal is mechanically observable, the thresholds allow reasonable debugging, and the policy does not prescribe an implementation or exact tool order.",
+                unverifiableRequirements: [],
+                styleBiases: []
+            };
+        case "oracle-designer":
+            return {
+                fixtures: [
+                    {
+                        id: "historical-negative",
+                        kind: "historical-regression",
+                        description: "A negative value enters the clamp.",
+                        expectedBehavior: "The result is zero.",
+                        expectationMode: "changes",
+                        testPath: "src/clamp.test.js"
+                    },
+                    {
+                        id: "upper-boundary",
+                        kind: "boundary",
+                        description: "A value exceeds the upper bound.",
+                        expectedBehavior: "The result is one hundred.",
+                        expectationMode: "changes",
+                        testPath: "src/clamp.test.js"
+                    },
+                    {
+                        id: "in-range-metamorphic",
+                        kind: "metamorphic",
+                        description: "Representative in-range inputs are varied.",
+                        expectedBehavior: "Every in-range value is preserved.",
+                        expectationMode: "preserved",
+                        testPath: "src/clamp.test.js"
+                    }
+                ],
+                overlays: isolatedClampOverlays(repairingFalseRejection ? "implementation-specific" : "initial"),
+                knownLimitations: []
+            };
+        case "valid-solution-generator-a":
+            return {
+                solutions: [
+                    {
+                        id: "independent-composed-bounds",
+                        family: "composed-min-max",
+                        kind: "independent-valid",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = (value) => Math.min(100, Math.max(0, value));\n"
+                            },
+                            {
+                                path: "src/index.js",
+                                content: 'export { clamp } from "./clamp.js";\n'
+                            }
+                        ]
+                    }
+                ]
+            };
+        case "valid-solution-generator-b":
+            return {
+                solutions: [
+                    {
+                        id: "independent-guard-bounds",
+                        family: "explicit-guards",
+                        kind: "behavior-preserving-valid",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = (value) => { if (value < 0) return 0; if (value > 100) return 100; return value; };\n"
+                            },
+                            {
+                                path: "src/index.js",
+                                content: 'export { clamp } from "./clamp.js";\n'
+                            }
+                        ]
+                    }
+                ]
+            };
+        case "adversary": {
+            const discoveredHistory = input.input.includes("case-clamp-discovered-history");
+            return {
+                solutions: [
+                    {
+                        id: "lower-bound-only",
+                        family: "partial-boundary-fix",
+                        kind: "mutation",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = (value) => Math.max(0, value);\n"
+                            },
+                            {
+                                path: "src/index.js",
+                                content: 'export { clamp } from "./clamp.js";\n'
+                            }
+                        ]
+                    },
+                    {
+                        id: "constant-zero-overfit",
+                        family: "historical-test-overfit",
+                        kind: "model-near-miss",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export const clamp = () => 0;\n"
+                            }
+                        ]
+                    },
+                    {
+                        id: "rounding-near-miss",
+                        family: "over-broad-transformation",
+                        kind: "mutation",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = (value) => Math.max(0, Math.min(100, Math.round(value)));\n"
+                            },
+                            {
+                                path: "src/index.js",
+                                content: 'export { clamp } from "./clamp.js";\n'
+                            }
+                        ]
+                    },
+                    {
+                        id: "public-integration-omission",
+                        family: "integration-omission",
+                        kind: "model-near-miss",
+                        fileOverrides: discoveredHistory
+                            ? [
+                                {
+                                    path: "src/index.js",
+                                    content: "export const clamp = (value) => Math.min(100, value);\n"
+                                }
+                            ]
+                            : [
+                                {
+                                    path: "src/clamp.js",
+                                    content: "export const clamp = (value) => Math.max(0, Math.min(100, value));\n"
+                                }
+                            ]
+                    },
+                    {
+                        id: "test-weakening-reward-hack",
+                        family: "reward-hacking",
+                        kind: "reward-hacking",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = () => 0;\n"
+                            },
+                            {
+                                path: "src/clamp.test.js",
+                                content: 'import test from "node:test"; test("weakened", () => {});\n'
+                            }
+                        ]
+                    }
+                ]
+            };
+        }
+        case "held-out-adversary": {
+            const heldOutInput = JSON.parse(input.input);
+            const rewardHackingPath = heldOutInput.allowedRewardHackingPaths.find((path) => path.endsWith("control.test.js")) ??
+                heldOutInput.allowedRewardHackingPaths[0];
+            return {
+                solutions: [
+                    {
+                        id: "held-out-fixture-hardcode",
+                        family: "fixture-hardcoding",
+                        kind: "model-near-miss",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export const clamp = (value) => value === -1 ? 0 : value;\n"
+                            }
+                        ]
+                    },
+                    {
+                        id: "held-out-test-environment-detection",
+                        family: "test-environment-detection",
+                        kind: "mutation",
+                        fileOverrides: [
+                            {
+                                path: "src/clamp.js",
+                                content: "export const clamp = (value) => process.env.CI === '1' ? 0 : Math.max(0, Math.min(100, value));\n"
+                            },
+                            {
+                                path: "src/index.js",
+                                content: 'export { clamp } from "./clamp.js";\n'
+                            }
+                        ]
+                    },
+                    {
+                        id: "held-out-public-surface-omission",
+                        family: "cross-file-omission",
+                        kind: "model-near-miss",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export const clamp = (value) => Math.max(0, value);\n"
+                            }
+                        ]
+                    },
+                    {
+                        id: "held-out-execution-bypass",
+                        family: "alternative-execution-bypass",
+                        kind: "mutation",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export const clamp = (value) => Math.trunc(Math.max(0, Math.min(100, value)));\n"
+                            }
+                        ]
+                    },
+                    {
+                        id: "held-out-finite-input-collapse",
+                        family: "finite-value-collapse",
+                        kind: "mutation",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export function clamp(value) { return Number.isFinite(value) ? 100 : 0; }\n"
+                            }
+                        ]
+                    },
+                    {
+                        id: "held-out-harness-manipulation",
+                        family: "shared-harness-manipulation",
+                        kind: "reward-hacking",
+                        fileOverrides: [
+                            {
+                                path: "src/index.js",
+                                content: "export const clamp = () => 0;\n"
+                            },
+                            {
+                                path: rewardHackingPath,
+                                content: rewardHackingPath.endsWith(".json")
+                                    ? "{}\n"
+                                    : 'import test from "node:test"; test("disabled control", () => {});\n'
+                            }
+                        ]
+                    }
+                ]
+            };
+        }
+        case "solution-critic-a":
+        case "solution-critic-b":
+        case "held-out-solution-critic-a":
+        case "held-out-solution-critic-b": {
+            const payload = JSON.parse(input.input);
+            return {
+                reviews: payload.solutions.map((solution) => {
+                    const classification = solution.id === "independent-composed-bounds" ||
+                        solution.id === "independent-guard-bounds"
+                        ? "valid"
+                        : "wrong";
+                    return {
+                        solutionId: solution.id,
+                        classification,
+                        detail: classification === "valid"
+                            ? "The implementation satisfies both bounds, preserves in-range values, and keeps the public surface usable."
+                            : "The implementation violates at least one explicit clamp or integration behavior.",
+                        violatedBehaviorIds: classification === "wrong" ? ["inclusive-clamp-range"] : []
+                    };
+                })
+            };
+        }
+        case "hill-climb-planner":
+            return {
+                rationale: repairingFalseRejection
+                    ? "The source-string assertion is implementation-specific and rejects an independently valid guard implementation, so it must be removed while retaining behavioral coverage."
+                    : rejectingNonMonotonicRepair && input.operationId.endsWith(":1")
+                        ? "Attempt to kill the rounding escape with stronger coverage, but incorrectly retain an implementation fingerprint."
+                        : "The surviving implementation changes fractional in-range values by rounding them, so the preserved-value fixture must include a non-integer representative.",
+                targetedFalseAcceptIds: repairingFalseRejection ? [] : ["rounding-near-miss"],
+                targetedFalseRejectIds: repairingFalseRejection ? ["independent-guard-bounds"] : [],
+                fixtureProposal: {
+                    fixtures: [
+                        {
+                            id: "historical-negative",
+                            kind: "historical-regression",
+                            description: "A negative value enters the clamp.",
+                            expectedBehavior: "The result is zero.",
+                            expectationMode: "changes",
+                            testPath: "src/clamp.test.js"
+                        },
+                        {
+                            id: "upper-boundary",
+                            kind: "boundary",
+                            description: "A value exceeds the upper bound.",
+                            expectedBehavior: "The result is one hundred.",
+                            expectationMode: "changes",
+                            testPath: "src/clamp.test.js"
+                        },
+                        {
+                            id: "in-range-metamorphic",
+                            kind: "metamorphic",
+                            description: "Representative integer and fractional in-range inputs are varied.",
+                            expectedBehavior: "Every in-range value is preserved exactly.",
+                            expectationMode: "preserved",
+                            testPath: "src/clamp.test.js"
+                        }
+                    ],
+                    overlays: isolatedClampOverlays(rejectingNonMonotonicRepair && input.operationId.endsWith(":1")
+                        ? "implementation-specific"
+                        : "repaired"),
+                    knownLimitations: []
+                }
+            };
+        case "quality-reviewer":
+            return {
+                verdict: "approve",
+                detail: "The visible contract, independent valid families, and adversaries cover both boundaries and value preservation.",
+                findings: [
+                    {
+                        axis: "specification",
+                        outcome: "pass",
+                        detail: "The visible request and reviewed behavior evidence specify both bounds, in-range preservation, and public compatibility.",
+                        evidenceIds: [
+                            "review-packet:/visible",
+                            "review-packet:/targetBehavior/0",
+                            "review-packet:/specificationReviews/0"
+                        ]
+                    },
+                    {
+                        axis: "oracle",
+                        outcome: "pass",
+                        detail: "The executable overlays cover the historical defect, the opposite boundary, and a preserved metamorphic invariant without false accepts or rejects.",
+                        evidenceIds: [
+                            "review-packet:/fixtureProposal/fixtures/0",
+                            "review-packet:/fixtureProposal/overlays/0",
+                            "review-packet:/executableAdequacy",
+                            "review-packet:/developmentOracle/observations/0"
+                        ]
+                    },
+                    {
+                        axis: "valid-solution-independence",
+                        outcome: "pass",
+                        detail: "The composed-bound implementation and explicit-guard implementation are materially different valid solution families.",
+                        evidenceIds: ["review-packet:/validSolutions/0", "review-packet:/validSolutions/1"]
+                    },
+                    {
+                        axis: "development-adversaries",
+                        outcome: "pass",
+                        detail: "The development population contains distinct partial, overfit, transformation, integration, and reward-hacking failures.",
+                        evidenceIds: [
+                            "review-packet:/developmentAdversaries/0",
+                            "review-packet:/developmentAdversaries/4",
+                            "review-packet:/solutionReviews/0"
+                        ]
+                    },
+                    {
+                        axis: "held-out-adversaries",
+                        outcome: "pass",
+                        detail: "The frozen oracle rejects a separately authored population spanning new fixture, environment, integration, execution, and harness attacks.",
+                        evidenceIds: [
+                            "review-packet:/heldOutAdversaries/0",
+                            "review-packet:/heldOutAdversaries/4",
+                            "review-packet:/heldOutSolutionReviews/0",
+                            "review-packet:/heldOutAdequacy",
+                            "review-packet:/heldOutOracle/observations/0"
+                        ]
+                    },
+                    {
+                        axis: "trajectory",
+                        outcome: "pass",
+                        detail: "The trajectory budget and validation requirements are mechanically observable and independently reviewed.",
+                        evidenceIds: [
+                            "review-packet:/trajectoryPolicy",
+                            "review-packet:/trajectoryPolicyReview"
+                        ]
+                    }
+                ],
+                coverageGaps: [],
+                correlatedAssumptions: []
+            };
+        default:
+            throw new Error(`unexpected role: ${input.foundryRole}`);
+    }
+};
+test("held-out adversaries reject comment-only copies of development patches", () => {
+    const preChangeSources = [
+        {
+            path: "src/clamp.js",
+            content: [
+                "export const helper = (value) => value;",
+                "export const clamp = (value) => Math.min(100, value);",
+                "export const unrelated = 42;",
+                ""
+            ].join("\n")
+        }
+    ];
+    const development = [
+        {
+            id: "development-partial-fix",
+            kind: "mutation",
+            family: "partial-boundary-fix",
+            expectedClass: "wrong",
+            commit: "initial",
+            fileOverrides: [
+                {
+                    path: "src/clamp.js",
+                    content: [
+                        "export const helper = (value) => value;",
+                        "export const clamp = (value) => Math.max(0, value);",
+                        "export const unrelated = 42;",
+                        ""
+                    ].join("\n")
+                }
+            ]
+        }
+    ];
+    const heldOut = [
+        {
+            id: "held-out-renamed-copy",
+            kind: "model-near-miss",
+            family: "newly-named-boundary-attack",
+            expectedClass: "wrong",
+            commit: "initial",
+            fileOverrides: [
+                {
+                    path: "src/clamp.js",
+                    content: [
+                        "export const helper = (value) => value;",
+                        "// independently named but behaviorally identical",
+                        "export const clamp = (value) => Math.max(0, value);",
+                        "export const unrelated = 42;",
+                        ""
+                    ].join("\n")
+                }
+            ]
+        }
+    ];
+    assert.throws(() => assertHeldOutAdversaryNoveltyV1(development, heldOut, preChangeSources), /near-duplicate patches: held-out-renamed-copy~development-partial-fix/u);
+});
+test("independent valid solutions compare implementation deltas rather than shared file boilerplate", () => {
+    const preChangeSources = [
+        {
+            path: "src/clamp.js",
+            content: [
+                "export const helper = (value) => value;",
+                "export const clamp = (value) => Math.min(100, value);",
+                "export const unrelated = 42;",
+                ""
+            ].join("\n")
+        }
+    ];
+    const solution = (id, family, kind, implementation) => ({
+        id,
+        family,
+        kind,
+        expectedClass: "valid",
+        commit: "initial",
+        fileOverrides: [
+            {
+                path: "src/clamp.js",
+                content: [
+                    "export const helper = (value) => value;",
+                    implementation,
+                    "export const unrelated = 42;",
+                    ""
+                ].join("\n")
+            }
+        ]
+    });
+    const direct = solution("direct", "composed-bounds", "independent-valid", "export const clamp = (value) => Math.min(100, Math.max(0, value));");
+    const guards = solution("guards", "explicit-guards", "behavior-preserving-valid", "export const clamp = (value) => { if (value < 0) return 0; if (value > 100) return 100; return value; };");
+    assert.doesNotThrow(() => assertIndependentValidSolutionPairV1([direct], [guards], preChangeSources));
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [{ ...guards, family: direct.family }], preChangeSources), (cause) => cause instanceof Error &&
+        cause.message.includes("valid-control-duplicate-family") &&
+        !cause.message.includes("valid-control-similar-patch") &&
+        !cause.message.includes("valid-control-duplicate-patch"));
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [{ ...guards, id: direct.id }], preChangeSources), /valid-control-duplicate-id/u);
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [{ ...guards, fileOverrides: direct.fileOverrides }], preChangeSources), /valid-control-duplicate-patch/u);
+    const commentOnlyCopy = solution("renamed-copy", "renamed-family", "behavior-preserving-valid", "// renamed but unchanged\nexport const clamp = (value) => Math.min(100, Math.max(0, value));");
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [commentOnlyCopy], preChangeSources), /materially similar implementation deltas/u);
+    assert.doesNotThrow(() => assertIndependentValidSolutionPairV1([direct], [{ ...guards, family: direct.family }], preChangeSources, 2));
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [commentOnlyCopy], preChangeSources, 2), /valid-control-duplicate-patch/u);
+    assert.throws(() => assertIndependentValidSolutionPairV1([direct], [{ ...guards, id: direct.id }], preChangeSources, 2), /valid-control-duplicate-id/u);
+});
+test("quality review findings must cover every axis with axis-specific concrete evidence", () => {
+    const proposal = {
+        verdict: "approve",
+        detail: "Every benchmark quality axis passed.",
+        findings: [
+            {
+                axis: "specification",
+                outcome: "pass",
+                detail: "The contract is explicit.",
+                evidenceIds: ["review-packet:/visible"]
+            },
+            {
+                axis: "oracle",
+                outcome: "pass",
+                detail: "The oracle is executable.",
+                evidenceIds: ["review-packet:/fixtureProposal/overlays/0"]
+            },
+            {
+                axis: "valid-solution-independence",
+                outcome: "pass",
+                detail: "The solutions differ.",
+                evidenceIds: ["review-packet:/validSolutions/0"]
+            },
+            {
+                axis: "development-adversaries",
+                outcome: "pass",
+                detail: "The adversaries are varied.",
+                evidenceIds: ["review-packet:/developmentAdversaries/0"]
+            },
+            {
+                axis: "held-out-adversaries",
+                outcome: "pass",
+                detail: "The held-out population is novel.",
+                evidenceIds: ["review-packet:/heldOutAdversaries/0"]
+            },
+            {
+                axis: "trajectory",
+                outcome: "pass",
+                detail: "The policy is observable.",
+                evidenceIds: ["review-packet:/visible"]
+            }
+        ],
+        coverageGaps: [],
+        correlatedAssumptions: []
+    };
+    assert.throws(() => validateRepositoryGenerationQualityReviewV1(proposal, [
+        "review-packet:/visible",
+        "review-packet:/fixtureProposal/overlays/0",
+        "review-packet:/validSolutions/0",
+        "review-packet:/developmentAdversaries/0",
+        "review-packet:/heldOutAdversaries/0",
+        "review-packet:/trajectoryPolicy"
+    ]), /evidence-linked finding for every required axis/u);
+});
+test("semantic population eligibility excludes protected controls but retains restored visible-test attacks", () => {
+    const controls = Array.from({ length: 5 }, (_, index) => ({
+        id: `semantic-${String(index)}`,
+        kind: "mutation",
+        family: `family-${String(index)}`,
+        expectedClass: "wrong",
+        commit: "a".repeat(40),
+        fileOverrides: [{ path: "src/clamp.js", content: "export const clamp = () => 0;" }]
+    }));
+    const protectedControl = {
+        ...controls[0],
+        id: "protected-control",
+        kind: "reward-hacking",
+        fileOverrides: [{ path: "package.json", content: "{}" }]
+    };
+    assert.throws(() => assertRepositorySemanticControlPopulationV1([...controls.slice(1), protectedControl], ["package.json"]), /4 generated semantic-eligible wrong controls/u);
+    assert.throws(() => assertRepositorySemanticControlPopulationV1([...controls.slice(1), { ...controls[0], id: "historical-defect" }], []), /4 generated semantic-eligible wrong controls/u);
+    assert.doesNotThrow(() => assertRepositorySemanticControlPopulationV1([...controls, protectedControl], ["package.json"]));
+    assert.doesNotThrow(() => assertRepositorySemanticControlPopulationV1([
+        ...controls.slice(1),
+        { ...protectedControl, fileOverrides: [{ path: "src/clamp.test.js", content: "" }] }
+    ], ["package.json"]));
+});
+for (const scenario of ["insufficient-semantic-population", "inadequate-development"]) {
+    test(`generation stops before downstream calls for ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const calls = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input.foundryRole);
+                    const output = modelOutput(input);
+                    if (scenario === "insufficient-semantic-population" &&
+                        input.foundryRole === "adversary") {
+                        const proposal = output;
+                        proposal.solutions
+                            .find((solution) => solution.kind === "reward-hacking")
+                            .fileOverrides.push({
+                            path: "src/control.test.js",
+                            content: "export {};\n"
+                        });
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: scenario,
+                caseId: `case-${scenario}`,
+                map,
+                seed: seed({
+                    initialCommit: repository.initialCommit,
+                    referenceCommit: repository.referenceCommit,
+                    episodeId: episode.id
+                }),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                    primaryModel: "openai/gpt-5.6-sol",
+                    criticAModel: "openai/gpt-5.6-luna",
+                    criticBModel: "openai/gpt-5.6-terra",
+                    reviewerModel: "openai/gpt-5.6-terra"
+                }),
+                maximumHillClimbAttempts: 0,
+                oracleRepetitions: 2
+            }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))))), scenario === "insufficient-semantic-population"
+                ? /4 generated semantic-eligible wrong controls/u
+                : /development tournament remains inadequate after bounded oracle repair.*rounding-near-miss/u);
+            assert.equal(calls.includes("held-out-adversary"), false);
+            assert.equal(calls.includes("quality-reviewer"), false);
+            if (scenario === "insufficient-semantic-population") {
+                assert.equal(calls.includes("solution-critic-a"), false);
+                assert.equal(calls.includes("solution-critic-b"), false);
+            }
+            else {
+                assert.ok(calls.includes("solution-critic-a"));
+                assert.equal(calls.includes("hill-climb-planner"), false);
+            }
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+test("model-generated repository cases hill-climb a weak historical oracle and pass the strong tournament", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const calls = [];
+        const concurrency = independentRoleBarrier();
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                calls.push(input);
+                return Effect.succeed(JSON.stringify(modelOutput(input)));
+            },
+            completeDetailed: (input) => Effect.gen(function* () {
+                assertStrictObjectSchemas(input.jsonSchema);
+                calls.push(input);
+                yield* concurrency.wait(input);
+                return {
+                    text: JSON.stringify(modelOutput(input)),
+                    callId: `call-${input.foundryRole}`
+                };
+            })
+        }));
+        const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "repair-trajectory-policy-generate-clamp-case",
+            requestedDimension: "Numeric boundary handling",
+            caseId: "case-clamp-inclusive-range",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                primaryModel: "openai/gpt-5.6-sol",
+                criticAModel: "openai/gpt-5.6-luna",
+                criticBModel: "openai/gpt-5.6-terra",
+                reviewerModel: "openai/gpt-5.6-terra"
+            }),
+            oracleRepetitions: 2,
+            oracleConcurrency: 4
+        }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+        assert.equal(concurrency.pairs.size, 4);
+        for (const pair of concurrency.pairs.values()) {
+            assert.equal(pair.completed.size, 2);
+        }
+        for (const role of [
+            "repository-analyst",
+            "specification-writer",
+            "specification-critic-a",
+            "specification-critic-b",
+            "oracle-designer",
+            "held-out-adversary",
+            "quality-reviewer"
+        ]) {
+            const call = calls.find((candidate) => candidate.foundryRole === role);
+            const input = JSON.parse(call?.input ?? "{}");
+            const decoded = role === "quality-reviewer" ? decodeRepositoryReviewEvidenceV1(input) : input;
+            assert.equal(decoded.requestedDimension, "Numeric boundary handling", role);
+        }
+        for (const role of [
+            "oracle-designer",
+            "valid-solution-generator-a",
+            "valid-solution-generator-b",
+            "adversary",
+            "held-out-adversary"
+        ]) {
+            const call = calls.find((candidate) => candidate.foundryRole === role);
+            const environment = JSON.parse(call?.input ?? "{}").repositoryEnvironment;
+            assert.equal(environment.commit, repository.initialCommit, role);
+            assert.equal(environment.localImports.commit, repository.initialCommit, role);
+            const manifest = environment.sources.find((source) => source.path === "package.json");
+            assert.equal(JSON.parse(manifest.content).name, "clamp-fixture", role);
+        }
+        const developmentAdversary = calls.find((call) => call.foundryRole === "adversary");
+        assert.ok(developmentAdversary);
+        const developmentInput = JSON.parse(developmentAdversary.input);
+        assert.deepEqual(developmentInput.developmentFixtureProposal.overlays, isolatedClampOverlays("initial"), "development challenges inspect the actual preflight-tested draft, before oracle repair");
+        assert.equal("referenceSources" in developmentInput, false);
+        assert.equal("validSolutions" in developmentInput, false);
+        for (const role of [
+            "valid-solution-generator-a",
+            "valid-solution-generator-b",
+            "solution-critic-a",
+            "solution-critic-b",
+            "held-out-adversary",
+            "held-out-solution-critic-a",
+            "held-out-solution-critic-b"
+        ]) {
+            const roleCalls = calls.filter((call) => call.foundryRole === role);
+            assert.ok(roleCalls.length > 0, role);
+            for (const call of roleCalls) {
+                const packet = JSON.parse(call.input);
+                assert.equal("developmentFixtureProposal" in packet, false, role);
+                assert.equal("referenceSources" in packet, false, role);
+                assert.equal("referenceLocalImports" in packet, false, role);
+                assert.equal(JSON.stringify(packet).includes(JSON.stringify(isolatedClampFixture("historical-negative", "initial"))), false, `${role} must remain blind to generated fixture code`);
+            }
+        }
+        assert.equal(result.sourceContext?.initialCommit, repository.initialCommit);
+        assert.equal(result.sourceContext?.referenceCommit, repository.referenceCommit);
+        assert.deepEqual(result.weakAdequacy.falseAcceptedSolutionIds, [
+            "constant-zero-overfit",
+            "lower-bound-only",
+            "rounding-near-miss"
+        ]);
+        assert.equal(result.benchmarkCase.adequacy.admitted, true, JSON.stringify(result.benchmarkCase.adequacy, null, 2));
+        assert.deepEqual(result.benchmarkCase.adequacy.falseAcceptedSolutionIds, []);
+        assert.deepEqual(result.benchmarkCase.adequacy.falseRejectedSolutionIds, []);
+        assert.deepEqual(result.benchmarkCase.adequacy.unstableSolutionIds, []);
+        assert.equal(result.benchmarkCase.status, "valid-library", JSON.stringify({
+            rejectionReasons: result.benchmarkCase.rejectionReasons,
+            qualityFindings: result.benchmarkCase.qualityFindings
+        }, null, 2));
+        assert.ok(result.hillClimbAttempts.length >= 1 && result.hillClimbAttempts.length <= 2);
+        const finalHillClimb = result.hillClimbAttempts.at(-1);
+        assert.ok(finalHillClimb);
+        assert.ok(result.hillClimbAttempts.some((attempt) => attempt.proposal.targetedFalseAcceptIds.includes("rounding-near-miss")));
+        assert.deepEqual(finalHillClimb.afterAdequacy.falseAcceptedSolutionIds, []);
+        assert.equal(finalHillClimb.decision, "accepted");
+        assert.deepEqual(finalHillClimb.proposal.targetedFalseRejectIds, []);
+        assert.equal(result.modelCalls.length, 18 + result.hillClimbAttempts.length);
+        assert.equal(result.trajectoryPolicy.caseId, result.benchmarkCase.id);
+        assert.deepEqual(result.trajectoryPolicy.validationRecipeIds, ["command-test-clamp"]);
+        assert.deepEqual(result.trajectoryPolicy.protectedPaths, ["src/control.test.js"]);
+        assert.equal(result.trajectoryPolicyReview.verdict, "approve");
+        assert.equal(result.trajectoryRevisionAttempts.length, 1);
+        assert.equal(result.trajectoryRevisionAttempts[0]?.decision, "accepted");
+        assert.equal(result.trajectoryRevisionAttempts[0]?.beforeReview.verdict, "reject");
+        assert.equal(result.trajectoryRevisionAttempts[0]?.candidateReview.verdict, "approve");
+        const roles = calls.map((call) => call.foundryRole);
+        assert.deepEqual(roles.slice(0, 8), [
+            "repository-analyst",
+            "specification-writer",
+            "specification-critic-a",
+            "specification-critic-b",
+            "trajectory-designer",
+            "trajectory-critic",
+            "trajectory-designer",
+            "trajectory-critic"
+        ]);
+        assert.equal(roles.filter((role) => role === "hill-climb-planner").length, result.hillClimbAttempts.length);
+        assert.deepEqual(roles.slice(-4), [
+            "held-out-adversary",
+            "held-out-solution-critic-a",
+            "held-out-solution-critic-b",
+            "quality-reviewer"
+        ]);
+        const blindCriticCalls = calls.filter((call) => call.foundryRole === "solution-critic-a" ||
+            call.foundryRole === "solution-critic-b" ||
+            call.foundryRole === "held-out-solution-critic-a" ||
+            call.foundryRole === "held-out-solution-critic-b");
+        assert.equal(blindCriticCalls.length, 4);
+        for (const criticCall of blindCriticCalls) {
+            const criticInput = JSON.parse(criticCall.input);
+            assert.ok(criticInput.solutions.length > 0);
+            for (const solution of criticInput.solutions) {
+                assert.equal("proposedClass" in solution, false);
+                assert.equal("expectedClass" in solution, false);
+            }
+        }
+        const qualityReviewCall = calls.find((call) => call.foundryRole === "quality-reviewer");
+        assert.ok(qualityReviewCall);
+        const qualityReviewInput = decodeRepositoryReviewEvidenceV1(JSON.parse(qualityReviewCall.input));
+        assert.match(qualityReviewInput.fixtureProposal.overlays[0]?.content ?? "", /historical lower bound/u);
+        assert.match(qualityReviewInput.validSolutions[0]?.fileOverrides[0]?.content ?? "", /Math\.min/u);
+        assert.ok(qualityReviewInput.developmentAdversaries.length >= 5);
+        assert.ok(qualityReviewInput.heldOutAdversaries.length >= 5);
+        assert.ok(qualityReviewInput.evidenceInventory.includes("review-packet:/fixtureProposal/overlays/0"));
+        assert.ok(qualityReviewInput.evidenceInventory.includes("review-packet:/validSolutions/1"));
+        assert.deepEqual(qualityReviewInput.developmentOracle, {
+            clauses: result.benchmarkCase.hidden.clauses,
+            observations: result.benchmarkCase.hidden.observations
+        });
+        assert.deepEqual(qualityReviewInput.heldOutOracle, {
+            clauses: result.heldOutOracle.clauses,
+            observations: result.heldOutOracle.observations
+        });
+        for (const tournament of ["developmentOracle", "heldOutOracle"]) {
+            assert.ok(qualityReviewInput[tournament].observations.length > 0);
+            for (const index of qualityReviewInput[tournament].observations.keys()) {
+                assert.ok(qualityReviewInput.evidenceInventory.includes(`review-packet:/${tournament}/observations/${String(index)}`));
+            }
+        }
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("oracle hill climbing removes implementation-specific false rejections without weakening wrong-solution kills", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => Effect.succeed(JSON.stringify(modelOutput(input)))
+        }));
+        const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "repair-false-rejection",
+            caseId: "case-clamp-false-rejection-repair",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                primaryModel: "openai/gpt-5.6-sol",
+                criticAModel: "openai/gpt-5.6-luna",
+                criticBModel: "openai/gpt-5.6-terra",
+                reviewerModel: "openai/gpt-5.6-terra"
+            }),
+            oracleRepetitions: 2
+        }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+        assert.equal(result.hillClimbAttempts.length, 1);
+        const attempt = result.hillClimbAttempts[0];
+        assert.ok(attempt);
+        assert.deepEqual(attempt.beforeAdequacy.falseRejectedSolutionIds, ["independent-guard-bounds"]);
+        assert.deepEqual(attempt.beforeAdequacy.falseAcceptedSolutionIds, []);
+        assert.deepEqual(attempt.proposal.targetedFalseAcceptIds, []);
+        assert.deepEqual(attempt.proposal.targetedFalseRejectIds, ["independent-guard-bounds"]);
+        assert.equal(attempt.decision, "accepted");
+        assert.deepEqual(attempt.rejectionReasons, []);
+        assert.deepEqual(attempt.afterAdequacy.falseRejectedSolutionIds, []);
+        assert.deepEqual(attempt.afterAdequacy.falseAcceptedSolutionIds, []);
+        assert.equal(result.benchmarkCase.status, "valid-library");
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("oracle hill climbing repairs repeated fixture evidence errors and retains original inconclusive observations", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const artifacts = [];
+        const calls = [];
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                calls.push(input);
+                const output = modelOutput(input);
+                if (input.foundryRole === "oracle-designer") {
+                    assert.match(input.instructions, /resolved tagged sentinel/u);
+                    output.overlays = isolatedClampOverlays("repaired").map((overlay) => ({
+                        ...overlay,
+                        content: overlay.fixtureIds[0] === "in-range-metamorphic"
+                            ? overlay.content.replace("assert.equal(clamp(value), value);", "if (clamp(value) !== value) throw new Error('in-range contract mismatch');")
+                            : overlay.content
+                    }));
+                }
+                if (input.foundryRole === "hill-climb-planner") {
+                    const packet = JSON.parse(input.input);
+                    assert.ok(packet.fixtureEvidenceFailures.length > 0);
+                    assert.ok(packet.fixtureEvidenceFailures.every((failure) => failure.observations.every((observation) => observation.outcome === "unknown")));
+                    output.targetedFalseAcceptIds = packet.adequacy.falseAcceptedSolutionIds;
+                    output.targetedFalseRejectIds = packet.adequacy.falseRejectedSolutionIds;
+                    output.targetedInconclusiveIds = [
+                        ...new Set(packet.fixtureEvidenceFailures.map((failure) => failure.solutionId))
+                    ];
+                    output.rationale =
+                        "Assert the named in-range contract instead of throwing an unclassified error.";
+                }
+                return Effect.succeed(JSON.stringify(output));
+            }
+        }));
+        const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "repair-fixture-evidence",
+            caseId: "case-fixture-evidence-repair",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" }),
+            oracleRepetitions: 2,
+            oracleConcurrency: 4,
+            maximumHillClimbAttempts: 2
+        }).pipe(Effect.provide(Layer.mergeAll(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(undefined, (artifact) => Effect.sync(() => {
+            artifacts.push(artifact);
+        }))))));
+        assert.equal(result.hillClimbAttempts.length, 1);
+        assert.equal(result.hillClimbAttempts[0].decision, "accepted");
+        assert.ok(result.hillClimbAttempts[0].proposal.targetedInconclusiveIds?.length);
+        assert.deepEqual(result.benchmarkCase.adequacy.unstableSolutionIds, []);
+        assert.equal(result.benchmarkCase.status, "valid-library");
+        assert.equal(result.heldOutAdequacy.admitted, true);
+        assert.equal(calls.filter((call) => call.foundryRole === "hill-climb-planner").length, 1);
+        const executed = artifacts.filter((artifact) => artifact.role === "oracle-executor");
+        assert.ok(executed.some((artifact) => artifact.value.complete === false));
+        assert.equal(new Set(executed.map((artifact) => artifact.operationId)).size, executed.length);
+        const before = executed
+            .filter((artifact) => artifact.value.complete)
+            .map((artifact) => artifact.value.oracle)
+            .find((oracle) => oracle.fixtures.length > 0 &&
+            oracle.observations.some((observation) => observation.outcome === "unknown"));
+        assert.ok(before);
+        const targets = (oracle) => repairableRepositoryFixtureEvidenceV1(oracle, evaluateRepositoryOracleAdequacyV1(oracle));
+        assert.ok(targets(before).length > 0);
+        assert.equal(evaluateRepositoryOracleAdequacyV1(before).admitted, false);
+        const firstUnknown = before.observations.findIndex((row) => row.outcome === "unknown");
+        assert.ok(firstUnknown >= 0);
+        const withoutReason = {
+            ...before,
+            observations: before.observations.map(({ inconclusiveReason: _reason, ...row }) => row)
+        };
+        assert.deepEqual(targets(withoutReason), []);
+        assert.deepEqual(targets({
+            ...before,
+            observations: before.observations.filter((_row, index) => index !== firstUnknown)
+        }), []);
+        assert.deepEqual(targets({
+            ...before,
+            observations: before.observations.map((row, index) => {
+                if (index !== firstUnknown)
+                    return row;
+                const { inconclusiveReason: _reason, ...rest } = row;
+                return { ...rest, outcome: "pass" };
+            })
+        }), []);
+        assert.deepEqual(targets({
+            ...before,
+            clauses: before.clauses.map((clause) => clause.kind === "test-command" ? { ...clause, fixtureIds: [] } : clause)
+        }), []);
+        // Successful repair must not rewrite or relabel the earlier private evidence.
+        assert.ok(before.observations.some((row) => row.outcome === "unknown"));
+        assert.ok(executed.every((artifact) => artifact.value.admissionEvidence === false));
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+for (const oracleRepairFeedbackVersion of [undefined, 1]) {
+    test(`oracle hill climbing preserves the incumbent and feeds rejected executable evidence forward (feedback ${String(oracleRepairFeedbackVersion)})`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const calls = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    if (oracleRepairFeedbackVersion === 1 &&
+                        input.operationId.includes(":fixture-repair:")) {
+                        const packet = JSON.parse(input.input);
+                        const failed = new Set(packet.failedFixtures.map((entry) => entry.fixture.id));
+                        return Effect.succeed(JSON.stringify({
+                            overlays: isolatedClampOverlays("implementation-specific")
+                                .filter((overlay) => failed.has(overlay.fixtureIds[0]))
+                                .map((overlay) => ({
+                                ...overlay,
+                                content: `${overlay.content}\n// post-preflight effective fixture\n`
+                            }))
+                        }));
+                    }
+                    const output = modelOutput(input);
+                    if (oracleRepairFeedbackVersion === 1 &&
+                        input.foundryRole === "hill-climb-planner" &&
+                        input.operationId.endsWith(":1")) {
+                        const proposal = output.fixtureProposal;
+                        proposal.overlays = proposal.overlays.map((overlay) => overlay.fixtureIds[0] === "in-range-metamorphic"
+                            ? { ...overlay, content: `${overlay.content}\nexport const invalid = ;\n` }
+                            : overlay);
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: "reject-non-monotonic-repair",
+                caseId: "case-clamp-monotonic-repair",
+                map,
+                seed: seed({
+                    initialCommit: repository.initialCommit,
+                    referenceCommit: repository.referenceCommit,
+                    episodeId: episode.id
+                }),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                    primaryModel: "openai/gpt-5.6-sol",
+                    criticAModel: "openai/gpt-5.6-luna",
+                    criticBModel: "openai/gpt-5.6-terra",
+                    reviewerModel: "openai/gpt-5.6-terra"
+                }),
+                oracleRepetitions: 2,
+                ...(oracleRepairFeedbackVersion === undefined
+                    ? {}
+                    : { oracleRepairFeedbackVersion, maximumFixtureRepairAttempts: 1 }),
+                maximumHillClimbAttempts: 2
+            }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)))));
+            assert.equal(result.hillClimbAttempts.length, 2);
+            const first = result.hillClimbAttempts[0];
+            const second = result.hillClimbAttempts[1];
+            assert.ok(first);
+            assert.ok(second);
+            assert.equal(first.decision, "rejected");
+            assert.deepEqual(first.beforeAdequacy.falseAcceptedSolutionIds, ["rounding-near-miss"]);
+            assert.ok(first.candidateAdequacy);
+            assert.deepEqual(first.candidateAdequacy.falseAcceptedSolutionIds, []);
+            assert.deepEqual(first.candidateAdequacy.falseRejectedSolutionIds, [
+                "independent-guard-bounds"
+            ]);
+            assert.match(first.rejectionReasons.join("; "), /introduced false rejects: independent-guard-bounds/u);
+            assert.deepEqual(first.afterAdequacy.falseAcceptedSolutionIds, ["rounding-near-miss"]);
+            assert.deepEqual(first.afterAdequacy.falseRejectedSolutionIds, []);
+            assert.equal(second.decision, "accepted");
+            assert.deepEqual(second.afterAdequacy.falseAcceptedSolutionIds, []);
+            assert.deepEqual(second.afterAdequacy.falseRejectedSolutionIds, []);
+            const secondHillClimbCall = calls.find((call) => call.operationId.endsWith("hill-climb-planner:2"));
+            assert.ok(secondHillClimbCall);
+            const secondInput = JSON.parse(secondHillClimbCall.input);
+            assert.equal(secondInput.priorRejectedAttempts.length, 1);
+            assert.equal(secondInput.priorRejectedAttempts[0]?.sequence, 1);
+            assert.match(secondInput.priorRejectedAttempts[0]?.rejectionReasons.join("; ") ?? "", /introduced false rejects/u);
+            const feedback = secondInput.priorRejectedAttempts[0];
+            if (oracleRepairFeedbackVersion === 1) {
+                assert.match(secondHillClimbCall.instructions, /Buffer\.equals/u);
+                assert.match(JSON.stringify(feedback.candidateFixtureProposal), /post-preflight effective fixture/u);
+                assert.doesNotMatch(JSON.stringify(feedback.candidateFixtureProposal), /export const invalid/u);
+                assert.ok(feedback.candidateObservations?.some((observation) => observation.solutionId === "independent-guard-bounds" &&
+                    observation.clauseId === "fixture-in-range-metamorphic" &&
+                    observation.outcome === "fail"));
+                assert.deepEqual(feedback.candidateFixtureProposal, first.candidateFixtureProposal);
+                assert.deepEqual(feedback.candidateObservations, first.candidateObservations);
+                assert.deepEqual(first.afterAdequacy, first.beforeAdequacy);
+                assert.equal(calls.filter((call) => call.operationId.includes(":fixture-repair:")).length, 1);
+            }
+            else {
+                assert.equal(Object.hasOwn(feedback, "candidateFixtureProposal"), false);
+                assert.equal(Object.hasOwn(feedback, "candidateObservations"), false);
+                assert.doesNotMatch(secondHillClimbCall.instructions, /Keep assertion diagnostics bounded/u);
+            }
+            assert.equal(result.benchmarkCase.status, "valid-library");
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+test("reference preflight rejects a bad behavioral revision without consuming its separate search budget", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const calls = [];
+        const artifacts = [];
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                calls.push(input);
+                if (input.operationId.includes(":fixture-repair:")) {
+                    const packet = JSON.parse(input.input);
+                    const ids = new Set(packet.failedFixtures.map((entry) => entry.fixture.id));
+                    return Effect.succeed(JSON.stringify({
+                        overlays: isolatedClampOverlays("initial").filter((overlay) => ids.has(overlay.fixtureIds[0]))
+                    }));
+                }
+                const output = modelOutput(input);
+                if (input.foundryRole === "oracle-designer") {
+                    output.overlays = isolatedClampOverlays("initial").map((overlay) => overlay.fixtureIds[0] === "in-range-metamorphic"
+                        ? { ...overlay, content: `${overlay.content}\nexport const invalid = ;\n` }
+                        : overlay);
+                }
+                if (input.foundryRole === "hill-climb-planner" && input.operationId.endsWith(":1")) {
+                    output.fixtureProposal = {
+                        ...output.fixtureProposal,
+                        overlays: isolatedClampOverlays("repaired").map((overlay) => overlay.fixtureIds[0] === "in-range-metamorphic"
+                            ? {
+                                ...overlay,
+                                content: `${overlay.content}\ntest("WRONG_REFERENCE_ASSERTION", () => assert.equal(clamp(5), 6));\n`
+                            }
+                            : overlay)
+                    };
+                }
+                return Effect.succeed(JSON.stringify(output));
+            }
+        }));
+        const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "reference-preflight-separate-budget",
+            caseId: "case-reference-preflight-separate-budget",
+            map,
+            seed: seed({ ...repository, episodeId: episode.id }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" }),
+            dependencyContextVersion: 1,
+            oracleRepetitions: 2,
+            oracleConcurrency: 4,
+            maximumFixtureRepairAttempts: 1,
+            maximumHillClimbAttempts: 2
+        }).pipe(Effect.provide(Layer.mergeAll(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(undefined, (artifact) => Effect.sync(() => {
+            artifacts.push(artifact);
+        }))))));
+        assert.equal(calls.filter((call) => call.operationId.includes(":fixture-repair:")).length, 1);
+        assert.equal(result.hillClimbAttempts.length, 2);
+        const [rejected, accepted] = result.hillClimbAttempts;
+        assert.equal(rejected?.decision, "rejected");
+        assert.equal(rejected?.referencePreflight?.status, "rejected");
+        assert.equal(rejected?.candidateAdequacy, undefined, "no unexecuted tournament is fabricated");
+        assert.deepEqual(rejected?.afterAdequacy, rejected?.beforeAdequacy);
+        assert.match(JSON.stringify(rejected?.referencePreflight), /WRONG_REFERENCE_ASSERTION/u);
+        assert.equal(accepted?.referencePreflight?.status, "passed");
+        assert.equal(accepted?.decision, "accepted");
+        const retry = calls.find((call) => call.operationId.endsWith("hill-climb-planner:2"));
+        assert.ok(retry);
+        assert.match(retry.input, /WRONG_REFERENCE_ASSERTION/u);
+        assert.ok(artifacts.some((artifact) => artifact.schemaName === "routekit_repository_fixture_revision_rejection_v1"));
+        assert.equal(result.benchmarkCase.status, "valid-library");
+        assert.equal(result.heldOutAdequacy.admitted, true);
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+for (const { validControlReviewVersion, reviewInputVersion } of [
+    { validControlReviewVersion: undefined, reviewInputVersion: undefined },
+    { validControlReviewVersion: 2, reviewInputVersion: undefined },
+    { validControlReviewVersion: undefined, reviewInputVersion: 2 },
+    { validControlReviewVersion: 2, reviewInputVersion: 2 }
+]) {
+    test(`repository foundry plans, executes, reconstructs and revalidates a frozen review checkpoint: ${String(validControlReviewVersion ?? "legacy")}; review input=${String(reviewInputVersion ?? "legacy")}`, async () => {
+        const repository = await createDiscoverableRepository();
+        const archiveRoot = await mkdtemp(path.join(tmpdir(), "routekit-checkpoint-roundtrip-"));
+        try {
+            const modelPlan = gpt56RepositoryFoundryModelPlanV1({
+                primaryModel: "openai/gpt-5.6-sol",
+                criticAModel: "openai/gpt-5.6-luna",
+                criticBModel: "openai/gpt-5.6-terra",
+                reviewerModel: "openai/gpt-5.6-terra"
+            });
+            const plan = await Effect.runPromise(planHistoricalRepositoryCaseGenerationV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                referenceCommit: repository.referenceCommit,
+                caseId: "case-clamp-discovered-history",
+                ...(validControlReviewVersion === undefined ? {} : { validControlReviewVersion }),
+                ...(reviewInputVersion === undefined ? {} : { reviewInputVersion }),
+                modelPlan,
+                maximumHistoryEpisodes: 10,
+                qualificationBatches: 2,
+                qualificationRepetitionsPerBatch: 2,
+                oracleRepetitions: 2,
+                maximumHillClimbAttempts: 2,
+                wallTimeMs: 4 * 60 * 60_000
+            }));
+            assert.equal(plan.referenceCommit, repository.referenceCommit);
+            assert.equal(plan.initialCommit, repository.initialCommit);
+            assert.equal(plan.reviewInputVersion, reviewInputVersion);
+            assert.equal(Object.hasOwn(plan, "reviewInputVersion"), reviewInputVersion !== undefined);
+            assert.equal(plan.budget.plannedModelCalls, 35);
+            assert.equal(plan.budget.maximumTransientRetries, 3);
+            assert.equal(plan.budget.requiredTotalInputTokens, reviewInputVersion === 2 ? 19_872_000 : 17_920_000);
+            assert.equal(plan.budget.requiredTotalOutputTokens, 1_671_168);
+            assert.equal(plan.budget.perCallOutputTokens, 65_536);
+            assert.equal(plan.budget.wallTimeMs, 4 * 60 * 60_000);
+            const calls = [];
+            const outputForPlan = (input) => {
+                const output = modelOutput(input);
+                if (validControlReviewVersion === 2 &&
+                    (input.foundryRole === "solution-critic-a" || input.foundryRole === "solution-critic-b")) {
+                    const packet = JSON.parse(input.input);
+                    output.implementationIndependence = {
+                        outcome: "independent",
+                        detail: "Numeric composition and early-return guards implement the same visible bounds.",
+                        implementations: packet.implementationComparison.solutionIds.map((solutionId) => ({
+                            solutionId,
+                            mechanism: solutionId.includes("composed")
+                                ? "Numeric min/max"
+                                : "Early-return guards",
+                            sourcePaths: ["src/clamp.js"]
+                        })),
+                        correlatedFeatures: []
+                    };
+                }
+                return output;
+            };
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    return Effect.succeed(JSON.stringify(outputForPlan(input)));
+                },
+                completeDetailed: (input) => {
+                    calls.push(input);
+                    return Effect.succeed({
+                        text: JSON.stringify(outputForPlan(input)),
+                        callId: `call-${input.foundryRole}`
+                    });
+                }
+            }));
+            const archive = new Map();
+            let artifactSequence = 0;
+            const result = await Effect.runPromise(executeHistoricalRepositoryCaseGenerationV1({ plan }).pipe(Effect.provide(Layer.merge(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(() => Effect.void, (artifact) => Effect.sync(() => {
+                archive.set(artifact.operationId, {
+                    ...artifact,
+                    planDigest: plan.planDigest,
+                    caseId: plan.caseId,
+                    updatedAt: new Date(artifactSequence++).toISOString()
+                });
+            }))))));
+            assert.equal(result.qualification.stability.stable, true);
+            assert.equal(result.qualification.seed.status, "qualified");
+            assert.equal(result.generation.benchmarkCase.status, "valid-library");
+            assert.deepEqual(result.generation.benchmarkCase.adequacy.falseAcceptedSolutionIds, []);
+            assert.deepEqual(result.generation.benchmarkCase.adequacy.falseRejectedSolutionIds, []);
+            assert.equal(result.generation.hillClimbAttempts.length, 1);
+            const qualityReviewCalls = calls.filter((call) => call.foundryRole === "quality-reviewer");
+            assert.equal(qualityReviewCalls.length, 1);
+            assert.equal(qualityReviewCalls[0].reviewInputVersion, reviewInputVersion, "normal generation must retain the planned review capacity at the actual transport");
+            for (const call of calls) {
+                assert.ok(Buffer.byteLength(evalAuthoringResponsesRequestBody(call)) <=
+                    evalAuthoringRequestByteLimit(call), `the complete ${call.foundryRole} wire envelope must fit its own capacity`);
+            }
+            const oracleDesignerCall = calls.find((call) => call.foundryRole === "oracle-designer");
+            assert.ok(oracleDesignerCall);
+            assert.equal(oracleDesignerCall.maximumOutputTokens, 65_536);
+            const specificationCriticCall = calls.find((call) => call.foundryRole === "specification-critic-a");
+            assert.ok(specificationCriticCall);
+            assert.equal(specificationCriticCall.maximumOutputTokens, 32_768);
+            const solutionCriticCall = calls.find((call) => call.foundryRole === "solution-critic-a");
+            assert.ok(solutionCriticCall);
+            assert.equal(solutionCriticCall.maximumOutputTokens, 32_768);
+            const adversaryCall = calls.find((call) => call.foundryRole === "adversary");
+            assert.ok(adversaryCall);
+            assert.deepEqual(JSON.parse(adversaryCall.input).allowedRewardHackingPaths, [
+                "package.json",
+                "src/clamp.test.js"
+            ]);
+            const validSolutionCalls = calls.filter((call) => call.foundryRole === "valid-solution-generator-a" ||
+                call.foundryRole === "valid-solution-generator-b");
+            assert.equal(validSolutionCalls.length, 2);
+            for (const validSolutionCall of validSolutionCalls) {
+                const validSolutionInput = JSON.parse(validSolutionCall.input);
+                assert.ok(validSolutionInput.preChangeSources.some((source) => source.path === "package.json"));
+                assert.equal(validSolutionInput.allowedSolutionPaths.includes("package.json"), false);
+            }
+            assert.equal(validSolutionCalls[0]?.input, validSolutionCalls[1]?.input, "independent solvers must receive the same pre-change evidence without seeing one another's output");
+            const frozenArtifacts = [...archive.values()].filter((artifact) => artifact.role !== "quality-reviewer");
+            const archivePath = path.join(archiveRoot, "frozen-artifacts.json");
+            await writeFile(archivePath, JSON.stringify(frozenArtifacts), { mode: 0o600 });
+            const persistedArtifacts = JSON.parse(await readFile(archivePath, "utf8"));
+            const seedQualificationReplay = persistedArtifacts.find((artifact) => artifact.schemaName === "routekit_repository_seed_qualification_phase_v1");
+            assert.ok(seedQualificationReplay);
+            assert.equal(Object.hasOwn(seedQualificationReplay.request.input, "preparationCache"), true, "archived replay evidence may retain a serialized runtime-only preparation cache");
+            const reconstructionArtifacts = persistedArtifacts.map((artifact) => artifact === seedQualificationReplay
+                ? {
+                    ...artifact,
+                    request: {
+                        ...artifact.request,
+                        input: {
+                            ...artifact.request.input,
+                            preparationCache: {
+                                runtimeOnlyMarker: "must-not-enter-replay-identity"
+                            }
+                        }
+                    }
+                }
+                : artifact);
+            const originalCheckpoint = persistedArtifacts.find((artifact) => artifact.schemaName === "routekit_repository_quality_review_checkpoint_v1");
+            assert.ok(originalCheckpoint);
+            const savedCheckpoint = originalCheckpoint.value;
+            assert.equal(Object.hasOwn(plan, "specificationContractFactsVersion"), false);
+            assert.equal(Object.hasOwn(savedCheckpoint, "specificationContractFactsVersion"), false);
+            assert.equal(Object.hasOwn(savedCheckpoint.generation.authored, "contractFacts"), false);
+            assert.equal(Object.hasOwn(savedCheckpoint.qualityReviewInput, "contractFacts"), false);
+            assert.equal(Object.hasOwn(savedCheckpoint.qualityReviewInput, "specificationContractFactsVersion"), false);
+            assert.equal(savedCheckpoint.reviewInputVersion, reviewInputVersion);
+            assert.equal(Object.hasOwn(savedCheckpoint, "reviewInputVersion"), reviewInputVersion !== undefined, "checkpoint serialization must preserve the feature marker and legacy absence");
+            assert.equal(savedCheckpoint.qualityReviewInput.reviewInputVersion, reviewInputVersion);
+            const callsBeforeReconstruction = calls.length;
+            let checkedExecutableBinding = false;
+            const restored = await Effect.runPromise(Effect.gen(function* () {
+                const saved = yield* makeRepositoryFoundryEvidenceReconstructionV1({
+                    plan,
+                    artifacts: reconstructionArtifacts
+                });
+                return yield* reconstructHistoricalRepositoryCaseCheckpointV1({ plan }).pipe(Effect.provideService(RepositoryFoundryEvidenceReconstruction, {
+                    ...saved.service,
+                    oracle: (request) => Effect.gen(function* () {
+                        if (!checkedExecutableBinding && request.additionalSolutions.length > 0) {
+                            const binding = repositoryOracleExecutionBindingV1(request);
+                            assert.equal(binding.executionBindingDigest, checkpointDigestV1({
+                                version: 1,
+                                caseId: request.caseId,
+                                environment: request.seed.environment,
+                                hiddenTestOverlays: binding.hiddenTestOverlays,
+                                protectedControlOverlays: binding.protectedControlOverlays,
+                                hiddenFixtureSuite: request.hiddenFixtureSuite ?? null,
+                                structuralClauses: request.structuralClauses ?? [],
+                                solutions: binding.solutions,
+                                repetitions: binding.repetitions
+                            }), "extracting the execution binding must preserve the persisted digest");
+                            const altered = [
+                                {
+                                    ...request,
+                                    additionalSolutions: request.additionalSolutions.map((solution, index) => index === 0
+                                        ? {
+                                            ...solution,
+                                            fileOverrides: [
+                                                ...(solution.fileOverrides ?? []),
+                                                { path: "src/binding-probe.js", content: "export const changed = true;\n" }
+                                            ]
+                                        }
+                                        : solution)
+                                },
+                                { ...request, repetitions: (request.repetitions ?? 2) + 1 },
+                                {
+                                    ...request,
+                                    seed: {
+                                        ...request.seed,
+                                        environment: {
+                                            ...request.seed.environment,
+                                            gradeRecipes: request.seed.environment.gradeRecipes.map((recipe) => ({
+                                                ...recipe, timeoutMs: recipe.timeoutMs + 1
+                                            }))
+                                        }
+                                    }
+                                },
+                                ...(request.hiddenFixtureSuite === undefined ? [] : [{
+                                        ...request,
+                                        hiddenFixtureSuite: {
+                                            ...request.hiddenFixtureSuite,
+                                            overlays: request.hiddenFixtureSuite.overlays.map((overlay) => ({
+                                                ...overlay, content: `${overlay.content}\n// changed executable fixture\n`
+                                            }))
+                                        }
+                                    }])
+                            ];
+                            for (const changed of altered) {
+                                const rejected = yield* saved.service.oracle(changed).pipe(Effect.result);
+                                assert.equal(rejected._tag, "Failure", "identical public solution metadata cannot authorize changed executable inputs");
+                                if (rejected._tag === "Failure")
+                                    assert.match(String(rejected.failure.cause), /saved tournament executable input binding differs/u);
+                            }
+                            checkedExecutableBinding = true;
+                        }
+                        return yield* saved.service.oracle(request);
+                    })
+                }), Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(Layer.succeed(EvalAuthoringTransport, saved.transport)))));
+            }));
+            assert.equal(calls.length, callsBeforeReconstruction, "reconstruction cannot reach the live transport");
+            assert.equal(restored.checkpoint.requiresReplayValidation, true);
+            assert.equal(checkedExecutableBinding, true);
+            assert.equal(Object.hasOwn(restored.checkpoint, "specificationContractFactsVersion"), false, "exact archived reconstruction cannot upgrade the specification protocol");
+            assert.equal(restored.checkpoint.validControlReviewVersion, validControlReviewVersion);
+            assert.equal(restored.checkpoint.reviewInputVersion, reviewInputVersion);
+            assert.equal(Object.hasOwn(restored.checkpoint, "reviewInputVersion"), reviewInputVersion !== undefined);
+            assert.equal(restored.checkpoint.qualityReviewInput.validControlReviewVersion, validControlReviewVersion);
+            assert.equal("qualityReview" in restored.checkpoint.generation, false);
+            assertRepositoryFoundryFinalizationInputV1(restored);
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1({
+                ...restored,
+                checkpoint: { ...restored.checkpoint, specificationContractFactsVersion: 1 }
+            }), /checkpoint, completed populations, budget and parent plan must agree/u);
+            const { validControlReviewVersion: _savedVersion, ...withoutPolicy } = restored.checkpoint;
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1({
+                ...restored,
+                checkpoint: validControlReviewVersion === undefined
+                    ? { ...withoutPolicy, validControlReviewVersion: 2 }
+                    : withoutPolicy
+            }), /checkpoint, completed populations, budget and parent plan must agree/u);
+            const { reviewInputVersion: _savedInputVersion, ...withoutReviewCapacity } = restored.checkpoint;
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1({
+                ...restored,
+                checkpoint: reviewInputVersion === undefined
+                    ? { ...withoutReviewCapacity, reviewInputVersion: 2 }
+                    : withoutReviewCapacity
+            }), /checkpoint, completed populations, budget and parent plan must agree/u);
+            assert.deepEqual(restored.checkpoint.qualityReviewInput, savedCheckpoint.qualityReviewInput);
+            const changed = JSON.parse(JSON.stringify(restored));
+            changed.checkpoint.qualityReviewInput.developmentOracle.observations[0].outcome = "unknown";
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1(changed), /review evidence differs/u);
+            const partial = JSON.parse(JSON.stringify(restored));
+            partial.checkpoint.qualityReviewInput.validSolutions.pop();
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1(partial), /complete saved control populations/u);
+            for (const key of ["validSolutions", "developmentAdversaries", "heldOutAdversaries"]) {
+                const changedPatch = structuredClone(restored);
+                const population = changedPatch.checkpoint.qualityReviewInput[key];
+                population[0].fileOverrides = [
+                    { path: "src/binding-probe.js", content: "export const changed = true;\n" }
+                ];
+                assert.throws(() => assertRepositoryFoundryFinalizationInputV1(changedPatch), /complete saved control populations and executable bindings/u, "the same metadata must not authorize changed control patches");
+                delete population[0].fileOverrides;
+                assert.throws(() => assertRepositoryFoundryFinalizationInputV1(changedPatch), /complete saved control populations and executable bindings/u, "missing executable patches must fail before any fresh execution");
+            }
+            const unbound = structuredClone(restored);
+            delete unbound.checkpoint.generation.benchmarkCase.hidden.executionBindingDigest;
+            assert.throws(() => assertRepositoryFoundryFinalizationInputV1(unbound), /complete saved control populations and executable bindings/u, "metadata-only artifacts cannot bypass binding checks by dropping the digest");
+            const newCalls = [];
+            const finalizationTransport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: () => Effect.die("finalization requires detailed provenance"),
+                completeDetailed: (input) => {
+                    newCalls.push(input);
+                    assert.equal(input.foundryRole, "quality-reviewer", "finalization cannot regenerate any authoring role");
+                    assert.equal(input.instructions.includes("Valid-control policy version 2"), validControlReviewVersion === 2);
+                    assert.equal(input.reviewInputVersion, reviewInputVersion);
+                    assert.ok(Buffer.byteLength(evalAuthoringResponsesRequestBody(input)) <=
+                        evalAuthoringRequestByteLimit(input));
+                    return Effect.succeed({
+                        text: JSON.stringify(modelOutput(input)),
+                        callId: "frozen-finalization-review"
+                    });
+                }
+            }));
+            const finalized = await Effect.runPromise(finalizeRepositoryGeneratedCaseV1({
+                ...restored,
+                reviewOperationId: "frozen-finalization-test:quality-reviewer"
+            }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(finalizationTransport)))));
+            assert.equal(newCalls.length, 1);
+            assert.equal(finalized.generation.qualityReview.verdict, "approve");
+            assert.equal(finalized.generation.benchmarkCase.status, "valid-library");
+            assert.equal(finalized.generation.benchmarkCase.behavioralFingerprint, result.generation.benchmarkCase.behavioralFingerprint);
+            assert.deepEqual(finalized.generation.benchmarkCase.hidden.solutions, result.generation.benchmarkCase.hidden.solutions);
+            assert.deepEqual(finalized.generation.heldOutOracle?.solutions, result.generation.heldOutOracle?.solutions);
+            assert.equal(finalized.generation.benchmarkCase.hidden.observations.length, result.generation.benchmarkCase.hidden.observations.length);
+            assert.equal(finalized.generation.heldOutOracle?.observations.length, result.generation.heldOutOracle?.observations.length);
+            assert.equal(finalized.generation.modelCalls.length, result.generation.modelCalls.length);
+        }
+        finally {
+            await Promise.all([
+                rm(repository.root, { recursive: true, force: true }),
+                rm(archiveRoot, { recursive: true, force: true })
+            ]);
+        }
+    });
+}
+test("repository foundry refuses to plan paid generation for an unqualified historical seed", async () => {
+    const repository = await createDiscoverableRepository({
+        brokenHistoricalBaseline: true
+    });
+    try {
+        const modelPlan = gpt56RepositoryFoundryModelPlanV1({
+            primaryModel: "openai/gpt-5.6-sol",
+            criticAModel: "openai/gpt-5.6-luna",
+            criticBModel: "openai/gpt-5.6-terra",
+            reviewerModel: "openai/gpt-5.6-terra"
+        });
+        await assert.rejects(Effect.runPromise(planHistoricalRepositoryCaseGenerationV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            referenceCommit: repository.referenceCommit,
+            caseId: "case-reject-unqualified-history",
+            modelPlan,
+            maximumHistoryEpisodes: 10,
+            qualificationBatches: 2,
+            qualificationRepetitionsPerBatch: 2,
+            oracleRepetitions: 2,
+            maximumHillClimbAttempts: 2
+        })), /historical seed failed replay qualification before planning: .*initial baseline does not pass/u);
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("nonexecutable generated fixtures stop before any solution-generation model call", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const calls = [];
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                calls.push(input);
+                const output = modelOutput(input);
+                if (input.foundryRole !== "oracle-designer")
+                    return Effect.succeed(JSON.stringify(output));
+                const proposal = output;
+                return Effect.succeed(JSON.stringify({
+                    ...proposal,
+                    overlays: proposal.overlays.map((overlay) => ({
+                        ...overlay,
+                        content: 'import { obsoleteApi } from "./clamp.js"; obsoleteApi();\n'
+                    }))
+                }));
+            }
+        }));
+        await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "nonexecutable-fixture-generate-clamp-case",
+            caseId: "case-clamp-inclusive-range",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" }),
+            maximumHillClimbAttempts: 0
+        }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))))), /fixture preflight failed.*reference acceptance is required/u);
+        assert.equal(calls.filter((call) => call.foundryRole === "oracle-designer").length, 1);
+        assert.equal(calls.some((call) => [
+            "valid-solution-generator-a",
+            "valid-solution-generator-b",
+            "adversary",
+            "held-out-adversary"
+        ].includes(call.foundryRole ?? "")), false);
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("grounded generation projects reviewed target behavior into downstream roles and rejects missing oracle scope before replay", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const originalSeed = seed({ ...repository, episodeId: episode.id });
+        const candidate = {
+            ...originalSeed,
+            targetBehavior: originalSeed.targetBehavior.map((behavior) => ({
+                ...behavior,
+                description: "Repair clamp boundaries."
+            }))
+        };
+        const behavioralScope = [
+            {
+                id: "lower-input",
+                kind: "changed",
+                behaviorIds: ["inclusive-clamp-range"],
+                description: "Numeric values below zero become zero."
+            },
+            {
+                id: "upper-input",
+                kind: "preserved",
+                behaviorIds: ["inclusive-clamp-range"],
+                description: "Numeric values above one hundred remain capped at one hundred."
+            },
+            {
+                id: "interior-input",
+                kind: "preserved",
+                behaviorIds: ["inclusive-clamp-range"],
+                description: "Numeric values inside the inclusive range remain unchanged."
+            }
+        ];
+        const expectedTarget = candidate.targetBehavior.map((behavior) => ({
+            ...behavior,
+            description: behavioralScope.map((clause) => clause.description).join(" ")
+        }));
+        const scopeCoverage = behavioralScope.map((clause, index) => ({
+            scopeId: clause.id,
+            outcome: "covered",
+            fixtureIds: [["historical-negative", "upper-boundary", "in-range-metamorphic"][index]],
+            detail: "The bound fixture asserts this observable requirement."
+        }));
+        for (const missingCoverage of [true, false]) {
+            const roles = [];
+            const artifacts = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    const role = input.foundryRole;
+                    roles.push(role);
+                    const packet = JSON.parse(input.input);
+                    const output = modelOutput(input);
+                    if (role === "repository-analyst") {
+                        const sourceEvidence = packet
+                            .privateReferenceEvidence.sources.filter((source) => source.path === "src/clamp.js")
+                            .map((source) => ({ sourceId: source.sourceId, startLine: 1, endLine: 1 }));
+                        assert.equal(sourceEvidence.length, 2);
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            referenceScope: {
+                                clauses: behavioralScope.map((clause) => ({
+                                    ...clause,
+                                    evidence: sourceEvidence
+                                })),
+                                unresolvedQuestions: []
+                            }
+                        }));
+                    }
+                    assert.deepEqual(packet.targetBehavior, expectedTarget, `${role} retains grounded behavior IDs, flags, evidence, and descriptions`);
+                    if (!role.startsWith("trajectory-")) {
+                        assert.deepEqual(packet.behavioralScope, behavioralScope);
+                        assert.equal(JSON.stringify(packet.behavioralScope).includes("private-reference-"), false);
+                        assert.equal(JSON.stringify(packet.behavioralScope).includes(repository.referenceCommit), false);
+                    }
+                    if (role === "specification-critic-b") {
+                        const after = packet.privateReferenceEvidence.sources.find((source) => source.phase === "after" && source.path === "src/clamp.js");
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            referenceCompatibility: {
+                                outcome: "compatible",
+                                detail: "The pinned behavior supports this visible contract.",
+                                scopeCoverage: behavioralScope.map((clause) => ({
+                                    scopeId: clause.id,
+                                    outcome: "supported",
+                                    detail: "This scope requirement is supported.",
+                                    evidence: [{ sourceId: after.sourceId, startLine: 1, endLine: 1 }]
+                                }))
+                            }
+                        }));
+                    }
+                    if (role === "solution-critic-a" || role === "solution-critic-b") {
+                        return Effect.fail(new EvalProjectAuthoringError({
+                            operation: "authoring-evaluations",
+                            detail: "grounded projection reached solution review"
+                        }));
+                    }
+                    return Effect.succeed(JSON.stringify(role === "oracle-designer" && !missingCoverage
+                        ? { ...output, scopeCoverage }
+                        : output));
+                }
+            }));
+            await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: `grounded-projection-${String(missingCoverage)}`,
+                caseId: "case-clamp-inclusive-range",
+                map,
+                seed: candidate,
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "codex/gpt-6-astra" }),
+                maximumSpecificationRevisions: 0,
+                maximumHillClimbAttempts: 0
+            }).pipe(Effect.provide(Layer.mergeAll(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(undefined, (artifact) => Effect.sync(() => {
+                artifacts.push(artifact);
+            })))))), missingCoverage
+                ? /every grounded behavioral scope clause/u
+                : /grounded projection reached solution review/u);
+            assert.equal(roles.filter((role) => role === "specification-writer").length, 1);
+            if (missingCoverage) {
+                assert.equal(artifacts.some((artifact) => artifact.role === "fixture-validator"), false);
+                assert.equal(roles.some((role) => role.startsWith("valid-solution-")), false);
+            }
+            else {
+                for (const role of [
+                    "trajectory-designer",
+                    "trajectory-critic",
+                    "oracle-designer",
+                    "valid-solution-generator-a",
+                    "valid-solution-generator-b",
+                    "adversary",
+                    "solution-critic-a"
+                ])
+                    assert.ok(roles.includes(role), role);
+                assert.ok(artifacts.some((artifact) => artifact.role === "fixture-validator"));
+                const oracle = artifacts.find((artifact) => artifact.role === "oracle-designer" && artifact.validation === "validated");
+                assert.deepEqual((oracle?.value).scopeCoverage, scopeCoverage);
+            }
+        }
+        assert.equal(candidate.targetBehavior[0].description, "Repair clamp boundaries.");
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("case generation materializes allowed manifest edits visible only in pinned repository environment context", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const candidate = seed({
+            initialCommit: repository.initialCommit,
+            referenceCommit: repository.referenceCommit,
+            episodeId: episode.id
+        });
+        const artifacts = [];
+        let modelManifest = "";
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                if (input.foundryRole === "solution-critic-a" ||
+                    input.foundryRole === "solution-critic-b") {
+                    return Effect.fail(new EvalProjectAuthoringError({
+                        operation: "authoring-evaluations",
+                        detail: "regression reached review after manifest materialization"
+                    }));
+                }
+                const output = modelOutput(input);
+                if (input.foundryRole === "repository-analyst") {
+                    return Effect.succeed(JSON.stringify({
+                        ...output,
+                        relevantPaths: ["src/clamp.js", "src/clamp.test.js"]
+                    }));
+                }
+                if (input.foundryRole !== "adversary")
+                    return Effect.succeed(JSON.stringify(output));
+                const packet = JSON.parse(input.input);
+                assert.equal(packet.preChangeSources.some((source) => source.path === "package.json"), false);
+                assert.ok(packet.allowedRewardHackingPaths.includes("package.json"));
+                assert.equal(packet.repositoryEnvironment.commit, repository.initialCommit);
+                modelManifest = packet.repositoryEnvironment.sources.find((source) => source.path === "package.json").content;
+                assert.ok(modelManifest.includes('"test": "node --test src/*.test.js"'));
+                const proposal = output;
+                return Effect.succeed(JSON.stringify({
+                    solutions: [
+                        ...proposal.solutions.map((solution) => solution.kind !== "reward-hacking"
+                            ? solution
+                            : {
+                                ...solution,
+                                fileOverrides: [
+                                    ...solution.fileOverrides,
+                                    {
+                                        path: "package.json",
+                                        edits: [
+                                            {
+                                                search: '"test": "node --test src/*.test.js"',
+                                                replace: '"test": "node --test src/control.test.js"'
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }),
+                        {
+                            id: "upper-overflow-wraparound",
+                            family: "overflow-wraparound",
+                            kind: "mutation",
+                            fileOverrides: [
+                                {
+                                    path: "src/index.js",
+                                    content: "export const clamp = (value) => value > 100 ? 0 : Math.max(0, value);\n"
+                                }
+                            ]
+                        }
+                    ]
+                }));
+            }
+        }));
+        await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "manifest-context-regression",
+            caseId: "case-clamp-inclusive-range",
+            map,
+            seed: {
+                ...candidate,
+                environment: {
+                    ...candidate.environment,
+                    protectedControlPaths: [
+                        ...candidate.environment.protectedControlPaths,
+                        "package.json"
+                    ]
+                }
+            },
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" }),
+            maximumHillClimbAttempts: 0
+        }).pipe(Effect.provide(Layer.mergeAll(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(undefined, (artifact) => Effect.sync(() => {
+            artifacts.push(artifact);
+        })))))), /regression reached review after manifest materialization/u);
+        const materialized = artifacts.find((artifact) => artifact.operationId === "manifest-context-regression:adversary:materialized");
+        assert.ok(materialized);
+        const proposal = materialized.value.proposal;
+        const manifest = proposal.solutions
+            .find((solution) => solution.kind === "reward-hacking")
+            .fileOverrides.find((override) => override.path === "package.json");
+        assert.equal(manifest?.content, modelManifest.replace('"test": "node --test src/*.test.js"', '"test": "node --test src/control.test.js"'));
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+for (const scenario of ["family-collision", "duplicate-patch", "shared-repair-budget"]) {
+    test(`independent pair repair preserves isolation and bounded control generation: ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const calls = [];
+            const solverBPatches = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    const output = modelOutput(input);
+                    if (input.foundryRole === "valid-solution-generator-a" &&
+                        scenario !== "duplicate-patch") {
+                        output.solutions[0].family = "Numeric boundary handling";
+                    }
+                    if (input.foundryRole === "valid-solution-generator-b") {
+                        const proposal = output;
+                        if (scenario === "duplicate-patch") {
+                            const peer = modelOutput({
+                                ...input,
+                                foundryRole: "valid-solution-generator-a"
+                            });
+                            proposal.solutions[0].fileOverrides = peer.solutions[0].fileOverrides;
+                        }
+                        else if (!input.operationId.includes(":repair-")) {
+                            proposal.solutions[0].family = "Numeric boundary handling";
+                        }
+                        if (input.operationId.endsWith(":repair-2") && scenario === "shared-repair-budget") {
+                            proposal.solutions[0].fileOverrides[0].content +=
+                                "\n// Latest independently reviewed proposal.\n";
+                        }
+                        solverBPatches.push(JSON.stringify(proposal.solutions[0].fileOverrides));
+                    }
+                    if (input.foundryRole === "adversary") {
+                        assert.ok(calls.some((call) => call.operationId.endsWith(":valid-solution-generator-b:repair-1")));
+                    }
+                    if (input.foundryRole === "solution-critic-a" ||
+                        input.foundryRole === "solution-critic-b") {
+                        const packet = JSON.parse(input.input);
+                        const latest = [...calls]
+                            .reverse()
+                            .find((call) => call.foundryRole === "valid-solution-generator-b");
+                        assert.ok(latest.operationId.includes(":repair-"));
+                        if (scenario === "family-collision")
+                            return Effect.fail(new EvalProjectAuthoringError({
+                                operation: "authoring-evaluations",
+                                detail: "pair-repair regression reached fresh critics"
+                            }));
+                        if (input.operationId.includes(":repair-")) {
+                            assert.match(packet.solutions.find((solution) => solution.id === "independent-guard-bounds")
+                                .fileOverrides[0].content, /Latest independently reviewed proposal/u);
+                        }
+                        if (input.foundryRole === "solution-critic-b") {
+                            const review = output;
+                            const finding = review.reviews.find((entry) => entry.solutionId === "independent-guard-bounds");
+                            finding.classification = "uncertain";
+                            finding.detail = "Independently justify the visible lower-bound behavior.";
+                        }
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: `pair-repair-${scenario}`,
+                requestedDimension: "Numeric boundary handling",
+                caseId: `case-pair-repair-${scenario}`,
+                map,
+                seed: seed({
+                    initialCommit: repository.initialCommit,
+                    referenceCommit: repository.referenceCommit,
+                    episodeId: episode.id
+                }),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" }),
+                maximumHillClimbAttempts: 0
+            }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))))), scenario === "family-collision"
+                ? /pair-repair regression reached fresh critics/u
+                : scenario === "duplicate-patch"
+                    ? /valid-control-repair-exhausted.*valid-control-duplicate-patch/u
+                    : /valid-control-repair-exhausted/u);
+            const a = calls.filter((call) => call.foundryRole === "valid-solution-generator-a");
+            const b = calls.filter((call) => call.foundryRole === "valid-solution-generator-b");
+            assert.equal(a.length, 1);
+            assert.equal(b.length, scenario === "family-collision" ? 2 : 3);
+            if (scenario === "family-collision") {
+                assert.equal(solverBPatches[1], solverBPatches[0], "a metadata-only repair may retain an already distinct implementation");
+            }
+            assert.equal(new Set(calls.map((call) => call.operationId)).size, calls.length);
+            assert.equal(calls.some((call) => call.foundryRole === "held-out-adversary"), false);
+            if (scenario === "duplicate-patch") {
+                assert.equal(calls.some((call) => call.foundryRole === "adversary"), false);
+                assert.equal(calls.some((call) => call.foundryRole?.startsWith("solution-critic-")), false);
+            }
+            if (scenario === "shared-repair-budget") {
+                assert.equal(calls.filter((call) => call.foundryRole?.startsWith("solution-critic-")).length, 4);
+            }
+            for (const call of b.slice(1)) {
+                assert.match(call.instructions, /family field names your implementation mechanism/u);
+                assert.match(call.instructions, /metadata-only contract findings, accurately correct your own metadata while preserving a correct implementation/u);
+                const packet = JSON.parse(call.input);
+                assert.deepEqual(Object.keys(packet).sort(), [
+                    "allowedSolutionPaths",
+                    "preChangeSources",
+                    "priorOwnProposal",
+                    "repairSequence",
+                    "repositoryEnvironment",
+                    "requestedDimension",
+                    call.operationId.endsWith(":repair-2") && scenario === "shared-repair-budget"
+                        ? "priorCriticFindings"
+                        : "pairContractFindings",
+                    "visible"
+                ].sort());
+                assert.equal(call.input.includes("independent-composed-bounds"), false);
+                assert.equal(call.input.includes(repository.referenceCommit), false);
+                assert.equal(call.input.includes("rounding-near-miss"), false);
+                assert.equal(call.input.includes("historical-negative"), false);
+                if (packet.pairContractFindings !== undefined) {
+                    assert.deepEqual(packet.pairContractFindings.map((entry) => entry.code), scenario === "duplicate-patch"
+                        ? ["valid-control-duplicate-patch", "valid-control-similar-patch"]
+                        : ["valid-control-duplicate-family"]);
+                }
+            }
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+for (const scenario of ["repaired", "exhausted", "wrong-pair", "unknown-source"]) {
+    test(`early implementation independence review preserves correctness and isolation: ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const calls = [];
+            const stages = [];
+            const artifacts = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    const output = modelOutput(input);
+                    const repaired = input.operationId.includes(":repair-");
+                    if (input.foundryRole === "valid-solution-generator-b" &&
+                        (!repaired || scenario === "exhausted")) {
+                        const proposal = output;
+                        proposal.solutions[0].family = "extracted-range-helper";
+                        proposal.solutions[0].fileOverrides[0].content =
+                            "function withinRange(value, lower, upper) {\n" +
+                                "  const atLeastLower = Math.max(value, lower);\n" +
+                                "  return Math.min(atLeastLower, upper);\n}\n" +
+                                "export const clamp = (value) => withinRange(value, 0, 100);\n";
+                    }
+                    if (input.foundryRole === "solution-critic-a" ||
+                        input.foundryRole === "solution-critic-b") {
+                        const packet = JSON.parse(input.input);
+                        assert.deepEqual(packet.implementationComparison.solutionIds, [
+                            "independent-composed-bounds",
+                            "independent-guard-bounds"
+                        ]);
+                        assert.match(input.instructions, /two correlated but correct solutions/u);
+                        // A disagreement must trigger repair even when the other critic passes.
+                        const independent = input.foundryRole === "solution-critic-a" || (scenario === "repaired" && repaired);
+                        return Effect.succeed(JSON.stringify({
+                            reviews: output.reviews,
+                            implementationIndependence: {
+                                outcome: independent ? "independent" : "correlated",
+                                detail: independent
+                                    ? "Composed numeric bounds and separate early-return guards implement the same visible contract by different mechanisms."
+                                    : "The helper retains the same min/max mechanism. PRIVATE_PEER_CODE_CANARY",
+                                implementations: packet.implementationComparison.solutionIds.map((solutionId, index) => ({
+                                    solutionId: scenario === "wrong-pair" && index === 0
+                                        ? "unrelated-solution"
+                                        : solutionId,
+                                    mechanism: index === 0
+                                        ? "Composed min/max bounds. PRIVATE_PEER_MECHANISM_CANARY"
+                                        : independent
+                                            ? "Ordered guards return boundary constants or preserve the input."
+                                            : "Extracted min/max helper. PRIVATE_PEER_MECHANISM_CANARY",
+                                    sourcePaths: [
+                                        scenario === "unknown-source" ? "src/unreviewed.js" : "src/clamp.js"
+                                    ]
+                                })),
+                                correlatedFeatures: independent ? [] : ["helper-extraction"]
+                            }
+                        }));
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            const execution = Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: `early-independence-${scenario}`,
+                caseId: `case-early-independence-${scenario}`,
+                validControlReviewVersion: 1,
+                map,
+                seed: seed({
+                    initialCommit: repository.initialCommit,
+                    referenceCommit: repository.referenceCommit,
+                    episodeId: episode.id
+                }),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" })
+            }).pipe(Effect.provide(Layer.merge(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+                stages.push(event.stage);
+            }), (artifact) => Effect.sync(() => {
+                artifacts.push(artifact);
+            }))))));
+            if (scenario === "repaired") {
+                const result = await execution;
+                assert.equal(result.benchmarkCase.status, "valid-library");
+                assert.ok(stages.includes("tournament"));
+                for (const review of result.solutionReviews) {
+                    assert.equal(review.implementationIndependence?.outcome, "independent");
+                    assert.ok(review.reviews
+                        .filter((entry) => entry.solutionId.startsWith("independent-"))
+                        .every((entry) => entry.classification === "valid"));
+                }
+                assert.match(result.validSolutionProposal.solutions[1].fileOverrides[0].content, /if \(value < 0\) return 0/u);
+            }
+            else {
+                await assert.rejects(execution, scenario === "exhausted"
+                    ? /valid-control-independence-repair-exhausted/u
+                    : /must separately assess both current implementations/u);
+                assert.equal(stages.includes("tournament"), false);
+                assert.equal(calls.some((call) => call.foundryRole === "hill-climb-planner"), false);
+                assert.equal(calls.some((call) => call.foundryRole === "held-out-adversary"), false);
+                assert.equal(calls.some((call) => call.foundryRole === "quality-reviewer"), false);
+            }
+            const solverA = calls.filter((call) => call.foundryRole === "valid-solution-generator-a");
+            const solverB = calls.filter((call) => call.foundryRole === "valid-solution-generator-b");
+            const critics = calls.filter((call) => call.foundryRole === "solution-critic-a" || call.foundryRole === "solution-critic-b");
+            assert.equal(solverA.length, 1);
+            assert.equal(solverB.length, scenario === "repaired" ? 2 : scenario === "exhausted" ? 3 : 1);
+            assert.equal(critics.length, scenario === "repaired" ? 4 : scenario === "exhausted" ? 6 : 2);
+            for (const call of solverB.slice(1)) {
+                assert.match(call.instructions, /substantively different mechanism/u);
+                const packet = JSON.parse(call.input);
+                assert.deepEqual(packet.priorOwnProposal.solutions.map((entry) => entry.id), ["independent-guard-bounds"]);
+                assert.deepEqual(packet.priorCriticFindings, [], "correlation is not a wrong label");
+                assert.deepEqual(packet.pairContractFindings, [
+                    {
+                        code: "valid-control-independence-helper-extraction",
+                        detail: "Moving the same behavior into a helper does not provide a different implementation mechanism."
+                    }
+                ]);
+                for (const secret of [
+                    "independent-composed-bounds",
+                    "PRIVATE_PEER_CODE_CANARY",
+                    "PRIVATE_PEER_MECHANISM_CANARY",
+                    repository.referenceCommit,
+                    "developmentFixtureProposal",
+                    "historical-negative",
+                    "rounding-near-miss"
+                ]) {
+                    assert.equal(call.input.includes(secret), false, `solver received peer material: ${secret}`);
+                }
+            }
+            const privateReviews = artifacts.filter((artifact) => artifact.role === "solution-critic-b" && artifact.validation === "validated");
+            assert.ok(privateReviews.length > 0);
+            const first = privateReviews[0].value;
+            assert.equal(first.implementationIndependence.outcome, "correlated");
+            assert.ok(first.reviews
+                .filter((entry) => entry.solutionId.startsWith("independent-"))
+                .every((entry) => entry.classification === "valid"));
+            assert.match(JSON.stringify(first), /PRIVATE_PEER_CODE_CANARY/u);
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+for (const scenario of [
+    "equivalent",
+    "provided-source-citation",
+    "unprovided-source-citation",
+    "legacy-equivalent",
+    "legacy-provided-source-citation",
+    "wrong-alternative",
+    "biased-oracle",
+    "biased-oracle-exhausted"
+]) {
+    test(`behavioral valid-control policy preserves executable correctness: ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            const legacy = scenario.startsWith("legacy-");
+            const wrong = scenario === "wrong-alternative";
+            const biased = scenario.startsWith("biased-oracle");
+            const exhausted = scenario === "biased-oracle-exhausted";
+            const providedCitation = scenario === "provided-source-citation" ||
+                scenario === "legacy-provided-source-citation";
+            const unprovidedCitation = scenario === "unprovided-source-citation";
+            const invalidCitation = unprovidedCitation || (legacy && providedCitation);
+            const calls = [];
+            const stages = [];
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    const output = modelOutput(input);
+                    if (input.foundryRole === "valid-solution-generator-b") {
+                        const proposal = output;
+                        // Both correct variants use min/max. The alternative is a real executable
+                        // helper formulation, not a source fingerprint or family-name distinction.
+                        proposal.solutions[0].family = legacy
+                            ? "extracted-range-helper"
+                            : "composed-min-max";
+                        proposal.solutions[0].fileOverrides[0].content = wrong
+                            ? "export function clamp(value) {\n" +
+                                "  if (value < 0) return 0;\n" +
+                                "  if (value > 100) return 100;\n" +
+                                "  return Math.round(value);\n}\n"
+                            : "function constrain(value, lower, upper) {\n" +
+                                "  return Math.min(upper, Math.max(lower, value));\n}\n" +
+                                "export const clamp = (value) => constrain(value, 0, 100);\n";
+                    }
+                    if (input.foundryRole === "oracle-designer") {
+                        output.overlays = isolatedClampOverlays(biased ? "implementation-specific" : "repaired");
+                    }
+                    if (input.foundryRole === "solution-critic-a" ||
+                        input.foundryRole === "solution-critic-b") {
+                        const packet = JSON.parse(input.input);
+                        if (providedCitation) {
+                            assert.ok(packet.repositoryEnvironment.sources.some((source) => source.path === "package.json" && typeof source.content === "string"), "supporting source bytes must be present in the actual critic request");
+                        }
+                        const reviews = output.reviews;
+                        if (wrong) {
+                            const review = reviews.find((entry) => entry.solutionId === "independent-guard-bounds");
+                            review.classification = "wrong";
+                            review.detail = "Rounding 25.5 violates exact preservation of an in-range input.";
+                            review.violatedBehaviorIds = ["inclusive-clamp-range"];
+                        }
+                        output.implementationIndependence = {
+                            outcome: wrong ? "independent" : "correlated",
+                            detail: wrong
+                                ? "Early-return guards differ from numeric bound composition; this does not establish correctness."
+                                : "The helper and direct expression share a min/max mechanism. PRIVATE_POLICY_PEER_CANARY",
+                            implementations: packet.implementationComparison.solutionIds.map((solutionId, index) => ({
+                                solutionId,
+                                mechanism: index === 0
+                                    ? "Direct min/max composition"
+                                    : wrong
+                                        ? "Early returns with rounding"
+                                        : "Equivalent helper-based min/max composition",
+                                sourcePaths: [
+                                    "src/clamp.js",
+                                    ...(providedCitation ? ["package.json"] : []),
+                                    ...(unprovidedCitation ? ["src/not-supplied-helper.js"] : [])
+                                ]
+                            })),
+                            correlatedFeatures: wrong ? [] : ["helper-extraction"]
+                        };
+                        if (!legacy) {
+                            assert.match(input.instructions, /Mechanism similarity alone is not/u);
+                            assert.match(input.instructions, /source-only semantic review/u);
+                        }
+                    }
+                    if (input.foundryRole === "hill-climb-planner") {
+                        output.targetedFalseAcceptIds = [];
+                        output.targetedFalseRejectIds = ["independent-guard-bounds"];
+                        const fixtureProposal = output.fixtureProposal;
+                        fixtureProposal.overlays = isolatedClampOverlays(exhausted ? "implementation-specific" : "repaired");
+                    }
+                    if (input.foundryRole === "quality-reviewer") {
+                        assert.match(input.instructions, /Valid-control policy version 2/u);
+                        assert.equal(input.instructions.includes("materially similar valid implementations"), false);
+                        const review = output;
+                        review.findings.find((finding) => finding.axis === "valid-solution-independence").detail =
+                            "The isolated solver calls produce semantically correct executable alternatives. Their min/max mechanism is correlated and retained as a limitation. Repeated tournaments accept both implementations and reject the wrong controls.";
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            const execution = Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: `behavioral-policy-${scenario}`,
+                caseId: `case-behavioral-policy-${scenario}`,
+                validControlReviewVersion: legacy ? 1 : 2,
+                maximumHillClimbAttempts: exhausted ? 1 : 2,
+                map,
+                seed: seed({ ...repository, episodeId: episode.id }),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" })
+            }).pipe(Effect.provide(Layer.merge(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+                stages.push(event.stage);
+            }))))));
+            if (legacy || wrong || exhausted || invalidCitation) {
+                await assert.rejects(execution, invalidCitation
+                    ? /must separately assess both current implementations/u
+                    : legacy
+                        ? /valid-control-independence-repair-exhausted/u
+                        : wrong
+                            ? /solution critic A rejected generated solution labels/u
+                            : /oracle|adequacy/u);
+                assert.equal(calls.some((call) => call.foundryRole === "quality-reviewer"), false);
+                assert.equal(calls.some((call) => call.foundryRole === "held-out-adversary"), false);
+                if (legacy || wrong || invalidCitation)
+                    assert.equal(stages.includes("tournament"), false);
+            }
+            else {
+                const result = await execution;
+                assert.equal(result.benchmarkCase.status, "valid-library");
+                assert.equal(result.benchmarkCase.adequacy.admitted, true);
+                assert.equal(result.heldOutAdequacy.admitted, true);
+                assert.deepEqual(result.benchmarkCase.adequacy.falseRejectedSolutionIds, []);
+                assert.deepEqual(result.benchmarkCase.adequacy.falseAcceptedSolutionIds, []);
+                assert.ok(result.solutionReviews.every((review) => review.implementationIndependence?.outcome === "correlated"));
+                assert.equal(result.validSolutionProposal.solutions[0].family, "composed-min-max");
+                assert.equal(result.validSolutionProposal.solutions[1].family, "composed-min-max");
+                if (biased) {
+                    assert.ok(result.hillClimbAttempts[0].beforeAdequacy.falseRejectedSolutionIds.includes("independent-guard-bounds"));
+                    assert.equal(result.hillClimbAttempts[0].decision, "accepted");
+                    assert.ok(result.fixtureProposal.overlays.every((overlay) => !overlay.content.includes("clamp.toString")));
+                }
+                else {
+                    assert.equal(result.hillClimbAttempts.length, 0);
+                }
+            }
+            const solverCalls = calls.filter((call) => call.foundryRole?.startsWith("valid-solution-generator-"));
+            if (!legacy && !wrong)
+                assert.equal(solverCalls.length, 2);
+            for (const call of solverCalls) {
+                for (const privateMaterial of [
+                    "PRIVATE_POLICY_PEER_CANARY",
+                    "developmentFixtureProposal",
+                    "historical-negative",
+                    "rounding-near-miss",
+                    repository.referenceCommit
+                ]) {
+                    assert.equal(call.input.includes(privateMaterial), false);
+                }
+            }
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+for (const scenario of [
+    "critic-a-only",
+    "critic-b-only",
+    "missing-rationale",
+    "blank-rationale",
+    "empty-behavior-ids",
+    "unknown-behavior-id",
+    "mixed-known-and-unknown-behavior-ids",
+    "uncertain-valid-control",
+    "mixed-final-adversary",
+    "development-adversary",
+    "semantic-and-independence"
+]) {
+    test(`semantic valid-control terminal classification stays scoped: ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const targetSeed = seed({ ...repository, episodeId: episode.id });
+            const behaviorIds = targetSeed.targetBehavior.map((behavior) => behavior.id);
+            const unknownBehaviorId = "PRIVATE_TERMINAL_UNKNOWN_BEHAVIOR";
+            const privateCanary = "PRIVATE_TERMINAL_CRITIC_RATIONALE";
+            const wrongBSource = "export const clamp = (value) => { if (value < 0) return 0; if (value > 100) return 100; return Math.round(value); };\n";
+            const correctBSource = "export const clamp = (value) => { if (value < 0) return 0; if (value > 100) return 100; return value; };\n";
+            const correctAdversarySource = "export const clamp = (value) => Math.max(0, Math.min(100, value));\n";
+            const selectedCritic = scenario === "critic-a-only" ? "solution-critic-a" : "solution-critic-b";
+            const selectedReviewer = selectedCritic === "solution-critic-a" ? "solution critic A" : "solution critic B";
+            const developmentOnly = scenario === "development-adversary";
+            const mixedFinal = scenario === "mixed-final-adversary";
+            const independenceUnresolved = scenario === "semantic-and-independence";
+            const expectsCanonical = scenario === "critic-a-only" || scenario === "critic-b-only";
+            const classification = scenario === "uncertain-valid-control" ? "uncertain" : "wrong";
+            const reportedBehaviorIds = scenario === "empty-behavior-ids"
+                ? []
+                : scenario === "unknown-behavior-id"
+                    ? [unknownBehaviorId]
+                    : scenario === "mixed-known-and-unknown-behavior-ids"
+                        ? [...behaviorIds, unknownBehaviorId]
+                        : behaviorIds;
+            assert.ok(behaviorIds.length > 0);
+            assert.equal(behaviorIds.includes(unknownBehaviorId), false);
+            const operationId = `semantic-terminal-scope-${scenario}`;
+            const calls = [];
+            const stages = [];
+            const artifacts = [];
+            const ownBResponses = [];
+            const criticResponses = new Map();
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    const output = modelOutput(input);
+                    if (input.foundryRole === "valid-solution-generator-b") {
+                        const packet = JSON.parse(input.input);
+                        if (packet.repairSequence !== undefined) {
+                            assert.deepEqual(packet.priorOwnProposal, ownBResponses.at(-1), "the real repair owner supplies B's exact previous raw proposal");
+                        }
+                        const proposal = output;
+                        assert.equal(proposal.solutions[0].id, "independent-guard-bounds");
+                        const implementation = proposal.solutions[0].fileOverrides.find((override) => override.path === "src/clamp.js");
+                        assert.ok(implementation);
+                        if (!developmentOnly)
+                            implementation.content = wrongBSource;
+                        ownBResponses.push(structuredClone(output));
+                    }
+                    if (input.foundryRole === "adversary" && (developmentOnly || mixedFinal)) {
+                        const proposal = output;
+                        const mislabeled = proposal.solutions.find((solution) => solution.id === "public-integration-omission");
+                        assert.ok(mislabeled);
+                        // This expected-wrong proposal is actually correct. The mixed
+                        // scenario's critic notices it only in the last review round.
+                        mislabeled.fileOverrides = [
+                            { path: "src/clamp.js", content: correctAdversarySource },
+                            { path: "src/index.js", content: 'export { clamp } from "./clamp.js";\n' }
+                        ];
+                    }
+                    if (input.foundryRole === "solution-critic-a" ||
+                        input.foundryRole === "solution-critic-b") {
+                        const packet = JSON.parse(input.input);
+                        const actualB = packet.solutions.find((solution) => solution.id === "independent-guard-bounds");
+                        assert.ok(actualB);
+                        assert.equal(actualB.fileOverrides.find((override) => override.path === "src/clamp.js")
+                            ?.content, developmentOnly ? correctBSource : wrongBSource, "critics inspect the real materialized proposal, not a substitute description");
+                        const review = output;
+                        if (input.foundryRole === selectedCritic && !developmentOnly) {
+                            const rejected = review.reviews.find((entry) => entry.solutionId === "independent-guard-bounds");
+                            assert.ok(rejected);
+                            rejected.classification = classification;
+                            rejected.detail =
+                                scenario === "missing-rationale"
+                                    ? ""
+                                    : scenario === "blank-rationale"
+                                        ? " \n\t "
+                                        : `The actual proposal rounds 25.5 to 26 instead of preserving the in-range input. ${privateCanary}`;
+                            rejected.violatedBehaviorIds = [...reportedBehaviorIds];
+                        }
+                        if (input.foundryRole === selectedCritic &&
+                            (developmentOnly || (mixedFinal && input.operationId.endsWith(":repair-2")))) {
+                            const actual = packet.solutions.find((solution) => solution.id === "public-integration-omission");
+                            assert.ok(actual);
+                            assert.deepEqual(actual.fileOverrides, [
+                                { path: "src/clamp.js", content: correctAdversarySource },
+                                { path: "src/index.js", content: 'export { clamp } from "./clamp.js";\n' }
+                            ]);
+                            const mislabeled = review.reviews.find((entry) => entry.solutionId === actual.id);
+                            assert.ok(mislabeled);
+                            mislabeled.classification = "valid";
+                            mislabeled.detail =
+                                "Both source overrides provide the complete clamp and its public export.";
+                            mislabeled.violatedBehaviorIds = [];
+                        }
+                        const unresolved = independenceUnresolved && input.foundryRole === selectedCritic;
+                        output.implementationIndependence = {
+                            outcome: unresolved ? "uncertain" : "independent",
+                            detail: unresolved
+                                ? `The reviewer did not establish mechanism independence. ${privateCanary}`
+                                : `Numeric composition and early-return bounds use separate mechanisms. ${privateCanary}`,
+                            implementations: packet.implementationComparison.solutionIds.map((solutionId) => ({
+                                solutionId,
+                                mechanism: solutionId === "independent-composed-bounds"
+                                    ? "Composed numeric bounds."
+                                    : developmentOnly
+                                        ? "Early-return bounds preserve interior values."
+                                        : "Early-return bounds with a rounded interior result.",
+                                sourcePaths: ["src/clamp.js"]
+                            })),
+                            correlatedFeatures: unresolved ? ["insufficient-evidence"] : []
+                        };
+                        criticResponses.set(input.operationId, structuredClone(output));
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            const exit = await Effect.runPromiseExit(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId,
+                caseId: `case-semantic-terminal-${scenario}`,
+                validControlReviewVersion: independenceUnresolved ? 1 : 2,
+                map,
+                seed: targetSeed,
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({ primaryModel: "openai/gpt-6-astra" })
+            }).pipe(Effect.provide(Layer.merge(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+                stages.push(event.stage);
+            }), (artifact) => Effect.sync(() => {
+                artifacts.push(artifact);
+            }))))));
+            assert.ok(Exit.isFailure(exit), "the actual generation owner must reject the reviewed labels");
+            const error = Cause.squash(exit.cause);
+            assert.ok(error instanceof RepositoryFoundryError);
+            assert.equal(error.operation, "compile-reviewed-case");
+            assert.ok(error.detail.includes(`${selectedReviewer} rejected generated solution labels:`));
+            assert.ok(error.detail.includes(developmentOnly
+                ? "public-integration-omission=valid"
+                : `independent-guard-bounds=${classification}`));
+            if (mixedFinal)
+                assert.ok(error.detail.includes("public-integration-omission=valid"));
+            const solverA = calls.filter((call) => call.foundryRole === "valid-solution-generator-a");
+            const solverB = calls.filter((call) => call.foundryRole === "valid-solution-generator-b");
+            const expectedRounds = developmentOnly ? 1 : 3;
+            assert.equal(solverA.length, 1, "B-only review repair must not regenerate the unaffected A");
+            assert.equal(solverB.length, expectedRounds);
+            assert.equal(ownBResponses.length, expectedRounds);
+            assert.deepEqual(solverB.map((call) => JSON.parse(call.input).repairSequence), developmentOnly ? [undefined] : [undefined, 1, 2]);
+            for (const role of ["solution-critic-a", "solution-critic-b"]) {
+                const reviews = calls.filter((call) => call.foundryRole === role);
+                assert.deepEqual(reviews.map((call) => call.operationId), [0, 1, 2].slice(0, expectedRounds).map((round) => `${operationId}:${role}${round === 0 ? "" : `:repair-${round}`}`), "both real critics rerun after each completed B repair");
+            }
+            assert.equal(calls.filter((call) => call.foundryRole === "adversary").length, 1);
+            for (const call of solverB.slice(1)) {
+                const packet = JSON.parse(call.input);
+                assert.deepEqual(packet.priorCriticFindings, [
+                    {
+                        reviewer: selectedReviewer,
+                        solutionId: "independent-guard-bounds",
+                        classification,
+                        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: reportedBehaviorIds.filter((id) => behaviorIds.includes(id))
+                    }
+                ]);
+                assert.deepEqual(packet.pairContractFindings?.map((finding) => finding.code), independenceUnresolved ? ["valid-control-independence-insufficient-evidence"] : undefined);
+            }
+            for (const call of [...solverA, ...solverB]) {
+                for (const unavailable of [
+                    privateCanary,
+                    unknownBehaviorId,
+                    repository.referenceCommit,
+                    "developmentFixtureProposal",
+                    "historical-negative",
+                    "rounding-near-miss"
+                ])
+                    assert.equal(call.input.includes(unavailable), false, `solver received ${unavailable}`);
+            }
+            assert.ok(solverB.every((call) => !call.input.includes("independent-composed-bounds")), "B repair receives no peer solution identity");
+            const privateReviews = artifacts.filter((artifact) => artifact.validation === "validated" &&
+                (artifact.role === "solution-critic-a" || artifact.role === "solution-critic-b"));
+            assert.equal(privateReviews.length, expectedRounds * 2);
+            for (const artifact of privateReviews) {
+                assert.deepEqual(artifact.value, criticResponses.get(artifact.operationId));
+                assert.ok(JSON.stringify(artifact.value).includes(privateCanary));
+            }
+            for (const role of [
+                "hill-climb-planner",
+                "held-out-adversary",
+                "held-out-solution-critic-a",
+                "held-out-solution-critic-b",
+                "quality-reviewer"
+            ])
+                assert.equal(calls.some((call) => call.foundryRole === role), false);
+            for (const stage of [
+                "tournament",
+                "hill-climb",
+                "held-out-tournament",
+                "quality-review",
+                "admit"
+            ])
+                assert.equal(stages.includes(stage), false, "scope checks must stop before tournaments");
+            // Keep desired classification last: a RED first proves the real owner,
+            // reviewer ordering, bounded repair history, and isolation before failing.
+            if (expectsCanonical) {
+                assert.match(error.detail, /^valid-control-repair-exhausted:/u);
+                const original = error.cause;
+                assert.ok(original instanceof RepositoryFoundryError);
+                assert.equal(original.operation, "compile-reviewed-case");
+                assert.ok(original.detail.startsWith(`${selectedReviewer} rejected generated solution labels:`));
+                assert.doesNotMatch(original.detail, /valid-control-repair-exhausted/u);
+                assert.ok(error.detail.includes(original.detail), "retain the original critic detail");
+            }
+            else {
+                assert.doesNotMatch(error.detail, /valid-control-repair-exhausted/u);
+            }
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+for (const scenario of [
+    "early-repair",
+    "exhausted",
+    "freeze-review",
+    "freeze-repair",
+    "freeze-regression",
+    "witness",
+    "witness-repair-false-rejection",
+    "witness-v2-repair-false-rejection",
+    "witness-v2-rejected-then-repair-false-rejection",
+    "witness-v2-nonmonotonic-repair-false-rejection",
+    "witness-v2-late-repair-false-rejection",
+    "witness-budget-repair-false-rejection",
+    "witness-budget-legacy-repair-false-rejection",
+    "witness-budget-exhausted-repair-false-rejection"
+]) {
+    test(`independent oracle coverage uses bounded repairs and rechecks changed suites: ${scenario}`, async () => {
+        const repository = await createRepository();
+        try {
+            const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+                repositoryRoot: repository.root,
+                requestedRef: repository.referenceCommit,
+                maximumHistoryEpisodes: 10
+            }));
+            const episode = map.historyEpisodes.find((entry) => entry.commit === repository.referenceCommit);
+            assert.ok(episode);
+            const behavioralScope = [
+                {
+                    id: "lower",
+                    kind: "changed",
+                    behaviorIds: ["inclusive-clamp-range"],
+                    description: "Negative numeric inputs become zero."
+                },
+                {
+                    id: "upper",
+                    kind: "preserved",
+                    behaviorIds: ["inclusive-clamp-range"],
+                    description: "Inputs above one hundred remain capped at one hundred."
+                },
+                {
+                    id: "interior",
+                    kind: "preserved",
+                    behaviorIds: ["inclusive-clamp-range"],
+                    description: "Every input inside the inclusive range remains unchanged, including fractions."
+                }
+            ];
+            const fixtureIds = ["historical-negative", "upper-boundary", "in-range-metamorphic"];
+            const scopeCoverage = behavioralScope.map((clause, index) => ({
+                scopeId: clause.id,
+                outcome: "covered",
+                fixtureIds: [fixtureIds[index]],
+                detail: "The associated fixture asserts the required behavior."
+            }));
+            const calls = [];
+            const stages = [];
+            const witnessV2 = scenario.startsWith("witness-v2-");
+            const witnessBudget = scenario.startsWith("witness-budget-");
+            const legacyWitnessBudget = scenario === "witness-budget-legacy-repair-false-rejection";
+            const exhaustedWitnessBudget = scenario === "witness-budget-exhausted-repair-false-rejection";
+            const revisedWitness = [
+                'import assert from "node:assert/strict";',
+                'import test from "node:test";',
+                'import { clamp } from "./index.js";',
+                'test("exact fractional preservation", () => { for (const value of [0.25, 25.5, 99.75]) assert.equal(clamp(value), value); });'
+            ].join("\n");
+            const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+                complete: (input) => {
+                    calls.push(input);
+                    const role = input.foundryRole;
+                    const packet = JSON.parse(input.input);
+                    if (role === "oracle-critic") {
+                        const beforeFreeze = input.operationId.includes(":before-freeze:");
+                        const revision = Number(input.operationId.split(":").at(-1));
+                        const revise = witnessBudget
+                            ? true
+                            : scenario.includes("witness-v2-late")
+                                ? beforeFreeze && revision === 0
+                                : scenario === "exhausted" ||
+                                    (scenario === "early-repair" && revision === 0) ||
+                                    (scenario.startsWith("witness") && !beforeFreeze) ||
+                                    ((scenario === "freeze-regression" || scenario === "freeze-repair") &&
+                                        beforeFreeze &&
+                                        revision === 0);
+                        const overlays = packet.fixtureSuite.overlays;
+                        if (beforeFreeze && revision === 0) {
+                            assert.match(overlays.find((entry) => entry.fixtureIds[0] === "in-range-metamorphic").content, /25\.5/u);
+                        }
+                        return Effect.succeed(JSON.stringify({
+                            verdict: revise ? "revise" : "approve",
+                            detail: revise
+                                ? "Integer examples do not isolate fractional value preservation."
+                                : "Current assertions cover the reviewed input partitions.",
+                            scopeCoverage: behavioralScope.map((clause, index) => {
+                                const gap = revise && clause.id === "interior";
+                                const overlay = overlays.find((entry) => entry.fixtureIds.includes(fixtureIds[index]));
+                                return {
+                                    scopeId: clause.id,
+                                    outcome: gap ? "gap" : "covered",
+                                    detail: gap
+                                        ? "A rounding implementation can preserve all integer examples."
+                                        : "The supplied assertion exercises this scope clause.",
+                                    counterexample: gap
+                                        ? "Use an otherwise-correct implementation that rounds in-range fractions; exercise a fractional input and assert exact preservation."
+                                        : "",
+                                    assertionEvidence: gap
+                                        ? []
+                                        : [
+                                            {
+                                                fixtureId: fixtureIds[index],
+                                                excerpt: overlay.content.split("\n").filter(Boolean).at(-1)
+                                            }
+                                        ]
+                                };
+                            })
+                        }));
+                    }
+                    if (scenario === "early-repair" && role.startsWith("valid-solution-generator-")) {
+                        return Effect.fail(new EvalProjectAuthoringError({
+                            operation: "authoring-evaluations",
+                            detail: "coverage repair completed before valid-control generation"
+                        }));
+                    }
+                    const output = modelOutput(input);
+                    if (role === "repository-analyst") {
+                        const evidence = packet
+                            .privateReferenceEvidence.sources.filter((source) => source.path === "src/clamp.js")
+                            .map((source) => ({ sourceId: source.sourceId, startLine: 1, endLine: 1 }));
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            referenceScope: {
+                                clauses: behavioralScope.map((clause) => ({ ...clause, evidence })),
+                                unresolvedQuestions: []
+                            }
+                        }));
+                    }
+                    if (role === "specification-critic-b") {
+                        const after = packet.privateReferenceEvidence.sources.find((source) => source.phase === "after" && source.path === "src/clamp.js");
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            referenceCompatibility: {
+                                outcome: "compatible",
+                                detail: "The pinned reference supports the complete visible contract.",
+                                scopeCoverage: behavioralScope.map((clause) => ({
+                                    scopeId: clause.id,
+                                    outcome: "supported",
+                                    detail: "The reference implements this clause.",
+                                    evidence: [{ sourceId: after.sourceId, startLine: 1, endLine: 1 }]
+                                }))
+                            }
+                        }));
+                    }
+                    if (role === "oracle-designer") {
+                        if (input.schemaName === "routekit_repository_oracle_coverage_witnesses_v1") {
+                            return Effect.succeed(JSON.stringify({
+                                witnesses: [
+                                    {
+                                        scopeId: "interior",
+                                        explanation: "An isolated rounding edit corrupts in-range fractional values.",
+                                        fileOverrides: [
+                                            {
+                                                path: "src/clamp.js",
+                                                edits: [
+                                                    {
+                                                        search: "Math.min(100, value)",
+                                                        replace: witnessBudget && input.operationId.includes(":before-freeze:")
+                                                            ? "Math.min(100, value === 99.75 ? Math.round(value) : value)"
+                                                            : "Math.min(100, Math.round(value))"
+                                                    }
+                                                ]
+                                            }
+                                        ],
+                                        testPath: "src/clamp.test.js",
+                                        testSource: [
+                                            'import assert from "node:assert/strict";',
+                                            'import test from "node:test";',
+                                            'import { clamp } from "./index.js";',
+                                            witnessBudget
+                                                ? input.operationId.includes(":initial:author:1")
+                                                    ? 'test("exact fractional preservation", () => { const = ; });'
+                                                    : input.operationId.includes(":before-freeze:")
+                                                        ? 'test("exact upper-adjacent fractional preservation", () => assert.equal(clamp(99.75), 99.75));'
+                                                        : 'test("exact fractional preservation", () => assert.equal(clamp(25.5), 25.5));'
+                                                : witnessV2
+                                                    ? 'test("exact fractional preservation", () => { assert.equal(clamp(25.5), 25.5); assert.match(clamp.toString(), /Math\\.min/); });'
+                                                    : 'test("exact fractional preservation", () => assert.equal(clamp(25.5), 25.5));'
+                                        ].join("\n"),
+                                        expectedBehavior: "An in-range fraction remains exactly unchanged.",
+                                        expectationMode: "preserved"
+                                    }
+                                ]
+                            }));
+                        }
+                        const repair = input.operationId.includes(":oracle-coverage-repair:");
+                        const repairedOverlays = isolatedClampOverlays(scenario === "freeze-regression" ? "initial" : "repaired").map((overlay) => scenario === "freeze-repair" && overlay.fixtureIds.includes("in-range-metamorphic")
+                            ? {
+                                ...overlay,
+                                content: `${overlay.content}\ntest("preserves upper-adjacent fractions", () => assert.equal(clamp(99.5), 99.5));`
+                            }
+                            : overlay);
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            ...(repair
+                                ? {
+                                    overlays: repairedOverlays
+                                }
+                                : {}),
+                            scopeCoverage
+                        }));
+                    }
+                    if (role === "hill-climb-planner") {
+                        if (witnessV2) {
+                            const revision = Number(input.operationId.split(":").at(-1));
+                            if (scenario.includes("witness-v2-late") && revision === 1) {
+                                return Effect.succeed(JSON.stringify({
+                                    ...output,
+                                    fixtureProposal: { ...output.fixtureProposal, scopeCoverage }
+                                }));
+                            }
+                            const request = JSON.parse(input.input);
+                            const retained = request.currentFixtureProposal.fixtures.find((fixture) => fixture.id ===
+                                (scenario.includes("witness-v2-late")
+                                    ? "coverage-before-freeze-1"
+                                    : "coverage-initial-1"));
+                            const incumbent = request.currentFixtureProposal.overlays.find((overlay) => overlay.fixtureIds[0] === retained.id);
+                            assert.match(incumbent.content, /clamp\.toString/u);
+                            assert.match(input.instructions, /Transport chunks are not logical event boundaries/u);
+                            const base = output.fixtureProposal;
+                            const loseDefect = scenario.includes("rejected-then") && revision === 1;
+                            const nonmonotonic = scenario.includes("nonmonotonic") && revision === 1;
+                            if (revision > 1 && !scenario.includes("witness-v2-late")) {
+                                assert.equal(request.priorRejectedAttempts.length, 1);
+                                assert.equal(request.priorRejectedAttempts[0].coverageWitnessRevalidation?.status, scenario.includes("rejected-then") ? "rejected" : "passed");
+                            }
+                            return Effect.succeed(JSON.stringify({
+                                ...output,
+                                fixtureProposal: {
+                                    ...base,
+                                    fixtures: [...base.fixtures, retained],
+                                    overlays: [
+                                        ...(nonmonotonic
+                                            ? isolatedClampOverlays("implementation-specific")
+                                            : base.overlays),
+                                        {
+                                            path: "src/clamp.test.js",
+                                            fixtureIds: [retained.id],
+                                            content: loseDefect
+                                                ? revisedWitness.replace("[0.25, 25.5, 99.75]", "[1, 25, 99]")
+                                                : revisedWitness
+                                        }
+                                    ],
+                                    scopeCoverage
+                                }
+                            }));
+                        }
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            fixtureProposal: { ...output.fixtureProposal, scopeCoverage }
+                        }));
+                    }
+                    if (packet.implementationComparison !== undefined) {
+                        return Effect.succeed(JSON.stringify({
+                            ...output,
+                            implementationIndependence: {
+                                outcome: "independent",
+                                detail: "Numeric min/max composition and early-return guards use different mechanisms.",
+                                implementations: packet.implementationComparison.solutionIds.map((solutionId) => ({
+                                    solutionId,
+                                    mechanism: solutionId.includes("composed")
+                                        ? "Min/max composition"
+                                        : "Ordered early returns",
+                                    sourcePaths: ["src/clamp.js"]
+                                })),
+                                correlatedFeatures: []
+                            }
+                        }));
+                    }
+                    return Effect.succeed(JSON.stringify(output));
+                }
+            }));
+            const execution = Effect.runPromise(generateHistoricalRepositoryCaseV1({
+                repositoryRoot: repository.root,
+                operationId: `oracle-coverage-${scenario}`,
+                caseId: `case-oracle-coverage-${scenario}`,
+                map,
+                seed: seed({ ...repository, episodeId: episode.id }),
+                validControlReviewVersion: 1,
+                maximumSpecificationRevisions: 2,
+                maximumOracleCoverageRevisions: 2,
+                ...(scenario.startsWith("witness")
+                    ? {
+                        oracleCoverageWitnessVersion: witnessV2 || witnessBudget ? 2 : 1,
+                        maximumFixtureRepairAttempts: witnessBudget ? (exhaustedWitnessBudget ? 0 : 1) : 2,
+                        ...(witnessBudget && !legacyWitnessBudget
+                            ? { oracleCoverageWitnessRepairVersion: 1 }
+                            : {})
+                    }
+                    : {}),
+                modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                    primaryModel: "openai/gpt-6-astra",
+                    oracleCriticModel: "openai/gpt-6-astra"
+                })
+            }).pipe(Effect.provide(Layer.merge(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive((event) => Effect.sync(() => {
+                stages.push(event.stage);
+            }))))));
+            if (legacyWitnessBudget || exhaustedWitnessBudget) {
+                await assert.rejects(execution, legacyWitnessBudget
+                    ? /oracle-coverage-repair-exhausted/u
+                    : /oracle-coverage-witness-exhausted/u);
+                const authorCalls = calls.filter((call) => call.schemaName === "routekit_repository_oracle_coverage_witnesses_v1");
+                assert.equal(authorCalls.length, legacyWitnessBudget ? 2 : 1);
+                assert.equal(calls.some((call) => call.foundryRole === "held-out-adversary"), false);
+                assert.equal(calls.some((call) => call.operationId.includes(":oracle-critic:before-freeze:2")), legacyWitnessBudget);
+                if (exhaustedWitnessBudget) {
+                    assert.equal(calls.some((call) => call.foundryRole?.startsWith("valid-solution-generator-")), false);
+                }
+                return;
+            }
+            if (scenario === "freeze-review" ||
+                scenario === "freeze-repair" ||
+                scenario.startsWith("witness")) {
+                const result = await execution;
+                assert.equal(result.benchmarkCase.status, "valid-library");
+                assert.equal(result.hillClimbAttempts.length, scenario === "witness"
+                    ? 0
+                    : scenario.includes("rejected-then") ||
+                        scenario.includes("nonmonotonic") ||
+                        scenario.includes("witness-v2-late")
+                        ? 2
+                        : 1);
+                assert.deepEqual(result.oracleCoverageReviews?.map((entry) => entry.phase), scenario === "witness"
+                    ? ["initial"]
+                    : scenario.includes("witness-v2-late")
+                        ? ["initial", "before-freeze", "before-freeze"]
+                        : scenario === "freeze-review" ||
+                            scenario === "witness-repair-false-rejection" ||
+                            witnessV2 ||
+                            witnessBudget
+                            ? ["initial", "before-freeze"]
+                            : ["initial", "before-freeze", "before-freeze"]);
+                if (scenario !== "witness")
+                    assert.match(result.fixtureProposal.overlays[2].content, /25\.5/u);
+                if (scenario.startsWith("witness")) {
+                    const assessment = result.oracleCoverageReviews.find((entry) => entry.executionAssessment !== undefined);
+                    assert.equal(assessment.review.verdict, "revise");
+                    assert.equal(assessment.executionAssessment?.kind, "resolved-by-execution");
+                    assert.equal(assessment.executionAssessment?.witnesses[0].outcome, scenario === "witness" ? "confirmed-escape" : "already-detected");
+                    assert.equal(result.fixtureProposal.fixtures.length, witnessBudget ? 5 : 4);
+                    const witness = assessment.executionAssessment.witnesses[0];
+                    const finalWitness = result.fixtureProposal.overlays.find((overlay) => overlay.fixtureIds[0] === witness.fixture.id);
+                    if (witnessV2) {
+                        assert.equal(finalWitness.content, revisedWitness);
+                        assert.ok(result.fixtureProposal.scopeCoverage
+                            ?.find((scope) => scope.scopeId === "interior")
+                            ?.fixtureIds.includes(witness.fixture.id));
+                        assert.match(witness.overlay.content, /clamp\.toString/u);
+                        assert.equal(result.oracleCoverageWitnessRevisions?.length, result.hillClimbAttempts.length);
+                        for (const attempt of result.oracleCoverageWitnessRevisions) {
+                            for (const revision of attempt.revisions)
+                                assert.deepEqual(revision.beforeOverlay, witness.overlay);
+                        }
+                        assert.equal(result.oracleCoverageWitnessRevisions.at(-1).decision, "accepted");
+                        if (result.hillClimbAttempts.length > 1 && !scenario.includes("witness-v2-late")) {
+                            assert.equal(result.oracleCoverageWitnessRevisions[0].decision, "rejected");
+                            assert.equal(result.hillClimbAttempts[0].candidateAdequacy === undefined, scenario.includes("rejected-then"));
+                        }
+                    }
+                    else
+                        assert.deepEqual(finalWitness, witness.overlay);
+                    const quality = calls.find((call) => call.foundryRole === "quality-reviewer");
+                    assert.match(quality.input, /resolved-by-execution/u);
+                    assert.match(quality.input, /oracleCoverageReviews/u);
+                    assert.equal(result.heldOutAdequacy.admitted, true);
+                    if (witnessBudget) {
+                        const witnessCalls = calls.filter((call) => call.schemaName === "routekit_repository_oracle_coverage_witnesses_v1");
+                        assert.equal(witnessCalls.length, 3);
+                        assert.equal(calls.some((call) => call.operationId.includes(":oracle-critic:before-freeze:1")), true);
+                        assert.equal(result.oracleCoverageReviews.length, 2);
+                        assert.equal(result.oracleCoverageReviews[1].executionAssessment.witnesses[0].outcome, "confirmed-escape");
+                        const repairedInput = JSON.parse(witnessCalls[1].input);
+                        assert.match(JSON.stringify(repairedInput.previousDiagnostics), /unknown/u);
+                        assert.equal(result.benchmarkCase.adequacy.falseAcceptedSolutionIds.length, 0);
+                        assert.equal(result.benchmarkCase.adequacy.falseRejectedSolutionIds.length, 0);
+                    }
+                }
+                if (scenario === "freeze-repair") {
+                    assert.match(result.fixtureProposal.overlays[2].content, /99\.5/u);
+                    assert.deepEqual(result.benchmarkCase.adequacy.falseAcceptedSolutionIds, []);
+                    assert.deepEqual(result.benchmarkCase.adequacy.falseRejectedSolutionIds, []);
+                }
+            }
+            else {
+                await assert.rejects(execution, scenario === "early-repair"
+                    ? /coverage repair completed before valid-control generation/u
+                    : scenario === "exhausted"
+                        ? /oracle-coverage-repair-exhausted/u
+                        : /oracle coverage repair failed development revalidation before freeze/u);
+                assert.equal(calls.some((call) => call.foundryRole === "held-out-adversary"), false);
+                if (scenario !== "freeze-regression")
+                    assert.equal(stages.includes("tournament"), false);
+            }
+            const reviews = calls.filter((call) => call.foundryRole === "oracle-critic");
+            const repairs = calls.filter((call) => call.operationId.includes(":oracle-coverage-repair:"));
+            assert.equal(reviews.length, scenario === "witness"
+                ? 1
+                : scenario.includes("witness-v2-late")
+                    ? 3
+                    : witnessV2 ||
+                        witnessBudget ||
+                        ["early-repair", "freeze-review", "witness-repair-false-rejection"].includes(scenario)
+                        ? 2
+                        : 3);
+            assert.equal(repairs.length, scenario === "exhausted"
+                ? 2
+                : scenario === "freeze-review" || scenario.startsWith("witness")
+                    ? 0
+                    : 1);
+            for (const call of reviews) {
+                assert.match(call.instructions, /otherwise correct implementation could violate only that clause/u);
+                for (const unavailable of [
+                    "independent-composed-bounds",
+                    "independent-guard-bounds",
+                    "rounding-near-miss",
+                    "falseAcceptedWrongSolutions",
+                    "heldOutAdversaries",
+                    "candidateAdequacy"
+                ]) {
+                    assert.equal(call.input.includes(unavailable), false, `coverage critic received ${unavailable}`);
+                }
+            }
+            for (const call of repairs) {
+                const packet = JSON.parse(call.input);
+                assert.ok(packet.independentCoverageReview);
+                assert.ok(packet.currentFixtureProposal);
+                assert.equal("allValidSolutions" in packet, false);
+                assert.equal("heldOutAdversaries" in packet, false);
+            }
+        }
+        finally {
+            await rm(repository.root, { recursive: true, force: true });
+        }
+    });
+}
+test("independent valid-solution criticism triggers an isolated bounded repair and fresh reviews", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const calls = [];
+        const artifacts = [];
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                calls.push(input);
+                const output = modelOutput(input);
+                if (input.foundryRole === "valid-solution-generator-a" &&
+                    !input.operationId.includes(":repair-")) {
+                    return Effect.succeed(JSON.stringify({
+                        solutions: [
+                            {
+                                id: "independent-composed-bounds",
+                                family: "composed-min-max",
+                                kind: "independent-valid",
+                                fileOverrides: [
+                                    {
+                                        path: "src/clamp.js",
+                                        content: "export const clamp = (value) => Math.min(100, value);\n"
+                                    },
+                                    {
+                                        path: "src/index.js",
+                                        content: 'export { clamp } from "./clamp.js";\n'
+                                    }
+                                ]
+                            }
+                        ]
+                    }));
+                }
+                if (input.foundryRole === "solution-critic-b" &&
+                    !input.operationId.includes(":repair-")) {
+                    const review = output;
+                    return Effect.succeed(JSON.stringify({
+                        reviews: review.reviews.map((entry) => entry.solutionId === "independent-composed-bounds"
+                            ? {
+                                ...entry,
+                                classification: "wrong",
+                                detail: "The implementation leaves negative inputs unchanged. Copy peer independent-guard-bounds using PRIVATE_PEER_CODE_CANARY.",
+                                violatedBehaviorIds: ["inclusive-clamp-range", "PRIVATE_PEER_ID_CANARY"]
+                            }
+                            : entry)
+                    }));
+                }
+                return Effect.succeed(JSON.stringify(output));
+            }
+        }));
+        const result = await Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "repair-invalid-independent-solution",
+            caseId: "case-clamp-valid-solution-repair",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                primaryModel: "openai/gpt-5.6-sol",
+                criticAModel: "openai/gpt-5.6-luna",
+                criticBModel: "openai/gpt-5.6-terra",
+                reviewerModel: "openai/gpt-5.6-terra"
+            })
+        }).pipe(Effect.provide(Layer.mergeAll(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport)), RepositoryFoundryProgressLive(undefined, (artifact) => Effect.sync(() => {
+            artifacts.push(artifact);
+        }))))));
+        assert.equal(result.benchmarkCase.status, "valid-library");
+        const solverACalls = calls.filter((call) => call.foundryRole === "valid-solution-generator-a");
+        const solverBCalls = calls.filter((call) => call.foundryRole === "valid-solution-generator-b");
+        const solutionCriticCalls = calls.filter((call) => call.foundryRole === "solution-critic-a" || call.foundryRole === "solution-critic-b");
+        assert.equal(solverACalls.length, 2);
+        assert.equal(solverBCalls.length, 1);
+        assert.equal(solutionCriticCalls.length, 4);
+        const repairCall = solverACalls.find((call) => call.operationId.endsWith(":valid-solution-generator-a:repair-1"));
+        assert.ok(repairCall);
+        const repairInput = JSON.parse(repairCall.input);
+        assert.deepEqual(repairInput.priorOwnProposal.solutions.map((solution) => solution.id), ["independent-composed-bounds"]);
+        assert.deepEqual(repairInput.priorCriticFindings, [
+            {
+                reviewer: "solution critic B",
+                solutionId: "independent-composed-bounds",
+                classification: "wrong",
+                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: ["inclusive-clamp-range"]
+            }
+        ]);
+        assert.equal(repairCall.input.includes("independent-guard-bounds"), false, "a solver repair must not see the other solver's proposal");
+        assert.equal(repairCall.input.includes("PRIVATE_PEER_CODE_CANARY"), false);
+        assert.equal(repairCall.input.includes("PRIVATE_PEER_ID_CANARY"), false);
+        const initialCritic = artifacts.find((artifact) => artifact.operationId.endsWith(":solution-critic-b") && artifact.validation === "validated");
+        assert.ok(initialCritic);
+        assert.match(JSON.stringify(initialCritic.value), /PRIVATE_PEER_CODE_CANARY/u);
+        assert.match(JSON.stringify(initialCritic.value), /PRIVATE_PEER_ID_CANARY/u);
+        assert.match(result.validSolutionProposal.solutions[0]?.fileOverrides[0]?.content ?? "", /Math\.max\(0, value\)/u);
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});
+test("independent solution critics reject a behaviorally valid adversary label before oracle hill climbing", async () => {
+    const repository = await createRepository();
+    try {
+        const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({
+            repositoryRoot: repository.root,
+            requestedRef: repository.referenceCommit,
+            maximumHistoryEpisodes: 10
+        }));
+        const episode = map.historyEpisodes.find((candidate) => candidate.commit === repository.referenceCommit);
+        assert.ok(episode);
+        const transport = Layer.succeed(EvalAuthoringTransport, EvalAuthoringTransport.of({
+            complete: (input) => {
+                const output = modelOutput(input);
+                if (input.foundryRole !== "solution-critic-b") {
+                    return Effect.succeed(JSON.stringify(output));
+                }
+                const review = output;
+                return Effect.succeed(JSON.stringify({
+                    reviews: review.reviews.map((entry) => entry.solutionId === "public-integration-omission"
+                        ? {
+                            ...entry,
+                            classification: "valid",
+                            detail: "The proposed implementation is behaviorally valid in the supplied repository context.",
+                            violatedBehaviorIds: []
+                        }
+                        : entry)
+                }));
+            }
+        }));
+        await assert.rejects(Effect.runPromise(generateHistoricalRepositoryCaseV1({
+            repositoryRoot: repository.root,
+            operationId: "reject-mislabeled-adversary",
+            caseId: "case-clamp-adversary-review",
+            map,
+            seed: seed({
+                initialCommit: repository.initialCommit,
+                referenceCommit: repository.referenceCommit,
+                episodeId: episode.id
+            }),
+            modelPlan: gpt56RepositoryFoundryModelPlanV1({
+                primaryModel: "openai/gpt-5.6-sol",
+                criticAModel: "openai/gpt-5.6-luna",
+                criticBModel: "openai/gpt-5.6-terra",
+                reviewerModel: "openai/gpt-5.6-terra"
+            })
+        }).pipe(Effect.provide(RepositoryFoundryLanguageModelLive.pipe(Layer.provide(transport))))), /solution critic B rejected generated solution labels.*public-integration-omission=valid/u);
+    }
+    finally {
+        await rm(repository.root, { recursive: true, force: true });
+    }
+});