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

package/dist/services/oracle-coverage-witness/service.js

@@ -0,0 +1,538 @@
+import { Effect, Schema } from "effect";
+import { repositoryCommandTestEvidenceV1 } from "../../adapters/repository-command-evidence.js";
+import { makeRepositoryPreparationCacheV1, replayRepositoryCommandsV1 } from "../../adapters/repository-command-runner.js";
+import { loadPinnedSolutionEditSourcesV1, materializeSolutionFileOverridesV1 } from "../../adapters/repository-solution-edits.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { REPOSITORY_FIXTURE_EVIDENCE_INSTRUCTIONS, repositoryFixtureAuthoringInstructionsV1 } from "../../repository-fixture-instructions.js";
+import { assertRepositoryHiddenFixtureSuiteV1 } from "../../repository-fixture-protocol.js";
+import { repositoryFoundryRoleOutputCeilingV1 } from "../../repository-foundry-plan-protocol.js";
+import { assertRepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { reportFoundryAuthoringArtifactV1, reportFoundryHeartbeatV1 } from "../foundry-progress/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+const WitnessProposal = Schema.Struct({
+    witnesses: Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        explanation: Schema.String,
+        fileOverrides: Schema.Array(Schema.Struct({
+            path: Schema.String,
+            edits: Schema.Array(Schema.Struct({ search: Schema.String, replace: Schema.String }))
+        })),
+        testPath: Schema.String,
+        testSource: Schema.String,
+        expectedBehavior: Schema.String,
+        expectationMode: Schema.Literals(["changes", "preserved"])
+    }))
+});
+const INSTRUCTIONS = `Turn each supplied coverage hypothesis into one isolated executable counterexample.
+Use the pinned reference as the correct implementation. Make the smallest implementation change that
+violates ONLY the named visible contract clause for the supplied scenario. Preserve all other behavior.
+Return one witness for every requested scopeId, with:
+- exactly one implementation fileOverride with exactly one exact edit against the REFERENCE source;
+- one small complete test file at an allowed testPath, containing exactly ONE named test;
+- a concrete observable assertion that passes the reference and fails this mutant.
+The test must call repository behavior. It must not inspect source text, patch identity, filenames,
+implementation style, or another test's results. Do not use a compound mutant whose unrelated defect
+could cause the assertion failure. Do not rewrite the visible contract or propose extra scope.
+Avoid fixed timing assumptions: use explicit state or a bounded deterministic scheduling observation.
+Use the repository's test framework and APIs shown in the pinned sources. Keep the witness focused;
+do not reproduce the original test suite or invent a general replacement implementation.
+Return {path, edits: [{search, replace}]}; search must occur exactly once in the supplied reference.
+Keep search below 8000 characters and replace below 12000 characters. Do not bundle separate defects.
+You do not receive the current generated fixtures. The host will independently check whether they
+already reject your mutant. If a previous witness was invalid, repair only the listed pending scopeIds
+using the actual execution diagnostics. Return only the structured proposal.
+
+${REPOSITORY_FIXTURE_EVIDENCE_INSTRUCTIONS}`;
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "compile-reviewed-case",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const canonicalPath = (path) => path.length > 0 &&
+    path.length <= 1_024 &&
+    !path.includes("\\") &&
+    !path.includes("\0") &&
+    !path.split("/").some((part) => part === "" || part === "." || part === "..");
+// The evidence adapter has already validated reporter identity, complete execution,
+// and assertion attribution. Requiring one executed test makes the witness isolated.
+const oneTest = (evidence, outcome) => evidence.outcome === outcome && /^executed=1(?:;|$)/u.test(evidence.detail);
+const executedPassingProbe = (evidence) => evidence.outcome === "pass" && /^executed=[1-9]\d*; failed=0; reporter=/u.test(evidence.detail);
+const executedSingleAssertionFailure = (evidence) => evidence.outcome === "fail" &&
+    /^executed=[1-9]\d*; assertionFailures=1; reporter=/u.test(evidence.detail);
+const executedTestCount = (evidence) => {
+    const matched = /^executed=([1-9]\d*)(?:;|$)/u.exec(evidence.detail);
+    return matched === null ? undefined : Number(matched[1]);
+};
+const diagnostic = (results) => results.map((result) => ({
+    recipeId: result.recipeId,
+    stage: result.stage,
+    exitCode: result.exitCode,
+    gradeExecuted: result.gradeExecuted,
+    timedOut: result.timedOut,
+    outputTruncated: result.outputTruncated,
+    stdout: result.stdout.slice(-6_000),
+    stderr: result.stderr.slice(-6_000)
+}));
+const replayWitness = Effect.fn("OracleCoverageWitness.replay")(function* (input) {
+    const { operationId, overlay, fileOverrides, preparationCache } = input;
+    const referenceCommit = input.seed.referenceCommit;
+    const overlays = [
+        ...input.seed.environment.protectedControlPaths.map((path) => ({
+            path,
+            sourceCommit: referenceCommit
+        })),
+        ...input.seed.capabilityEvidence
+            .filter((entry) => entry.kind === "test" && entry.path !== undefined)
+            .map((entry) => ({ path: entry.path, sourceCommit: referenceCommit }))
+    ];
+    const recipe = [...input.seed.environment.gradeRecipes]
+        .filter((entry) => entry.cwd === "." || overlay.path.startsWith(`${entry.cwd}/`))
+        .sort((left, right) => right.cwd.length - left.cwd.length)[0];
+    if (recipe === undefined)
+        return yield* failure("coverage witness has no reviewed test recipe");
+    const replayInput = {
+        repositoryRoot: input.repositoryRoot,
+        commit: input.seed.referenceCommit,
+        recipes: [recipe],
+        repetitions: 2,
+        trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+        candidateValidationRecipes: input.seed.environment.candidateValidationRecipes,
+        overlays,
+        contentOverlays: [{ path: overlay.path, content: overlay.content }],
+        fileOverrides
+    };
+    const replay = yield* replayRepositoryCommandsV1({
+        ...replayInput,
+        preparationCache
+    }).pipe(Effect.match({
+        onFailure: (error) => ({ results: [], error }),
+        onSuccess: (results) => ({ results, error: undefined })
+    }));
+    const { results } = replay;
+    const observations = results
+        .filter((result) => result.recipeId === recipe.id)
+        .map((result) => repositoryCommandTestEvidenceV1(result, recipe.id));
+    const evidence = observations.length === 2 &&
+        observations.every((entry) => entry.outcome === observations[0].outcome && entry.detail === observations[0].detail)
+        ? observations[0]
+        : { outcome: "unknown", detail: "coverage probe did not produce two agreeing repetitions" };
+    yield* reportFoundryAuthoringArtifactV1({
+        version: 1,
+        operationId,
+        role: "coverage-witness-executor",
+        model: "local-replay",
+        reasoningEffort: "none",
+        schemaName: "routekit_repository_coverage_witness_replay_v1",
+        validation: "validated",
+        request: {
+            instructions: "Replay one coverage probe in isolation; no benchmark admission authority.",
+            input: { replayInput },
+            jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+            maximumOutputTokens: 0
+        },
+        response: { text: JSON.stringify({ evidence, ...replay }) },
+        value: { diagnosticOnly: true, admissionEvidence: false, evidence, ...replay }
+    });
+    if (replay.error !== undefined ||
+        results.some((result) => result.stage === "trusted-preparation" || result.timedOut || result.outputTruncated)) {
+        return yield* failure("coverage witness stopped on infrastructure or incomplete execution", {
+            operationId,
+            evidence,
+            diagnostics: diagnostic(results)
+        });
+    }
+    return { results, evidence, operationId };
+});
+/**
+ * A witness preserves a demonstrated defect-detection obligation, not immutable
+ * test mechanics. This only validates a proposed revision; its caller owns
+ * adoption after the complete candidate tournament succeeds.
+ */
+export const validateRepositoryOracleCoverageWitnessRevisionsV1 = Effect.fn("OracleCoverageWitness.validateRevisions")(function* (input) {
+    return yield* Effect.scoped(Effect.gen(function* () {
+        const changes = yield* Effect.try({
+            try: () => {
+                assertRepositoryTaskSeedV1(input.seed);
+                assertRepositoryHiddenFixtureSuiteV1(input.suite);
+                if (input.seed.status !== "qualified" ||
+                    input.seed.referenceCommit === undefined ||
+                    input.operationId.trim().length === 0 ||
+                    new Set(input.retained.map((entry) => entry.witness.fixture.id)).size !==
+                        input.retained.length)
+                    throw new Error("revisions require a qualified reference and unique retained witnesses");
+                return input.retained.flatMap((entry) => {
+                    const { witness } = entry;
+                    const fixture = input.suite.fixtures.find((candidate) => candidate.id === witness.fixture.id);
+                    const overlay = input.suite.overlays.find((candidate) => candidate.fixtureIds[0] === witness.fixture.id);
+                    if (witness.referenceCommit !== input.seed.referenceCommit ||
+                        !executedPassingProbe(witness.referenceEvidence) ||
+                        !executedSingleAssertionFailure(witness.mutantEvidence) ||
+                        witness.fileOverrides.length !== 1 ||
+                        witness.fileOverrides.some((override) => !canonicalPath(override.path) ||
+                            input.seed.environment.protectedControlPaths.includes(override.path) ||
+                            input.seed.capabilityEvidence.some((evidence) => evidence.kind === "test" && evidence.path === override.path)) ||
+                        fixture === undefined ||
+                        Object.entries(witness.fixture).some(([key, value]) => fixture[key] !== value) ||
+                        overlay === undefined ||
+                        overlay.path !== witness.overlay.path ||
+                        entry.overlay.path !== witness.overlay.path ||
+                        entry.overlay.fixtureIds.length !== 1 ||
+                        entry.overlay.fixtureIds[0] !== witness.fixture.id ||
+                        !canonicalPath(overlay.path) ||
+                        input.seed.environment.protectedControlPaths.includes(overlay.path) ||
+                        !input.seed.capabilityEvidence.some((evidence) => evidence.kind === "test" && evidence.path === overlay.path) ||
+                        overlay.content.length > 32_000)
+                        throw new Error("witness revisions must preserve original reference, mutant, metadata and reviewed path");
+                    return overlay.content === entry.overlay.content ? [] : [{ ...entry, overlay }];
+                });
+            },
+            catch: (cause) => failure("coverage witness revision failed identity validation", cause)
+        });
+        if (changes.length === 0)
+            return [];
+        const preparationCache = yield* makeRepositoryPreparationCacheV1({
+            repositoryRoot: input.repositoryRoot,
+            commits: [input.seed.referenceCommit],
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes
+        });
+        return yield* Effect.forEach(changes, (entry) => Effect.gen(function* () {
+            const operationId = `${input.operationId}:${entry.witness.fixture.id}`;
+            const reference = yield* replayWitness({
+                repositoryRoot: input.repositoryRoot,
+                seed: input.seed,
+                preparationCache,
+                operationId: `${operationId}:reference`,
+                overlay: entry.overlay,
+                fileOverrides: []
+            });
+            const referenceCompatible = executedPassingProbe(reference.evidence) &&
+                executedTestCount(reference.evidence) ===
+                    executedTestCount(entry.witness.referenceEvidence);
+            const mutant = referenceCompatible
+                ? yield* replayWitness({
+                    repositoryRoot: input.repositoryRoot,
+                    seed: input.seed,
+                    preparationCache,
+                    operationId: `${operationId}:mutant`,
+                    overlay: entry.overlay,
+                    fileOverrides: entry.witness.fileOverrides
+                })
+                : undefined;
+            const validated = referenceCompatible &&
+                mutant !== undefined &&
+                executedSingleAssertionFailure(mutant.evidence) &&
+                executedTestCount(mutant.evidence) ===
+                    executedTestCount(entry.witness.mutantEvidence);
+            const revision = {
+                scopeId: entry.witness.scopeId,
+                fixtureId: entry.witness.fixture.id,
+                originalExecutionOperationId: entry.witness.executionOperationId,
+                executionOperationId: operationId,
+                referenceCommit: entry.witness.referenceCommit,
+                beforeOverlay: input.retained.find((retained) => retained.witness.fixture.id === entry.witness.fixture.id).overlay,
+                overlay: entry.overlay,
+                referenceEvidence: reference.evidence,
+                ...(mutant === undefined ? {} : { mutantEvidence: mutant.evidence }),
+                status: validated ? "validated" : "rejected",
+                detail: validated
+                    ? "Two reference passes and two isolated assertion failures preserve the original witnessed defect."
+                    : "The revised witness did not establish two reference passes and two isolated original-mutant assertion failures."
+            };
+            yield* reportFoundryAuthoringArtifactV1({
+                version: 1,
+                operationId,
+                role: "coverage-witness-executor",
+                model: "host",
+                reasoningEffort: "none",
+                schemaName: "routekit_repository_coverage_witness_revision_v1",
+                validation: "validated",
+                request: {
+                    instructions: "Validate revised witness mechanics against the original reference and mutant. This does not adopt a suite or admit a benchmark.",
+                    input: {
+                        witness: entry.witness,
+                        beforeOverlay: revision.beforeOverlay,
+                        overlay: entry.overlay
+                    },
+                    jsonSchema: { type: "object", properties: {}, additionalProperties: false },
+                    maximumOutputTokens: 0
+                },
+                response: { text: JSON.stringify(revision) },
+                value: { diagnosticOnly: true, admissionEvidence: false, ...revision }
+            });
+            yield* reportFoundryHeartbeatV1({
+                role: "coverage-witness-executor",
+                detail: `coverage witness revision; fixture=${revision.fixtureId}; status=${revision.status}; reference=${reference.evidence.outcome}; original mutant=${mutant?.evidence.outcome ?? "unmeasured"}`
+            });
+            return revision;
+        }), { concurrency: 2 });
+    }));
+});
+/** Resolve a fixed set of critic hypotheses through execution, without minting a model approval. */
+export const resolveRepositoryOracleCoverageWitnessesV1 = Effect.fn("OracleCoverageWitness.resolve")(function* (input) {
+    return yield* Effect.scoped(Effect.gen(function* () {
+        const referenceCommit = input.seed.referenceCommit;
+        const claims = input.review.scopeCoverage.filter((entry) => entry.outcome !== "covered");
+        if (input.seed.status !== "qualified" ||
+            referenceCommit === undefined ||
+            claims.length === 0 ||
+            claims.length > 16 ||
+            new Set(claims.map((entry) => entry.scopeId)).size !== claims.length ||
+            !Number.isSafeInteger(input.maximumAttempts) ||
+            input.maximumAttempts < 1 ||
+            input.maximumAttempts > 2 ||
+            !/^[a-z][a-z0-9-]{0,63}$/u.test(input.witnessPrefix)) {
+            return yield* failure("coverage witnesses require a qualified reference, fixed claims and a bounded allowance");
+        }
+        yield* Effect.try({
+            try: () => {
+                assertRepositoryTaskSeedV1(input.seed);
+                assertRepositoryHiddenFixtureSuiteV1(input.suite);
+                if (input.operationId.trim().length === 0 ||
+                    input.review.verdict !== "revise" ||
+                    input.allowedSolutionPaths.size === 0 ||
+                    [...input.allowedSolutionPaths].some((path) => !canonicalPath(path) ||
+                        input.allowedTestPaths.has(path) ||
+                        input.seed.environment.protectedControlPaths.includes(path) ||
+                        input.seed.capabilityEvidence.some((entry) => entry.kind === "test" && entry.path === path)) ||
+                    input.suite.overlays.some((overlay) => !canonicalPath(overlay.path) ||
+                        !input.allowedTestPaths.has(overlay.path) ||
+                        input.seed.environment.protectedControlPaths.includes(overlay.path))) {
+                    throw new Error("witness paths must preserve reviewed tests and protected controls");
+                }
+            },
+            catch: (cause) => failure("coverage witnesses require a valid incumbent fixture suite", cause)
+        });
+        const languageModel = yield* RepositoryFoundryLanguageModel;
+        const sources = yield* loadPinnedSolutionEditSourcesV1({
+            repositoryRoot: input.repositoryRoot,
+            initialCommit: referenceCommit,
+            visibleSources: input.referenceSources,
+            allowedPaths: input.allowedSolutionPaths
+        });
+        const preparationCache = yield* makeRepositoryPreparationCacheV1({
+            repositoryRoot: input.repositoryRoot,
+            commits: [referenceCommit],
+            trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes
+        });
+        const run = (operationId, overlay, fileOverrides) => replayWitness({
+            repositoryRoot: input.repositoryRoot,
+            seed: input.seed,
+            preparationCache,
+            operationId,
+            overlay,
+            fileOverrides
+        });
+        const resolved = [];
+        const modelCalls = [];
+        let pending = claims;
+        let previousDiagnostics = [];
+        for (let attempt = 0; attempt < input.maximumAttempts; attempt += 1) {
+            yield* input.onGenerationAttempt(attempt);
+            const generated = yield* languageModel.generateStructured({
+                plan: input.modelPlan,
+                role: "oracle-designer",
+                operationId: `${input.operationId}:author:${String(attempt + 1)}`,
+                instructions: repositoryFixtureAuthoringInstructionsV1(INSTRUCTIONS, input.oracleCoverageWitnessVersion, input.oracleRepairFeedbackVersion),
+                input: {
+                    ...input.context,
+                    referenceCommit,
+                    referenceSources: input.referenceSources,
+                    allowedSolutionPaths: [...input.allowedSolutionPaths],
+                    allowedTestPaths: [...input.allowedTestPaths],
+                    gradeRecipes: input.seed.environment.gradeRecipes,
+                    coverageHypotheses: pending,
+                    previousDiagnostics
+                },
+                schemaName: "routekit_repository_oracle_coverage_witnesses_v1",
+                outputSchema: WitnessProposal,
+                maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("oracle-designer")
+            });
+            modelCalls.push(generated.call);
+            const validation = yield* Effect.try({
+                try: () => {
+                    const expected = new Set(pending.map((entry) => entry.scopeId));
+                    const proposed = generated.value.witnesses;
+                    if (proposed.length !== expected.size ||
+                        new Set(proposed.map((entry) => entry.scopeId)).size !== expected.size ||
+                        proposed.some((entry) => !expected.has(entry.scopeId) ||
+                            !canonicalPath(entry.testPath) ||
+                            !input.allowedTestPaths.has(entry.testPath) ||
+                            input.seed.environment.protectedControlPaths.includes(entry.testPath) ||
+                            !input.seed.capabilityEvidence.some((evidence) => evidence.kind === "test" && evidence.path === entry.testPath) ||
+                            entry.testSource.trim().length === 0 ||
+                            entry.testSource.length > 32_000 ||
+                            entry.explanation.trim().length === 0 ||
+                            entry.expectedBehavior.trim().length === 0 ||
+                            entry.fileOverrides.length !== 1 ||
+                            entry.fileOverrides[0].edits.length !== 1 ||
+                            entry.fileOverrides[0].edits[0].search.length > 8_000 ||
+                            entry.fileOverrides[0].edits[0].replace.length > 12_000)) {
+                        throw new Error("witnesses must match every pending scope once and use reviewed paths");
+                    }
+                    return proposed.map((entry) => {
+                        const materialized = materializeSolutionFileOverridesV1({
+                            fileOverrides: entry.fileOverrides,
+                            sources,
+                            allowedPaths: input.allowedSolutionPaths
+                        });
+                        if (materialized.fileOverrides.every((override) => sources.find((source) => source.path === override.path)?.content ===
+                            override.content)) {
+                            throw new Error("a witness mutant must change the pinned reference implementation");
+                        }
+                        const id = `${input.witnessPrefix}-${String(claims.findIndex((claim) => claim.scopeId === entry.scopeId) + 1)}`;
+                        if (input.suite.fixtures.some((fixture) => fixture.id === id)) {
+                            throw new Error("coverage witness identity collides with an incumbent fixture");
+                        }
+                        return {
+                            ...entry,
+                            fileOverrides: materialized.fileOverrides,
+                            fixture: {
+                                id,
+                                kind: "boundary",
+                                source: "generated",
+                                description: `Executed counterexample for ${entry.scopeId}: ${entry.explanation}`,
+                                expectedBehavior: entry.expectedBehavior,
+                                testPath: entry.testPath,
+                                expectationMode: entry.expectationMode
+                            },
+                            overlay: { path: entry.testPath, content: entry.testSource, fixtureIds: [id] }
+                        };
+                    });
+                },
+                catch: (cause) => failure("coverage witness proposal failed validation", cause)
+            }).pipe(Effect.match({
+                onFailure: (error) => ({ ok: false, error }),
+                onSuccess: (proposals) => ({ ok: true, proposals })
+            }));
+            if (!validation.ok) {
+                previousDiagnostics = [
+                    {
+                        detail: validation.error.detail,
+                        cause: validation.error.cause instanceof Error
+                            ? validation.error.cause.message
+                            : String(validation.error.cause),
+                        priorProposal: generated.value
+                    }
+                ];
+                continue;
+            }
+            const reports = yield* Effect.forEach(validation.proposals, (proposal) => Effect.gen(function* () {
+                const operationId = `${input.operationId}:execution:${String(attempt + 1)}:${proposal.fixture.id}`;
+                const reference = yield* run(`${operationId}:reference`, proposal.overlay, []);
+                const mutant = oneTest(reference.evidence, "pass")
+                    ? yield* run(`${operationId}:mutant`, proposal.overlay, proposal.fileOverrides)
+                    : undefined;
+                const valid = oneTest(reference.evidence, "pass") &&
+                    mutant !== undefined &&
+                    oneTest(mutant.evidence, "fail");
+                const incumbentEvidence = [];
+                const incumbentReplays = [];
+                if (valid) {
+                    for (const [index, overlay] of input.suite.overlays.entries()) {
+                        const replay = yield* run(`${operationId}:incumbent:${String(index + 1)}`, overlay, proposal.fileOverrides);
+                        incumbentReplays.push(replay.operationId);
+                        incumbentEvidence.push({
+                            fixtureId: overlay.fixtureIds[0],
+                            evidence: replay.evidence
+                        });
+                        if (replay.evidence.outcome !== "pass")
+                            break;
+                    }
+                }
+                const known = valid &&
+                    incumbentEvidence.length > 0 &&
+                    incumbentEvidence.every((entry) => entry.evidence.outcome !== "unknown");
+                const report = {
+                    scopeId: proposal.scopeId,
+                    proposal,
+                    reference: { evidence: reference.evidence, results: reference.results },
+                    ...(mutant === undefined
+                        ? {}
+                        : { mutant: { evidence: mutant.evidence, results: mutant.results } }),
+                    incumbentEvidence,
+                    replayOperationIds: [
+                        reference.operationId,
+                        ...(mutant === undefined ? [] : [mutant.operationId]),
+                        ...incumbentReplays
+                    ],
+                    resolved: known
+                };
+                yield* reportFoundryAuthoringArtifactV1({
+                    version: 1,
+                    operationId,
+                    role: "coverage-witness-executor",
+                    model: "host",
+                    reasoningEffort: "none",
+                    schemaName: "routekit_repository_coverage_witness_execution_v1",
+                    validation: "validated",
+                    request: {
+                        instructions: "Host execution of one fixed coverage hypothesis; not a model approval or benchmark admission.",
+                        input: { referenceCommit, suite: input.suite, scopeId: proposal.scopeId },
+                        jsonSchema: { type: "object" },
+                        maximumOutputTokens: 0
+                    },
+                    response: { text: JSON.stringify(report) },
+                    value: { diagnosticOnly: true, admissionEvidence: false, ...report }
+                });
+                yield* reportFoundryHeartbeatV1({
+                    role: "coverage-witness-executor",
+                    detail: `coverage witness; reference=${reference.evidence.outcome}; mutant=${mutant?.evidence.outcome ?? "unmeasured"}; incumbent=${known ? (incumbentEvidence.some((entry) => entry.evidence.outcome === "fail") ? "detected" : "escaped") : "unresolved"}; resolved=${String(known)}`
+                });
+                if (!known) {
+                    return {
+                        scopeId: proposal.scopeId,
+                        diagnostics: {
+                            scopeId: proposal.scopeId,
+                            priorProposal: proposal,
+                            referenceEvidence: reference.evidence,
+                            referenceDiagnostics: diagnostic(reference.results),
+                            mutantEvidence: mutant?.evidence,
+                            mutantDiagnostics: mutant === undefined ? [] : diagnostic(mutant.results),
+                            incumbentEvidence
+                        }
+                    };
+                }
+                const witness = {
+                    scopeId: proposal.scopeId,
+                    hypothesis: claims.find((claim) => claim.scopeId === proposal.scopeId)
+                        .counterexample,
+                    outcome: incumbentEvidence.some((entry) => entry.evidence.outcome === "fail")
+                        ? "already-detected"
+                        : "confirmed-escape",
+                    explanation: proposal.explanation,
+                    referenceCommit,
+                    fileOverrides: proposal.fileOverrides,
+                    fixture: proposal.fixture,
+                    overlay: proposal.overlay,
+                    referenceEvidence: reference.evidence,
+                    mutantEvidence: mutant.evidence,
+                    incumbentEvidence,
+                    executionOperationId: operationId
+                };
+                resolved.push(witness);
+                return { scopeId: proposal.scopeId, diagnostics: undefined };
+            }), { concurrency: 2 });
+            pending = claims.filter((claim) => !resolved.some((entry) => entry.scopeId === claim.scopeId));
+            if (pending.length === 0) {
+                const ordered = claims.map((claim) => resolved.find((entry) => entry.scopeId === claim.scopeId));
+                // Retain the isolated test for every resolved hypothesis. Retaining a whole
+                // incumbent overlay instead could freeze unrelated overconstraints and
+                // prevent a later valid-solution repair. Already-detected claims remain
+                // separately labeled and never count as a newly detected escape.
+                const additions = ordered;
+                const suite = {
+                    ...input.suite,
+                    fixtures: [...input.suite.fixtures, ...additions.map((entry) => entry.fixture)],
+                    overlays: [...input.suite.overlays, ...additions.map((entry) => entry.overlay)]
+                };
+                yield* Effect.try({
+                    try: () => assertRepositoryHiddenFixtureSuiteV1(suite),
+                    catch: (cause) => failure("coverage witnesses could not be added to the incumbent", cause)
+                });
+                return { suite, witnesses: ordered, modelCalls };
+            }
+            previousDiagnostics = reports.flatMap((report) => report.diagnostics === undefined ? [] : [report.diagnostics]);
+        }
+        return yield* failure(`oracle-coverage-witness-exhausted: ${String(pending.length)} coverage hypotheses lack valid isolated execution evidence`, { pendingScopeIds: pending.map((entry) => entry.scopeId), previousDiagnostics });
+    }));
+});