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

package/dist/services/eval-capabilities/service.js

@@ -0,0 +1,1433 @@
+import { Clock, Effect, Option, Schema, Semaphore } from "effect";
+import { evalCapabilityExecutionEnvelopeV1 } from "../../eval-capability-execution-envelope.js";
+import { EVAL_CAPABILITY_SCIENTIFIC_PHASE_POLICY_V1, evalCapabilityScientificAttemptCostV1, evalCapabilityScientificPhaseV1, evalCapabilityScientificProgressPredecessorV1 } from "../../eval-capability-policy.js";
+import { agenticDigestV1, decodeAgenticCapabilityRequestV1, decodeAgenticCapabilityResultV1, decodeAgenticQualityScorecardV1, decodeAgenticScientificProgressReceiptV1, makeAgenticProgressFingerprintV1 } from "../../agentic-capabilities-protocol.js";
+import { replayRepositoryCommandsV1 } from "../../adapters/repository-command-runner.js";
+import { repositoryCommandProbeOutcomeV1 } from "../../adapters/repository-command-evidence.js";
+import { RepositoryHiddenFixtureSuiteV1 } from "../../repository-fixture-protocol.js";
+import { makeCaseCheckpointStoreV1 } from "../../case-checkpoint-store.js";
+import { checkpointDigestV1, PIPELINE_CHECKPOINT_SCHEMAS, PIPELINE_STAGES, RepositoryExecutableSolutionSchemaV1 } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { RepositoryHiddenOracleV1 } from "../../repository-oracle-protocol.js";
+import { evaluateRepositoryOracleScopeCoverageV1 } from "../../repository-oracle-scope-policy.js";
+import { repositoryOracleSolutionObservationsCompleteV1 } from "../../repository-quality-policy.js";
+import { RepositorySpecificationReviewV1 } from "../../repository-specification-critique-protocol.js";
+import { assertRepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { RepositorySeedQualificationProgressV1 } from "../../repository-seed-qualification-progress-protocol.js";
+import { BudgetedLanguageModelLive, budgetExhaustedErrorOfV1, makePipelineStateAccessorV1 } from "../budgeted-model/service.js";
+import { draftEvalCandidateV1 } from "../eval-candidate/service.js";
+import { planEvalEnvironmentV1 } from "../eval-environment/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+import { runPipelineAdmitStageV1, runPipelineChallengeCapabilityV1 } from "../pipeline-challenge/service.js";
+import { runPipelineControlsCapabilityV1 } from "../pipeline-controls/service.js";
+import { runPipelineOracleStageV1 } from "../pipeline-oracle/service.js";
+import { runPipelineTournamentCapabilityV1 } from "../pipeline-tournament/service.js";
+import { qualifyHistoricalTaskSeedAcrossBatchesResumableV1, repositorySeedQualificationProgressSummaryV1 } from "../task-seed/service.js";
+export { EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_MODEL_CALLS_V1, EVAL_CAPABILITY_SCIENTIFIC_MAXIMUM_WALL_TIME_MS_V1, EVAL_CAPABILITY_SCIENTIFIC_PHASE_POLICY_V1, evalCapabilityScientificPhaseV1 } from "../../eval-capability-policy.js";
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "run-pipeline-stage",
+    detail: `${detail}${cause instanceof RepositoryFoundryError ? `: ${cause.detail}` : cause instanceof Error ? `: ${cause.message}` : ""}`,
+    ...(cause === undefined ? {} : { cause })
+});
+const REFERENCE_QUALIFICATION_WORK_CHECKPOINT = "reference-qualification";
+const GROUNDED_WORK_INDEX = "grounded-continuations";
+const GroundedWorkIndexV1 = Schema.Array(Schema.Struct({
+    name: Schema.String,
+    contentDigest: Schema.String,
+    stage: Schema.Literals(PIPELINE_STAGES)
+}));
+const PendingHeldOutCheckpointV1 = Schema.Struct({
+    frozen: Schema.String,
+    agenticPendingHeldOut: RepositoryExecutableSolutionSchemaV1,
+    agenticPendingOracle: Schema.optionalKey(RepositoryHiddenOracleV1)
+});
+export const evalCapabilityArtifactHandleV1 = (stage, value) => `${stage}-${checkpointDigestV1(value)}`;
+const acceptedSpec = (checkpoint) => {
+    const review = Schema.decodeUnknownOption(RepositorySpecificationReviewV1)(checkpoint?.reviews.at(-1));
+    return (Option.isSome(review) &&
+        review.value.verdict === "sufficient" &&
+        review.value.dimensionFit?.outcome === "fit" &&
+        review.value.referenceCompatibility?.outcome === "compatible" &&
+        (review.value.criticalBehaviorCoverage?.every((entry) => entry.outcome === "covered") ??
+            false) &&
+        !review.value.findings.some((entry) => entry.severity === "blocker"));
+};
+const CANDIDATE_ALLOWED_CAPABILITIES = [
+    "get_progress",
+    "draft_specification",
+    "plan_environment",
+    "qualify_reference",
+    "author_oracle",
+    "generate_controls",
+    "evaluate_oracle",
+    "repair_oracle",
+    "freeze_candidate",
+    "run_held_out_challenge",
+    "request_admission",
+    "reject_candidate"
+];
+const measureSolutions = (oracle, expected, evidence) => {
+    const solutions = oracle?.solutions.filter((solution) => solution.expectedClass === expected) ?? [];
+    let passed = 0;
+    let failed = 0;
+    let missing = solutions.length === 0 ? 1 : 0;
+    for (const solution of solutions) {
+        const observations = oracle.observations.filter((row) => row.solutionId === solution.id);
+        if (!repositoryOracleSolutionObservationsCompleteV1(oracle, solution.id)) {
+            missing += 1;
+            continue;
+        }
+        const discriminated = expected === "valid"
+            ? observations.every((row) => row.outcome === "pass")
+            : observations.some((row) => row.outcome === "fail");
+        if (discriminated)
+            passed += 1;
+        else
+            failed += 1;
+    }
+    return { passed, failed, missing, evidence: solutions.length === 0 ? [] : evidence };
+};
+/** Measurements cite executed checkpoint evidence. Draft/model assertions never count as observed quality. */
+export const evalCandidateQualityScorecardV1 = (input) => {
+    const c = input.checkpoints;
+    const handle = (stage) => c[stage] === undefined ? [] : [evalCapabilityArtifactHandleV1(stage, c[stage])];
+    const reference = c.seed === undefined
+        ? { passed: 0, failed: 0, missing: 1, evidence: [] }
+        : {
+            passed: c.seed.qualification.stability.stable && c.seed.seed.status === "qualified"
+                ? c.seed.qualification.stability.batches.length
+                : 0,
+            failed: c.seed.seed.status === "rejected" ? 1 : 0,
+            missing: c.seed.seed.status === "qualified" ? 0 : 1,
+            evidence: handle("seed")
+        };
+    const validControls = measureSolutions(c.tournament?.oracle, "valid", handle("tournament"));
+    const wrongControls = measureSolutions(c.tournament?.oracle, "wrong", handle("tournament"));
+    const heldOut = measureSolutions(c.challenge?.oracle, "wrong", handle("challenge"));
+    const admitted = c.admit?.verdict === "admitted";
+    return decodeAgenticQualityScorecardV1({
+        version: 1,
+        candidate: input.candidate,
+        revision: input.revision,
+        reference,
+        validControls,
+        wrongControls,
+        heldOut,
+        // Scope coverage is executed by the existing admission service, not inferred from model self-reports.
+        coverage: (c.spec?.scope ?? []).map((scope) => ({
+            cell: scope.id,
+            observed: admitted,
+            evidence: admitted ? handle("admit") : []
+        })),
+        disposition: admitted
+            ? "admitted"
+            : (input.disposition ??
+                (c.admit?.verdict === "rejected"
+                    ? "rejected"
+                    : c.seed?.seed.status === "qualified"
+                        ? "qualified"
+                        : "draft")),
+        reasons: [...new Set([...(input.reasons ?? []), ...(c.admit?.reasons ?? [])])].slice(0, 32),
+        missingEvidence: [
+            reference.missing > 0 ? "reference" : undefined,
+            validControls.missing > 0 ? "valid_controls" : undefined,
+            wrongControls.missing > 0 ? "wrong_controls" : undefined,
+            heldOut.missing > 0 ? "held_out" : undefined
+        ].filter((entry) => entry !== undefined),
+        usage: {
+            elapsedMs: Math.max(0, Math.trunc(input.elapsedMs)),
+            receivedCalls: input.receivedCalls,
+            spendKnownUsd: input.spendKnownUsd ?? "0",
+            spendUnknown: input.spendUnknown ?? input.receivedCalls > 0
+        },
+        admission: admitted ? evalCapabilityArtifactHandleV1("admit", c.admit) : null
+    });
+};
+/**
+ * One scientific capability is allowed enough time to finish a complete
+ * repository-grounded role chain (analysis, visible authoring, and private
+ * review) under normal provider tail latency. Cloud admission and the sandbox
+ * executor import this same value so the host never reserves a shorter slice
+ * than the worker can use.
+ */
+const scientificRoleForCapability = (capability) => {
+    switch (capability) {
+        case "draft_specification":
+            return "specification-author";
+        case "plan_environment":
+        case "probe_fixture":
+        case "qualify_reference":
+            return "seed-author";
+        case "author_oracle":
+            return "oracle-author";
+        case "generate_controls":
+            return "control-author";
+        case "evaluate_oracle":
+        case "repair_oracle":
+            return "oracle-critic";
+        case "run_held_out_challenge":
+            return "adversary-author";
+        case "request_admission":
+            return "admission-reviewer";
+        default:
+            return "eval-orchestrator";
+    }
+};
+const scientificStageForCapability = (capability) => {
+    switch (capability) {
+        case "draft_specification":
+            return "spec";
+        case "plan_environment":
+        case "probe_fixture":
+        case "qualify_reference":
+            return "seed";
+        case "author_oracle":
+            return "oracle";
+        case "generate_controls":
+            return "controls";
+        case "evaluate_oracle":
+        case "repair_oracle":
+            return "tournament";
+        case "run_held_out_challenge":
+            return "challenge";
+        case "request_admission":
+            return "admit";
+        default:
+            return null;
+    }
+};
+const sameProgressFingerprint = (left, right) => left.acceptedEvidenceDigest === right.acceptedEvidenceDigest &&
+    left.completedGateDigest === right.completedGateDigest &&
+    left.environmentDigest === right.environmentDigest &&
+    (left.continuationProgressDigest ?? null) ===
+        (right.continuationProgressDigest ?? null);
+const NON_SCIENTIFIC_DIGEST_KEYS = new Set([
+    "callId",
+    "completedAt",
+    "createdAt",
+    "durationMs",
+    "elapsedMs",
+    "observedAt",
+    "operationId",
+    "requestId",
+    "startedAt",
+    "updatedAt"
+]);
+export const acceptedScientificDigestV1 = (value) => {
+    const normalize = (current) => {
+        if (Array.isArray(current))
+            return current.map(normalize);
+        if (typeof current !== "object" || current === null)
+            return current;
+        return Object.fromEntries(Object.entries(current)
+            .filter(([key]) => !NON_SCIENTIFIC_DIGEST_KEYS.has(key))
+            .map(([key, nested]) => [key, normalize(nested)]));
+    };
+    return agenticDigestV1(normalize(value));
+};
+/**
+ * One candidate's trusted scientific runtime. The caller resolves campaign/source/model authority;
+ * tool JSON supplies handles, never context, checkpoint maps, or provider identities.
+ * The supplied store owns persistence; immutable artifact snapshots precede each mutable head.
+ */
+export const makeEvalCapabilitiesV1 = Effect.fn("EvalCapabilities.make")(function* (input) {
+    const inner = yield* RepositoryFoundryLanguageModel;
+    const store = input.store ?? makeCaseCheckpointStoreV1({ caseDirectory: input.context.caseDirectory });
+    const restoredGroundedWork = yield* store.readWorkCheckpoint(GROUNDED_WORK_INDEX, GroundedWorkIndexV1);
+    const groundedWork = new Map(Option.isSome(restoredGroundedWork)
+        ? restoredGroundedWork.value.map((entry) => [entry.name, entry])
+        : []);
+    const groundedContinuationValue = () => ({
+        version: 1,
+        candidateRevision: input.proposal.candidate.revision,
+        checkpoints: [...groundedWork.values()].sort((left, right) => left.name.localeCompare(right.name))
+    });
+    const groundedArtifact = () => {
+        if (groundedWork.size === 0)
+            return undefined;
+        const contentDigest = acceptedScientificDigestV1(groundedContinuationValue());
+        return {
+            handle: `continuation-progress-grounded-${contentDigest}`,
+            contentDigest,
+            kind: "continuation_progress"
+        };
+    };
+    const saveGroundedIndex = () => store.writeWorkCheckpoint(GROUNDED_WORK_INDEX, [...groundedWork.values()]);
+    const workPersistence = yield* Semaphore.make(1);
+    const workCheckpointStoreFor = (stage) => ({
+        ...store,
+        writeWorkCheckpoint: (name, value) => workPersistence.withPermit(Effect.gen(function* () {
+            yield* store.writeWorkCheckpoint(name, value);
+            if (!name.startsWith("grounded-authoring-") &&
+                !name.startsWith("model-feedback-") &&
+                !name.startsWith("pipeline-execution-"))
+                return;
+            groundedWork.set(name, { name, stage, contentDigest: acceptedScientificDigestV1(value) });
+            yield* saveGroundedIndex();
+        })).pipe(Effect.uninterruptible)
+    });
+    let prepared = input.environment;
+    const retainedQualificationProgress = yield* store.readWorkCheckpoint(REFERENCE_QUALIFICATION_WORK_CHECKPOINT, RepositorySeedQualificationProgressV1);
+    let qualificationProgress = Option.isSome(retainedQualificationProgress)
+        ? retainedQualificationProgress.value
+        : undefined;
+    const candidate = input.proposal.candidate;
+    const acceptedScientificArtifacts = new Map((input.acceptedScientificArtifacts ?? []).map((artifact) => [
+        artifact.handle,
+        artifact
+    ]));
+    const initialProgressReceipts = [...(input.progressReceipts ?? [])];
+    let checkpoints = {};
+    const tournamentReady = () => checkpoints.tournament?.adequacy.admitted === true &&
+        checkpoints.spec !== undefined &&
+        checkpoints.oracle !== undefined &&
+        evaluateRepositoryOracleScopeCoverageV1({
+            spec: checkpoints.spec, oracleCheckpoint: checkpoints.oracle,
+            oracle: checkpoints.tournament.oracle,
+            repetitions: input.context.oracleRepetitions, label: "development"
+        }).reasons.length === 0;
+    let pendingChallenge;
+    for (const stage of PIPELINE_STAGES) {
+        if (stage === "challenge") {
+            const value = yield* store.readStage(stage, Schema.Union([PIPELINE_CHECKPOINT_SCHEMAS.challenge, PendingHeldOutCheckpointV1]));
+            if (Option.isSome(value)) {
+                if ("stage" in value.value)
+                    checkpoints = { ...checkpoints, challenge: value.value };
+                else
+                    pendingChallenge = value.value;
+            }
+            continue;
+        }
+        const value = yield* store.readStage(stage, PIPELINE_CHECKPOINT_SCHEMAS[stage]);
+        if (Option.isSome(value))
+            checkpoints = { ...checkpoints, [stage]: value.value };
+    }
+    if (checkpoints.seed !== undefined) {
+        yield* Effect.try({
+            try: () => assertRepositoryTaskSeedV1(checkpoints.seed.seed),
+            catch: (cause) => new RepositoryFoundryError({
+                operation: "extract-task-seeds",
+                classification: "environment_blocked",
+                detail: "retained seed checkpoint does not satisfy the executed behavioral evidence contract; select another candidate or repair the grading environment",
+                cause
+            })
+        });
+    }
+    const existingState = yield* store.readState;
+    const startedAt = yield* Clock.currentTimeMillis;
+    const initialState = Option.isSome(existingState)
+        ? existingState.value
+        : {
+            version: 1,
+            caseId: input.context.caseId,
+            repositoryRoot: input.context.repositoryRoot,
+            dimension: input.context.dimension,
+            model: input.context.primaryModel,
+            identityDigest: candidate.revision,
+            stage: "seed",
+            status: "running",
+            startedAt: new Date(startedAt).toISOString(),
+            updatedAt: new Date(startedAt).toISOString(),
+            modelCalls: 0,
+            elapsedMs: 0,
+            resumeCount: 0,
+            folds: 0
+        };
+    if (initialState.identityDigest !== candidate.revision ||
+        initialState.caseId !== input.context.caseId)
+        return yield* failure("candidate store belongs to a different immutable proposal");
+    const state = yield* makePipelineStateAccessorV1(initialState);
+    const persist = (stage, value) => Effect.gen(function* () {
+        // Normalize before hashing, exactly like legacy checkpoint persistence.
+        // Runtime oracle solutions may carry execution-only fields that the persisted
+        // schema drops; hashing those would make every restored parent handle stale.
+        const checkpoint = yield* Schema.decodeUnknownEffect(PIPELINE_CHECKPOINT_SCHEMAS[stage])(value).pipe(Effect.mapError((cause) => failure("invalid scientific checkpoint", cause)));
+        const contentDigest = checkpointDigestV1(checkpoint);
+        const artifact = {
+            handle: evalCapabilityArtifactHandleV1(stage, checkpoint),
+            stage,
+            contentDigest,
+            checkpoint
+        };
+        yield* store.writeCall(`artifact-${contentDigest}`, 1, {
+            request: { stage },
+            response: checkpoint
+        });
+        if (input.onArtifact !== undefined)
+            yield* input.onArtifact(artifact);
+        yield* store.writeStage(stage, checkpoint);
+        checkpoints = { ...checkpoints, [stage]: checkpoint };
+        // A completed stage supersedes its authoring continuation. Keep the
+        // durable work for crash recovery, but never advertise it as another gate.
+        const complete = stage === "spec"
+            ? acceptedSpec(checkpoints.spec)
+            : stage === "oracle" ||
+                (stage === "controls" &&
+                    (checkpoints.controls?.valid.length ?? 0) > 0 &&
+                    (checkpoints.controls?.wrong.length ?? 0) > 0) ||
+                stage === "challenge" ||
+                (stage === "tournament" && tournamentReady());
+        if (complete) {
+            for (const [name, entry] of groundedWork) {
+                if (entry.stage === stage)
+                    groundedWork.delete(name);
+            }
+            yield* saveGroundedIndex();
+        }
+        acceptedScientificArtifacts.set(artifact.handle, {
+            handle: artifact.handle,
+            contentDigest: acceptedScientificDigestV1(checkpoint),
+            kind: stage
+        });
+    });
+    const stageInput = (stage) => ({
+        context: input.context,
+        map: input.map,
+        checkpoints,
+        workCheckpointStore: workCheckpointStoreFor(stage),
+        checkpoint: (value) => persist(stage, value).pipe(Effect.orDie)
+    });
+    const getHandle = (stage) => checkpoints[stage] === undefined
+        ? undefined
+        : evalCapabilityArtifactHandleV1(stage, checkpoints[stage]);
+    const scientificInputs = () => ({
+        sourceDigest: candidate.sourceDigest,
+        environmentDigest: agenticDigestV1(prepared?.plan ?? checkpoints.seed?.seed.environment ?? null),
+        specificationDigest: checkpointDigestV1(checkpoints.spec ?? null),
+        oracleDigest: checkpointDigestV1(checkpoints.oracle ?? null),
+        controlsDigest: checkpointDigestV1(checkpoints.controls ?? null),
+        policyDigest: agenticDigestV1({
+            repetitions: input.context.oracleRepetitions,
+            foldLimit: input.context.foldLimit
+        }),
+        modelPlanDigest: agenticDigestV1(input.context.modelPlan)
+    });
+    const frozenHandle = () => `frozen-${agenticDigestV1({ candidate: candidate.revision, inputs: scientificInputs(), tournament: checkpointDigestV1(checkpoints.tournament ?? null) })}`;
+    const qualificationBindingDigest = (environment = prepared) => environment === undefined
+        ? undefined
+        : agenticDigestV1({
+            version: 2,
+            candidateRevision: candidate.revision,
+            sourceDigest: candidate.sourceDigest,
+            initialCommit: input.proposal.seed.initialState.commit,
+            referenceCommit: input.proposal.seed.referenceCommit,
+            environment: environment.environment,
+            executionMode: environment.plan.executionMode,
+            runtime: environment.plan.runtime,
+            batchesRequired: 2,
+            repetitionsPerBatch: 2
+        });
+    const qualificationProgressArtifact = () => {
+        const bindingDigest = qualificationBindingDigest();
+        if (qualificationProgress === undefined ||
+            bindingDigest === undefined ||
+            qualificationProgress.bindingDigest !== bindingDigest)
+            return undefined;
+        const contentDigest = acceptedScientificDigestV1(qualificationProgress);
+        return {
+            handle: `qualification-progress-${contentDigest}`,
+            contentDigest,
+            kind: "qualification_progress"
+        };
+    };
+    const persistQualificationProgress = (progress) => {
+        const handle = `qualification-progress-${acceptedScientificDigestV1(progress)}`;
+        return store
+            .writeWorkCheckpoint(REFERENCE_QUALIFICATION_WORK_CHECKPOINT, progress)
+            .pipe(Effect.andThen(store.writeCall(handle, 1, {
+            request: {
+                tool: "qualify_reference",
+                candidateRevision: candidate.revision
+            },
+            response: progress
+        })), Effect.tap(() => Effect.sync(() => {
+            qualificationProgress = progress;
+        })));
+    };
+    const challengeContinuationValue = (pending) => ({
+        version: 1,
+        capability: "run_held_out_challenge",
+        candidateRevision: candidate.revision,
+        bindingDigest: agenticDigestV1(pending.frozen),
+        checkpoint: pending
+    });
+    const challengeProgressArtifact = () => {
+        if (pendingChallenge === undefined ||
+            checkpoints.challenge !== undefined ||
+            pendingChallenge.frozen !== frozenHandle())
+            return undefined;
+        const contentDigest = acceptedScientificDigestV1(challengeContinuationValue(pendingChallenge));
+        return {
+            handle: `continuation-progress-challenge-${contentDigest}`,
+            contentDigest,
+            kind: "continuation_progress"
+        };
+    };
+    const persistChallengeProgress = (pending) => Effect.gen(function* () {
+        // Normalize before both persistence and hashing so restoration yields
+        // exactly the same accepted continuation, including metadata-only oracle solutions.
+        const checkpoint = yield* Schema.decodeUnknownEffect(PendingHeldOutCheckpointV1)(pending).pipe(Effect.mapError((cause) => failure("invalid held-out continuation", cause)));
+        const value = challengeContinuationValue(checkpoint);
+        const handle = `continuation-progress-challenge-${acceptedScientificDigestV1(value)}`;
+        yield* store.writeCall(handle, 1, {
+            request: { tool: "run_held_out_challenge", candidateRevision: candidate.revision },
+            response: value
+        });
+        yield* store.writeStage("challenge", checkpoint);
+        pendingChallenge = checkpoint;
+    }).pipe(Effect.uninterruptible, Effect.orDie);
+    const completedScientificGates = () => {
+        const gates = [];
+        if (prepared !== undefined)
+            gates.push("environment_planned");
+        if (acceptedSpec(checkpoints.spec))
+            gates.push("specification_accepted");
+        if (checkpoints.seed?.seed.status === "qualified")
+            gates.push("reference_qualified");
+        if (checkpoints.oracle !== undefined)
+            gates.push("oracle_authored");
+        if ((checkpoints.controls?.valid.length ?? 0) > 0)
+            gates.push("valid_controls_generated");
+        if ((checkpoints.controls?.wrong.length ?? 0) > 0)
+            gates.push("wrong_controls_generated");
+        if (tournamentReady())
+            gates.push("oracle_evaluated");
+        if (acceptedScientificArtifacts.has(frozenHandle()))
+            gates.push("candidate_frozen");
+        if (checkpoints.challenge?.verdict === "passed")
+            gates.push("held_out_challenge_passed");
+        if (checkpoints.admit?.verdict === "admitted")
+            gates.push("candidate_admitted");
+        return gates;
+    };
+    const currentScientificArtifacts = () => {
+        const current = PIPELINE_STAGES.flatMap((stage) => {
+            const checkpoint = checkpoints[stage];
+            if (checkpoint === undefined)
+                return [];
+            return [
+                {
+                    handle: evalCapabilityArtifactHandleV1(stage, checkpoint),
+                    contentDigest: acceptedScientificDigestV1(checkpoint),
+                    kind: stage
+                }
+            ];
+        });
+        if (prepared !== undefined) {
+            current.push({
+                handle: prepared.plan.planId,
+                contentDigest: acceptedScientificDigestV1(prepared),
+                kind: "environment"
+            });
+        }
+        const continuation = qualificationProgressArtifact();
+        if (continuation !== undefined)
+            current.push(continuation);
+        const challengeContinuation = challengeProgressArtifact();
+        if (challengeContinuation !== undefined)
+            current.push(challengeContinuation);
+        const groundedContinuation = groundedArtifact();
+        if (groundedContinuation !== undefined)
+            current.push(groundedContinuation);
+        for (const artifact of acceptedScientificArtifacts.values()) {
+            if (artifact.kind === "observation" ||
+                (artifact.kind === "frozen_candidate" && artifact.handle === frozenHandle())) {
+                current.push(artifact);
+            }
+        }
+        return [
+            ...new Map(current.map((artifact) => [
+                `${artifact.kind}:${artifact.contentDigest}`,
+                artifact
+            ])).values()
+        ].sort((left, right) => `${left.kind}:${left.contentDigest}`.localeCompare(`${right.kind}:${right.contentDigest}`));
+    };
+    const scientificFingerprint = () => makeAgenticProgressFingerprintV1({
+        acceptedEvidence: currentScientificArtifacts(),
+        completedGates: completedScientificGates(),
+        environmentDigest: prepared === undefined ? null : acceptedScientificDigestV1(prepared.plan)
+    });
+    const requireHandle = (received, expected, label) => {
+        if (expected === undefined || received !== expected)
+            throw failure(`unaccepted or stale ${label} handle`);
+    };
+    const readyToFreeze = () => checkpoints.seed?.seed.status === "qualified" &&
+        acceptedSpec(checkpoints.spec) &&
+        checkpoints.oracle !== undefined &&
+        checkpoints.controls !== undefined &&
+        checkpoints.controls.valid.length > 0 &&
+        checkpoints.controls.wrong.length > 0 &&
+        tournamentReady();
+    const assertReady = () => {
+        if (!readyToFreeze())
+            throw failure("freeze requires executed reference, reviewed specification, controls and an adequate tournament");
+        const seed = checkpoints.seed;
+        if (seed === undefined)
+            throw failure("freeze requires a qualified seed checkpoint");
+        assertRepositoryTaskSeedV1(seed.seed);
+        for (const [parent, child] of [
+            ["seed", "spec"],
+            ["spec", "oracle"],
+            ["oracle", "controls"],
+            ["controls", "tournament"]
+        ]) {
+            if (checkpoints[child].parentDigest !== checkpointDigestV1(checkpoints[parent]))
+                throw failure(`stale ${child} evidence does not bind the current ${parent}`);
+        }
+    };
+    /**
+     * One prerequisite registry drives both capability advertisement and
+     * execution admission. Argument-handle validation remains capability-local,
+     * but the host can no longer advertise a transition that the same runtime
+     * will deterministically reject for missing scientific state.
+     */
+    const hasCapabilityPrerequisites = (capability) => {
+        const specificationAccepted = acceptedSpec(checkpoints.spec);
+        const referenceQualified = checkpoints.seed?.seed.status === "qualified";
+        const environmentPlanned = prepared !== undefined;
+        const oracleAuthored = checkpoints.oracle !== undefined;
+        const controlsGenerated = checkpoints.controls !== undefined &&
+            (checkpoints.controls.valid.length > 0 ||
+                checkpoints.controls.wrong.length > 0);
+        const challengeBindsCurrentTournament = checkpoints.challenge !== undefined &&
+            checkpoints.challenge.parentDigest ===
+                checkpointDigestV1(checkpoints.tournament ?? null);
+        // A persisted challenge is itself durable proof that the current
+        // tournament was frozen. This keeps replay/admission available after a
+        // process restart even when the caller does not rehydrate call artifacts.
+        const frozen = acceptedScientificArtifacts.has(frozenHandle()) ||
+            challengeBindsCurrentTournament;
+        switch (capability) {
+            case "get_progress":
+            case "reject_candidate":
+            case "finish_campaign":
+                return true;
+            case "draft_specification":
+                return !referenceQualified;
+            case "plan_environment":
+                return !referenceQualified;
+            case "probe_fixture":
+                return environmentPlanned && !referenceQualified;
+            case "qualify_reference":
+                return specificationAccepted && environmentPlanned && !referenceQualified;
+            case "author_oracle":
+                return specificationAccepted && referenceQualified;
+            case "generate_controls":
+                return (specificationAccepted &&
+                    referenceQualified &&
+                    environmentPlanned &&
+                    oracleAuthored &&
+                    checkpoints.challenge === undefined);
+            case "evaluate_oracle":
+            case "repair_oracle":
+                return oracleAuthored && controlsGenerated;
+            case "freeze_candidate":
+                return readyToFreeze();
+            case "run_held_out_challenge":
+                return readyToFreeze() && frozen;
+            case "request_admission":
+                return (readyToFreeze() &&
+                    frozen &&
+                    checkpoints.challenge?.verdict === "passed");
+            default:
+                return false;
+        }
+    };
+    const currentScorecard = (disposition, reasons) => Effect.gen(function* () {
+        const current = yield* state.get;
+        const scorecard = yield* Effect.try({
+            try: () => evalCandidateQualityScorecardV1({
+                candidate: candidate.candidate,
+                revision: candidate.revision,
+                checkpoints,
+                disposition,
+                reasons,
+                elapsedMs: current.elapsedMs,
+                receivedCalls: current.modelCalls
+            }),
+            catch: (cause) => failure("could not encode candidate quality evidence", cause)
+        });
+        yield* store.writeCall(`scorecard-${agenticDigestV1(scorecard)}`, 1, {
+            request: { candidate: candidate.candidate },
+            response: scorecard
+        });
+        if (input.onScorecard !== undefined)
+            yield* input.onScorecard(scorecard);
+        return scorecard;
+    });
+    const invoke = Effect.fn("EvalCapabilities.invoke")(function* (invocation) {
+        const request = yield* Effect.try({
+            try: () => decodeAgenticCapabilityRequestV1(invocation.request),
+            catch: (cause) => failure("invalid capability request", cause)
+        });
+        const before = yield* state.get;
+        const invocationStartedAt = yield* Clock.currentTimeMillis;
+        const scientificPhase = evalCapabilityScientificPhaseV1(request.tool);
+        const phasePolicy = scientificPhase === null
+            ? null
+            : EVAL_CAPABILITY_SCIENTIFIC_PHASE_POLICY_V1[scientificPhase];
+        const beforeArtifacts = currentScientificArtifacts();
+        const beforeArtifactHandles = new Set(beforeArtifacts.map((artifact) => artifact.handle));
+        const beforeGates = completedScientificGates();
+        const beforeFingerprint = scientificFingerprint();
+        const progressReceipts = [
+            ...(invocation.authoritativeProgressReceipts ?? initialProgressReceipts)
+        ].sort((left, right) => left.recordedAt.localeCompare(right.recordedAt));
+        const latestProgressReceipt = evalCapabilityScientificProgressPredecessorV1({
+            capability: request.tool,
+            fingerprint: beforeFingerprint,
+            history: progressReceipts
+        });
+        const repeatedUnchangedCapability = latestProgressReceipt !== undefined &&
+            latestProgressReceipt.capability === request.tool &&
+            latestProgressReceipt.sameFingerprintCount >= 2 &&
+            sameProgressFingerprint(latestProgressReceipt.resultingFingerprint, beforeFingerprint);
+        const phaseReceipts = scientificPhase === null
+            ? []
+            : progressReceipts.filter((receipt) => receipt.phase === scientificPhase);
+        const phaseAttemptsConsumed = phaseReceipts.reduce((total, receipt) => total + evalCapabilityScientificAttemptCostV1(receipt), 0);
+        const parsedDeadline = invocation.deadlineAt === undefined ? undefined : Date.parse(invocation.deadlineAt);
+        if (parsedDeadline !== undefined && !Number.isFinite(parsedDeadline))
+            return yield* failure("invalid capability deadline");
+        const campaignWallTimeRemainingAtStart = Math.max(0, parsedDeadline === undefined
+            ? input.context.budget.maxWallMs - before.elapsedMs
+            : parsedDeadline - invocationStartedAt);
+        const envelopeDecision = evalCapabilityExecutionEnvelopeV1({
+            capability: request.tool,
+            ...(invocation.maximumModelCalls === undefined
+                ? {}
+                : { requestedMaximumModelCalls: invocation.maximumModelCalls }),
+            ...(invocation.maximumWallMs === undefined
+                ? {}
+                : { requestedMaximumWallMs: invocation.maximumWallMs }),
+            campaignModelCallsRemaining: input.context.budget.maxModelCalls - before.modelCalls,
+            campaignWallTimeRemainingMs: campaignWallTimeRemainingAtStart
+        });
+        const downstreamCalls = envelopeDecision.downstreamReserve.calls;
+        const downstreamWallTimeMs = envelopeDecision.downstreamReserve.wallTimeMs;
+        const finalizationWallTimeMs = envelopeDecision.finalizationReserve.wallTimeMs;
+        const phaseAttemptsAvailable = phasePolicy === null
+            ? Number.MAX_SAFE_INTEGER
+            : Math.max(0, phasePolicy.maximumAttempts - phaseAttemptsConsumed);
+        const maximumCalls = envelopeDecision.admitted
+            ? envelopeDecision.envelope.maximumModelCalls
+            : 1;
+        const maximumWallMs = envelopeDecision.admitted
+            ? envelopeDecision.envelope.maximumWallTimeMs
+            : 1;
+        const budget = {
+            maxModelCalls: Math.min(input.context.budget.maxModelCalls, before.modelCalls + maximumCalls),
+            maxWallMs: Math.min(input.context.budget.maxWallMs, before.elapsedMs + maximumWallMs)
+        };
+        const accepted = [];
+        let gradeExecuted;
+        let detail = "Capability completed; inspect accepted evidence before advancing.";
+        let disposition;
+        let outcome = "completed";
+        let yieldedAtSliceBoundary = false;
+        let completedLogicalAttempt = false;
+        const execute = Effect.gen(function* () {
+            if (repeatedUnchangedCapability) {
+                outcome = "scientific_rejection";
+                disposition = "rejected";
+                detail =
+                    "Scientific no-progress circuit opened after two unchanged results for this capability. The third unchanged attempt was rejected before model, repository, or grader work, preserving downstream reserves.";
+                return;
+            }
+            if (!envelopeDecision.admitted ||
+                (scientificPhase !== null && phaseAttemptsAvailable <= 0)) {
+                outcome = "budget_exhausted";
+                detail = scientificPhase === null
+                    ? "The capability cannot fit within the remaining campaign budget."
+                    : "The host-owned scientific phase budget cannot admit this operation without consuming the mandatory downstream reserve.";
+                return;
+            }
+            yield* Effect.try({
+                try: () => {
+                    if ("candidate" in request.args && request.args.candidate !== undefined)
+                        requireHandle(request.args.candidate, candidate.candidate, "candidate");
+                },
+                catch: (cause) => cause instanceof RepositoryFoundryError
+                    ? cause
+                    : failure("candidate handle validation failed", cause)
+            });
+            if ((before.status === "admitted" || before.status === "rejected") &&
+                request.tool !== "get_progress" &&
+                request.tool !== "finish_campaign")
+                return yield* failure("terminal candidate is immutable; inspect it or start a new candidate revision");
+            if (scientificPhase !== null &&
+                (before.modelCalls >= input.context.budget.maxModelCalls ||
+                    campaignWallTimeRemainingAtStart <= 0)) {
+                outcome = "budget_exhausted";
+                return;
+            }
+            if (!hasCapabilityPrerequisites(request.tool)) {
+                return yield* failure(request.tool === "freeze_candidate"
+                    ? "candidate is not ready to freeze"
+                    : request.tool === "qualify_reference"
+                        ? "reference qualification requires an accepted grounded specification review"
+                        : `${request.tool} prerequisites are not satisfied by the accepted candidate state`);
+            }
+            switch (request.tool) {
+                case "draft_specification": {
+                    if (checkpoints.seed?.seed.status === "qualified") {
+                        outcome = "progress";
+                        detail =
+                            "Reference already qualified; use the retained source specification or start a new candidate revision.";
+                        break;
+                    }
+                    const spec = yield* draftEvalCandidateV1({
+                        proposal: input.proposal,
+                        context: input.context,
+                        map: input.map,
+                        previous: checkpoints.spec,
+                        workCheckpointStore: workCheckpointStoreFor("spec"),
+                        checkpoint: (value) => persist("spec", value).pipe(Effect.orDie)
+                    });
+                    accepted.push(evalCapabilityArtifactHandleV1("spec", spec));
+                    if (!acceptedSpec(spec)) {
+                        outcome = "progress";
+                        detail =
+                            "Source-grounded draft retained with review findings; revise before qualification.";
+                    }
+                    break;
+                }
+                case "plan_environment": {
+                    if (checkpoints.seed?.seed.status === "qualified")
+                        return yield* failure("qualified environments are immutable; create a new candidate revision to change preparation");
+                    const planned = yield* planEvalEnvironmentV1({
+                        repositoryRoot: input.context.repositoryRoot,
+                        candidate: candidate.candidate,
+                        revision: candidate.revision,
+                        sourceDigest: candidate.sourceDigest,
+                        seed: input.proposal.seed,
+                        recipeIds: request.args.recipeIds,
+                        executionMode: request.args.executionMode,
+                        requiredArtifacts: request.args.requiredArtifacts,
+                        runtime: input.runtime,
+                        justification: request.args.justification
+                    });
+                    // Explanatory rewrites are not environment repairs. Preserve the
+                    // accepted handle and failed-unit evidence when executable inputs
+                    // are unchanged; only a real plan change may restart qualification.
+                    prepared =
+                        prepared === undefined ||
+                            qualificationBindingDigest(planned) !== qualificationBindingDigest() ||
+                            agenticDigestV1(planned.plan.requiredArtifacts) !==
+                                agenticDigestV1(prepared.plan.requiredArtifacts)
+                            ? planned
+                            : prepared;
+                    if (qualificationProgress !== undefined &&
+                        qualificationProgress.bindingDigest !== qualificationBindingDigest()) {
+                        yield* store.deleteWorkCheckpoint(REFERENCE_QUALIFICATION_WORK_CHECKPOINT);
+                        qualificationProgress = undefined;
+                    }
+                    yield* store.writeCall(prepared.plan.planId, 1, { request, response: prepared });
+                    acceptedScientificArtifacts.set(prepared.plan.planId, {
+                        handle: prepared.plan.planId,
+                        contentDigest: acceptedScientificDigestV1(prepared),
+                        kind: "environment"
+                    });
+                    if (input.onEnvironment !== undefined)
+                        yield* input.onEnvironment(prepared);
+                    accepted.push(prepared.plan.planId);
+                    break;
+                }
+                case "probe_fixture": {
+                    if (prepared === undefined) {
+                        outcome = "environment_blocked";
+                        gradeExecuted = false;
+                        detail = "Select an explicit environment plan before repository execution.";
+                        break;
+                    }
+                    yield* Effect.try({
+                        try: () => requireHandle(request.args.environment, prepared.plan.planId, "environment"),
+                        catch: (cause) => failure("invalid environment handle", cause)
+                    });
+                    if (input.resolveFixtureDraft === undefined)
+                        return yield* failure("fixture draft handle resolver is unavailable; no grade was executed");
+                    const suite = yield* input.resolveFixtureDraft(request.args.fixtureDraft).pipe(Effect.flatMap((value) => Schema.decodeUnknownEffect(RepositoryHiddenFixtureSuiteV1)(value)), Effect.mapError((cause) => failure("invalid fixture draft", cause)));
+                    // A diagnostic probe materializes one workspace. Helpers and test files
+                    // must coexist; this is not the independent-overlay scientific admission gate.
+                    if (suite.overlays.length === 0 ||
+                        new Set(suite.overlays.map((overlay) => overlay.path)).size !== suite.overlays.length)
+                        return yield* failure("a fixture probe requires a nonempty workspace with distinct overlay paths");
+                    const results = yield* replayRepositoryCommandsV1({
+                        repositoryRoot: input.context.repositoryRoot,
+                        commit: input.proposal.seed.referenceCommit ?? input.proposal.seed.initialState.commit,
+                        recipes: prepared.environment.gradeRecipes,
+                        trustedPreparationRecipes: prepared.environment.trustedPreparationRecipes,
+                        candidateValidationRecipes: prepared.environment.candidateValidationRecipes,
+                        contentOverlays: suite.overlays.map(({ path, content }) => ({ path, content })),
+                        repetitions: 1
+                    });
+                    outcome = repositoryCommandProbeOutcomeV1(results);
+                    gradeExecuted = outcome !== "environment_blocked";
+                    const probe = { suiteDigest: agenticDigestV1(suite), results, gradeExecuted, outcome };
+                    const handle = `probe-${agenticDigestV1(probe)}`;
+                    yield* store.writeCall(handle, 1, { request, response: probe });
+                    acceptedScientificArtifacts.set(handle, {
+                        handle,
+                        contentDigest: acceptedScientificDigestV1(probe),
+                        kind: "observation"
+                    });
+                    accepted.push(handle);
+                    break;
+                }
+                case "qualify_reference": {
+                    if (!acceptedSpec(checkpoints.spec))
+                        return yield* failure("reference qualification requires an accepted grounded specification review");
+                    if (prepared === undefined) {
+                        outcome = "environment_blocked";
+                        gradeExecuted = false;
+                        detail = "Plan the environment before qualification.";
+                        break;
+                    }
+                    yield* Effect.try({
+                        try: () => requireHandle(request.args.environment, prepared.plan.planId, "environment"),
+                        catch: (cause) => failure("invalid environment handle", cause)
+                    });
+                    if (checkpoints.seed?.seed.status !== "qualified") {
+                        const bindingDigest = qualificationBindingDigest();
+                        if (qualificationProgress !== undefined &&
+                            qualificationProgress.bindingDigest !== bindingDigest) {
+                            yield* store.deleteWorkCheckpoint(REFERENCE_QUALIFICATION_WORK_CHECKPOINT);
+                            qualificationProgress = undefined;
+                        }
+                        const resumed = yield* qualifyHistoricalTaskSeedAcrossBatchesResumableV1({
+                            repositoryRoot: input.context.repositoryRoot,
+                            seed: { ...input.proposal.seed, environment: prepared.environment },
+                            bindingDigest,
+                            ...(qualificationProgress === undefined
+                                ? {}
+                                : { progress: qualificationProgress }),
+                            checkpoint: persistQualificationProgress,
+                            batches: 2,
+                            repetitionsPerBatch: 2
+                        });
+                        const qualification = resumed.qualification;
+                        const checkpoint = {
+                            version: 1,
+                            stage: "seed",
+                            parentDigest: checkpointDigestV1(input.context),
+                            createdAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+                            seed: qualification.seed,
+                            qualification,
+                            repository: {
+                                root: input.context.repositoryRoot,
+                                commit: input.map.repository.commit,
+                                tree: input.map.repository.tree
+                            },
+                            selection: {
+                                candidates: [
+                                    {
+                                        commit: input.proposal.seed.referenceCommit,
+                                        subject: input.proposal.seed.summary,
+                                        score: 0,
+                                        rationale: input.proposal.rationale
+                                    }
+                                ],
+                                selectedCommit: input.proposal.seed.referenceCommit,
+                                rejected: []
+                            }
+                        };
+                        yield* persist("seed", checkpoint);
+                        yield* store.deleteWorkCheckpoint(REFERENCE_QUALIFICATION_WORK_CHECKPOINT);
+                        qualificationProgress = undefined;
+                        if (checkpoints.spec !== undefined)
+                            yield* persist("spec", {
+                                ...checkpoints.spec,
+                                parentDigest: checkpointDigestV1(checkpoints.seed)
+                            });
+                    }
+                    gradeExecuted = true;
+                    if (checkpoints.seed?.seed.status !== "qualified") {
+                        const seed = checkpoints.seed?.seed;
+                        const environmentBlocked = [
+                            ...(seed?.baselineObservations ?? []),
+                            ...(seed?.postChangeObservations ?? [])
+                        ].some((row) => row.detail.includes("gradeExecuted=false"));
+                        outcome = environmentBlocked ? "environment_blocked" : "scientific_rejection";
+                        gradeExecuted = !environmentBlocked;
+                        disposition = environmentBlocked ? "environment_blocked" : "rejected";
+                        detail = seed?.rejectionReasons.join("; ") ?? "Reference qualification did not pass.";
+                    }
+                    accepted.push(getHandle("seed"));
+                    if (getHandle("spec") !== undefined)
+                        accepted.push(getHandle("spec"));
+                    break;
+                }
+                case "author_oracle": {
+                    yield* Effect.try({
+                        try: () => {
+                            requireHandle(request.args.specification, getHandle("spec"), "specification");
+                            if (!acceptedSpec(checkpoints.spec))
+                                throw failure("oracle authoring requires an accepted grounded specification review");
+                        },
+                        catch: (cause) => failure("specification prerequisite failed", cause)
+                    });
+                    const value = yield* runPipelineOracleStageV1(stageInput("oracle"));
+                    yield* persist("oracle", value);
+                    accepted.push(getHandle("oracle"));
+                    gradeExecuted = true;
+                    break;
+                }
+                case "generate_controls": {
+                    yield* Effect.try({
+                        try: () => {
+                            requireHandle(request.args.specification, getHandle("spec"), "specification");
+                            requireHandle(request.args.environment, prepared?.plan.planId, "environment");
+                            if (checkpoints.challenge !== undefined)
+                                throw failure("repair the challenged candidate before changing controls");
+                        },
+                        catch: (cause) => failure("control prerequisites failed", cause)
+                    });
+                    const value = yield* runPipelineControlsCapabilityV1({
+                        ...stageInput("controls"),
+                        kind: request.args.kind,
+                        maximumNewControls: 1
+                    });
+                    yield* persist("controls", value);
+                    accepted.push(getHandle("controls"));
+                    detail =
+                        `Accepted cumulative controls checkpoint; valid=${String(value.valid.length)}; wrong=${String(value.wrong.length)}. ` +
+                            "This returned handle supersedes all previous controls snapshots. For evaluate_oracle, pass only this latest handle in the controls list.";
+                    gradeExecuted = true;
+                    break;
+                }
+                case "evaluate_oracle":
+                case "repair_oracle": {
+                    yield* Effect.try({
+                        try: () => requireHandle(request.args.oracle, getHandle("oracle"), "oracle"),
+                        catch: (cause) => failure("oracle prerequisite failed", cause)
+                    });
+                    if (request.tool === "evaluate_oracle")
+                        yield* Effect.try({
+                            try: () => {
+                                for (const handle of request.args.controls)
+                                    requireHandle(handle, getHandle("controls"), "controls");
+                            },
+                            catch: (cause) => failure("control prerequisite failed; use only the latest cumulative controls checkpoint returned by generate_controls, not superseded snapshots", cause)
+                        });
+                    if (request.tool === "repair_oracle" && checkpoints.challenge !== undefined) {
+                        const challenged = checkpoints.challenge;
+                        if (challenged.verdict === "passed")
+                            return yield* failure("passed held-out evidence must not be used for repair");
+                        if (challenged.fold >= input.context.foldLimit || checkpoints.controls === undefined) {
+                            outcome = "scientific_rejection";
+                            disposition = "rejected";
+                            detail = "Fresh challenge failed at the fold limit.";
+                            break;
+                        }
+                        const controls = checkpoints.controls;
+                        // Consume held-out evidence as development evidence before invalidating it.
+                        const nextState = { ...before, folds: Math.max(before.folds, challenged.fold + 1) };
+                        yield* state.set(nextState);
+                        yield* store.writeState(nextState);
+                        yield* persist("controls", {
+                            ...controls,
+                            wrong: [
+                                ...controls.wrong,
+                                ...challenged.heldOut.filter((held) => !controls.wrong.some((wrong) => wrong.id === held.id))
+                            ]
+                        });
+                        yield* store.deleteFrom("tournament");
+                        checkpoints = {
+                            seed: checkpoints.seed,
+                            spec: checkpoints.spec,
+                            oracle: checkpoints.oracle,
+                            controls: checkpoints.controls
+                        };
+                    }
+                    const value = yield* runPipelineTournamentCapabilityV1({
+                        ...stageInput("tournament"),
+                        maximumIterations: request.tool === "evaluate_oracle" ? 0 : 1
+                    });
+                    yield* persist("tournament", value);
+                    accepted.push(getHandle("tournament"));
+                    gradeExecuted = true;
+                    if (!value.adequacy.admitted) {
+                        outcome = "progress";
+                        detail =
+                            value.adequacy.rejectionReasons.join("; ") ||
+                                "Tournament returned measured repair findings.";
+                    }
+                    break;
+                }
+                case "freeze_candidate": {
+                    yield* Effect.try({
+                        try: () => {
+                            requireHandle(request.args.revision, candidate.revision, "candidate revision");
+                            assertReady();
+                        },
+                        catch: (cause) => failure("candidate is not ready to freeze", cause)
+                    });
+                    const handle = frozenHandle();
+                    const frozen = {
+                        candidate,
+                        inputs: scientificInputs(),
+                        tournament: getHandle("tournament")
+                    };
+                    yield* store.writeCall(handle, 1, {
+                        request,
+                        response: frozen
+                    });
+                    acceptedScientificArtifacts.set(handle, {
+                        handle,
+                        contentDigest: acceptedScientificDigestV1(frozen),
+                        kind: "frozen_candidate"
+                    });
+                    accepted.push(handle);
+                    break;
+                }
+                case "run_held_out_challenge": {
+                    yield* Effect.try({
+                        try: () => {
+                            assertReady();
+                            requireHandle(request.args.frozenCandidate, frozenHandle(), "frozen candidate");
+                        },
+                        catch: (cause) => failure("challenge prerequisite failed", cause)
+                    });
+                    if (checkpoints.challenge === undefined) {
+                        // Changed frozen inputs invalidate partial evidence just as they
+                        // invalidate its accepted-progress handle. Never execute stale work.
+                        const pending = pendingChallenge?.frozen === frozenHandle()
+                            ? pendingChallenge
+                            : undefined;
+                        const fold = (yield* state.get).folds;
+                        const value = yield* runPipelineChallengeCapabilityV1({
+                            ...stageInput("challenge"),
+                            checkpoints: {
+                                ...checkpoints,
+                                challenge: { fold }
+                            },
+                            materialized: pending?.agenticPendingHeldOut,
+                            ...(pending?.agenticPendingOracle !== undefined
+                                ? { resumeOracle: pending.agenticPendingOracle }
+                                : {}),
+                            onMaterialized: (solution) => persistChallengeProgress({
+                                frozen: frozenHandle(),
+                                agenticPendingHeldOut: solution
+                            }),
+                            onOracleProgress: (solution, oracle) => persistChallengeProgress({
+                                frozen: frozenHandle(),
+                                agenticPendingHeldOut: solution,
+                                agenticPendingOracle: oracle
+                            })
+                        });
+                        yield* persist("challenge", value);
+                        pendingChallenge = undefined;
+                    }
+                    accepted.push(getHandle("challenge"));
+                    gradeExecuted = true;
+                    if (checkpoints.challenge?.verdict !== "passed") {
+                        outcome = "scientific_rejection";
+                        detail =
+                            "Frozen held-out challenge failed. Repeating the tool cannot select another challenge; repair consumes this evidence and requires a new freeze.";
+                    }
+                    break;
+                }
+                case "request_admission": {
+                    yield* Effect.try({
+                        try: () => {
+                            assertReady();
+                            requireHandle(request.args.frozenCandidate, frozenHandle(), "frozen candidate");
+                            requireHandle(request.args.qualification, getHandle("challenge"), "held-out qualification");
+                            if (checkpoints.challenge?.parentDigest !== checkpointDigestV1(checkpoints.tournament))
+                                throw failure("held-out challenge does not bind current frozen tournament");
+                        },
+                        catch: (cause) => failure("admission prerequisite failed", cause)
+                    });
+                    const value = yield* runPipelineAdmitStageV1(stageInput("admit"));
+                    yield* persist("admit", value);
+                    accepted.push(getHandle("admit"));
+                    gradeExecuted = true;
+                    if (value.verdict === "rejected") {
+                        outcome = "scientific_rejection";
+                        disposition = "rejected";
+                        detail = value.reasons.join("; ");
+                    }
+                    break;
+                }
+                case "get_progress":
+                    accepted.push(...PIPELINE_STAGES.flatMap((stage) => getHandle(stage) === undefined ? [] : [getHandle(stage)]));
+                    break;
+                case "reject_candidate":
+                    outcome = "scientific_rejection";
+                    disposition = "rejected";
+                    detail = request.args.reason;
+                    break;
+                case "finish_campaign":
+                    detail = request.args.reason;
+                    break;
+                default:
+                    return yield* failure(`${request.tool} is a repository/session capability, not a scientific candidate operation`);
+            }
+        });
+        const result = yield* execute.pipe(Effect.provide(BudgetedLanguageModelLive({ store, state, budget, startedAtMs: invocationStartedAt, inner })), Effect.timeoutOption(maximumWallMs), Effect.result);
+        if (result._tag === "Failure") {
+            const environmentBlocked = result.failure instanceof RepositoryFoundryError &&
+                result.failure.classification === "environment_blocked";
+            outcome = environmentBlocked
+                ? "environment_blocked"
+                : budgetExhaustedErrorOfV1(result.failure) === undefined
+                    ? "progress"
+                    : "budget_exhausted";
+            if (environmentBlocked)
+                gradeExecuted = false;
+            detail =
+                result.failure instanceof RepositoryFoundryError
+                    ? result.failure.detail
+                    : String(result.failure);
+        }
+        else if (Option.isNone(result.success)) {
+            yieldedAtSliceBoundary = true;
+            outcome = "progress";
+            const summary = request.tool === "qualify_reference" && qualificationProgress !== undefined
+                ? repositorySeedQualificationProgressSummaryV1(qualificationProgress)
+                : undefined;
+            detail =
+                summary === undefined
+                    ? "Capability wall-time bound reached; retained checkpoints and command diagnostics are available for continuation."
+                    : `Capability wall-time bound reached after checkpointing reference qualification progress: completedBatches=${String(summary.completedBatches)}/${String(summary.batchesRequired)}; activeUnits=${String(summary.completedUnits)}/${String(summary.unitsPerBatch)}. Continuation resumes at the next incomplete repetition.`;
+        }
+        else {
+            completedLogicalAttempt = true;
+        }
+        const retainedQualificationArtifact = qualificationProgressArtifact();
+        if (request.tool === "qualify_reference" &&
+            retainedQualificationArtifact !== undefined &&
+            !beforeArtifactHandles.has(retainedQualificationArtifact.handle) &&
+            !accepted.includes(retainedQualificationArtifact.handle)) {
+            accepted.push(retainedQualificationArtifact.handle);
+        }
+        const retainedChallengeArtifact = challengeProgressArtifact();
+        if (request.tool === "run_held_out_challenge" &&
+            retainedChallengeArtifact !== undefined &&
+            !beforeArtifactHandles.has(retainedChallengeArtifact.handle) &&
+            !accepted.includes(retainedChallengeArtifact.handle)) {
+            accepted.push(retainedChallengeArtifact.handle);
+        }
+        const after = yield* state.get;
+        const invocationCompletedAt = yield* Clock.currentTimeMillis;
+        const elapsedMs = before.elapsedMs + Math.max(0, invocationCompletedAt - invocationStartedAt);
+        const campaignWallTimeRemainingAfter = Math.max(0, parsedDeadline === undefined
+            ? input.context.budget.maxWallMs - elapsedMs
+            : parsedDeadline - invocationCompletedAt);
+        if (outcome === "budget_exhausted" &&
+            after.modelCalls < input.context.budget.maxModelCalls &&
+            campaignWallTimeRemainingAfter > 0) {
+            yieldedAtSliceBoundary = true;
+            outcome = "progress";
+            detail = `Capability slice completed without consuming the campaign budget: ${detail}`;
+        }
+        if (outcome === "environment_blocked")
+            disposition = "environment_blocked";
+        if (outcome === "budget_exhausted")
+            disposition = "exhausted";
+        const scientificStage = scientificStageForCapability(request.tool);
+        if (scientificStage !== null && completedLogicalAttempt && !yieldedAtSliceBoundary) {
+            const completedWork = [...groundedWork.values()].filter((entry) => entry.stage === scientificStage);
+            if (completedWork.length > 0) {
+                yield* workPersistence.withPermit(Effect.gen(function* () {
+                    for (const entry of completedWork) {
+                        groundedWork.delete(entry.name);
+                        yield* store.deleteWorkCheckpoint(entry.name);
+                    }
+                    yield* saveGroundedIndex();
+                })).pipe(Effect.uninterruptible);
+            }
+        }
+        else if (scientificStage !== null && yieldedAtSliceBoundary) {
+            const provisionalFingerprint = scientificFingerprint();
+            if (!sameProgressFingerprint(beforeFingerprint, provisionalFingerprint)) {
+                const name = `pipeline-execution-capability-slice-${request.tool}`;
+                const value = {
+                    version: 1,
+                    capability: request.tool,
+                    candidateRevision: candidate.revision,
+                    fingerprint: provisionalFingerprint
+                };
+                yield* workPersistence.withPermit(Effect.gen(function* () {
+                    yield* store.writeWorkCheckpoint(name, value);
+                    groundedWork.set(name, {
+                        name,
+                        stage: scientificStage,
+                        contentDigest: acceptedScientificDigestV1(value)
+                    });
+                    yield* saveGroundedIndex();
+                })).pipe(Effect.uninterruptible);
+            }
+        }
+        // One immutable manifest represents all durable work, irrespective of the
+        // number of fixture units. Finalize the slice marker first so the returned
+        // handle and receipt delta always name the same authoritative manifest.
+        const groundedContinuation = groundedArtifact();
+        if (groundedContinuation !== undefined &&
+            !beforeArtifactHandles.has(groundedContinuation.handle)) {
+            for (const [name, { contentDigest }] of groundedWork) {
+                const work = yield* store.readWorkCheckpoint(name, Schema.Unknown);
+                if (Option.isNone(work) || acceptedScientificDigestV1(work.value) !== contentDigest)
+                    return yield* failure("grounded continuation does not bind its durable work checkpoint");
+            }
+            yield* store.writeCall(groundedContinuation.handle, 1, {
+                request: { candidateRevision: candidate.revision },
+                response: groundedContinuationValue()
+            });
+            accepted.push(groundedContinuation.handle);
+        }
+        const afterArtifacts = currentScientificArtifacts();
+        const afterArtifactHandles = new Set(afterArtifacts.map((artifact) => artifact.handle));
+        const afterGates = completedScientificGates();
+        const resultingFingerprint = scientificFingerprint();
+        const sameFingerprintCount = sameProgressFingerprint(beforeFingerprint, resultingFingerprint)
+            ? (latestProgressReceipt !== undefined &&
+                latestProgressReceipt.capability === request.tool &&
+                sameProgressFingerprint(latestProgressReceipt.resultingFingerprint, beforeFingerprint)
+                ? latestProgressReceipt.sameFingerprintCount
+                : 0) + 1
+            : 0;
+        const attemptCost = evalCapabilityScientificAttemptCostV1({
+            previousFingerprint: beforeFingerprint,
+            resultingFingerprint,
+            inputRevision: candidate.revision,
+            outputRevision: candidate.revision,
+            gatesCompleted: afterGates.filter((gate) => !beforeGates.includes(gate)),
+            gatesInvalidated: beforeGates.filter((gate) => !afterGates.includes(gate)),
+            sameFingerprintCount
+        });
+        if (scientificPhase !== null &&
+            sameFingerprintCount >= 3 &&
+            (outcome === "completed" || outcome === "progress")) {
+            outcome = "scientific_rejection";
+            disposition = "rejected";
+            detail =
+                "Scientific no-progress circuit opened after three unchanged accepted-state results. No further repeat of this capability is admissible for the candidate.";
+        }
+        const terminal = checkpoints.admit?.verdict === "admitted"
+            ? "admitted"
+            : disposition === "rejected"
+                ? "rejected"
+                : undefined;
+        const settledState = {
+            ...after,
+            elapsedMs,
+            ...(terminal === undefined ? {} : { status: terminal, stage: "done" })
+        };
+        yield* state.set(settledState);
+        yield* store.writeState(settledState);
+        const receipt = scientificPhase === null
+            ? undefined
+            : yield* Effect.try({
+                try: () => {
+                    const recordedAt = new Date(invocationStartedAt + Math.max(0, elapsedMs - before.elapsedMs)).toISOString();
+                    const remainingCalls = Math.max(0, input.context.budget.maxModelCalls - after.modelCalls);
+                    const remainingWallTimeMs = campaignWallTimeRemainingAfter;
+                    const value = {
+                        version: 1,
+                        operationId: invocation.operationId,
+                        capability: request.tool,
+                        scientificRole: scientificRoleForCapability(request.tool),
+                        phase: scientificPhase,
+                        inputRevision: candidate.revision,
+                        outputRevision: candidate.revision,
+                        acceptedEvidenceDigest: resultingFingerprint.acceptedEvidenceDigest,
+                        previousFingerprint: beforeFingerprint,
+                        resultingFingerprint,
+                        acceptedEvidenceAdded: afterArtifacts
+                            .filter((artifact) => !beforeArtifactHandles.has(artifact.handle))
+                            .map((artifact) => artifact.handle),
+                        acceptedEvidenceRemoved: beforeArtifacts
+                            .filter((artifact) => !afterArtifactHandles.has(artifact.handle))
+                            .map((artifact) => artifact.handle),
+                        gatesCompleted: afterGates.filter((gate) => !beforeGates.includes(gate)),
+                        gatesInvalidated: beforeGates.filter((gate) => !afterGates.includes(gate)),
+                        sameFingerprintCount,
+                        consumption: {
+                            wallTimeMs: Math.max(0, elapsedMs - before.elapsedMs),
+                            receivedCalls: Math.max(0, after.modelCalls - before.modelCalls),
+                            spendKnownUsd: "0",
+                            spendUnknown: after.modelCalls > before.modelCalls
+                        },
+                        remaining: {
+                            phaseCalls: Math.max(0, remainingCalls - downstreamCalls),
+                            phaseSpendUsd: null,
+                            phaseWallTimeMs: Math.max(0, remainingWallTimeMs -
+                                downstreamWallTimeMs -
+                                finalizationWallTimeMs),
+                            phaseAttempts: Math.max(0, (phasePolicy?.maximumAttempts ?? 0) - phaseAttemptsConsumed - attemptCost),
+                            downstreamCalls: Math.min(downstreamCalls, remainingCalls),
+                            downstreamSpendUsd: null,
+                            downstreamWallTimeMs: Math.min(downstreamWallTimeMs, Math.max(0, remainingWallTimeMs - finalizationWallTimeMs)),
+                            downstreamAttempts: phasePolicy?.downstream.attempts ?? 0
+                        },
+                        recordedAt
+                    };
+                    return decodeAgenticScientificProgressReceiptV1({
+                        ...value,
+                        receiptId: `progress-${agenticDigestV1(value)}`
+                    });
+                },
+                catch: (cause) => failure("could not encode scientific progress receipt", cause)
+            });
+        if (receipt !== undefined) {
+            // This receipt remains provisional until Cloud accepts the enclosing
+            // capability completion. The next invocation supplies the host-owned
+            // accepted chain, so an interrupted or rejected completion can never
+            // advance local scientific sequencing or enter a recovery checkpoint.
+            if (invocation.authoritativeProgressReceipts === undefined) {
+                // Preserve the standalone package contract for callers that do not
+                // have a remote authority. Production passes an explicit array on
+                // every invocation, including the empty authoritative chain.
+                initialProgressReceipts.push(receipt);
+                yield* store.writeCall(receipt.receiptId, 1, {
+                    request: { operationId: invocation.operationId },
+                    response: receipt
+                });
+                if (input.onProgressReceipt !== undefined) {
+                    yield* input.onProgressReceipt(receipt);
+                }
+            }
+        }
+        yield* currentScorecard(disposition, [detail.slice(0, 4096)]);
+        const diagnostics = `diagnostics-${agenticDigestV1({ operation: invocation.operationId, detail, accepted })}`;
+        yield* store.writeCall(diagnostics, 1, { request, response: { outcome, detail, accepted } });
+        const allowedNext = terminal !== undefined
+            ? ["get_progress", "list_candidates", "read_diagnostics", "finish_campaign"]
+            : outcome === "budget_exhausted"
+                ? ["get_progress", "finish_campaign"]
+                : outcome === "environment_blocked" && request.tool === "qualify_reference"
+                    ? ["get_progress", "read_diagnostics", "plan_environment", "reject_candidate"]
+                    : outcome === "scientific_rejection" && sameFingerprintCount >= 3
+                        ? ["get_progress", "reject_candidate", "finish_campaign"]
+                        : CANDIDATE_ALLOWED_CAPABILITIES.filter((capability) => (outcome !== "environment_blocked" || capability !== request.tool) &&
+                            (sameFingerprintCount < 2 || capability !== request.tool) &&
+                            hasCapabilityPrerequisites(capability));
+        return yield* Effect.try({
+            try: () => decodeAgenticCapabilityResultV1({
+                outcome,
+                operation: invocation.operationId,
+                inputDigest: agenticDigestV1(request),
+                candidateRevision: candidate.revision,
+                accepted,
+                evidenceSummary: detail.slice(0, 7000),
+                ...(gradeExecuted === undefined ? {} : { gradeExecuted }),
+                diagnostics,
+                ...(receipt === undefined ? {} : { progressReceipt: receipt }),
+                usage: {
+                    receivedCalls: after.modelCalls - before.modelCalls,
+                    spendKnownUsd: "0",
+                    spendUnknown: after.modelCalls > before.modelCalls
+                },
+                allowedNext
+            }),
+            catch: (cause) => failure("could not encode bounded capability result", cause)
+        });
+    });
+    return {
+        invoke,
+        scorecard: currentScorecard(),
+        environment: () => prepared,
+        handles: () => Object.fromEntries(PIPELINE_STAGES.map((stage) => [stage, getHandle(stage)]))
+    };
+});