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

package/dist/case-pipeline-protocol.d.ts

@@ -0,0 +1,2626 @@
+import { type Effect, type Option, Schema } from "effect";
+import type { RepositoryFoundryError } from "./errors.js";
+import type { RepositoryBehaviorMapV1 } from "./repository-behavior-protocol.js";
+import type { RepositoryExecutableSolutionV1 } from "./repository-execution-protocol.js";
+import type { RepositoryFoundryProgressStageV1 } from "./repository-foundry-progress-protocol.js";
+import { RepositoryFoundryReasoningEffortV1 } from "./repository-language-model-protocol.js";
+import type { RepositoryFoundryLanguageModel } from "./services/language-model/service.js";
+import type { RepositoryOracleCoverageWitnessV1 } from "./services/oracle-coverage-witness/service.js";
+/**
+ * Additive case-generation pipeline protocol. Every stage persists one
+ * checkpoint; the orchestrator resumes from the first stage without one.
+ * Model output is advisory everywhere; executed observations are the only
+ * admission evidence.
+ */
+export declare const PIPELINE_STAGES: readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"];
+export declare const PipelineStageV1: Schema.Literals<readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit"]>;
+export type PipelineStageV1 = typeof PipelineStageV1.Type;
+export declare const PipelineStatusV1: Schema.Literals<readonly ["running", "admitted", "rejected", "exhausted", "failed"]>;
+export type PipelineStatusV1 = typeof PipelineStatusV1.Type;
+export declare const DimensionContractV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly description: Schema.String;
+    readonly includes: Schema.$Array<Schema.String>;
+    readonly excludes: Schema.$Array<Schema.String>;
+}>;
+export type DimensionContractV1 = typeof DimensionContractV1.Type;
+/** The single budget. No per-stage or per-role allowances exist. */
+export declare const PipelineBudgetV1: Schema.Struct<{
+    readonly maxModelCalls: Schema.Finite;
+    readonly maxWallMs: Schema.Finite;
+}>;
+export type PipelineBudgetV1 = typeof PipelineBudgetV1.Type;
+export declare const PipelineStateV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly caseId: Schema.String;
+    readonly repositoryRoot: Schema.String;
+    readonly dimension: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly includes: Schema.$Array<Schema.String>;
+        readonly excludes: Schema.$Array<Schema.String>;
+    }>;
+    readonly model: Schema.String;
+    /**
+     * Digest of the immutable scientific inputs. The requested cumulative budget
+     * is deliberately excluded so an exhausted case can resume with a larger
+     * ceiling without changing its identity.
+     */
+    readonly identityDigest: Schema.optionalKey<Schema.String>;
+    readonly stage: Schema.Literals<readonly ["seed", "spec", "oracle", "controls", "tournament", "challenge", "admit", "done"]>;
+    readonly status: Schema.Literals<readonly ["running", "admitted", "rejected", "exhausted", "failed"]>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly startedAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly modelCalls: Schema.Finite;
+    /** Cumulative across resumes; the budget wrapper persists it on every received call. */
+    readonly elapsedMs: Schema.Finite;
+    readonly resumeCount: Schema.Finite;
+    readonly folds: Schema.Finite;
+}>;
+export type PipelineStateV1 = typeof PipelineStateV1.Type;
+export declare const PipelineLedgerPhaseV1: Schema.Literals<readonly ["start", "received", "validated", "failed", "retry"]>;
+export type PipelineLedgerPhaseV1 = typeof PipelineLedgerPhaseV1.Type;
+export declare const PipelineLedgerEntryV1: Schema.Struct<{
+    readonly at: Schema.String;
+    readonly operationId: Schema.String;
+    readonly role: Schema.String;
+    readonly model: Schema.String;
+    readonly phase: Schema.Literals<readonly ["start", "received", "validated", "failed", "retry"]>;
+    readonly attempt: Schema.Finite;
+    readonly callId: Schema.optionalKey<Schema.String>;
+    readonly detail: Schema.optionalKey<Schema.String>;
+    readonly inputBytes: Schema.optionalKey<Schema.Finite>;
+    readonly outputBytes: Schema.optionalKey<Schema.Finite>;
+}>;
+export type PipelineLedgerEntryV1 = typeof PipelineLedgerEntryV1.Type;
+export declare const PIPELINE_DEFAULT_ORACLE_REPETITIONS = 2;
+export declare const PIPELINE_DEFAULT_ORACLE_CONCURRENCY = 2;
+export declare const PIPELINE_DEFAULT_FOLD_LIMIT = 2;
+export declare const PipelineCaseContextV1: Schema.Struct<{
+    readonly repositoryRoot: Schema.String;
+    readonly caseId: Schema.String;
+    readonly caseDirectory: Schema.String;
+    readonly dimension: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly includes: Schema.$Array<Schema.String>;
+        readonly excludes: Schema.$Array<Schema.String>;
+    }>;
+    readonly primaryModel: Schema.String;
+    readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+    /** Legacy plan so substrate services that still take a plan keep working. */
+    readonly modelPlan: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly assignments: Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["repository-analyst", "specification-writer", "specification-critic-a", "specification-critic-b", "trajectory-designer", "trajectory-critic", "oracle-designer", "valid-solution-generator-a", "valid-solution-generator-b", "adversary", "solution-critic-a", "solution-critic-b", "held-out-adversary", "held-out-solution-critic-a", "held-out-solution-critic-b", "quality-reviewer", "hill-climb-planner", "oracle-critic"]>;
+            readonly model: Schema.String;
+            readonly reasoningEffort: Schema.Literals<readonly ["low", "medium", "high", "xhigh", "max", "ultra"]>;
+        }>>;
+    }>;
+    readonly budget: Schema.Struct<{
+        readonly maxModelCalls: Schema.Finite;
+        readonly maxWallMs: Schema.Finite;
+    }>;
+    readonly referenceCommit: Schema.optionalKey<Schema.String>;
+    readonly requestedRef: Schema.optionalKey<Schema.String>;
+    readonly oracleRepetitions: Schema.Finite;
+    readonly oracleConcurrency: Schema.Finite;
+    readonly foldLimit: Schema.Finite;
+}>;
+export type PipelineCaseContextV1 = typeof PipelineCaseContextV1.Type;
+/**
+ * Build a context with defaults and a legacy model plan. Legacy primary roles
+ * require high or stronger reasoning, so weaker efforts are lifted to "high"
+ * inside the plan only; `reasoningEffort` keeps the requested value.
+ */
+export declare const makePipelineCaseContextV1: (input: {
+    readonly repositoryRoot: string;
+    readonly caseId: string;
+    readonly caseDirectory: string;
+    readonly dimension: DimensionContractV1;
+    readonly primaryModel: string;
+    readonly budget: PipelineBudgetV1;
+    readonly reasoningEffort?: RepositoryFoundryReasoningEffortV1;
+    readonly referenceCommit?: string;
+    readonly requestedRef?: string;
+    readonly oracleRepetitions?: number;
+    readonly oracleConcurrency?: number;
+    readonly foldLimit?: number;
+}) => PipelineCaseContextV1;
+export declare const RepositoryCommandFileOverrideSchemaV1: Schema.Union<readonly [Schema.Struct<{
+    readonly path: Schema.String;
+    readonly content: Schema.String;
+}>, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly delete: Schema.Literal<true>;
+}>]>;
+export declare const RepositoryExecutableSolutionSchemaV1: Schema.Struct<{
+    readonly commit: Schema.String;
+    readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>, Schema.Struct<{
+        readonly path: Schema.String;
+        readonly delete: Schema.Literal<true>;
+    }>]>>>;
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+    readonly family: Schema.String;
+    readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+}>;
+export declare const RepositoryOracleCoverageWitnessSchemaV1: Schema.Struct<{
+    readonly scopeId: Schema.String;
+    readonly hypothesis: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["already-detected", "confirmed-escape"]>;
+    readonly explanation: Schema.String;
+    readonly referenceCommit: Schema.String;
+    readonly fileOverrides: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>>;
+    readonly fixture: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"historical-regression">;
+        readonly expectationMode: Schema.Literal<"changes">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"boundary">;
+        readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"counterfactual">;
+        readonly expectationMode: Schema.Literal<"changes">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"metamorphic">;
+        readonly expectationMode: Schema.Literal<"preserved">;
+        readonly id: Schema.String;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+        readonly testPath: Schema.String;
+    }>]>;
+    readonly overlay: Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+    }>;
+    readonly referenceEvidence: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+        readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+    }>;
+    readonly mutantEvidence: Schema.Struct<{
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+        readonly detail: Schema.String;
+        readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+    }>;
+    readonly incumbentEvidence: Schema.$Array<Schema.Struct<{
+        readonly fixtureId: Schema.String;
+        readonly evidence: Schema.Struct<{
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+            readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+        }>;
+    }>>;
+    readonly executionOperationId: Schema.String;
+}>;
+type Equivalent<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+type Assert<T extends true> = T;
+/** Compile-time proof that the schemas above match the substrate types. */
+export type ExecutableSolutionSchemaMatchesV1 = Assert<Equivalent<typeof RepositoryExecutableSolutionSchemaV1.Type, RepositoryExecutableSolutionV1>>;
+export type CoverageWitnessSchemaMatchesV1 = Assert<Equivalent<typeof RepositoryOracleCoverageWitnessSchemaV1.Type, RepositoryOracleCoverageWitnessV1>>;
+export declare const SeedCheckpointV1: Schema.Struct<{
+    readonly seed: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly id: Schema.String;
+        readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+        readonly source: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-fix">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-feature">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-refactor">;
+            readonly changeEpisodeId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"existing-test">;
+            readonly testIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"public-api">;
+            readonly surfaceIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"schema-contract">;
+            readonly protocolIds: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"production-request">;
+            readonly requestId: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+            readonly reviewId: Schema.String;
+        }>]>;
+        readonly summary: Schema.String;
+        readonly capabilityEvidence: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+            readonly id: Schema.String;
+            readonly path: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly initialState: Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly parentCommit: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly targetBehavior: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly evidence: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                readonly id: Schema.String;
+                readonly path: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>>;
+        readonly referenceCommit: Schema.optionalKey<Schema.String>;
+        readonly baselineObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+            readonly subjectId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly candidateTestIds: Schema.$Array<Schema.String>;
+        readonly environment: Schema.Struct<{
+            readonly packageManager: Schema.optionalKey<Schema.Struct<{
+                readonly name: Schema.Literal<"pnpm">;
+                readonly version: Schema.String;
+            }>>;
+            readonly lockfilePath: Schema.optionalKey<Schema.String>;
+            readonly protectedControlPaths: Schema.$Array<Schema.String>;
+            readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+            readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                readonly cwd: Schema.String;
+                readonly executable: Schema.String;
+                readonly args: Schema.$Array<Schema.String>;
+                readonly timeoutMs: Schema.Finite;
+            }>>;
+        }>;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+        readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+    readonly qualification: Schema.Struct<{
+        readonly seed: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly id: Schema.String;
+            readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-fix">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-feature">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-refactor">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"existing-test">;
+                readonly testIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"public-api">;
+                readonly surfaceIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"schema-contract">;
+                readonly protocolIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"production-request">;
+                readonly requestId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+                readonly reviewId: Schema.String;
+            }>]>;
+            readonly summary: Schema.String;
+            readonly capabilityEvidence: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                readonly id: Schema.String;
+                readonly path: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly initialState: Schema.Struct<{
+                readonly commit: Schema.String;
+                readonly parentCommit: Schema.optionalKey<Schema.String>;
+            }>;
+            readonly targetBehavior: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                    readonly id: Schema.String;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                }>>;
+            }>>;
+            readonly referenceCommit: Schema.optionalKey<Schema.String>;
+            readonly baselineObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly candidateTestIds: Schema.$Array<Schema.String>;
+            readonly environment: Schema.Struct<{
+                readonly packageManager: Schema.optionalKey<Schema.Struct<{
+                    readonly name: Schema.Literal<"pnpm">;
+                    readonly version: Schema.String;
+                }>>;
+                readonly lockfilePath: Schema.optionalKey<Schema.String>;
+                readonly protectedControlPaths: Schema.$Array<Schema.String>;
+                readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+            }>;
+            readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+            readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly stability: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly seedId: Schema.String;
+            readonly batchesRequired: Schema.Finite;
+            readonly repetitionsPerBatch: Schema.Finite;
+            readonly stable: Schema.Boolean;
+            readonly batches: Schema.$Array<Schema.Struct<{
+                readonly batch: Schema.Finite;
+                readonly status: Schema.Literals<readonly ["qualified", "rejected"]>;
+                readonly phaseSignatures: Schema.$Array<Schema.Struct<{
+                    readonly phase: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+                    readonly signatures: Schema.$Array<Schema.String>;
+                }>>;
+                readonly rejectionReasons: Schema.$Array<Schema.String>;
+            }>>;
+            readonly divergentPhases: Schema.$Array<Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>>;
+            readonly failureSignatures: Schema.$Array<Schema.Struct<{
+                readonly signature: Schema.String;
+                readonly count: Schema.Finite;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+    }>;
+    readonly repository: Schema.Struct<{
+        readonly root: Schema.String;
+        readonly commit: Schema.String;
+        readonly tree: Schema.String;
+    }>;
+    readonly selection: Schema.Struct<{
+        readonly candidates: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly subject: Schema.String;
+            readonly score: Schema.Finite;
+            readonly rationale: Schema.String;
+        }>>;
+        readonly selectedCommit: Schema.String;
+        readonly rejected: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly reason: Schema.String;
+        }>>;
+    }>;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"seed">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type SeedCheckpointV1 = typeof SeedCheckpointV1.Type;
+export declare const SpecScopeEntryV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["changed", "preserved"]>;
+    readonly behaviorIds: Schema.$Array<Schema.String>;
+    readonly description: Schema.String;
+}>;
+export type SpecScopeEntryV1 = typeof SpecScopeEntryV1.Type;
+export declare const SpecCheckpointV1: Schema.Struct<{
+    readonly visible: Schema.Union<readonly [Schema.Struct<{
+        readonly lane: Schema.Literal<"request">;
+        readonly id: Schema.String;
+        readonly request: Schema.Struct<{
+            readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+            readonly method: Schema.Literal<"POST">;
+            readonly path: Schema.String;
+            readonly headers: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly value: Schema.String;
+            }>>;
+            readonly bodyJson: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly lane: Schema.Literal<"repository-agent">;
+        readonly id: Schema.String;
+        readonly requestText: Schema.String;
+        readonly checkoutCommit: Schema.String;
+        readonly allowedTools: Schema.$Array<Schema.Literals<readonly ["read", "search", "edit", "shell", "test"]>>;
+        readonly constraints: Schema.$Array<Schema.String>;
+    }>]>;
+    readonly analysis: Schema.Struct<{
+        readonly summary: Schema.String;
+        readonly userObservableBehaviors: Schema.$Array<Schema.String>;
+        readonly constraints: Schema.$Array<Schema.String>;
+        readonly risks: Schema.$Array<Schema.String>;
+    }>;
+    readonly scope: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["changed", "preserved"]>;
+        readonly behaviorIds: Schema.$Array<Schema.String>;
+        readonly description: Schema.String;
+    }>>;
+    readonly contextSources: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>>;
+    /** Advisory model reviews; write RepositorySpecificationReviewV1 values where possible. */
+    readonly reviews: Schema.$Array<Schema.Unknown>;
+    readonly revisions: Schema.Finite;
+    readonly leakFindings: Schema.$Array<Schema.String>;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"spec">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type SpecCheckpointV1 = typeof SpecCheckpointV1.Type;
+export declare const OracleFixtureMetadataV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["historical-regression", "boundary", "counterfactual", "metamorphic"]>;
+    readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+    readonly description: Schema.String;
+    readonly expectedBehavior: Schema.String;
+    readonly testPath: Schema.String;
+}>;
+export type OracleFixtureMetadataV1 = typeof OracleFixtureMetadataV1.Type;
+export declare const OracleScopeCoverageV1: Schema.Struct<{
+    readonly scopeId: Schema.String;
+    readonly outcome: Schema.Literals<readonly ["covered", "unsupported", "contradictory", "uncertain"]>;
+    readonly fixtureIds: Schema.$Array<Schema.String>;
+    readonly detail: Schema.String;
+}>;
+export type OracleScopeCoverageV1 = typeof OracleScopeCoverageV1.Type;
+export declare const OracleCheckpointV1: Schema.Struct<{
+    readonly suite: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-regression">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"boundary">;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"counterfactual">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"metamorphic">;
+            readonly expectationMode: Schema.Literal<"preserved">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>]>>;
+        readonly overlays: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+        }>>;
+    }>;
+    readonly fixtureMetadata: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-regression", "boundary", "counterfactual", "metamorphic"]>;
+        readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+        readonly description: Schema.String;
+        readonly expectedBehavior: Schema.String;
+        readonly testPath: Schema.String;
+    }>>;
+    /** Advisory model self-report; witnesses are the executed evidence. */
+    readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["covered", "unsupported", "contradictory", "uncertain"]>;
+        readonly fixtureIds: Schema.$Array<Schema.String>;
+        readonly detail: Schema.String;
+    }>>;
+    readonly preflight: Schema.Struct<{
+        readonly passed: Schema.Literal<true>;
+        readonly repairs: Schema.Finite;
+    }>;
+    readonly witnesses: Schema.$Array<Schema.Struct<{
+        readonly scopeId: Schema.String;
+        readonly hypothesis: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["already-detected", "confirmed-escape"]>;
+        readonly explanation: Schema.String;
+        readonly referenceCommit: Schema.String;
+        readonly fileOverrides: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>>;
+        readonly fixture: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-regression">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"boundary">;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"counterfactual">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"metamorphic">;
+            readonly expectationMode: Schema.Literal<"preserved">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>]>;
+        readonly overlay: Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+        }>;
+        readonly referenceEvidence: Schema.Struct<{
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+            readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+        }>;
+        readonly mutantEvidence: Schema.Struct<{
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+            readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+        }>;
+        readonly incumbentEvidence: Schema.$Array<Schema.Struct<{
+            readonly fixtureId: Schema.String;
+            readonly evidence: Schema.Struct<{
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>;
+        }>>;
+        readonly executionOperationId: Schema.String;
+    }>>;
+    readonly coverageRounds: Schema.Finite;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"oracle">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type OracleCheckpointV1 = typeof OracleCheckpointV1.Type;
+export declare const SolutionCritiqueV1: Schema.Struct<{
+    readonly solutionId: Schema.String;
+    readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+    readonly detail: Schema.String;
+    readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+}>;
+export type SolutionCritiqueV1 = typeof SolutionCritiqueV1.Type;
+export declare const ControlsCheckpointV1: Schema.Struct<{
+    readonly valid: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>, Schema.Struct<{
+            readonly path: Schema.String;
+            readonly delete: Schema.Literal<true>;
+        }>]>>>;
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    }>>;
+    readonly wrong: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>, Schema.Struct<{
+            readonly path: Schema.String;
+            readonly delete: Schema.Literal<true>;
+        }>]>>>;
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    }>>;
+    /** Advisory. */
+    readonly critiques: Schema.$Array<Schema.Struct<{
+        readonly solutionId: Schema.String;
+        readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+    }>>;
+    readonly regenerations: Schema.Finite;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"controls">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type ControlsCheckpointV1 = typeof ControlsCheckpointV1.Type;
+export declare const TournamentHistoryEntryV1: Schema.Struct<{
+    readonly sequence: Schema.Finite;
+    readonly decision: Schema.Literals<readonly ["accepted", "rejected"]>;
+    readonly targeted: Schema.$Array<Schema.String>;
+    readonly rejectionReasons: Schema.$Array<Schema.String>;
+    readonly candidateAdequacy: Schema.optionalKey<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly admitted: Schema.Boolean;
+        readonly validSolutionCount: Schema.Finite;
+        readonly wrongSolutionCount: Schema.Finite;
+        readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+        readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+        readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+        readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+        readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+        readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+            readonly family: Schema.String;
+            readonly killed: Schema.Finite;
+            readonly total: Schema.Finite;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+export type TournamentHistoryEntryV1 = typeof TournamentHistoryEntryV1.Type;
+export declare const TournamentCheckpointV1: Schema.Struct<{
+    /** The incumbent suite after the last accepted iteration. */
+    readonly suite: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-regression">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"boundary">;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"counterfactual">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"metamorphic">;
+            readonly expectationMode: Schema.Literal<"preserved">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>]>>;
+        readonly overlays: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+        }>>;
+    }>;
+    readonly adequacy: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly admitted: Schema.Boolean;
+        readonly validSolutionCount: Schema.Finite;
+        readonly wrongSolutionCount: Schema.Finite;
+        readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+        readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+        readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+        readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+        readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+        readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+            readonly family: Schema.String;
+            readonly killed: Schema.Finite;
+            readonly total: Schema.Finite;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+    readonly oracle: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+        readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+        readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+        readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-regression">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"boundary">;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"counterfactual">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"metamorphic">;
+            readonly expectationMode: Schema.Literal<"preserved">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>]>>;
+        readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"candidate-policy">;
+            readonly policyId: Schema.String;
+            readonly forbiddenPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"test-command">;
+            readonly recipeId: Schema.String;
+            readonly expectedExitCode: Schema.Finite;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"json-field">;
+            readonly pointer: Schema.String;
+            readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+            readonly expectedJson: Schema.optionalKey<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ordered-events">;
+            readonly eventTypes: Schema.$Array<Schema.String>;
+            readonly terminalEvent: Schema.optionalKey<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"property">;
+            readonly propertyId: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"differential">;
+            readonly implementationIds: Schema.$Array<Schema.String>;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"architecture">;
+            readonly ruleId: Schema.String;
+            readonly expectedPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"transformation-completeness">;
+            readonly ruleId: Schema.String;
+            readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+            readonly requiredNewPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"semantic-residual">;
+            readonly criterion: Schema.String;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>]>>;
+        readonly solutions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+            readonly commit: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly observations: Schema.$Array<Schema.Struct<{
+            readonly solutionId: Schema.String;
+            readonly clauseId: Schema.String;
+            readonly repetition: Schema.Finite;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+            readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+        }>>;
+        readonly knownLimitations: Schema.$Array<Schema.String>;
+    }>;
+    readonly valid: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>, Schema.Struct<{
+            readonly path: Schema.String;
+            readonly delete: Schema.Literal<true>;
+        }>]>>>;
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    }>>;
+    readonly wrong: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>, Schema.Struct<{
+            readonly path: Schema.String;
+            readonly delete: Schema.Literal<true>;
+        }>]>>>;
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    }>>;
+    /** Lazy advisory control reviews, checkpointed after every completed critic round. */
+    readonly critiques: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly solutionId: Schema.String;
+        readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+        readonly detail: Schema.String;
+        readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+    }>>>;
+    readonly history: Schema.$Array<Schema.Struct<{
+        readonly sequence: Schema.Finite;
+        readonly decision: Schema.Literals<readonly ["accepted", "rejected"]>;
+        readonly targeted: Schema.$Array<Schema.String>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+        readonly candidateAdequacy: Schema.optionalKey<Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly admitted: Schema.Boolean;
+            readonly validSolutionCount: Schema.Finite;
+            readonly wrongSolutionCount: Schema.Finite;
+            readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+            readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+            readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+            readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+            readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+            readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                readonly family: Schema.String;
+                readonly killed: Schema.Finite;
+                readonly total: Schema.Finite;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>>;
+    }>>;
+    readonly iterations: Schema.Finite;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"tournament">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type TournamentCheckpointV1 = typeof TournamentCheckpointV1.Type;
+export declare const ChallengeCheckpointV1: Schema.Struct<{
+    readonly heldOut: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>, Schema.Struct<{
+            readonly path: Schema.String;
+            readonly delete: Schema.Literal<true>;
+        }>]>>>;
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+        readonly family: Schema.String;
+        readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+    }>>;
+    readonly adequacy: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly admitted: Schema.Boolean;
+        readonly validSolutionCount: Schema.Finite;
+        readonly wrongSolutionCount: Schema.Finite;
+        readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+        readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+        readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+        readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+        readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+        readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+            readonly family: Schema.String;
+            readonly killed: Schema.Finite;
+            readonly total: Schema.Finite;
+        }>>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+    readonly oracle: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly caseId: Schema.String;
+        readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+        readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+        readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+        readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"historical-regression">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"boundary">;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"counterfactual">;
+            readonly expectationMode: Schema.Literal<"changes">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"metamorphic">;
+            readonly expectationMode: Schema.Literal<"preserved">;
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+            readonly testPath: Schema.String;
+        }>]>>;
+        readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"candidate-policy">;
+            readonly policyId: Schema.String;
+            readonly forbiddenPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"test-command">;
+            readonly recipeId: Schema.String;
+            readonly expectedExitCode: Schema.Finite;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"json-field">;
+            readonly pointer: Schema.String;
+            readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+            readonly expectedJson: Schema.optionalKey<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"ordered-events">;
+            readonly eventTypes: Schema.$Array<Schema.String>;
+            readonly terminalEvent: Schema.optionalKey<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"property">;
+            readonly propertyId: Schema.String;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"differential">;
+            readonly implementationIds: Schema.$Array<Schema.String>;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"architecture">;
+            readonly ruleId: Schema.String;
+            readonly expectedPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"transformation-completeness">;
+            readonly ruleId: Schema.String;
+            readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+            readonly requiredNewPaths: Schema.$Array<Schema.String>;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"semantic-residual">;
+            readonly criterion: Schema.String;
+            readonly id: Schema.String;
+            readonly critical: Schema.Boolean;
+            readonly description: Schema.String;
+        }>]>>;
+        readonly solutions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+            readonly commit: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly observations: Schema.$Array<Schema.Struct<{
+            readonly solutionId: Schema.String;
+            readonly clauseId: Schema.String;
+            readonly repetition: Schema.Finite;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+            readonly detail: Schema.String;
+            readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+        }>>;
+        readonly knownLimitations: Schema.$Array<Schema.String>;
+    }>;
+    readonly verdict: Schema.Literals<readonly ["passed", "failed"]>;
+    readonly fold: Schema.Finite;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"challenge">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type ChallengeCheckpointV1 = typeof ChallengeCheckpointV1.Type;
+export declare const AdmitCheckpointV1: Schema.Struct<{
+    readonly benchmarkCase: Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly id: Schema.String;
+        readonly capabilityId: Schema.String;
+        readonly familyId: Schema.String;
+        readonly seedId: Schema.String;
+        readonly lane: Schema.Literals<readonly ["request", "repository-agent"]>;
+        readonly visible: Schema.Union<readonly [Schema.Struct<{
+            readonly lane: Schema.Literal<"request">;
+            readonly id: Schema.String;
+            readonly request: Schema.Struct<{
+                readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+                readonly method: Schema.Literal<"POST">;
+                readonly path: Schema.String;
+                readonly headers: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly value: Schema.String;
+                }>>;
+                readonly bodyJson: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly lane: Schema.Literal<"repository-agent">;
+            readonly id: Schema.String;
+            readonly requestText: Schema.String;
+            readonly checkoutCommit: Schema.String;
+            readonly allowedTools: Schema.$Array<Schema.Literals<readonly ["read", "search", "edit", "shell", "test"]>>;
+            readonly constraints: Schema.$Array<Schema.String>;
+        }>]>;
+        readonly hidden: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+            readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+            readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+            readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>>;
+            readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"candidate-policy">;
+                readonly policyId: Schema.String;
+                readonly forbiddenPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"test-command">;
+                readonly recipeId: Schema.String;
+                readonly expectedExitCode: Schema.Finite;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"json-field">;
+                readonly pointer: Schema.String;
+                readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+                readonly expectedJson: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"ordered-events">;
+                readonly eventTypes: Schema.$Array<Schema.String>;
+                readonly terminalEvent: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"property">;
+                readonly propertyId: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"differential">;
+                readonly implementationIds: Schema.$Array<Schema.String>;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"architecture">;
+                readonly ruleId: Schema.String;
+                readonly expectedPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"transformation-completeness">;
+                readonly ruleId: Schema.String;
+                readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+                readonly requiredNewPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"semantic-residual">;
+                readonly criterion: Schema.String;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>]>>;
+            readonly solutions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+                readonly family: Schema.String;
+                readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+                readonly commit: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly solutionId: Schema.String;
+                readonly clauseId: Schema.String;
+                readonly repetition: Schema.Finite;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>>;
+            readonly knownLimitations: Schema.$Array<Schema.String>;
+        }>;
+        readonly trajectoryPolicy: Schema.optionalKey<Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly purpose: Schema.Literal<"routing-signal">;
+            readonly validationRecipeIds: Schema.$Array<Schema.String>;
+            readonly protectedPaths: Schema.$Array<Schema.String>;
+            readonly thresholds: Schema.Struct<{
+                readonly maximumToolCalls: Schema.Finite;
+                readonly maximumFailedToolCalls: Schema.Finite;
+                readonly maximumRepeatedFailedActions: Schema.Finite;
+            }>;
+            readonly requirements: Schema.Struct<{
+                readonly passingValidationAfterLastMutation: Schema.Boolean;
+                readonly noProtectedPathMutations: Schema.Boolean;
+            }>;
+            readonly rationale: Schema.String;
+        }>>;
+        readonly adequacy: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly admitted: Schema.Boolean;
+            readonly validSolutionCount: Schema.Finite;
+            readonly wrongSolutionCount: Schema.Finite;
+            readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+            readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+            readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+            readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+            readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+            readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                readonly family: Schema.String;
+                readonly killed: Schema.Finite;
+                readonly total: Schema.Finite;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly qualityFindings: Schema.$Array<Schema.Struct<{
+            readonly axis: Schema.Literals<readonly ["authenticity", "specification-sufficiency", "oracle-adequacy", "stability", "distinctness", "realism", "leakage", "triviality", "coverage"]>;
+            readonly outcome: Schema.Literals<readonly ["pass", "fail", "review-required"]>;
+            readonly detail: Schema.String;
+            readonly evidence: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                readonly id: Schema.String;
+                readonly path: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly evidenceIds: Schema.$Array<Schema.String>;
+        }>>;
+        readonly behavioralFingerprint: Schema.String;
+        readonly status: Schema.Literals<readonly ["rejected", "valid-library", "routing-eligible", "routing-active"]>;
+        readonly rejectionReasons: Schema.$Array<Schema.String>;
+    }>;
+    readonly verdict: Schema.Literals<readonly ["admitted", "rejected"]>;
+    readonly reasons: Schema.$Array<Schema.String>;
+    readonly evidence: Schema.Struct<{
+        readonly validCount: Schema.Finite;
+        readonly wrongCount: Schema.Finite;
+        readonly heldOutWrongCount: Schema.Finite;
+        readonly semanticKills: Schema.$Array<Schema.String>;
+    }>;
+    readonly version: Schema.Literal<1>;
+    readonly stage: Schema.Literal<"admit">;
+    readonly parentDigest: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type AdmitCheckpointV1 = typeof AdmitCheckpointV1.Type;
+export type PipelineCheckpointsV1 = {
+    readonly seed?: SeedCheckpointV1;
+    readonly spec?: SpecCheckpointV1;
+    readonly oracle?: OracleCheckpointV1;
+    readonly controls?: ControlsCheckpointV1;
+    readonly tournament?: TournamentCheckpointV1;
+    readonly challenge?: ChallengeCheckpointV1;
+    readonly admit?: AdmitCheckpointV1;
+};
+export declare const PIPELINE_CHECKPOINT_SCHEMAS: {
+    readonly seed: Schema.Struct<{
+        readonly seed: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly id: Schema.String;
+            readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+            readonly source: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-fix">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-feature">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-refactor">;
+                readonly changeEpisodeId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"existing-test">;
+                readonly testIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"public-api">;
+                readonly surfaceIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"schema-contract">;
+                readonly protocolIds: Schema.$Array<Schema.String>;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"production-request">;
+                readonly requestId: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+                readonly reviewId: Schema.String;
+            }>]>;
+            readonly summary: Schema.String;
+            readonly capabilityEvidence: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                readonly id: Schema.String;
+                readonly path: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly initialState: Schema.Struct<{
+                readonly commit: Schema.String;
+                readonly parentCommit: Schema.optionalKey<Schema.String>;
+            }>;
+            readonly targetBehavior: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                    readonly id: Schema.String;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                }>>;
+            }>>;
+            readonly referenceCommit: Schema.optionalKey<Schema.String>;
+            readonly baselineObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                readonly subjectId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+            }>>;
+            readonly candidateTestIds: Schema.$Array<Schema.String>;
+            readonly environment: Schema.Struct<{
+                readonly packageManager: Schema.optionalKey<Schema.Struct<{
+                    readonly name: Schema.Literal<"pnpm">;
+                    readonly version: Schema.String;
+                }>>;
+                readonly lockfilePath: Schema.optionalKey<Schema.String>;
+                readonly protectedControlPaths: Schema.$Array<Schema.String>;
+                readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+                readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                    readonly cwd: Schema.String;
+                    readonly executable: Schema.String;
+                    readonly args: Schema.$Array<Schema.String>;
+                    readonly timeoutMs: Schema.Finite;
+                }>>;
+            }>;
+            readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+            readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly qualification: Schema.Struct<{
+            readonly seed: Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly id: Schema.String;
+                readonly status: Schema.Literals<readonly ["candidate", "qualified", "rejected"]>;
+                readonly source: Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"historical-fix">;
+                    readonly changeEpisodeId: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"historical-feature">;
+                    readonly changeEpisodeId: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"historical-refactor">;
+                    readonly changeEpisodeId: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"existing-test">;
+                    readonly testIds: Schema.$Array<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"public-api">;
+                    readonly surfaceIds: Schema.$Array<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"schema-contract">;
+                    readonly protocolIds: Schema.$Array<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"production-request">;
+                    readonly requestId: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"reviewed-synthetic-gap">;
+                    readonly reviewId: Schema.String;
+                }>]>;
+                readonly summary: Schema.String;
+                readonly capabilityEvidence: Schema.$Array<Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                    readonly id: Schema.String;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly initialState: Schema.Struct<{
+                    readonly commit: Schema.String;
+                    readonly parentCommit: Schema.optionalKey<Schema.String>;
+                }>;
+                readonly targetBehavior: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly description: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly evidence: Schema.$Array<Schema.Struct<{
+                        readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                        readonly id: Schema.String;
+                        readonly path: Schema.optionalKey<Schema.String>;
+                    }>>;
+                }>>;
+                readonly referenceCommit: Schema.optionalKey<Schema.String>;
+                readonly baselineObservations: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                    readonly subjectId: Schema.String;
+                    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                    readonly detail: Schema.String;
+                }>>;
+                readonly preChangeObservations: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                    readonly subjectId: Schema.String;
+                    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                    readonly detail: Schema.String;
+                }>>;
+                readonly postChangeObservations: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["test-command", "schema", "property", "event-trace", "structural"]>;
+                    readonly subjectId: Schema.String;
+                    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                    readonly detail: Schema.String;
+                }>>;
+                readonly candidateTestIds: Schema.$Array<Schema.String>;
+                readonly environment: Schema.Struct<{
+                    readonly packageManager: Schema.optionalKey<Schema.Struct<{
+                        readonly name: Schema.Literal<"pnpm">;
+                        readonly version: Schema.String;
+                    }>>;
+                    readonly lockfilePath: Schema.optionalKey<Schema.String>;
+                    readonly protectedControlPaths: Schema.$Array<Schema.String>;
+                    readonly trustedPreparationRecipes: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                        readonly cwd: Schema.String;
+                        readonly executable: Schema.String;
+                        readonly args: Schema.$Array<Schema.String>;
+                        readonly timeoutMs: Schema.Finite;
+                    }>>;
+                    readonly candidateValidationRecipes: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                        readonly cwd: Schema.String;
+                        readonly executable: Schema.String;
+                        readonly args: Schema.$Array<Schema.String>;
+                        readonly timeoutMs: Schema.Finite;
+                    }>>;
+                    readonly baselineGradeRecipes: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                        readonly cwd: Schema.String;
+                        readonly executable: Schema.String;
+                        readonly args: Schema.$Array<Schema.String>;
+                        readonly timeoutMs: Schema.Finite;
+                    }>>;
+                    readonly gradeRecipes: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+                        readonly cwd: Schema.String;
+                        readonly executable: Schema.String;
+                        readonly args: Schema.$Array<Schema.String>;
+                        readonly timeoutMs: Schema.Finite;
+                    }>>;
+                }>;
+                readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+                readonly risks: Schema.$Array<Schema.Literals<readonly ["ambiguous-intent", "bundled-change", "external-service", "flaky-baseline", "reference-only-oracle", "weak-test-delta", "unrealistic-mutation", "private-context", "cross-batch-instability", "review-required"]>>;
+                readonly rejectionReasons: Schema.$Array<Schema.String>;
+            }>;
+            readonly stability: Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly seedId: Schema.String;
+                readonly batchesRequired: Schema.Finite;
+                readonly repetitionsPerBatch: Schema.Finite;
+                readonly stable: Schema.Boolean;
+                readonly batches: Schema.$Array<Schema.Struct<{
+                    readonly batch: Schema.Finite;
+                    readonly status: Schema.Literals<readonly ["qualified", "rejected"]>;
+                    readonly phaseSignatures: Schema.$Array<Schema.Struct<{
+                        readonly phase: Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>;
+                        readonly signatures: Schema.$Array<Schema.String>;
+                    }>>;
+                    readonly rejectionReasons: Schema.$Array<Schema.String>;
+                }>>;
+                readonly divergentPhases: Schema.$Array<Schema.Literals<readonly ["baseline", "pre-change", "post-change"]>>;
+                readonly failureSignatures: Schema.$Array<Schema.Struct<{
+                    readonly signature: Schema.String;
+                    readonly count: Schema.Finite;
+                }>>;
+                readonly rejectionReasons: Schema.$Array<Schema.String>;
+            }>;
+        }>;
+        readonly repository: Schema.Struct<{
+            readonly root: Schema.String;
+            readonly commit: Schema.String;
+            readonly tree: Schema.String;
+        }>;
+        readonly selection: Schema.Struct<{
+            readonly candidates: Schema.$Array<Schema.Struct<{
+                readonly commit: Schema.String;
+                readonly subject: Schema.String;
+                readonly score: Schema.Finite;
+                readonly rationale: Schema.String;
+            }>>;
+            readonly selectedCommit: Schema.String;
+            readonly rejected: Schema.$Array<Schema.Struct<{
+                readonly commit: Schema.String;
+                readonly reason: Schema.String;
+            }>>;
+        }>;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"seed">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly spec: Schema.Struct<{
+        readonly visible: Schema.Union<readonly [Schema.Struct<{
+            readonly lane: Schema.Literal<"request">;
+            readonly id: Schema.String;
+            readonly request: Schema.Struct<{
+                readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+                readonly method: Schema.Literal<"POST">;
+                readonly path: Schema.String;
+                readonly headers: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly value: Schema.String;
+                }>>;
+                readonly bodyJson: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly lane: Schema.Literal<"repository-agent">;
+            readonly id: Schema.String;
+            readonly requestText: Schema.String;
+            readonly checkoutCommit: Schema.String;
+            readonly allowedTools: Schema.$Array<Schema.Literals<readonly ["read", "search", "edit", "shell", "test"]>>;
+            readonly constraints: Schema.$Array<Schema.String>;
+        }>]>;
+        readonly analysis: Schema.Struct<{
+            readonly summary: Schema.String;
+            readonly userObservableBehaviors: Schema.$Array<Schema.String>;
+            readonly constraints: Schema.$Array<Schema.String>;
+            readonly risks: Schema.$Array<Schema.String>;
+        }>;
+        readonly scope: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["changed", "preserved"]>;
+            readonly behaviorIds: Schema.$Array<Schema.String>;
+            readonly description: Schema.String;
+        }>>;
+        readonly contextSources: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly content: Schema.String;
+        }>>;
+        /** Advisory model reviews; write RepositorySpecificationReviewV1 values where possible. */
+        readonly reviews: Schema.$Array<Schema.Unknown>;
+        readonly revisions: Schema.Finite;
+        readonly leakFindings: Schema.$Array<Schema.String>;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"spec">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly oracle: Schema.Struct<{
+        readonly suite: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>>;
+            readonly overlays: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+            }>>;
+        }>;
+        readonly fixtureMetadata: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-regression", "boundary", "counterfactual", "metamorphic"]>;
+            readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+            readonly description: Schema.String;
+            readonly expectedBehavior: Schema.String;
+            readonly testPath: Schema.String;
+        }>>;
+        /** Advisory model self-report; witnesses are the executed evidence. */
+        readonly scopeCoverage: Schema.$Array<Schema.Struct<{
+            readonly scopeId: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["covered", "unsupported", "contradictory", "uncertain"]>;
+            readonly fixtureIds: Schema.$Array<Schema.String>;
+            readonly detail: Schema.String;
+        }>>;
+        readonly preflight: Schema.Struct<{
+            readonly passed: Schema.Literal<true>;
+            readonly repairs: Schema.Finite;
+        }>;
+        readonly witnesses: Schema.$Array<Schema.Struct<{
+            readonly scopeId: Schema.String;
+            readonly hypothesis: Schema.String;
+            readonly outcome: Schema.Literals<readonly ["already-detected", "confirmed-escape"]>;
+            readonly explanation: Schema.String;
+            readonly referenceCommit: Schema.String;
+            readonly fileOverrides: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>>;
+            readonly fixture: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>;
+            readonly overlay: Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+            }>;
+            readonly referenceEvidence: Schema.Struct<{
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>;
+            readonly mutantEvidence: Schema.Struct<{
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>;
+            readonly incumbentEvidence: Schema.$Array<Schema.Struct<{
+                readonly fixtureId: Schema.String;
+                readonly evidence: Schema.Struct<{
+                    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                    readonly detail: Schema.String;
+                    readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+                }>;
+            }>>;
+            readonly executionOperationId: Schema.String;
+        }>>;
+        readonly coverageRounds: Schema.Finite;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"oracle">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly controls: Schema.Struct<{
+        readonly valid: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>, Schema.Struct<{
+                readonly path: Schema.String;
+                readonly delete: Schema.Literal<true>;
+            }>]>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        }>>;
+        readonly wrong: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>, Schema.Struct<{
+                readonly path: Schema.String;
+                readonly delete: Schema.Literal<true>;
+            }>]>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        }>>;
+        /** Advisory. */
+        readonly critiques: Schema.$Array<Schema.Struct<{
+            readonly solutionId: Schema.String;
+            readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+            readonly detail: Schema.String;
+            readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+        }>>;
+        readonly regenerations: Schema.Finite;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"controls">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly tournament: Schema.Struct<{
+        /** The incumbent suite after the last accepted iteration. */
+        readonly suite: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>>;
+            readonly overlays: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+            }>>;
+        }>;
+        readonly adequacy: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly admitted: Schema.Boolean;
+            readonly validSolutionCount: Schema.Finite;
+            readonly wrongSolutionCount: Schema.Finite;
+            readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+            readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+            readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+            readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+            readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+            readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                readonly family: Schema.String;
+                readonly killed: Schema.Finite;
+                readonly total: Schema.Finite;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly oracle: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+            readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+            readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+            readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>>;
+            readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"candidate-policy">;
+                readonly policyId: Schema.String;
+                readonly forbiddenPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"test-command">;
+                readonly recipeId: Schema.String;
+                readonly expectedExitCode: Schema.Finite;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"json-field">;
+                readonly pointer: Schema.String;
+                readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+                readonly expectedJson: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"ordered-events">;
+                readonly eventTypes: Schema.$Array<Schema.String>;
+                readonly terminalEvent: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"property">;
+                readonly propertyId: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"differential">;
+                readonly implementationIds: Schema.$Array<Schema.String>;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"architecture">;
+                readonly ruleId: Schema.String;
+                readonly expectedPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"transformation-completeness">;
+                readonly ruleId: Schema.String;
+                readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+                readonly requiredNewPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"semantic-residual">;
+                readonly criterion: Schema.String;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>]>>;
+            readonly solutions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+                readonly family: Schema.String;
+                readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+                readonly commit: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly solutionId: Schema.String;
+                readonly clauseId: Schema.String;
+                readonly repetition: Schema.Finite;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>>;
+            readonly knownLimitations: Schema.$Array<Schema.String>;
+        }>;
+        readonly valid: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>, Schema.Struct<{
+                readonly path: Schema.String;
+                readonly delete: Schema.Literal<true>;
+            }>]>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        }>>;
+        readonly wrong: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>, Schema.Struct<{
+                readonly path: Schema.String;
+                readonly delete: Schema.Literal<true>;
+            }>]>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        }>>;
+        /** Lazy advisory control reviews, checkpointed after every completed critic round. */
+        readonly critiques: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly solutionId: Schema.String;
+            readonly classification: Schema.Literals<readonly ["valid", "wrong", "uncertain"]>;
+            readonly detail: Schema.String;
+            readonly violatedBehaviorIds: Schema.$Array<Schema.String>;
+        }>>>;
+        readonly history: Schema.$Array<Schema.Struct<{
+            readonly sequence: Schema.Finite;
+            readonly decision: Schema.Literals<readonly ["accepted", "rejected"]>;
+            readonly targeted: Schema.$Array<Schema.String>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+            readonly candidateAdequacy: Schema.optionalKey<Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly caseId: Schema.String;
+                readonly admitted: Schema.Boolean;
+                readonly validSolutionCount: Schema.Finite;
+                readonly wrongSolutionCount: Schema.Finite;
+                readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+                readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+                readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+                readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+                readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+                readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                    readonly family: Schema.String;
+                    readonly killed: Schema.Finite;
+                    readonly total: Schema.Finite;
+                }>>;
+                readonly rejectionReasons: Schema.$Array<Schema.String>;
+            }>>;
+        }>>;
+        readonly iterations: Schema.Finite;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"tournament">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly challenge: Schema.Struct<{
+        readonly heldOut: Schema.$Array<Schema.Struct<{
+            readonly commit: Schema.String;
+            readonly fileOverrides: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly path: Schema.String;
+                readonly content: Schema.String;
+            }>, Schema.Struct<{
+                readonly path: Schema.String;
+                readonly delete: Schema.Literal<true>;
+            }>]>>>;
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+            readonly family: Schema.String;
+            readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+        }>>;
+        readonly adequacy: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly admitted: Schema.Boolean;
+            readonly validSolutionCount: Schema.Finite;
+            readonly wrongSolutionCount: Schema.Finite;
+            readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+            readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+            readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+            readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+            readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+            readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                readonly family: Schema.String;
+                readonly killed: Schema.Finite;
+                readonly total: Schema.Finite;
+            }>>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly oracle: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly caseId: Schema.String;
+            readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+            readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+            readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+            readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"historical-regression">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"boundary">;
+                readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"counterfactual">;
+                readonly expectationMode: Schema.Literal<"changes">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"metamorphic">;
+                readonly expectationMode: Schema.Literal<"preserved">;
+                readonly id: Schema.String;
+                readonly description: Schema.String;
+                readonly expectedBehavior: Schema.String;
+                readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                readonly testPath: Schema.String;
+            }>]>>;
+            readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"candidate-policy">;
+                readonly policyId: Schema.String;
+                readonly forbiddenPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"test-command">;
+                readonly recipeId: Schema.String;
+                readonly expectedExitCode: Schema.Finite;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"json-field">;
+                readonly pointer: Schema.String;
+                readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+                readonly expectedJson: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"ordered-events">;
+                readonly eventTypes: Schema.$Array<Schema.String>;
+                readonly terminalEvent: Schema.optionalKey<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"property">;
+                readonly propertyId: Schema.String;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"differential">;
+                readonly implementationIds: Schema.$Array<Schema.String>;
+                readonly fixtureIds: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"architecture">;
+                readonly ruleId: Schema.String;
+                readonly expectedPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"transformation-completeness">;
+                readonly ruleId: Schema.String;
+                readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+                readonly requiredNewPaths: Schema.$Array<Schema.String>;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"semantic-residual">;
+                readonly criterion: Schema.String;
+                readonly id: Schema.String;
+                readonly critical: Schema.Boolean;
+                readonly description: Schema.String;
+            }>]>>;
+            readonly solutions: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+                readonly family: Schema.String;
+                readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+                readonly commit: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly solutionId: Schema.String;
+                readonly clauseId: Schema.String;
+                readonly repetition: Schema.Finite;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                readonly detail: Schema.String;
+                readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+            }>>;
+            readonly knownLimitations: Schema.$Array<Schema.String>;
+        }>;
+        readonly verdict: Schema.Literals<readonly ["passed", "failed"]>;
+        readonly fold: Schema.Finite;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"challenge">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+    readonly admit: Schema.Struct<{
+        readonly benchmarkCase: Schema.Struct<{
+            readonly version: Schema.Literal<1>;
+            readonly id: Schema.String;
+            readonly capabilityId: Schema.String;
+            readonly familyId: Schema.String;
+            readonly seedId: Schema.String;
+            readonly lane: Schema.Literals<readonly ["request", "repository-agent"]>;
+            readonly visible: Schema.Union<readonly [Schema.Struct<{
+                readonly lane: Schema.Literal<"request">;
+                readonly id: Schema.String;
+                readonly request: Schema.Struct<{
+                    readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+                    readonly method: Schema.Literal<"POST">;
+                    readonly path: Schema.String;
+                    readonly headers: Schema.$Array<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly value: Schema.String;
+                    }>>;
+                    readonly bodyJson: Schema.String;
+                }>;
+            }>, Schema.Struct<{
+                readonly lane: Schema.Literal<"repository-agent">;
+                readonly id: Schema.String;
+                readonly requestText: Schema.String;
+                readonly checkoutCommit: Schema.String;
+                readonly allowedTools: Schema.$Array<Schema.Literals<readonly ["read", "search", "edit", "shell", "test"]>>;
+                readonly constraints: Schema.$Array<Schema.String>;
+            }>]>;
+            readonly hidden: Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly caseId: Schema.String;
+                readonly hardFailurePolicy: Schema.Literal<"any-critical-hard-clause-fails">;
+                readonly executionBindingDigest: Schema.optionalKey<Schema.String>;
+                readonly executionRepetitions: Schema.optionalKey<Schema.Finite>;
+                readonly fixtures: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"historical-regression">;
+                    readonly expectationMode: Schema.Literal<"changes">;
+                    readonly id: Schema.String;
+                    readonly description: Schema.String;
+                    readonly expectedBehavior: Schema.String;
+                    readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                    readonly testPath: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"boundary">;
+                    readonly expectationMode: Schema.Literals<readonly ["changes", "preserved"]>;
+                    readonly id: Schema.String;
+                    readonly description: Schema.String;
+                    readonly expectedBehavior: Schema.String;
+                    readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                    readonly testPath: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"counterfactual">;
+                    readonly expectationMode: Schema.Literal<"changes">;
+                    readonly id: Schema.String;
+                    readonly description: Schema.String;
+                    readonly expectedBehavior: Schema.String;
+                    readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                    readonly testPath: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"metamorphic">;
+                    readonly expectationMode: Schema.Literal<"preserved">;
+                    readonly id: Schema.String;
+                    readonly description: Schema.String;
+                    readonly expectedBehavior: Schema.String;
+                    readonly source: Schema.Literals<readonly ["historical", "generated", "reviewed"]>;
+                    readonly testPath: Schema.String;
+                }>]>>;
+                readonly clauses: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly kind: Schema.Literal<"candidate-policy">;
+                    readonly policyId: Schema.String;
+                    readonly forbiddenPaths: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"test-command">;
+                    readonly recipeId: Schema.String;
+                    readonly expectedExitCode: Schema.Finite;
+                    readonly fixtureIds: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"json-field">;
+                    readonly pointer: Schema.String;
+                    readonly operator: Schema.Literals<readonly ["equals", "present", "absent"]>;
+                    readonly expectedJson: Schema.optionalKey<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"ordered-events">;
+                    readonly eventTypes: Schema.$Array<Schema.String>;
+                    readonly terminalEvent: Schema.optionalKey<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"property">;
+                    readonly propertyId: Schema.String;
+                    readonly fixtureIds: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"differential">;
+                    readonly implementationIds: Schema.$Array<Schema.String>;
+                    readonly fixtureIds: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"architecture">;
+                    readonly ruleId: Schema.String;
+                    readonly expectedPaths: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"transformation-completeness">;
+                    readonly ruleId: Schema.String;
+                    readonly forbiddenLegacyPaths: Schema.$Array<Schema.String>;
+                    readonly requiredNewPaths: Schema.$Array<Schema.String>;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>, Schema.Struct<{
+                    readonly kind: Schema.Literal<"semantic-residual">;
+                    readonly criterion: Schema.String;
+                    readonly id: Schema.String;
+                    readonly critical: Schema.Boolean;
+                    readonly description: Schema.String;
+                }>]>>;
+                readonly solutions: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["historical-reference", "independent-valid", "simplified-valid", "behavior-preserving-valid", "historical-defect", "mutation", "model-near-miss", "reward-hacking"]>;
+                    readonly family: Schema.String;
+                    readonly expectedClass: Schema.Literals<readonly ["valid", "wrong"]>;
+                    readonly commit: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly observations: Schema.$Array<Schema.Struct<{
+                    readonly solutionId: Schema.String;
+                    readonly clauseId: Schema.String;
+                    readonly repetition: Schema.Finite;
+                    readonly outcome: Schema.Literals<readonly ["pass", "fail", "unknown"]>;
+                    readonly detail: Schema.String;
+                    readonly inconclusiveReason: Schema.optionalKey<Schema.Literal<"unattributed-test-failure">>;
+                }>>;
+                readonly knownLimitations: Schema.$Array<Schema.String>;
+            }>;
+            readonly trajectoryPolicy: Schema.optionalKey<Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly caseId: Schema.String;
+                readonly purpose: Schema.Literal<"routing-signal">;
+                readonly validationRecipeIds: Schema.$Array<Schema.String>;
+                readonly protectedPaths: Schema.$Array<Schema.String>;
+                readonly thresholds: Schema.Struct<{
+                    readonly maximumToolCalls: Schema.Finite;
+                    readonly maximumFailedToolCalls: Schema.Finite;
+                    readonly maximumRepeatedFailedActions: Schema.Finite;
+                }>;
+                readonly requirements: Schema.Struct<{
+                    readonly passingValidationAfterLastMutation: Schema.Boolean;
+                    readonly noProtectedPathMutations: Schema.Boolean;
+                }>;
+                readonly rationale: Schema.String;
+            }>>;
+            readonly adequacy: Schema.Struct<{
+                readonly version: Schema.Literal<1>;
+                readonly caseId: Schema.String;
+                readonly admitted: Schema.Boolean;
+                readonly validSolutionCount: Schema.Finite;
+                readonly wrongSolutionCount: Schema.Finite;
+                readonly falseRejectedSolutionIds: Schema.$Array<Schema.String>;
+                readonly falseAcceptedSolutionIds: Schema.$Array<Schema.String>;
+                readonly unstableSolutionIds: Schema.$Array<Schema.String>;
+                readonly unobservedClauseIds: Schema.$Array<Schema.String>;
+                readonly insufficientObservationPairs: Schema.$Array<Schema.String>;
+                readonly mutationFamilyKills: Schema.$Array<Schema.Struct<{
+                    readonly family: Schema.String;
+                    readonly killed: Schema.Finite;
+                    readonly total: Schema.Finite;
+                }>>;
+                readonly rejectionReasons: Schema.$Array<Schema.String>;
+            }>;
+            readonly qualityFindings: Schema.$Array<Schema.Struct<{
+                readonly axis: Schema.Literals<readonly ["authenticity", "specification-sufficiency", "oracle-adequacy", "stability", "distinctness", "realism", "leakage", "triviality", "coverage"]>;
+                readonly outcome: Schema.Literals<readonly ["pass", "fail", "review-required"]>;
+                readonly detail: Schema.String;
+                readonly evidence: Schema.$Array<Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+                    readonly id: Schema.String;
+                    readonly path: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly evidenceIds: Schema.$Array<Schema.String>;
+            }>>;
+            readonly behavioralFingerprint: Schema.String;
+            readonly status: Schema.Literals<readonly ["rejected", "valid-library", "routing-eligible", "routing-active"]>;
+            readonly rejectionReasons: Schema.$Array<Schema.String>;
+        }>;
+        readonly verdict: Schema.Literals<readonly ["admitted", "rejected"]>;
+        readonly reasons: Schema.$Array<Schema.String>;
+        readonly evidence: Schema.Struct<{
+            readonly validCount: Schema.Finite;
+            readonly wrongCount: Schema.Finite;
+            readonly heldOutWrongCount: Schema.Finite;
+            readonly semanticKills: Schema.$Array<Schema.String>;
+        }>;
+        readonly version: Schema.Literal<1>;
+        readonly stage: Schema.Literal<"admit">;
+        readonly parentDigest: Schema.String;
+        readonly createdAt: Schema.String;
+    }>;
+};
+export type PipelineCheckpointOfV1<Stage extends PipelineStageV1> = NonNullable<PipelineCheckpointsV1[Stage]>;
+export declare const HostFeedbackFindingKindV1: Schema.Literals<readonly ["schema", "contract", "materialization", "compile", "execution", "critique"]>;
+export type HostFeedbackFindingKindV1 = typeof HostFeedbackFindingKindV1.Type;
+export declare const HostFeedbackFindingV1: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["schema", "contract", "materialization", "compile", "execution", "critique"]>;
+    readonly message: Schema.String;
+    readonly path: Schema.optionalKey<Schema.String>;
+}>;
+export type HostFeedbackFindingV1 = typeof HostFeedbackFindingV1.Type;
+/** Sent back to the SAME role with its prior output; never a terminal outcome. */
+export declare const HostFeedbackV1: Schema.Struct<{
+    readonly attempt: Schema.Finite;
+    readonly findings: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["schema", "contract", "materialization", "compile", "execution", "critique"]>;
+        readonly message: Schema.String;
+        readonly path: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly priorOutput: Schema.Unknown;
+}>;
+export type HostFeedbackV1 = typeof HostFeedbackV1.Type;
+declare const PipelineBudgetExhaustedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PipelineBudgetExhaustedError";
+} & Readonly<A>;
+export declare class PipelineBudgetExhaustedError extends PipelineBudgetExhaustedError_base<{
+    readonly budget: PipelineBudgetV1;
+    readonly modelCalls: number;
+    readonly elapsedMs: number;
+    readonly stage: string;
+}> {
+    get message(): string;
+}
+declare const PipelineStageError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PipelineStageError";
+} & Readonly<A>;
+export declare class PipelineStageError extends PipelineStageError_base<{
+    readonly stage: PipelineStageV1;
+    readonly detail: string;
+    readonly cause?: unknown;
+    /** Only reference qualification or unsupported repositories are terminal. */
+    readonly terminal: boolean;
+}> {
+    get message(): string;
+}
+/**
+ * Typed durable work below a completed stage. This small store contract is
+ * shared by stages and the concrete case store without a protocol/store cycle.
+ */
+export type PipelineWorkCheckpointStoreV1 = {
+    readonly readWorkCheckpoint: <A>(name: string, schema: Schema.Codec<A, unknown, never, unknown>) => Effect.Effect<Option.Option<A>, RepositoryFoundryError>;
+    readonly writeWorkCheckpoint: (name: string, value: unknown) => Effect.Effect<void, RepositoryFoundryError>;
+    readonly deleteWorkCheckpoint: (name: string) => Effect.Effect<void, RepositoryFoundryError>;
+};
+export type PipelineStageInputV1<Out> = {
+    readonly context: PipelineCaseContextV1;
+    readonly map: RepositoryBehaviorMapV1;
+    readonly checkpoints: PipelineCheckpointsV1;
+    readonly workCheckpointStore?: PipelineWorkCheckpointStoreV1;
+    /** Persist an intermediate value so a crash mid-loop resumes mid-loop. */
+    readonly checkpoint: (partial: Out) => Effect.Effect<void>;
+};
+export type PipelineStageRunV1<Out> = (input: PipelineStageInputV1<Out>) => Effect.Effect<Out, RepositoryFoundryError | PipelineBudgetExhaustedError, RepositoryFoundryLanguageModel>;
+/** sha256 over key-sorted JSON so equal checkpoints digest equally. */
+export declare const checkpointDigestV1: (value: unknown) => string;
+/** Stable admission identity; cumulative budget is intentionally extendable. */
+export declare const pipelineScientificIdentityDigestV1: (context: PipelineCaseContextV1, map: Pick<RepositoryBehaviorMapV1, "repository">) => string;
+export declare const pipelineStageToProgressStageV1: (stage: PipelineStageV1) => RepositoryFoundryProgressStageV1;
+export declare const pipelineStageIndexV1: (stage: PipelineStageV1) => number;
+export declare const nextPipelineStageV1: (stage: PipelineStageV1) => PipelineStageV1 | "done";
+export {};