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

package/dist/test/agentic-capabilities.test.js

@@ -0,0 +1,1461 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { promisify } from "node:util";
+import { Effect, Schema } from "effect";
+import { replayRepositoryCommandsV1, RepositoryCommandExecutionPort } from "../adapters/repository-command-runner.js";
+import { makeCaseCheckpointStoreV1 } from "../case-checkpoint-store.js";
+import { makePipelineCaseContextV1 } from "../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../errors.js";
+import { EVAL_CAPABILITY_DURABLE_FINALIZATION_RESERVE_MS_V1, evalCapabilityExecutionEnvelopeV1 } from "../eval-capability-execution-envelope.js";
+import { EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_MODEL_CALLS_V1, EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_WALL_TIME_MS_V1 } from "../eval-capability-policy.js";
+import { discoverEvalCandidatesV1 } from "../services/eval-candidate/service.js";
+import { acceptedScientificDigestV1, evalCandidateQualityScorecardV1, makeEvalCapabilitiesV1 } from "../services/eval-capabilities/service.js";
+import { RepositoryCommandObservability } from "../services/command-observability/service.js";
+import { RepositoryFoundryLanguageModel } from "../services/language-model/service.js";
+import { buildRepositoryBehaviorMapV1 } from "../services/repository-model/service.js";
+import { runPipelineOracleStageV1 } from "../services/pipeline-oracle/service.js";
+import { runPipelineControlsCapabilityV1 } from "../services/pipeline-controls/service.js";
+const exec = promisify(execFile);
+const runtime = {
+    name: "node",
+    version: process.versions.node,
+    platform: process.platform,
+    architecture: process.arch
+};
+const dimension = {
+    id: "clamp",
+    description: "Clamp lower bound without changing the upper bound.",
+    includes: ["behavioral regression"],
+    excludes: ["formatting"]
+};
+const sourcePath = "packages/main/src/index.js";
+async function fixture(t, maximumModelCalls = 30, regressionTestPath = "packages/main/src/index.test.js") {
+    const root = await mkdtemp(join(tmpdir(), "agentic-capabilities-"));
+    const stateRoot = await mkdtemp(join(tmpdir(), "agentic-capabilities-state-"));
+    t.after(async () => {
+        await rm(root, { recursive: true, force: true });
+        await rm(stateRoot, { recursive: true, force: true });
+    });
+    const git = async (...args) => (await exec("git", ["-C", root, ...args])).stdout.trim();
+    await git("init", "-q");
+    await git("config", "user.email", "eval@example.test");
+    await git("config", "user.name", "Eval Fixture");
+    await mkdir(join(root, "packages/main/src"), { recursive: true });
+    await writeFile(join(root, "package.json"), JSON.stringify({ name: "fixture", private: true, workspaces: ["packages/*"] }));
+    await writeFile(join(root, "packages/main/package.json"), JSON.stringify({
+        name: "fixture-main",
+        type: "module",
+        exports: "./src/index.js",
+        scripts: { test: "node --test" }
+    }));
+    await writeFile(join(root, sourcePath), "export const clamp = (value) => Math.min(100, value);\n");
+    await writeFile(join(root, "packages/main/src/index.test.js"), 'import assert from "node:assert/strict"; import test from "node:test"; import { clamp } from "./index.js"; test("upper", () => assert.equal(clamp(101), 100));\n');
+    await git("add", ".");
+    await git("commit", "-qm", "feat: add upper clamp");
+    await writeFile(join(root, sourcePath), "export const clamp = (value) => Math.max(0, Math.min(100, value));\n");
+    await writeFile(join(root, regressionTestPath), 'import assert from "node:assert/strict"; import test from "node:test"; import { clamp } from "./index.js"; test("upper", () => assert.equal(clamp(101), 100)); test("lower", () => assert.equal(clamp(-1), 0));\n');
+    await git("add", ".");
+    await git("commit", "-qm", "fix: clamp lower bound");
+    const map = await Effect.runPromise(buildRepositoryBehaviorMapV1({ repositoryRoot: root, requestedRef: "HEAD" }));
+    const proposals = await Effect.runPromise(discoverEvalCandidatesV1({ map, coverageCell: "clamp", query: "clamp" }));
+    assert.equal(proposals.candidates.length, 1);
+    const proposal = proposals.candidates[0];
+    const context = makePipelineCaseContextV1({
+        repositoryRoot: root,
+        caseDirectory: stateRoot,
+        caseId: "agentic-clamp",
+        dimension,
+        primaryModel: "openai/fixture",
+        budget: { maxModelCalls: maximumModelCalls, maxWallMs: 90 * 60_000 },
+        oracleRepetitions: 2,
+        oracleConcurrency: 1
+    });
+    return { root, stateRoot, map, proposal, context };
+}
+function fixtureSuite(testPath = "packages/main/src/index.test.js") {
+    const entries = [
+        {
+            id: "negative",
+            kind: "historical-regression",
+            expectationMode: "changes",
+            assertion: "assert.equal(clamp(-1), 0)"
+        },
+        {
+            id: "upper",
+            kind: "boundary",
+            expectationMode: "preserved",
+            assertion: "assert.equal(clamp(101), 100)"
+        },
+        {
+            id: "fraction",
+            kind: "metamorphic",
+            expectationMode: "preserved",
+            assertion: "assert.equal(clamp(25.5), 25.5)"
+        }
+    ];
+    return {
+        version: 1,
+        caseId: "agentic-clamp",
+        fixtures: entries.map(({ assertion: _assertion, ...entry }) => ({
+            ...entry,
+            description: entry.id,
+            expectedBehavior: entry.id,
+            source: "generated",
+            testPath
+        })),
+        overlays: entries.map((entry) => ({
+            path: testPath,
+            fixtureIds: [entry.id],
+            content: `import assert from "node:assert/strict"; import test from "node:test"; import { clamp } from "./index.js"; test("${entry.id}", () => { ${entry.assertion}; });`
+        }))
+    };
+}
+function model(heldOutEscapes = false, specificationAccepted = true, regressionTestPath = "packages/main/src/index.test.js") {
+    const calls = [];
+    const inner = {
+        generateAssignedStructured: (request) => Effect.gen(function* () {
+            calls.push(request.schemaName);
+            const input = request.input;
+            const task = input.task;
+            let value;
+            if (request.schemaName === "routekit_pipeline_spec_analysis_v1")
+                value = {
+                    action: "submit",
+                    result: {
+                        summary: "Clamp lower inputs at zero while preserving upper behavior.",
+                        userObservableBehaviors: ["negative returns zero", "upper returns 100"],
+                        constraints: ["preserve export"],
+                        risks: [],
+                        relevantPaths: [sourcePath],
+                        scope: ["changed", "preserved"].map((kind) => ({
+                            id: kind,
+                            kind,
+                            behaviorIds: [task.seed.targetBehavior[0].id],
+                            description: kind === "changed"
+                                ? "Negative inputs return zero."
+                                : "Upper cap and exact in-range values remain preserved.",
+                            evidence: ["initial", "reference"].map((commit) => ({
+                                commit,
+                                path: sourcePath,
+                                startLine: 1,
+                                endLine: 1
+                            }))
+                        }))
+                    }
+                };
+            else if (request.schemaName === "routekit_pipeline_visible_task_v1")
+                value = {
+                    requestText: "Clamp negative inputs to zero, preserve upper cap at one hundred and in-range values.",
+                    constraints: ["Preserve public export."]
+                };
+            else if (request.schemaName === "routekit_pipeline_specification_review_v1")
+                value = {
+                    action: "submit",
+                    result: {
+                        verdict: specificationAccepted ? "sufficient" : "insufficient",
+                        detail: specificationAccepted
+                            ? "All grounded behavior is specified."
+                            : "The visible task still needs a grounded revision.",
+                        findings: [],
+                        criticalBehaviorCoverage: task
+                            .targetBehavior.filter((behavior) => behavior.critical)
+                            .map((behavior) => ({
+                            behaviorId: behavior.id,
+                            outcome: "covered",
+                            detail: "Stated explicitly."
+                        })),
+                        dimensionFit: {
+                            requestedDimension: dimension.id,
+                            outcome: "fit",
+                            detail: "Behavior repair.",
+                            evidencePaths: [sourcePath]
+                        },
+                        referenceCompatibility: {
+                            outcome: "compatible",
+                            detail: "Reference satisfies scope.",
+                            scopeCoverage: task.scope.map((scope) => ({
+                                scopeId: scope.id,
+                                outcome: "supported",
+                                detail: "Pinned implementation supports it.",
+                                evidence: [
+                                    {
+                                        sourceId: task.sourceCatalog.find((source) => source.path === sourcePath && source.phase === "reference").sourceId,
+                                        startLine: 1,
+                                        endLine: 1
+                                    }
+                                ]
+                            }))
+                        }
+                    }
+                };
+            else if (request.schemaName === "routekit_pipeline_oracle_submission_v1")
+                value = {
+                    action: "submit",
+                    result: {
+                        suite: fixtureSuite(regressionTestPath),
+                        scopeCoverage: [
+                            {
+                                scopeId: "changed",
+                                outcome: "covered",
+                                fixtureIds: ["negative"],
+                                detail: "Lower clamp assertion."
+                            },
+                            {
+                                scopeId: "preserved",
+                                outcome: "covered",
+                                fixtureIds: ["upper", "fraction"],
+                                detail: "Upper cap and exact fractional values asserted."
+                            }
+                        ]
+                    }
+                };
+            else if (request.schemaName === "routekit_pipeline_valid_solution_generator_a_v1")
+                value = {
+                    id: "solver-a",
+                    family: "composition",
+                    kind: "independent-valid",
+                    fileOverrides: [
+                        {
+                            path: sourcePath,
+                            content: "export const clamp = (value) => Math.min(100, Math.max(0, value));\n"
+                        }
+                    ]
+                };
+            else if (request.schemaName === "routekit_pipeline_adversary_v1")
+                value = {
+                    id: "wrong-rounding",
+                    family: "rounding",
+                    kind: "mutation",
+                    fileOverrides: [
+                        {
+                            path: sourcePath,
+                            content: "export const clamp = (value) => Math.min(100, Math.max(0, Math.round(value)));\n"
+                        }
+                    ]
+                };
+            else if (request.schemaName === "routekit_pipeline_held_out_adversary_v1")
+                value = {
+                    solutions: [
+                        {
+                            id: "heldout-truncation",
+                            family: "truncation",
+                            kind: "model-near-miss",
+                            fileOverrides: [
+                                {
+                                    path: sourcePath,
+                                    content: heldOutEscapes
+                                        ? "export const clamp = (value) => Math.min(100, Math.max(0, value));\n"
+                                        : "export const clamp = (value) => Math.min(100, Math.max(0, Math.trunc(value)));\n"
+                                }
+                            ]
+                        }
+                    ]
+                };
+            else
+                return yield* new RepositoryFoundryError({
+                    operation: "invoke-language-model",
+                    detail: `unexpected model request ${request.schemaName}`
+                });
+            const decoded = yield* Schema.decodeUnknownEffect(request.outputSchema)(typeof value === "object" && value !== null && "action" in value ? { turn: value } : value).pipe(Effect.mapError((cause) => new RepositoryFoundryError({
+                operation: "invoke-language-model",
+                detail: `fixture response invalid ${String(cause)}`,
+                cause
+            })));
+            return {
+                value: decoded,
+                call: { operationId: request.operationId, ...request.assignment }
+            };
+        }),
+        generateStructured: () => Effect.fail(new RepositoryFoundryError({
+            operation: "invoke-language-model",
+            detail: "unplanned structured call"
+        }))
+    };
+    return { inner, calls };
+}
+async function harness(t, heldOutEscapes = false, maximumModelCalls = 30, regressionTestPath = "packages/main/src/index.test.js") {
+    const repo = await fixture(t, maximumModelCalls, regressionTestPath);
+    const scripted = model(heldOutEscapes, true, regressionTestPath);
+    const observed = [];
+    const capabilities = await Effect.runPromise(makeEvalCapabilitiesV1({ ...repo, runtime }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, scripted.inner)));
+    const invoke = (request) => capabilities.invoke(request).pipe(Effect.provideService(RepositoryCommandObservability, {
+        observe: (event) => {
+            observed.push(event.kind);
+        }
+    }));
+    return { ...repo, scripted, capabilities, invoke, observed };
+}
+test("scientific execution uses the shared fixed downstream reserve and ten-minute ceiling", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "draft_specification",
+        requestedMaximumModelCalls: EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_MODEL_CALLS_V1,
+        requestedMaximumWallMs: EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_WALL_TIME_MS_V1,
+        campaignModelCallsRemaining: 120,
+        campaignWallTimeRemainingMs: 90 * 60_000
+    });
+    assert.equal(decision.admitted, true);
+    assert.deepEqual(decision.downstreamReserve, {
+        calls: 24,
+        wallTimeMs: 75 * 60_000,
+        attempts: 6
+    });
+    assert.deepEqual(decision.minimumRequired, {
+        calls: 25,
+        wallTimeMs: 75 * 60_000 +
+            EVAL_CAPABILITY_DURABLE_FINALIZATION_RESERVE_MS_V1 +
+            1
+    });
+    assert.deepEqual(decision.finalizationReserve, { wallTimeMs: 30_000 });
+    assert.deepEqual(decision.availableForCapability, {
+        calls: 96,
+        wallTimeMs: 870_000
+    });
+    assert.deepEqual(decision.envelope, {
+        maximumModelCalls: EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_MODEL_CALLS_V1,
+        maximumWallTimeMs: EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_WALL_TIME_MS_V1
+    });
+});
+test("the rounded incident budget admits a shorter positive slice instead of requiring the maximum", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "draft_specification",
+        requestedMaximumModelCalls: 12,
+        requestedMaximumWallMs: 10 * 60_000,
+        campaignModelCallsRemaining: 104,
+        campaignWallTimeRemainingMs: 82 * 60_000
+    });
+    assert.equal(decision.admitted, true);
+    assert.deepEqual(decision.requestedMaximum, { calls: 12, wallTimeMs: 600_000 });
+    assert.deepEqual(decision.downstreamReserve, {
+        calls: 24,
+        wallTimeMs: 4_500_000,
+        attempts: 6
+    });
+    assert.deepEqual(decision.finalizationReserve, { wallTimeMs: 30_000 });
+    assert.deepEqual(decision.availableForCapability, {
+        calls: 80,
+        wallTimeMs: 390_000
+    });
+    assert.deepEqual(decision.envelope, {
+        maximumModelCalls: 12,
+        maximumWallTimeMs: 390_000
+    });
+});
+test("the exact incident capsule keeps durable finalization outside its adaptive slice", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "draft_specification",
+        requestedMaximumModelCalls: 12,
+        requestedMaximumWallMs: 600_000,
+        campaignModelCallsRemaining: 104,
+        campaignWallTimeRemainingMs: 5_016_723
+    });
+    assert.equal(decision.admitted, true);
+    assert.deepEqual(decision.available, {
+        calls: 104,
+        wallTimeMs: 5_016_723
+    });
+    assert.deepEqual(decision.downstreamReserve, {
+        calls: 24,
+        wallTimeMs: 4_500_000,
+        attempts: 6
+    });
+    assert.deepEqual(decision.finalizationReserve, { wallTimeMs: 30_000 });
+    assert.deepEqual(decision.availableForCapability, {
+        calls: 80,
+        wallTimeMs: 486_723
+    });
+    assert.deepEqual(decision.envelope, {
+        maximumModelCalls: 12,
+        maximumWallTimeMs: 486_723
+    });
+});
+test("scientific execution denies on calls when no positive call slice remains", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "draft_specification",
+        requestedMaximumModelCalls: 12,
+        requestedMaximumWallMs: 600_000,
+        campaignModelCallsRemaining: 24,
+        campaignWallTimeRemainingMs: 5_400_000
+    });
+    assert.equal(decision.admitted, false);
+    assert.equal(decision.admitted ? null : decision.dimension, "calls");
+    assert.equal(decision.envelope, null);
+    assert.deepEqual(decision.availableForCapability, {
+        calls: 0,
+        wallTimeMs: 870_000
+    });
+});
+test("scientific execution denies on wall time when only downstream and finalization reserves remain", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "draft_specification",
+        requestedMaximumModelCalls: 12,
+        requestedMaximumWallMs: 600_000,
+        campaignModelCallsRemaining: 104,
+        campaignWallTimeRemainingMs: 4_530_000
+    });
+    assert.equal(decision.admitted, false);
+    assert.equal(decision.admitted ? null : decision.dimension, "wall_time");
+    assert.equal(decision.envelope, null);
+    assert.deepEqual(decision.availableForCapability, {
+        calls: 80,
+        wallTimeMs: 0
+    });
+});
+test("control capabilities remain reachable after scientific budget exhaustion", () => {
+    const decision = evalCapabilityExecutionEnvelopeV1({
+        capability: "finish_campaign",
+        campaignModelCallsRemaining: 0,
+        campaignWallTimeRemainingMs: 0
+    });
+    assert.equal(decision.admitted, true);
+    assert.deepEqual(decision.downstreamReserve, { calls: 0, wallTimeMs: 0, attempts: 0 });
+    assert.deepEqual(decision.finalizationReserve, { wallTimeMs: 0 });
+    assert.deepEqual(decision.envelope, { maximumModelCalls: 1, maximumWallTimeMs: 1 });
+});
+test("finish_campaign executes after the candidate runtime has exhausted calls and wall time", async (t) => {
+    const repo = await fixture(t, 30);
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: repo.context.caseDirectory });
+    const now = new Date().toISOString();
+    await Effect.runPromise(store.writeState({
+        version: 1,
+        caseId: repo.context.caseId,
+        repositoryRoot: repo.context.repositoryRoot,
+        dimension: repo.context.dimension,
+        model: repo.context.primaryModel,
+        identityDigest: repo.proposal.candidate.revision,
+        stage: "seed",
+        status: "running",
+        startedAt: now,
+        updatedAt: now,
+        modelCalls: repo.context.budget.maxModelCalls,
+        elapsedMs: repo.context.budget.maxWallMs,
+        resumeCount: 0,
+        folds: 0
+    }));
+    const scripted = model();
+    const capabilities = await Effect.runPromise(makeEvalCapabilitiesV1({ ...repo, store, runtime }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, scripted.inner)));
+    const result = await Effect.runPromise(capabilities.invoke({
+        operationId: "finish-after-exhaustion",
+        deadlineAt: new Date(Date.now() - 1_000).toISOString(),
+        request: { tool: "finish_campaign", args: { reason: "Budget is exhausted." } }
+    }));
+    assert.equal(result.outcome, "completed", result.evidenceSummary);
+    assert.deepEqual(result.allowedNext, [
+        "get_progress",
+        "draft_specification",
+        "plan_environment",
+        "reject_candidate"
+    ]);
+    assert.equal(scripted.calls.length, 0);
+});
+test("terminal candidate results recommend only inspect, reselection, and finish capabilities", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    const rejected = await Effect.runPromise(h.invoke({
+        operationId: "reject-terminal-candidate",
+        request: {
+            tool: "reject_candidate",
+            args: {
+                candidate,
+                reason: "Candidate is conclusively unsuitable.",
+                evidence: []
+            }
+        }
+    }));
+    assert.equal(rejected.outcome, "scientific_rejection");
+    assert.deepEqual(rejected.allowedNext, [
+        "get_progress",
+        "list_candidates",
+        "read_diagnostics",
+        "finish_campaign"
+    ]);
+    assert.ok(!rejected.allowedNext.includes("reject_candidate"));
+    assert.ok(!rejected.allowedNext.includes("request_admission"));
+});
+test("source-only grounded draft returns immutable artifacts and honest missing quality measurements", async (t) => {
+    const h = await harness(t);
+    const drafted = await Effect.runPromise(h.invoke({
+        operationId: "draft-1",
+        request: { tool: "draft_specification", args: { candidate: h.proposal.candidate.candidate } }
+    }));
+    assert.equal(drafted.outcome, "completed", drafted.evidenceSummary);
+    assert.equal(drafted.usage.receivedCalls, 3);
+    assert.equal(drafted.accepted.length, 1);
+    assert.equal(h.scripted.calls.length, 3);
+    assert.deepEqual(h.observed, []);
+    const scorecard = await Effect.runPromise(h.capabilities.scorecard);
+    assert.equal(scorecard.disposition, "draft");
+    assert.equal(scorecard.reference.missing, 1);
+    assert.equal(scorecard.usage.receivedCalls, 3);
+    assert.equal(scorecard.usage.spendUnknown, true);
+    assert.ok((await readdir(join(h.stateRoot, "calls"))).some((path) => path.startsWith("artifact-")));
+    const frozen = await Effect.runPromise(h.invoke({
+        operationId: "freeze-without-evidence",
+        request: {
+            tool: "freeze_candidate",
+            args: { candidate: h.proposal.candidate.candidate, revision: h.proposal.candidate.revision }
+        }
+    }));
+    assert.equal(frozen.outcome, "progress");
+    assert.deepEqual(frozen.accepted, []);
+    assert.match(frozen.evidenceSummary, /not ready to freeze/u);
+});
+test("scientific progress projects wall time from the absolute invocation deadline", async (t) => {
+    const h = await harness(t);
+    const deadlineAt = new Date(Date.now() + 78 * 60_000).toISOString();
+    const result = await Effect.runPromise(h.invoke({
+        operationId: "absolute-deadline-draft",
+        deadlineAt,
+        request: {
+            tool: "draft_specification",
+            args: { candidate: h.proposal.candidate.candidate }
+        }
+    }));
+    assert.equal(result.outcome, "completed", result.evidenceSummary);
+    assert.equal(result.progressReceipt?.remaining.downstreamWallTimeMs, 75 * 60_000);
+    assert.ok((result.progressReceipt?.remaining.phaseWallTimeMs ?? 0) > 140_000);
+    assert.ok((result.progressReceipt?.remaining.phaseWallTimeMs ?? Infinity) <= 150_000);
+});
+test("host progress authority ignores provisional receipts until the host returns them", async (t) => {
+    const h = await harness(t, false, 60);
+    const request = {
+        tool: "draft_specification",
+        args: { candidate: h.proposal.candidate.candidate }
+    };
+    const first = await Effect.runPromise(h.invoke({
+        operationId: "authority-first",
+        request,
+        authoritativeProgressReceipts: []
+    }));
+    assert.ok(first.progressReceipt);
+    assert.equal(first.progressReceipt.sameFingerprintCount, 0);
+    assert.equal((await readdir(join(h.stateRoot, "calls"))).some((path) => path.startsWith(first.progressReceipt.receiptId)), false, "a host-controlled provisional receipt must not enter the local checkpoint store");
+    const ignored = await Effect.runPromise(h.invoke({
+        operationId: "authority-provisional-ignored",
+        request,
+        authoritativeProgressReceipts: []
+    }));
+    assert.ok(ignored.progressReceipt);
+    assert.equal(ignored.progressReceipt.remaining.phaseAttempts, first.progressReceipt.remaining.phaseAttempts, "an unaccepted local receipt cannot consume an authoritative phase attempt");
+    const accepted = await Effect.runPromise(h.invoke({
+        operationId: "authority-host-accepted",
+        request,
+        authoritativeProgressReceipts: [first.progressReceipt]
+    }));
+    assert.ok(accepted.progressReceipt);
+    assert.equal(accepted.progressReceipt.remaining.phaseAttempts, first.progressReceipt.remaining.phaseAttempts - 1, "the exact receipt advances the chain only after the host returns it");
+    assert.equal(accepted.progressReceipt.sameFingerprintCount, 1);
+    assert.deepEqual(accepted.progressReceipt.previousFingerprint, first.progressReceipt.resultingFingerprint);
+});
+test("an invocation yields at its call budget without exhausting the whole campaign", async (t) => {
+    const h = await harness(t);
+    const result = await Effect.runPromise(h.invoke({
+        operationId: "one-call-slice",
+        maximumModelCalls: 1,
+        request: { tool: "draft_specification", args: { candidate: h.proposal.candidate.candidate } }
+    }));
+    assert.equal(result.outcome, "progress");
+    assert.equal(result.usage.receivedCalls, 1);
+    assert.equal(result.progressReceipt?.remaining.phaseAttempts, 8);
+    assert.match(result.evidenceSummary, /without consuming the campaign budget/u);
+    const continued = await Effect.runPromise(h.invoke({
+        operationId: "continued-slice",
+        request: { tool: "draft_specification", args: { candidate: h.proposal.candidate.candidate } }
+    }));
+    assert.equal(continued.outcome, "completed", continued.evidenceSummary);
+    assert.equal(continued.usage.receivedCalls, 2, "completed grounded analysis is not purchased again");
+    assert.equal((await Effect.runPromise(h.capabilities.scorecard)).usage.receivedCalls, 3);
+});
+test("three unchanged specification receipts open the scientific circuit without spending the downstream reserve", async (t) => {
+    const h = await harness(t, false, 60);
+    const request = {
+        tool: "draft_specification",
+        args: { candidate: h.proposal.candidate.candidate }
+    };
+    const results = [];
+    for (let index = 0; index < 3; index += 1) {
+        results.push(await Effect.runPromise(h.invoke({
+            operationId: `unchanged-draft-${String(index + 1)}`,
+            request
+        })));
+    }
+    const last = results[2].progressReceipt;
+    const unrelatedNoOp = {
+        ...last,
+        receiptId: "unrelated-no-op",
+        operationId: "unrelated-no-op",
+        capability: "plan_environment",
+        phase: "environment",
+        previousFingerprint: last.resultingFingerprint,
+        sameFingerprintCount: 1,
+        recordedAt: new Date(Date.parse(last.recordedAt) + 1).toISOString()
+    };
+    const replayed = await Effect.runPromise(makeEvalCapabilitiesV1({
+        context: h.context,
+        map: h.map,
+        proposal: h.proposal,
+        runtime,
+        progressReceipts: [...results.flatMap((result) => result.progressReceipt === undefined ? [] : [result.progressReceipt]), unrelatedNoOp]
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    results.push(await Effect.runPromise(replayed.invoke({ operationId: "unchanged-draft-4", request })));
+    assert.equal(results[0].progressReceipt?.sameFingerprintCount, 0);
+    assert.equal(results[1].progressReceipt?.sameFingerprintCount, 1);
+    assert.equal(results[2].progressReceipt?.sameFingerprintCount, 2);
+    assert.ok(!results[2].allowedNext.includes("draft_specification"));
+    assert.equal(results[3].outcome, "scientific_rejection");
+    assert.equal(results[3].progressReceipt?.sameFingerprintCount, 3);
+    assert.deepEqual(results[3].progressReceipt?.previousFingerprint, results[2].progressReceipt?.resultingFingerprint);
+    assert.equal(results[3].usage.receivedCalls, 0);
+    assert.equal(results[3].progressReceipt?.remaining.downstreamCalls, 24);
+    assert.ok((results[3].progressReceipt?.remaining.phaseCalls ?? 0) > 0, "the circuit opens before consuming the remaining phase allowance");
+    assert.equal(h.scripted.calls.length, 3, "cached analysis, writer and critic are free; unchanged repeats perform no model call");
+});
+test("grade timeout is an environment blocker, and an explanatory replan cannot erase it", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    await Effect.runPromise(h.invoke({
+        operationId: "timeout-spec", request: { tool: "draft_specification", args: { candidate } }
+    }));
+    const plan = {
+        tool: "plan_environment",
+        args: {
+            candidate, recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source", targetRoots: ["packages/main"], requiredArtifacts: [],
+            justification: "Execute the reviewed source."
+        }
+    };
+    const planned = await Effect.runPromise(h.invoke({ operationId: "timeout-plan", request: plan }));
+    const environment = planned.accepted[0];
+    let commands = 0;
+    const qualify = (operationId) => Effect.runPromise(h.invoke({
+        operationId, request: { tool: "qualify_reference", args: { candidate, environment } }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => Effect.sync(() => {
+            commands += 1;
+            return { exitCode: null, timedOut: true, stdout: "", stderr: "" };
+        })
+    })));
+    const blocked = await qualify("timeout-first");
+    assert.equal(blocked.outcome, "environment_blocked");
+    assert.equal(blocked.gradeExecuted, false);
+    assert.ok(!blocked.allowedNext.includes("qualify_reference"));
+    assert.ok(!blocked.allowedNext.includes("draft_specification"));
+    assert.ok(blocked.allowedNext.includes("plan_environment"));
+    assert.ok(!blocked.progressReceipt?.gatesCompleted.includes("reference_qualified"));
+    const completedCommands = commands;
+    assert.ok(completedCommands > 0);
+    const replanned = await Effect.runPromise(h.invoke({
+        operationId: "timeout-no-op-plan",
+        request: { ...plan, args: { ...plan.args, justification: "A different explanation only." } }
+    }));
+    assert.deepEqual(replanned.accepted, planned.accepted);
+    assert.deepEqual(replanned.progressReceipt?.acceptedEvidenceAdded, []);
+    assert.deepEqual(replanned.progressReceipt?.acceptedEvidenceRemoved, []);
+    assert.equal((await qualify("timeout-retained")).outcome, "environment_blocked");
+    assert.equal(commands, completedCommands);
+});
+test("a caller cannot inject checkpoint or provider authority into a tool request", async (t) => {
+    const h = await harness(t);
+    await assert.rejects(Effect.runPromise(h.invoke({
+        operationId: "invalid",
+        request: {
+            tool: "get_progress",
+            args: { checkpoints: { admit: "passed" }, model: "auto" }
+        }
+    })), /invalid capability request/u);
+    assert.deepEqual(h.scripted.calls, []);
+});
+test("injected execution port runs the real isolated checkout and overlays without credentials", async (t) => {
+    const h = await fixture(t);
+    const calls = [];
+    const results = await Effect.runPromise(replayRepositoryCommandsV1({
+        repositoryRoot: h.root,
+        commit: h.map.repository.commit,
+        recipes: [
+            {
+                id: "read-real-overlay",
+                kind: "custom",
+                executable: "node",
+                cwd: ".",
+                args: [
+                    "-e",
+                    "process.stdout.write(require('node:fs').readFileSync('diagnostic.txt','utf8'))"
+                ],
+                timeoutMs: 5_000
+            }
+        ],
+        fileOverrides: [{ path: "diagnostic.txt", content: "真实🔎 diagnostic overlay" }],
+        repetitions: 1
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (input) => Effect.tryPromise({
+            try: async () => {
+                calls.push(input);
+                const result = await exec(input.executable, [...input.args], {
+                    cwd: input.cwd,
+                    env: input.environment,
+                    timeout: input.timeoutMs
+                });
+                return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+            },
+            catch: (cause) => new RepositoryFoundryError({
+                operation: "run-command",
+                detail: "injected platform command failed",
+                cause
+            })
+        })
+    })));
+    assert.equal(calls.length, 1);
+    assert.notEqual(calls[0].cwd, h.root);
+    assert.equal(calls[0].environment.PLANETSCALE_PASSWORD, undefined);
+    assert.equal(results[0].stdout, "真实🔎 diagnostic overlay");
+    assert.equal(results[0].gradeExecuted, true);
+    await assert.rejects(readFile(join(h.root, "diagnostic.txt")), /ENOENT/u);
+});
+test("scorecards refuse fabricated admission without executed reference, controls and held-out evidence", () => {
+    assert.throws(() => evalCandidateQualityScorecardV1({
+        candidate: "candidate",
+        revision: "revision",
+        checkpoints: {
+            admit: { verdict: "admitted", reasons: [] }
+        },
+        elapsedMs: 1,
+        receivedCalls: 0
+    }), /admission requires/u);
+});
+test("typed scientific resource exhaustion is an environment blockage, never progress", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    await Effect.runPromise(h.invoke({
+        operationId: "resource-specification",
+        request: { tool: "draft_specification", args: { candidate } }
+    }));
+    const planned = await Effect.runPromise(h.invoke({
+        operationId: "resource-plan",
+        request: {
+            tool: "plan_environment",
+            args: {
+                candidate,
+                recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+                executionMode: "source",
+                targetRoots: ["packages/main"],
+                requiredArtifacts: [],
+                justification: "Exercise typed command resource classification."
+            }
+        }
+    }));
+    const environment = planned.accepted[0];
+    const result = await Effect.runPromise(h.invoke({
+        operationId: "resource-qualification",
+        request: {
+            tool: "qualify_reference",
+            args: { candidate, environment }
+        }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => Effect.fail(new RepositoryFoundryError({
+            operation: "run-command",
+            detail: "scientific_command_resource_exhausted",
+            classification: "environment_blocked",
+            cause: { code: "scientific_command_resource_exhausted" }
+        }))
+    })));
+    assert.equal(result.outcome, "environment_blocked");
+    assert.equal(result.gradeExecuted, false);
+    assert.equal(result.evidenceSummary, "scientific_command_resource_exhausted");
+});
+test("reference qualification cannot run or retain evidence before specification acceptance", async (t) => {
+    const repo = await fixture(t);
+    const scripted = model(false, false);
+    const capabilities = await Effect.runPromise(makeEvalCapabilitiesV1({ ...repo, runtime }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, scripted.inner)));
+    const candidate = repo.proposal.candidate.candidate;
+    const drafted = await Effect.runPromise(capabilities.invoke({
+        operationId: "unaccepted-specification",
+        request: { tool: "draft_specification", args: { candidate } }
+    }));
+    assert.equal(drafted.outcome, "progress", drafted.evidenceSummary);
+    const specification = capabilities.handles().spec;
+    assert.ok(specification, "the reviewable draft must remain retained");
+    const planned = await Effect.runPromise(capabilities.invoke({
+        operationId: "unaccepted-specification-plan",
+        request: {
+            tool: "plan_environment",
+            args: {
+                candidate,
+                recipeIds: repo.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+                executionMode: "source",
+                targetRoots: ["packages/main"],
+                requiredArtifacts: [],
+                justification: "Prove reference execution is ordered after specification acceptance."
+            }
+        }
+    }));
+    let gradeExecutions = 0;
+    const blocked = await Effect.runPromise(capabilities
+        .invoke({
+        operationId: "unaccepted-specification-qualification",
+        request: {
+            tool: "qualify_reference",
+            args: { candidate, environment: planned.accepted[0] }
+        }
+    })
+        .pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => {
+            gradeExecutions += 1;
+            return Effect.succeed({ exitCode: 0, stdout: "", stderr: "" });
+        }
+    })));
+    assert.equal(blocked.outcome, "progress");
+    assert.match(blocked.evidenceSummary, /reference qualification requires an accepted grounded specification review/u);
+    assert.equal(gradeExecutions, 0);
+    assert.equal(capabilities.handles().spec, specification);
+    assert.equal(capabilities.handles().seed, undefined);
+    assert.ok(blocked.allowedNext.includes("draft_specification"));
+    assert.equal(blocked.allowedNext.includes("qualify_reference"), false);
+    assert.equal(blocked.allowedNext.includes("author_oracle"), false);
+    assert.equal(blocked.allowedNext.includes("generate_controls"), false);
+    assert.equal(blocked.allowedNext.includes("request_admission"), false);
+    assert.equal((await readdir(join(repo.stateRoot, "work")).catch((error) => error.code === "ENOENT" ? [] : Promise.reject(error))).includes("reference-qualification.json"), false);
+    const revised = await Effect.runPromise(capabilities.invoke({
+        operationId: "revise-unaccepted-specification",
+        request: { tool: "draft_specification", args: { candidate } }
+    }));
+    assert.equal(revised.outcome, "progress", revised.evidenceSummary);
+});
+test("qualification slice progress is materialized as immutable accepted evidence", async (t) => {
+    const repo = await fixture(t);
+    const scripted = model();
+    const baseStore = makeCaseCheckpointStoreV1({ caseDirectory: repo.stateRoot });
+    let qualificationCheckpointed = false;
+    const store = {
+        ...baseStore,
+        writeWorkCheckpoint: (name, value) => baseStore.writeWorkCheckpoint(name, value).pipe(Effect.tap(() => Effect.sync(() => {
+            if (name === "reference-qualification")
+                qualificationCheckpointed = true;
+        })))
+    };
+    const capabilities = await Effect.runPromise(makeEvalCapabilitiesV1({ ...repo, runtime, store }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, scripted.inner)));
+    const candidate = repo.proposal.candidate.candidate;
+    await Effect.runPromise(capabilities.invoke({
+        operationId: "progress-specification",
+        request: { tool: "draft_specification", args: { candidate } }
+    }));
+    const planned = await Effect.runPromise(capabilities.invoke({
+        operationId: "progress-plan",
+        request: {
+            tool: "plan_environment",
+            args: {
+                candidate,
+                recipeIds: repo.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+                executionMode: "source",
+                targetRoots: ["packages/main"],
+                requiredArtifacts: [],
+                justification: "Exercise durable qualification progress handoff."
+            }
+        }
+    }));
+    const result = await Effect.runPromise(capabilities.invoke({
+        operationId: "progress-qualification",
+        maximumWallMs: 2_000,
+        request: {
+            tool: "qualify_reference",
+            args: { candidate, environment: planned.accepted[0] }
+        }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (input) => qualificationCheckpointed
+            ? Effect.never
+            : Effect.succeed({
+                exitCode: 0,
+                stdout: input.args.includes("--test")
+                    ? "TAP version 13\n# Subtest: baseline\nok 1 - baseline\n# tests 1\n# pass 1\n# fail 0\n# cancelled 0\n# skipped 0\n# todo 0\n"
+                    : "",
+                stderr: ""
+            })
+    })));
+    assert.equal(result.outcome, "progress", result.evidenceSummary);
+    const handle = result.accepted.find((accepted) => accepted.startsWith("qualification-progress-"));
+    assert.ok(handle, "the bounded result must accept its retained qualification progress");
+    assert.ok(result.progressReceipt?.acceptedEvidenceAdded.includes(handle), "Cloud reconstructs accepted continuation state from receipt deltas, not result.accepted");
+    assert.ok(result.progressReceipt?.resultingFingerprint.continuationProgressDigest);
+    const call = JSON.parse(await readFile(join(repo.stateRoot, "calls", `${handle}.attempt-1.json`), "utf8"));
+    assert.equal(call.request.tool, "qualify_reference");
+    assert.equal(call.request.candidateRevision, repo.proposal.candidate.revision);
+    assert.ok(call.response, "the immutable accepted artifact must contain retained progress");
+});
+test("oracle authoring continuation survives a capability process restart without claiming a scientific gate", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    const invoke = async (request) => {
+        const result = await Effect.runPromise(h.invoke({
+            operationId: `grounded-prepare-${request.tool}`, maximumWallMs: 120_000, request
+        }));
+        assert.equal(result.outcome, "completed", result.evidenceSummary);
+        return result;
+    };
+    await invoke({ tool: "draft_specification", args: { candidate } });
+    const plan = await invoke({
+        tool: "plan_environment",
+        args: {
+            candidate, recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source", targetRoots: ["packages/main"], requiredArtifacts: [],
+            justification: "Exercise durable authoring continuation."
+        }
+    });
+    await invoke({ tool: "qualify_reference", args: { candidate, environment: plan.accepted[0] } });
+    const specification = h.capabilities.handles().spec;
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: h.stateRoot });
+    const priorUnits = [];
+    for (let index = 0; index < 40; index += 1) {
+        const name = `grounded-authoring-fixture-retained-${String(index)}`;
+        const value = { version: 1, bindingDigest: "a".repeat(64), results: [], ordinal: index };
+        await Effect.runPromise(store.writeWorkCheckpoint(name, value));
+        priorUnits.push({ name, stage: "oracle", contentDigest: acceptedScientificDigestV1(value) });
+    }
+    await Effect.runPromise(store.writeWorkCheckpoint("grounded-continuations", priorUnits));
+    const interruptedRuntime = await Effect.runPromise(makeEvalCapabilitiesV1({
+        ...h, runtime, environment: h.capabilities.environment()
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const partial = await Effect.runPromise(interruptedRuntime.invoke({
+        operationId: "grounded-interrupted", maximumWallMs: 1_000,
+        request: { tool: "author_oracle", args: { candidate, specification } }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, { run: () => Effect.never })));
+    assert.equal(partial.outcome, "progress", partial.evidenceSummary);
+    assert.equal(h.capabilities.handles().oracle, undefined);
+    const continuation = partial.accepted.find((handle) => handle.startsWith("continuation-progress-grounded-"));
+    assert.ok(continuation);
+    assert.equal(partial.accepted.length, 1, "one manifest, not an unbounded handle per fixture");
+    const manifest = JSON.parse(await readFile(join(h.stateRoot, "calls", `${continuation}.attempt-1.json`), "utf8")).response;
+    assert.equal(manifest.checkpoints.length, 42, "all retained units plus one bounded slice marker bind one continuation");
+    assert.ok(partial.progressReceipt?.acceptedEvidenceAdded.includes(continuation));
+    assert.equal(partial.progressReceipt?.sameFingerprintCount, 0);
+    assert.equal(partial.progressReceipt?.remaining.phaseAttempts, 12, "a productive authoring slice does not consume a new scientific attempt");
+    assert.equal(partial.progressReceipt?.gatesCompleted.includes("oracle_authored"), false);
+    assert.equal(partial.progressReceipt?.previousFingerprint?.acceptedEvidenceDigest, partial.progressReceipt?.resultingFingerprint.acceptedEvidenceDigest, "retained work is not completed scientific evidence");
+    const receivedCalls = h.scripted.calls.length;
+    const environment = JSON.parse(await readFile(join(h.stateRoot, "calls", `${plan.accepted[0]}.attempt-1.json`), "utf8")).response;
+    const restored = await Effect.runPromise(makeEvalCapabilitiesV1({
+        ...h, runtime, environment,
+        progressReceipts: partial.progressReceipt === undefined ? [] : [partial.progressReceipt]
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const completed = await Effect.runPromise(restored.invoke({
+        operationId: "grounded-resumed", maximumWallMs: 120_000,
+        request: { tool: "author_oracle", args: { candidate, specification } }
+    }));
+    assert.equal(completed.outcome, "completed", completed.evidenceSummary);
+    assert.equal(h.scripted.calls.length, receivedCalls, "resume pending host replay, not the model");
+    assert.ok(restored.handles().oracle);
+    assert.ok(completed.progressReceipt?.gatesCompleted.includes("oracle_authored"));
+    assert.ok(completed.progressReceipt?.acceptedEvidenceRemoved.includes(continuation));
+    assert.deepEqual(completed.progressReceipt?.previousFingerprint, partial.progressReceipt?.resultingFingerprint);
+});
+test("blind control response survives a slice before validation without claiming control admission", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    const invoke = async (request) => {
+        const result = await Effect.runPromise(h.invoke({
+            operationId: `feedback-prepare-${request.tool}`, maximumWallMs: 120_000, request
+        }));
+        assert.equal(result.outcome, "completed", result.evidenceSummary);
+        return result;
+    };
+    await invoke({ tool: "draft_specification", args: { candidate } });
+    const plan = await invoke({
+        tool: "plan_environment",
+        args: {
+            candidate, recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source", targetRoots: ["packages/main"], requiredArtifacts: [],
+            justification: "Retain blind control authoring across its execution slice."
+        }
+    });
+    const environment = plan.accepted[0];
+    await invoke({ tool: "qualify_reference", args: { candidate, environment } });
+    const specification = h.capabilities.handles().spec;
+    await invoke({ tool: "author_oracle", args: { candidate, specification } });
+    const request = {
+        tool: "generate_controls",
+        args: { candidate, specification, environment, kind: "valid" }
+    };
+    const partial = await Effect.runPromise(h.invoke({
+        operationId: "feedback-interrupted", maximumWallMs: 1_000, request
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, { run: () => Effect.never })));
+    assert.equal(partial.outcome, "progress", partial.evidenceSummary);
+    assert.equal(h.capabilities.handles().controls, undefined);
+    assert.equal(partial.progressReceipt?.gatesCompleted.includes("valid_controls_generated"), false);
+    assert.equal(partial.accepted.length, 1);
+    assert.ok(partial.progressReceipt?.resultingFingerprint.continuationProgressDigest);
+    const calls = h.scripted.calls.length;
+    const restored = await Effect.runPromise(makeEvalCapabilitiesV1({
+        ...h, runtime, environment: h.capabilities.environment(),
+        progressReceipts: partial.progressReceipt === undefined ? [] : [partial.progressReceipt]
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const completed = await Effect.runPromise(restored.invoke({
+        operationId: "feedback-resumed", maximumWallMs: 120_000, request
+    }));
+    assert.equal(completed.outcome, "completed", completed.evidenceSummary);
+    assert.equal(h.scripted.calls.length, calls, "resume executes the received control, not the model");
+    assert.ok(completed.progressReceipt?.gatesCompleted.includes("valid_controls_generated"));
+    assert.equal(completed.progressReceipt?.gatesCompleted.includes("wrong_controls_generated"), false);
+    const controls = JSON.parse(await readFile(join(h.stateRoot, "controls.json"), "utf8"));
+    const checkpoints = {
+        seed: JSON.parse(await readFile(join(h.stateRoot, "seed.json"), "utf8")),
+        spec: JSON.parse(await readFile(join(h.stateRoot, "spec.json"), "utf8")),
+        oracle: JSON.parse(await readFile(join(h.stateRoot, "oracle.json"), "utf8")),
+        controls: { ...controls, valid: [], wrong: [] }
+    };
+    for (const [replacementRound, expectedNewCalls] of [[1, 1], [1, 1], [2, 2]]) {
+        await Effect.runPromise(runPipelineControlsCapabilityV1({
+            context: h.context, map: h.map, checkpoints, kind: "valid", replacementRound,
+            workCheckpointStore: makeCaseCheckpointStoreV1({ caseDirectory: h.stateRoot }),
+            checkpoint: () => Effect.void
+        }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+        assert.equal(h.scripted.calls.length, calls + expectedNewCalls, "same replacement round resumes; a new scientific rejection requires a fresh proposal");
+    }
+});
+test("individual capability chain admits only after real reference, controls, tournament and fresh held-out execution", async (t) => {
+    const h = await harness(t);
+    let operation = 0;
+    const invoke = async (request) => {
+        const result = await Effect.runPromise(h.invoke({ operationId: `chain-${String(++operation)}`, maximumWallMs: 120_000, request }));
+        assert.equal(result.outcome, "completed", `${request.tool}: ${result.evidenceSummary}`);
+        return result;
+    };
+    const candidate = h.proposal.candidate.candidate;
+    await invoke({ tool: "draft_specification", args: { candidate } });
+    const planned = await invoke({
+        tool: "plan_environment",
+        args: {
+            candidate,
+            recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source",
+            targetRoots: ["packages/main"],
+            requiredArtifacts: [],
+            justification: "Execute source recipe without compilation."
+        }
+    });
+    const environment = planned.accepted[0];
+    const qualified = await invoke({ tool: "qualify_reference", args: { candidate, environment } });
+    assert.equal(qualified.gradeExecuted, true);
+    const specification = h.capabilities.handles().spec;
+    const authored = await invoke({ tool: "author_oracle", args: { candidate, specification } });
+    const oracleHandle = h.capabilities.handles().oracle;
+    const oracleCheckpoint = await readFile(join(h.stateRoot, "oracle.json"), "utf8");
+    const oracleAuthorCalls = h.scripted.calls.length;
+    for (let repetition = 1; repetition <= 2; repetition += 1) {
+        const resumed = await invoke({ tool: "author_oracle", args: { candidate, specification } });
+        assert.equal(h.capabilities.handles().oracle, oracleHandle);
+        assert.equal(await readFile(join(h.stateRoot, "oracle.json"), "utf8"), oracleCheckpoint);
+        assert.deepEqual(resumed.progressReceipt?.resultingFingerprint, authored.progressReceipt?.resultingFingerprint);
+        assert.deepEqual(resumed.progressReceipt?.acceptedEvidenceAdded, []);
+        assert.deepEqual(resumed.progressReceipt?.acceptedEvidenceRemoved, []);
+        assert.equal(resumed.progressReceipt?.sameFingerprintCount, repetition);
+        assert.equal(h.scripted.calls.length, oracleAuthorCalls);
+    }
+    const legacyCheckpoints = {
+        seed: JSON.parse(await readFile(join(h.stateRoot, "seed.json"), "utf8")),
+        spec: JSON.parse(await readFile(join(h.stateRoot, "spec.json"), "utf8")),
+        oracle: { ...JSON.parse(oracleCheckpoint), coverageRounds: 1 }
+    };
+    let migrations = 0;
+    const migrate = (checkpoints) => Effect.runPromise(runPipelineOracleStageV1({
+        context: h.context, map: h.map, checkpoints,
+        checkpoint: () => Effect.sync(() => { migrations += 1; })
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const migrated = await migrate(legacyCheckpoints);
+    assert.equal(migrated.coverageRounds, 0);
+    assert.deepEqual(migrated.scopeCoverage, JSON.parse(oracleCheckpoint).scopeCoverage);
+    assert.equal(await migrate({ ...legacyCheckpoints, oracle: migrated }), migrated);
+    assert.equal(migrations, 1, "legacy coverage normalization happens exactly once");
+    await invoke({
+        tool: "generate_controls",
+        args: { candidate, specification, environment, kind: "valid" }
+    });
+    const previousControls = h.capabilities.handles().controls;
+    const cumulative = await invoke({
+        tool: "generate_controls",
+        args: { candidate, specification, environment, kind: "wrong" }
+    });
+    assert.match(cumulative.evidenceSummary, /cumulative controls checkpoint; valid=1; wrong=1/u);
+    assert.match(cumulative.evidenceSummary, /supersedes all previous controls snapshots/u);
+    const callsBeforeStaleSnapshot = h.scripted.calls.length;
+    const stale = await Effect.runPromise(h.invoke({
+        operationId: "chain-stale-controls",
+        request: {
+            tool: "evaluate_oracle",
+            args: {
+                candidate, oracle: h.capabilities.handles().oracle,
+                controls: [previousControls, h.capabilities.handles().controls]
+            }
+        }
+    }));
+    assert.equal(stale.outcome, "progress");
+    assert.match(stale.evidenceSummary, /use only the latest cumulative controls checkpoint/u);
+    assert.match(stale.evidenceSummary, /unaccepted or stale controls handle/u);
+    assert.equal(h.scripted.calls.length, callsBeforeStaleSnapshot, "stale snapshots are rejected before any additional model or scientific work");
+    assert.equal(h.capabilities.handles().tournament, undefined);
+    const evaluated = await invoke({
+        tool: "evaluate_oracle",
+        args: {
+            candidate,
+            oracle: h.capabilities.handles().oracle,
+            controls: [h.capabilities.handles().controls]
+        }
+    });
+    assert.ok(evaluated.allowedNext.includes("freeze_candidate"));
+    assert.equal(evaluated.allowedNext.includes("run_held_out_challenge"), false);
+    const tournamentPath = join(h.stateRoot, "tournament.json");
+    const retainedTournament = await readFile(tournamentPath, "utf8");
+    const legacyTournament = JSON.parse(retainedTournament);
+    await writeFile(tournamentPath, JSON.stringify({
+        ...legacyTournament,
+        oracle: {
+            ...legacyTournament.oracle,
+            observations: legacyTournament.oracle.observations.filter((row) => !(row.solutionId === "historical-defect" && row.clauseId === "fixture-negative"))
+        }
+    }));
+    try {
+        const restoredLegacy = await Effect.runPromise(makeEvalCapabilitiesV1({
+            ...h, runtime, environment: h.capabilities.environment()
+        }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+        const legacyProgress = await Effect.runPromise(restoredLegacy.invoke({
+            operationId: "legacy-scope-progress", request: { tool: "get_progress", args: { candidate } }
+        }));
+        assert.equal(legacyProgress.allowedNext.includes("freeze_candidate"), false, "a legacy adequate flag cannot replace missing executed scope evidence");
+        assert.equal(legacyProgress.allowedNext.includes("run_held_out_challenge"), false);
+    }
+    finally {
+        await writeFile(tournamentPath, retainedTournament);
+    }
+    const frozen = await invoke({
+        tool: "freeze_candidate",
+        args: { candidate, revision: h.proposal.candidate.revision }
+    });
+    const frozenCandidate = frozen.accepted[0];
+    assert.ok(frozen.allowedNext.includes("run_held_out_challenge"));
+    const frozenPayload = JSON.parse(await readFile(join(h.stateRoot, "calls", `${frozenCandidate}.attempt-1.json`), "utf8"));
+    const baseStore = makeCaseCheckpointStoreV1({ caseDirectory: h.stateRoot });
+    let oracleCheckpointed = false;
+    const store = {
+        ...baseStore,
+        writeStage: (...args) => baseStore.writeStage(...args).pipe(Effect.tap(() => Effect.sync(() => {
+            if (args[0] === "challenge" && typeof args[1] === "object" &&
+                args[1] !== null && "agenticPendingOracle" in args[1])
+                oracleCheckpointed = true;
+        })))
+    };
+    const restoreChallenge = () => Effect.runPromise(makeEvalCapabilitiesV1({
+        ...h, runtime, store, environment: h.capabilities.environment(),
+        acceptedScientificArtifacts: [{
+                handle: frozenCandidate,
+                kind: "frozen_candidate",
+                contentDigest: acceptedScientificDigestV1(frozenPayload.response)
+            }]
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const sliced = await restoreChallenge();
+    const partial = await Effect.runPromise(sliced.invoke({
+        operationId: "held-out-first-slice", maximumWallMs: 3_000,
+        request: { tool: "run_held_out_challenge", args: { frozenCandidate } }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: (command) => oracleCheckpointed
+            ? Effect.never
+            : Effect.tryPromise({
+                try: async () => {
+                    const output = await exec(command.executable, [...command.args], {
+                        cwd: command.cwd,
+                        env: command.environment,
+                        timeout: command.timeoutMs
+                    });
+                    return { exitCode: 0, stdout: output.stdout, stderr: output.stderr };
+                },
+                catch: (cause) => new RepositoryFoundryError({
+                    operation: "run-command", detail: "fixture reference command failed", cause
+                })
+            })
+    })));
+    assert.equal(partial.outcome, "progress", partial.evidenceSummary);
+    assert.ok(oracleCheckpointed, "first completed solution must be saved before interruption");
+    const continuation = partial.accepted.find((handle) => handle.startsWith("continuation-progress-challenge-"));
+    assert.ok(continuation);
+    assert.ok(partial.progressReceipt?.acceptedEvidenceAdded.includes(continuation));
+    assert.equal(partial.progressReceipt?.sameFingerprintCount, 0);
+    assert.ok(partial.progressReceipt?.resultingFingerprint.continuationProgressDigest);
+    assert.equal(partial.progressReceipt?.gatesCompleted.includes("held_out_challenge_passed"), false);
+    const saved = await readFile(join(h.stateRoot, "challenge.json"), "utf8");
+    const authoredCalls = h.scripted.calls.length;
+    const interrupted = await restoreChallenge();
+    const noNewWork = await Effect.runPromise(interrupted.invoke({
+        operationId: "held-out-interrupted-resume", maximumWallMs: 200,
+        authoritativeProgressReceipts: [partial.progressReceipt],
+        request: { tool: "run_held_out_challenge", args: { frozenCandidate } }
+    }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+        run: () => Effect.never
+    })));
+    assert.equal(noNewWork.outcome, "progress", noNewWork.evidenceSummary);
+    assert.equal(await readFile(join(h.stateRoot, "challenge.json"), "utf8"), saved, "resumed materialization must not erase an already checkpointed oracle");
+    assert.deepEqual(noNewWork.progressReceipt?.previousFingerprint, partial.progressReceipt?.resultingFingerprint, "serialized continuation identity is stable");
+    assert.equal(h.scripted.calls.length, authoredCalls, "resume must never resample the adversary");
+    const resumed = await restoreChallenge();
+    const challenge = await Effect.runPromise(resumed.invoke({
+        operationId: "held-out-complete",
+        authoritativeProgressReceipts: [partial.progressReceipt, noNewWork.progressReceipt],
+        request: { tool: "run_held_out_challenge", args: { frozenCandidate } }
+    }));
+    assert.equal(challenge.outcome, "completed", challenge.evidenceSummary);
+    assert.ok(challenge.progressReceipt?.acceptedEvidenceRemoved.includes(continuation));
+    assert.equal(challenge.progressReceipt?.resultingFingerprint.continuationProgressDigest, null);
+    assert.ok(challenge.progressReceipt?.gatesCompleted.includes("held_out_challenge_passed"));
+    const calls = h.scripted.calls.length;
+    const restored = await Effect.runPromise(makeEvalCapabilitiesV1({ ...h, runtime, environment: h.capabilities.environment() }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner)));
+    const replay = await Effect.runPromise(restored.invoke({
+        operationId: "restored-challenge",
+        request: { tool: "run_held_out_challenge", args: { frozenCandidate } }
+    }));
+    assert.equal(replay.outcome, "completed", replay.evidenceSummary);
+    assert.deepEqual(replay.accepted, challenge.accepted);
+    assert.equal(h.scripted.calls.length, calls, "same frozen challenge is reused, never resampled");
+    const admitted = await Effect.runPromise(restored.invoke({
+        operationId: "restored-admission",
+        request: {
+            tool: "request_admission",
+            args: { frozenCandidate, qualification: challenge.accepted[0] }
+        }
+    }));
+    assert.equal(admitted.outcome, "completed", admitted.evidenceSummary);
+    const scorecard = await Effect.runPromise(restored.scorecard);
+    assert.equal(scorecard.disposition, "admitted");
+    assert.ok(scorecard.reference.passed > 0);
+    assert.ok(scorecard.validControls.passed > 0);
+    assert.ok(scorecard.wrongControls.passed > 0);
+    assert.ok(scorecard.heldOut.passed > 0);
+    assert.deepEqual(scorecard.missingEvidence, []);
+    assert.ok(h.observed.includes("started") && h.observed.includes("completed"));
+});
+test("a diagnostic multi-file fixture probe materializes helper and test overlays together", async (t) => {
+    const repo = await fixture(t);
+    const scripted = model();
+    const suite = {
+        version: 1,
+        caseId: repo.context.caseId,
+        fixtures: [
+            {
+                id: "helper-probe",
+                kind: "metamorphic",
+                expectationMode: "preserved",
+                description: "Uses helper fixture.",
+                expectedBehavior: "Helper and repository result agree.",
+                source: "generated",
+                testPath: "packages/main/src/index.test.js"
+            }
+        ],
+        overlays: [
+            {
+                path: "packages/main/src/helper.js",
+                content: "export const expected = 25.5;",
+                fixtureIds: []
+            },
+            {
+                path: "packages/main/src/index.test.js",
+                content: 'import assert from "node:assert/strict"; import test from "node:test"; import {clamp} from "./index.js"; import {expected} from "./helper.js"; test("uses helper", () => assert.equal(clamp(expected), expected));',
+                fixtureIds: ["helper-probe"]
+            }
+        ]
+    };
+    const capabilities = await Effect.runPromise(makeEvalCapabilitiesV1({
+        ...repo,
+        runtime,
+        resolveFixtureDraft: (handle) => handle === "helper-fixture"
+            ? Effect.succeed(suite)
+            : Effect.fail(new RepositoryFoundryError({
+                operation: "run-pipeline-stage",
+                detail: "unknown fixture"
+            }))
+    }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, scripted.inner)));
+    const candidate = repo.proposal.candidate.candidate;
+    const plan = await Effect.runPromise(capabilities.invoke({
+        operationId: "multi-plan",
+        request: {
+            tool: "plan_environment",
+            args: {
+                candidate,
+                recipeIds: repo.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+                executionMode: "source",
+                targetRoots: ["packages/main"],
+                requiredArtifacts: [],
+                justification: "Probe helper and test as one workspace."
+            }
+        }
+    }));
+    assert.equal(plan.outcome, "completed", plan.evidenceSummary);
+    const probed = await Effect.runPromise(capabilities.invoke({
+        operationId: "multi-probe",
+        request: {
+            tool: "probe_fixture",
+            args: { candidate, environment: plan.accepted[0], fixtureDraft: "helper-fixture" }
+        }
+    }));
+    assert.equal(probed.outcome, "completed", probed.evidenceSummary);
+    assert.equal(probed.gradeExecuted, true);
+    assert.deepEqual(scripted.calls, []);
+});
+test("a failed frozen challenge is not resampled and repair consumes it as development evidence", async (t) => {
+    const h = await harness(t, true);
+    let operation = 0;
+    const invoke = (request) => Effect.runPromise(h.invoke({ operationId: `fold-${String(++operation)}`, request }));
+    const candidate = h.proposal.candidate.candidate;
+    await invoke({ tool: "draft_specification", args: { candidate } });
+    const planned = await invoke({
+        tool: "plan_environment",
+        args: {
+            candidate,
+            recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source",
+            targetRoots: ["packages/main"],
+            requiredArtifacts: [],
+            justification: "Source regression recipe."
+        }
+    });
+    const environment = planned.accepted[0];
+    await invoke({ tool: "qualify_reference", args: { candidate, environment } });
+    const specification = h.capabilities.handles().spec;
+    await invoke({ tool: "author_oracle", args: { candidate, specification } });
+    await invoke({
+        tool: "generate_controls",
+        args: { candidate, specification, environment, kind: "valid" }
+    });
+    await invoke({
+        tool: "generate_controls",
+        args: { candidate, specification, environment, kind: "wrong" }
+    });
+    await invoke({
+        tool: "evaluate_oracle",
+        args: {
+            candidate,
+            oracle: h.capabilities.handles().oracle,
+            controls: [h.capabilities.handles().controls]
+        }
+    });
+    const frozen = await invoke({
+        tool: "freeze_candidate",
+        args: { candidate, revision: h.proposal.candidate.revision }
+    });
+    assert.equal(frozen.outcome, "completed", frozen.evidenceSummary);
+    const frozenCandidate = frozen.accepted[0];
+    const failed = await invoke({ tool: "run_held_out_challenge", args: { frozenCandidate } });
+    assert.equal(failed.outcome, "scientific_rejection", failed.evidenceSummary);
+    const calls = h.scripted.calls.length;
+    const retried = await invoke({ tool: "run_held_out_challenge", args: { frozenCandidate } });
+    assert.equal(retried.outcome, "scientific_rejection");
+    assert.deepEqual(retried.accepted, failed.accepted);
+    assert.equal(h.scripted.calls.length, calls);
+    const repaired = await invoke({
+        tool: "repair_oracle",
+        args: { candidate, oracle: h.capabilities.handles().oracle, findings: failed.diagnostics }
+    });
+    assert.equal(repaired.outcome, "progress", "the valid disguised adversary is a measured repair finding, not admission");
+    const store = makeCaseCheckpointStoreV1({ caseDirectory: h.stateRoot });
+    const controls = JSON.parse(await readFile(store.stagePath("controls"), "utf8"));
+    assert.ok(controls.wrong.some((control) => control.id === "heldout-truncation"));
+    await assert.rejects(readFile(store.stagePath("challenge")), /ENOENT/u);
+    const old = await invoke({ tool: "run_held_out_challenge", args: { frozenCandidate } });
+    assert.equal(old.outcome, "progress");
+    assert.deepEqual(old.accepted, []);
+});
+test("restoring a seed never treats a legacy compile-only verdict as reference qualification", async (t) => {
+    const h = await harness(t);
+    const candidate = h.proposal.candidate.candidate;
+    const invoke = async (request) => {
+        const result = await Effect.runPromise(h.invoke({
+            operationId: `legacy-seed-${request.tool}`, maximumWallMs: 120_000, request
+        }));
+        assert.equal(result.outcome, "completed", result.evidenceSummary);
+        return result;
+    };
+    await invoke({ tool: "draft_specification", args: { candidate } });
+    const planned = await invoke({
+        tool: "plan_environment",
+        args: {
+            candidate,
+            recipeIds: h.proposal.seed.environment.gradeRecipes.map((recipe) => recipe.id),
+            executionMode: "source", targetRoots: ["packages/main"], requiredArtifacts: [],
+            justification: "Execute the real source recipe."
+        }
+    });
+    await invoke({ tool: "qualify_reference", args: { candidate, environment: planned.accepted[0] } });
+    const path = join(h.stateRoot, "seed.json");
+    const retained = JSON.parse(await readFile(path, "utf8"));
+    await writeFile(path, JSON.stringify({
+        ...retained,
+        seed: {
+            ...retained.seed,
+            preChangeObservations: retained.seed.preChangeObservations.map((row) => ({
+                ...row, detail: "exit=2; stage=candidate-validation; gradeExecuted=false"
+            }))
+        }
+    }));
+    const callsBeforeRestore = h.scripted.calls.length;
+    await assert.rejects(Effect.runPromise(makeEvalCapabilitiesV1({ ...h, runtime, environment: h.capabilities.environment() }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, h.scripted.inner))), /retained seed checkpoint does not satisfy the executed behavioral evidence contract/u);
+    assert.equal(h.scripted.calls.length, callsBeforeRestore);
+});
+for (const interruptDiscovery of [false, true]) {
+    test(`blind controls use initial baseline when regression tests were added (empty discovery=${String(interruptDiscovery)})`, async (t) => {
+        const h = await harness(t, false, 30, "packages/main/src/regression.test.js");
+        const candidate = h.proposal.candidate.candidate;
+        let operation = 0;
+        const invoke = async (request) => {
+            const result = await Effect.runPromise(h.invoke({
+                operationId: `new-test-${String(++operation)}`, maximumWallMs: 120_000, request
+            }));
+            assert.equal(result.outcome, "completed", `${request.tool}: ${result.evidenceSummary}`);
+            return result;
+        };
+        await invoke({ tool: "draft_specification", args: { candidate } });
+        const plan = await invoke({
+            tool: "plan_environment",
+            args: {
+                candidate,
+                recipeIds: h.proposal.seed.environment.gradeRecipes.map(({ id }) => id),
+                executionMode: "source", targetRoots: ["packages/main"], requiredArtifacts: [],
+                justification: "Execute real baseline and newly added regression separately."
+            }
+        });
+        const environment = plan.accepted[0];
+        const prepared = h.capabilities.environment();
+        assert.ok(prepared.environment.gradeRecipes[0].args.includes("src/regression.test.js"));
+        assert.ok(prepared.environment.baselineGradeRecipes[0].args.includes("src/index.test.js"));
+        await invoke({ tool: "qualify_reference", args: { candidate, environment } });
+        const specification = h.capabilities.handles().spec;
+        await invoke({ tool: "author_oracle", args: { candidate, specification } });
+        let commands = 0;
+        let falseSuccesses = 0;
+        for (const kind of ["valid", "wrong"]) {
+            const result = await Effect.runPromise(h.invoke({
+                operationId: `controls-${kind}`, maximumWallMs: 120_000,
+                request: { tool: "generate_controls", args: { candidate, specification, environment, kind } }
+            }).pipe(Effect.provideService(RepositoryCommandExecutionPort, {
+                run: (input) => Effect.gen(function* () {
+                    commands += 1;
+                    assert.ok(input.args.includes("src/index.test.js"));
+                    assert.ok(!input.args.includes("src/regression.test.js"), "blind sanity cannot require the absent reference test");
+                    if (interruptDiscovery && commands === 1) {
+                        falseSuccesses += 1;
+                        return { exitCode: 0, stdout: "TAP version 13\n1..0\n# tests 0\n# pass 0\n# fail 0\n# cancelled 0\n# skipped 0\n# todo 0\n", stderr: "" };
+                    }
+                    const result = yield* Effect.tryPromise({
+                        try: () => exec(input.executable, [...input.args], {
+                            cwd: input.cwd, env: input.environment, timeout: input.timeoutMs
+                        }),
+                        catch: (cause) => new RepositoryFoundryError({ operation: "run-command", detail: "fixture sanity command failed", cause })
+                    });
+                    return { exitCode: 0, stdout: result.stdout, stderr: result.stderr };
+                })
+            })));
+            assert.equal(result.outcome, "completed", result.evidenceSummary);
+        }
+        assert.equal(commands, interruptDiscovery ? 3 : 2, "empty discovery must return feedback and require an actual passing replay");
+        assert.equal(falseSuccesses, interruptDiscovery ? 1 : 0);
+        const checkpoint = JSON.parse(await readFile(join(h.stateRoot, "controls.json"), "utf8"));
+        assert.equal(checkpoint.valid.length, 1);
+        assert.equal(checkpoint.wrong.length, 1);
+        assert.equal(checkpoint.regenerations, interruptDiscovery ? 1 : 0);
+    });
+}