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

package/dist/services/pipeline-challenge/service.js

@@ -0,0 +1,427 @@
+import { Clock, Effect, Schema } from "effect";
+import { loadPinnedSolutionEditSourcesV1, materializeSolutionFileOverridesV1, RepositorySolutionFileOutputV1 } from "../../adapters/repository-solution-edits.js";
+import { checkpointDigestV1, pipelineStageToProgressStageV1 } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { repositoryFoundryRoleOutputCeilingV1 } from "../../repository-foundry-plan-protocol.js";
+import { repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { admitRepositoryBenchmarkCaseV1, compileValidatedBenchmarkLibraryV1, evaluateRepositoryOracleAdequacyV1, repositoryBehavioralFingerprintV1 } from "../../repository-quality-policy.js";
+import { evaluateRepositoryOracleScopeCoverageV1, repositoryOracleRepeatedRowsV1 as repeatedRows, repositoryOracleAttributedSemanticFailureV1 as isAttributedSemanticFailure } from "../../repository-oracle-scope-policy.js";
+import { generateWithFeedbackV1 } from "../budgeted-model/service.js";
+import { reportFoundryStageV1 } from "../foundry-progress/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+import { buildHistoricalHiddenOracleV1 } from "../oracle-builder/service.js";
+import { deriveRepositoryTaskFamiliesV1 } from "../task-family/service.js";
+const HeldOutAdversaryProposalV1 = Schema.Struct({
+    solutions: Schema.Array(Schema.Struct({
+        id: Schema.String,
+        family: Schema.String,
+        kind: Schema.Literals(["mutation", "model-near-miss", "reward-hacking"]),
+        fileOverrides: Schema.Array(RepositorySolutionFileOutputV1)
+    }))
+});
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "run-pipeline-stage",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const qualityFinding = (axis, detail, evidenceIds) => ({
+    axis,
+    outcome: "pass",
+    detail,
+    evidence: [],
+    evidenceIds
+});
+const verifyExecutedOracle = (input) => {
+    const reasons = [];
+    const semanticKills = new Set();
+    const clauses = input.oracle.clauses.filter((clause) => clause.critical && clause.kind !== "semantic-residual");
+    const clauseIds = new Set(clauses.map(({ id }) => id));
+    const solutionIds = new Set(input.oracle.solutions.map(({ id }) => id));
+    if (!Number.isSafeInteger(input.repetitions) || input.repetitions < 2) {
+        reasons.push(`${input.label}: execution repetitions must be at least two`);
+    }
+    if (clauses.length === 0)
+        reasons.push(`${input.label}: no critical executable clauses`);
+    if (input.requireReference && !solutionIds.has("historical-reference")) {
+        reasons.push(`${input.label}: historical reference is absent`);
+    }
+    for (const row of input.oracle.observations) {
+        if (!solutionIds.has(row.solutionId) ||
+            !clauseIds.has(row.clauseId) ||
+            row.outcome === "unknown") {
+            reasons.push(`${input.label}: inconclusive or unbound observation ${row.solutionId}/${row.clauseId}`);
+        }
+    }
+    for (const solution of input.oracle.solutions) {
+        let semanticPass = false;
+        let semanticKill = false;
+        const policyRejected = solution.expectedClass === "wrong" &&
+            clauses.some((clause) => {
+                if (clause.kind !== "candidate-policy")
+                    return false;
+                const rows = input.oracle.observations.filter((row) => row.solutionId === solution.id && row.clauseId === clause.id);
+                return (repeatedRows(rows, input.repetitions) && rows.every(({ outcome }) => outcome === "fail"));
+            });
+        for (const clause of clauses) {
+            const rows = input.oracle.observations.filter((row) => row.solutionId === solution.id && row.clauseId === clause.id);
+            if (policyRejected && clause.kind !== "candidate-policy") {
+                if (rows.length > 0) {
+                    reasons.push(`${input.label}: policy-rejected solution has inconsistent later observations ${solution.id}/${clause.id}`);
+                }
+                continue;
+            }
+            if (!repeatedRows(rows, input.repetitions)) {
+                reasons.push(`${input.label}: incomplete repeats for ${solution.id}/${clause.id}`);
+                continue;
+            }
+            if (solution.expectedClass === "valid") {
+                if (!rows.every(({ outcome }) => outcome === "pass")) {
+                    reasons.push(`${input.label}: valid solution failed ${solution.id}/${clause.id}`);
+                }
+                if (clause.kind === "test-command" &&
+                    rows.every((row) => row.outcome === "pass" &&
+                        row.detail.includes("stage=grade") &&
+                        row.detail.includes("gradeExecuted=true") &&
+                        row.detail.includes("timeout=false") &&
+                        row.detail.includes("exit=0") &&
+                        !row.detail.includes("output=truncated"))) {
+                    semanticPass = true;
+                }
+            }
+            else if (rows.every((row) => isAttributedSemanticFailure(row, clause))) {
+                semanticKill = true;
+            }
+        }
+        if (solution.expectedClass === "valid" && !semanticPass) {
+            reasons.push(`${input.label}: valid solution has no completed grading pass ${solution.id}`);
+        }
+        if (solution.expectedClass === "wrong") {
+            if (!semanticKill && !policyRejected) {
+                reasons.push(`${input.label}: wrong solution lacks an attributed failure ${solution.id}`);
+            }
+            else {
+                semanticKills.add(solution.id);
+            }
+        }
+    }
+    return { reasons, semanticKills: [...semanticKills].sort() };
+};
+const executableEvidenceIds = (oracle) => oracle.observations.map(({ solutionId, clauseId, repetition }) => `execution:${oracle.caseId}:${solutionId}:${clauseId}:${String(repetition)}`);
+const materializeHeldOut = (input) => {
+    const findings = [];
+    if (input.proposal.solutions.length === 0) {
+        return {
+            findings: [
+                { kind: "contract", message: "Submit at least one executable held-out adversary." }
+            ]
+        };
+    }
+    for (const proposed of input.proposal.solutions) {
+        if (proposed.id.trim().length === 0 || proposed.family.trim().length === 0) {
+            findings.push({
+                kind: "contract",
+                message: "Held-out adversary id and family must be non-empty."
+            });
+            continue;
+        }
+        if (input.existingIds.has(proposed.id)) {
+            findings.push({
+                kind: "contract",
+                message: `Held-out adversary id is already in use: ${proposed.id}`
+            });
+            continue;
+        }
+        if (proposed.fileOverrides.some(({ path }) => input.protectedPaths.has(path))) {
+            findings.push({
+                kind: "materialization",
+                message: "Held-out adversaries may not edit protected harness paths. Revise the implementation edits."
+            });
+            continue;
+        }
+        try {
+            const materialized = materializeSolutionFileOverridesV1({
+                fileOverrides: proposed.fileOverrides,
+                sources: input.sources,
+                allowedPaths: input.allowedPaths
+            });
+            return {
+                solution: {
+                    id: proposed.id,
+                    family: proposed.family,
+                    kind: proposed.kind,
+                    expectedClass: "wrong",
+                    commit: input.initialCommit,
+                    fileOverrides: materialized.fileOverrides
+                },
+                findings: []
+            };
+        }
+        catch (cause) {
+            findings.push({
+                kind: "materialization",
+                message: cause instanceof Error ? cause.message : String(cause)
+            });
+        }
+    }
+    return { findings };
+};
+export const runPipelineChallengeCapabilityV1 = (input) => Effect.gen(function* () {
+    const seedCheckpoint = input.checkpoints.seed;
+    const spec = input.checkpoints.spec;
+    const tournament = input.checkpoints.tournament;
+    if (seedCheckpoint === undefined || spec === undefined || tournament === undefined) {
+        return yield* failure("challenge requires accepted seed, specification, and tournament checkpoints");
+    }
+    const seed = seedCheckpoint.seed;
+    if (seed.status !== "qualified" || seed.referenceCommit === undefined) {
+        return yield* failure("challenge requires a replay-qualified pinned reference");
+    }
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    const assignment = yield* Effect.try({
+        try: () => repositoryFoundryModelAssignmentV1(input.context.modelPlan, "held-out-adversary"),
+        catch: (cause) => failure("could not resolve held-out adversary assignment", cause)
+    });
+    const protectedPaths = new Set(seed.environment.protectedControlPaths);
+    const allowedPaths = new Set(spec.contextSources.map(({ path }) => path).filter((path) => !protectedPaths.has(path)));
+    if (allowedPaths.size === 0) {
+        return yield* failure("challenge has no reviewed pre-change implementation source available");
+    }
+    const sources = yield* loadPinnedSolutionEditSourcesV1({
+        repositoryRoot: input.context.repositoryRoot,
+        initialCommit: seed.initialState.commit,
+        visibleSources: spec.contextSources,
+        allowedPaths
+    });
+    if (sources.length === 0) {
+        return yield* failure("challenge could not load a complete pinned pre-change edit source");
+    }
+    const existingIds = new Set(tournament.oracle.solutions.map(({ id }) => id));
+    let accepted = input.materialized;
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1("challenge"), `case=${input.context.caseId}; fold=${String(input.checkpoints.challenge?.fold ?? 0)}; status=authoring-fresh-held-out`);
+    if (accepted === undefined)
+        yield* generateWithFeedbackV1({
+            ...(input.workCheckpointStore === undefined ? {} : {
+                checkpoint: {
+                    store: input.workCheckpointStore,
+                    binding: {
+                        parentDigest: checkpointDigestV1(tournament),
+                        initialCommit: seed.initialState.commit,
+                        existingIds: [...existingIds].sort(),
+                        allowedPaths: [...allowedPaths].sort()
+                    }
+                }
+            }),
+            languageModel,
+            assignment,
+            operationId: `${input.context.caseId}:challenge:fold-${String(input.checkpoints.challenge?.fold ?? 0)}`,
+            instructions: [
+                "Act as a fresh blind adversary for the visible repository task.",
+                "You receive only the public task, complete routing dimension contract, target behavior prose, and pinned pre-change sources.",
+                "You do not receive the reference implementation, hidden fixture suite, development oracle, or prior adversaries.",
+                "Propose a plausible implementation that is materially wrong for the requested behavior while still likely to build.",
+                "Use exact search/replace edits over supplied source text. Do not edit tests or protected harness controls.",
+                "Host schema and materialization findings will be returned to this same role before execution.",
+                "After one proposal materializes, it is frozen: execution failure becomes the held-out verdict and is never repaired."
+            ].join("\n"),
+            input: {
+                dimension: input.context.dimension,
+                visible: spec.visible,
+                targetBehavior: seed.targetBehavior.map(({ id, description, critical }) => ({
+                    id,
+                    description,
+                    critical
+                })),
+                preChangeSources: sources.map(({ path, content }) => ({ path, content })),
+                protectedPaths: [...protectedPaths]
+            },
+            schemaName: "routekit_pipeline_held_out_adversary_v1",
+            outputSchema: HeldOutAdversaryProposalV1,
+            maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("held-out-adversary"),
+            maxAttempts: Math.max(1, Math.trunc(input.context.budget.maxModelCalls) + 1),
+            validate: (proposal) => Effect.sync(() => {
+                const result = materializeHeldOut({
+                    proposal,
+                    initialCommit: seed.initialState.commit,
+                    existingIds,
+                    sources,
+                    allowedPaths,
+                    protectedPaths
+                });
+                accepted = result.solution;
+                return result.findings;
+            })
+        });
+    if (accepted === undefined) {
+        return yield* failure("held-out adversary was accepted without an executable materialization");
+    }
+    // Materialization is a one-time transition. Re-emitting it on resume can
+    // replace the persisted oracle continuation with the earlier empty state.
+    if (input.materialized === undefined && input.onMaterialized !== undefined)
+        yield* input.onMaterialized(accepted);
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1("challenge"), `case=${input.context.caseId}; status=executing-frozen-held-out`);
+    const oracle = yield* buildHistoricalHiddenOracleV1({
+        repositoryRoot: input.context.repositoryRoot,
+        caseId: input.context.caseId,
+        seed,
+        additionalSolutions: [accepted],
+        hiddenFixtureSuite: tournament.suite,
+        repetitions: input.context.oracleRepetitions,
+        oracleConcurrency: input.context.oracleConcurrency,
+        ...(input.resumeOracle === undefined
+            ? {}
+            : { resumeOracle: input.resumeOracle }),
+        ...(input.onOracleProgress === undefined
+            ? {}
+            : {
+                onReplayCompleted: (partialOracle) => input.onOracleProgress(accepted, partialOracle)
+            })
+    });
+    const adequacy = evaluateRepositoryOracleAdequacyV1(oracle);
+    const fold = input.checkpoints.challenge?.fold ?? 0;
+    const checkpoint = {
+        version: 1,
+        stage: "challenge",
+        parentDigest: checkpointDigestV1(tournament),
+        createdAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+        heldOut: [accepted],
+        adequacy,
+        oracle,
+        verdict: adequacy.admitted ? "passed" : "failed",
+        fold
+    };
+    yield* input.checkpoint(checkpoint);
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1("challenge"), `case=${input.context.caseId}; verdict=${checkpoint.verdict}; fold=${String(fold)}`);
+    return checkpoint;
+});
+export const runPipelineAdmitStageV1 = (input) => Effect.gen(function* () {
+    const seedCheckpoint = input.checkpoints.seed;
+    const spec = input.checkpoints.spec;
+    const oracleCheckpoint = input.checkpoints.oracle;
+    const tournament = input.checkpoints.tournament;
+    const challenge = input.checkpoints.challenge;
+    if (seedCheckpoint === undefined ||
+        spec === undefined ||
+        oracleCheckpoint === undefined ||
+        tournament === undefined ||
+        challenge === undefined) {
+        return yield* failure("admit requires accepted seed, specification, oracle, tournament, and challenge checkpoints");
+    }
+    const reasons = [];
+    if (challenge.verdict !== "passed")
+        reasons.push("fresh held-out challenge did not pass");
+    const development = verifyExecutedOracle({
+        oracle: tournament.oracle,
+        repetitions: input.context.oracleRepetitions,
+        label: "development",
+        requireReference: true
+    });
+    const heldOut = verifyExecutedOracle({
+        oracle: challenge.oracle,
+        repetitions: input.context.oracleRepetitions,
+        label: "held-out",
+        requireReference: true
+    });
+    reasons.push(...development.reasons, ...heldOut.reasons);
+    reasons.push(...evaluateRepositoryOracleScopeCoverageV1({
+        spec,
+        oracleCheckpoint,
+        oracle: tournament.oracle,
+        repetitions: input.context.oracleRepetitions,
+        label: "development"
+    }).reasons);
+    if (!tournament.adequacy.admitted)
+        reasons.push(...tournament.adequacy.rejectionReasons);
+    if (!challenge.adequacy.admitted)
+        reasons.push(...challenge.adequacy.rejectionReasons);
+    if (seedCheckpoint.seed.status !== "qualified" ||
+        seedCheckpoint.seed.referenceCommit === undefined) {
+        reasons.push("seed is not replay-qualified against a pinned reference");
+    }
+    if (spec.visible.lane !== "repository-agent" ||
+        spec.visible.checkoutCommit !== seedCheckpoint.seed.initialState.commit) {
+        reasons.push("visible task checkout does not match the replay-qualified initial commit");
+    }
+    const protectedPaths = new Set(seedCheckpoint.seed.environment.protectedControlPaths);
+    for (const solution of [...tournament.valid, ...tournament.wrong, ...challenge.heldOut]) {
+        const violation = solution.fileOverrides?.find(({ path }) => protectedPaths.has(path));
+        if (violation !== undefined)
+            reasons.push(`solution ${solution.id} edits protected path ${violation.path}`);
+    }
+    const families = yield* deriveRepositoryTaskFamiliesV1({
+        map: input.map,
+        seeds: [seedCheckpoint.seed]
+    });
+    const family = families.find(({ seedIds }) => seedIds.includes(seedCheckpoint.seed.id));
+    if (family === undefined)
+        reasons.push("replay-qualified seed has no repository task family");
+    const evidenceIds = [
+        ...executableEvidenceIds(tournament.oracle),
+        ...executableEvidenceIds(challenge.oracle)
+    ];
+    const qualityFindings = [
+        qualityFinding("authenticity", "Pinned historical reference and defect were replayed repeatedly.", evidenceIds),
+        qualityFinding("specification-sufficiency", "The visible task was exercised by the reference and blind valid controls.", evidenceIds),
+        qualityFinding("oracle-adequacy", "Every executable critical solution/clause pair has repeated conclusive observations.", evidenceIds),
+        qualityFinding("stability", "Repeated isolated executions produced stable outcomes.", evidenceIds),
+        qualityFinding("distinctness", "Blind valid controls pass while development and held-out wrong controls receive attributed failures.", evidenceIds),
+        qualityFinding("realism", "The replay-qualified task and candidate implementations execute through repository-owned commands.", evidenceIds),
+        qualityFinding("leakage", "The fixture-blind controls and fresh held-out adversary were evaluated only after the oracle was frozen.", evidenceIds),
+        qualityFinding("triviality", "Behavioral grading discriminates passing implementations from attributed wrong implementations.", evidenceIds),
+        qualityFinding("coverage", "Critical oracle clauses were observed for the admitted solution populations.", evidenceIds)
+    ];
+    const fallbackFamily = {
+        id: `family-${seedCheckpoint.seed.id}`,
+        capabilityId: `capability-${seedCheckpoint.seed.id}`
+    };
+    const selectedFamily = family ?? fallbackFamily;
+    const benchmarkCase = admitRepositoryBenchmarkCaseV1({
+        draft: {
+            version: 1,
+            id: input.context.caseId,
+            capabilityId: selectedFamily.capabilityId,
+            familyId: selectedFamily.id,
+            seedId: seedCheckpoint.seed.id,
+            lane: "repository-agent",
+            visible: spec.visible,
+            hidden: tournament.oracle,
+            adequacy: tournament.adequacy,
+            qualityFindings,
+            behavioralFingerprint: repositoryBehavioralFingerprintV1({
+                capabilityId: selectedFamily.capabilityId,
+                familyId: selectedFamily.id,
+                behaviorClauses: seedCheckpoint.seed.targetBehavior.map(({ description }) => description),
+                oracle: tournament.oracle
+            })
+        }
+    });
+    if (benchmarkCase.status !== "valid-library")
+        reasons.push(...benchmarkCase.rejectionReasons);
+    const library = compileValidatedBenchmarkLibraryV1([benchmarkCase]);
+    if (!library.cases.some(({ id }) => id === benchmarkCase.id)) {
+        reasons.push("compiled benchmark library did not retain the case");
+    }
+    const semanticKills = [
+        ...new Set([...development.semanticKills, ...heldOut.semanticKills])
+    ].sort();
+    const checkpoint = {
+        version: 1,
+        stage: "admit",
+        parentDigest: checkpointDigestV1(challenge),
+        createdAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+        benchmarkCase,
+        verdict: reasons.length === 0 ? "admitted" : "rejected",
+        reasons,
+        evidence: {
+            validCount: tournament.oracle.solutions.filter(({ expectedClass }) => expectedClass === "valid").length,
+            wrongCount: tournament.oracle.solutions.filter(({ expectedClass }) => expectedClass === "wrong").length,
+            heldOutWrongCount: challenge.heldOut.length,
+            semanticKills
+        }
+    };
+    yield* input.checkpoint(checkpoint);
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1("admit"), `case=${input.context.caseId}; verdict=${checkpoint.verdict}; reasons=${String(reasons.length)}`);
+    return checkpoint;
+});
+export const runPipelineChallengeStageV1 = (input) => runPipelineChallengeCapabilityV1(input);
+export const runPipelineChallengeV1 = runPipelineChallengeStageV1;
+export const runPipelineAdmitV1 = runPipelineAdmitStageV1;

package/dist/services/pipeline-controls/service.d.ts

@@ -0,0 +1,130 @@
+import { Effect } from "effect";
+import { type ControlsCheckpointV1, type PipelineBudgetExhaustedError, type PipelineCaseContextV1, type PipelineStageRunV1, type PipelineStageInputV1, type PipelineWorkCheckpointStoreV1, SolutionCritiqueV1 } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryExecutableSolutionV1 } from "../../repository-execution-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+/**
+ * Run fixture-blind correctness review only when execution has false-rejected
+ * a generated valid control. Callers may supply prior completed rounds when
+ * resuming or when an older controls checkpoint already contains them.
+ */
+export declare const runPipelineControlCorrectnessCriticsV1: (input: {
+    readonly context: PipelineCaseContextV1;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly spec: {
+        readonly visible: unknown;
+        readonly analysis: unknown;
+        readonly scope: readonly unknown[];
+        readonly contextSources: readonly {
+            readonly path: string;
+            readonly content: string;
+        }[];
+    };
+    readonly solutions: readonly RepositoryExecutableSolutionV1[];
+    readonly priorCritiques?: readonly SolutionCritiqueV1[];
+    readonly workCheckpointStore?: PipelineWorkCheckpointStoreV1;
+    readonly onRound?: (critiques: readonly SolutionCritiqueV1[], regenerations: number) => Effect.Effect<void>;
+}) => Effect.Effect<{
+    critiques: {
+        readonly solutionId: string;
+        readonly classification: "valid" | "wrong" | "uncertain";
+        readonly detail: string;
+        readonly violatedBehaviorIds: readonly string[];
+    }[];
+    regenerations: number;
+}, RepositoryFoundryError | PipelineBudgetExhaustedError, RepositoryFoundryLanguageModel>;
+/**
+ * Generate fixture-blind valid and wrong controls. Each proposal is exact-edit
+ * materialized and run in an isolated checkout before it is accepted. Model
+ * labels remain advisory; the tournament stage performs semantic adjudication.
+ */
+export declare const runPipelineControlsCapabilityV1: (input: PipelineStageInputV1<ControlsCheckpointV1> & {
+    readonly kind?: "valid" | "wrong";
+    readonly maximumNewControls?: number;
+    /** A scientifically rejected control needs fresh authoring, not a replay of its old response. */
+    readonly replacementRound?: number;
+}) => Effect.Effect<{
+    readonly valid: readonly {
+        readonly kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+        readonly id: string;
+        readonly expectedClass: "valid" | "wrong";
+        readonly commit: string;
+        readonly family: string;
+        readonly fileOverrides?: readonly ({
+            readonly path: string;
+            readonly content: string;
+        } | {
+            readonly path: string;
+            readonly delete: true;
+        })[] | undefined;
+    }[];
+    readonly wrong: readonly {
+        readonly kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+        readonly id: string;
+        readonly expectedClass: "valid" | "wrong";
+        readonly commit: string;
+        readonly family: string;
+        readonly fileOverrides?: readonly ({
+            readonly path: string;
+            readonly content: string;
+        } | {
+            readonly path: string;
+            readonly delete: true;
+        })[] | undefined;
+    }[];
+    readonly critiques: readonly {
+        readonly solutionId: string;
+        readonly classification: "valid" | "wrong" | "uncertain";
+        readonly detail: string;
+        readonly violatedBehaviorIds: readonly string[];
+    }[];
+    readonly regenerations: number;
+    readonly version: 1;
+    readonly stage: "controls";
+    readonly parentDigest: string;
+    readonly createdAt: string;
+}, RepositoryFoundryError | PipelineBudgetExhaustedError, RepositoryFoundryLanguageModel>;
+/** Short name used by the orchestrator. */
+export declare const runPipelineControlsStageV1: PipelineStageRunV1<ControlsCheckpointV1>;
+export declare const runPipelineControlsV1: PipelineStageRunV1<{
+    readonly valid: readonly {
+        readonly kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+        readonly id: string;
+        readonly expectedClass: "valid" | "wrong";
+        readonly commit: string;
+        readonly family: string;
+        readonly fileOverrides?: readonly ({
+            readonly path: string;
+            readonly content: string;
+        } | {
+            readonly path: string;
+            readonly delete: true;
+        })[] | undefined;
+    }[];
+    readonly wrong: readonly {
+        readonly kind: "historical-reference" | "independent-valid" | "simplified-valid" | "behavior-preserving-valid" | "historical-defect" | "mutation" | "model-near-miss" | "reward-hacking";
+        readonly id: string;
+        readonly expectedClass: "valid" | "wrong";
+        readonly commit: string;
+        readonly family: string;
+        readonly fileOverrides?: readonly ({
+            readonly path: string;
+            readonly content: string;
+        } | {
+            readonly path: string;
+            readonly delete: true;
+        })[] | undefined;
+    }[];
+    readonly critiques: readonly {
+        readonly solutionId: string;
+        readonly classification: "valid" | "wrong" | "uncertain";
+        readonly detail: string;
+        readonly violatedBehaviorIds: readonly string[];
+    }[];
+    readonly regenerations: number;
+    readonly version: 1;
+    readonly stage: "controls";
+    readonly parentDigest: string;
+    readonly createdAt: string;
+}>;