@velum-labs/routekit-eval-setup 1.0.0

package/dist/project-contracts.d.ts

@@ -0,0 +1,1197 @@
+import { type EvalComparisonResult as EvalComparisonResultType } from "@velum-labs/routekit-eval-contracts";
+import { Schema } from "effect";
+export declare const EVAL_PROJECT_VERSION: 1;
+export declare const EvalProjectQuestion: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["workload-description", "candidate-models", "classifier-model", "author-model", "judge-model", "routing-objective", "maximum-unknown-weight", "routing-constraints"]>;
+    readonly prompt: Schema.String;
+    readonly options: Schema.$Array<Schema.String>;
+}>;
+export type EvalProjectQuestion = typeof EvalProjectQuestion.Type;
+export declare const EvalProjectSetupProgress: Schema.Union<readonly [Schema.TaggedStruct<"WorkloadDescriptionRequired", {}>, Schema.TaggedStruct<"CandidateModelsRequired", {
+    readonly workloadDescription: Schema.String;
+}>, Schema.TaggedStruct<"ClassifierModelRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+}>, Schema.TaggedStruct<"AuthorModelRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+}>, Schema.TaggedStruct<"JudgeModelRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+}>, Schema.TaggedStruct<"RoutingObjectiveRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly judgeModel: Schema.String;
+}>, Schema.TaggedStruct<"MaximumUnknownWeightRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly judgeModel: Schema.String;
+    readonly objective: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"highest-quality">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-cost">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-latency">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"balanced">;
+        readonly minimumQuality: Schema.Finite;
+        readonly weights: Schema.Struct<{
+            readonly quality: Schema.Finite;
+            readonly cost: Schema.Finite;
+            readonly latency: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"pareto">;
+        readonly minimumQuality: Schema.Finite;
+        readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+    }>]>;
+}>, Schema.TaggedStruct<"RoutingConstraintsRequired", {
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly judgeModel: Schema.String;
+    readonly objective: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"highest-quality">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-cost">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-latency">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"balanced">;
+        readonly minimumQuality: Schema.Finite;
+        readonly weights: Schema.Struct<{
+            readonly quality: Schema.Finite;
+            readonly cost: Schema.Finite;
+            readonly latency: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"pareto">;
+        readonly minimumQuality: Schema.Finite;
+        readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+    }>]>;
+    readonly maximumUnknownWeight: Schema.Finite;
+}>]>;
+export type EvalProjectSetupProgress = typeof EvalProjectSetupProgress.Type;
+export declare const EvalProjectConfiguration: Schema.Struct<{
+    readonly workloadDescription: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly judgeModel: Schema.String;
+    readonly objective: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"highest-quality">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-cost">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"lowest-latency">;
+        readonly minimumQuality: Schema.Finite;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"balanced">;
+        readonly minimumQuality: Schema.Finite;
+        readonly weights: Schema.Struct<{
+            readonly quality: Schema.Finite;
+            readonly cost: Schema.Finite;
+            readonly latency: Schema.Finite;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"pareto">;
+        readonly minimumQuality: Schema.Finite;
+        readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+    }>]>;
+    readonly maximumUnknownWeight: Schema.Finite;
+    readonly constraints: Schema.optionalKey<Schema.Struct<{
+        readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+        readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+    }>>;
+}>;
+export type EvalProjectConfiguration = typeof EvalProjectConfiguration.Type;
+export declare const EvalProjectState: Schema.Union<readonly [Schema.Struct<{
+    readonly stage: Schema.Literal<"setup-required">;
+    readonly progress: Schema.Union<readonly [Schema.TaggedStruct<"WorkloadDescriptionRequired", {}>, Schema.TaggedStruct<"CandidateModelsRequired", {
+        readonly workloadDescription: Schema.String;
+    }>, Schema.TaggedStruct<"ClassifierModelRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+    }>, Schema.TaggedStruct<"AuthorModelRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+    }>, Schema.TaggedStruct<"JudgeModelRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+    }>, Schema.TaggedStruct<"RoutingObjectiveRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+    }>, Schema.TaggedStruct<"MaximumUnknownWeightRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+    }>, Schema.TaggedStruct<"RoutingConstraintsRequired", {
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+    }>]>;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"dimensions-review">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"evaluations-review">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly basisDigest: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"ready">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"running">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly planId: Schema.String;
+    readonly runId: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"qualified">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly runId: Schema.String;
+    readonly reportPath: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly stage: Schema.Literal<"activated">;
+    readonly configuration: Schema.Struct<{
+        readonly workloadDescription: Schema.String;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly classifierModel: Schema.String;
+        readonly authorModel: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+    }>;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly runId: Schema.String;
+    readonly reportPath: Schema.String;
+    readonly evidenceDigest: Schema.String;
+    readonly targetIdentity: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly projectId: Schema.String;
+    readonly revision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sourceInventory: Schema.$Array<Schema.String>;
+}>]>;
+export type EvalProjectState = typeof EvalProjectState.Type;
+export declare const EvalDimensionCase: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly prompt: Schema.String;
+    readonly context: Schema.optionalKey<Schema.String>;
+    readonly rubric: Schema.String;
+}>;
+export type EvalDimensionCase = typeof EvalDimensionCase.Type;
+export declare const EvalDimensionSuite: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly dimensionId: Schema.String;
+    readonly maximumOutputTokens: Schema.Finite;
+    readonly cases: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly prompt: Schema.String;
+        readonly context: Schema.optionalKey<Schema.String>;
+        readonly rubric: Schema.String;
+    }>>;
+}>;
+export type EvalDimensionSuite = typeof EvalDimensionSuite.Type;
+export declare const EvalDecompositionBenchmarkCase: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly request: Schema.String;
+    readonly expected: Schema.Struct<{
+        readonly weights: Schema.$Array<Schema.Struct<{
+            readonly dimensionId: Schema.String;
+            readonly weight: Schema.Finite;
+        }>>;
+        readonly unknownWeight: Schema.Finite;
+    }>;
+}>;
+export type EvalDecompositionBenchmarkCase = typeof EvalDecompositionBenchmarkCase.Type;
+export declare const EvalDecompositionBenchmark: Schema.Struct<{
+    readonly maximumVectorL1Error: Schema.Finite;
+    readonly cases: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly request: Schema.String;
+        readonly expected: Schema.Struct<{
+            readonly weights: Schema.$Array<Schema.Struct<{
+                readonly dimensionId: Schema.String;
+                readonly weight: Schema.Finite;
+            }>>;
+            readonly unknownWeight: Schema.Finite;
+        }>;
+    }>>;
+}>;
+export type EvalDecompositionBenchmark = typeof EvalDecompositionBenchmark.Type;
+export declare const EvalCompositionCase: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly prompt: Schema.String;
+    readonly context: Schema.optionalKey<Schema.String>;
+    readonly rubric: Schema.String;
+    readonly decomposition: Schema.Struct<{
+        readonly weights: Schema.$Array<Schema.Struct<{
+            readonly dimensionId: Schema.String;
+            readonly weight: Schema.Finite;
+        }>>;
+        readonly unknownWeight: Schema.Finite;
+    }>;
+    readonly requirements: Schema.Struct<{
+        readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+        readonly requiresTools: Schema.Boolean;
+        readonly requiresVision: Schema.Boolean;
+        readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+        readonly maxOutputTokens: Schema.optionalKey<Schema.Finite>;
+    }>;
+}>;
+export type EvalCompositionCase = typeof EvalCompositionCase.Type;
+export declare const EvalCompositionSuite: Schema.Struct<{
+    readonly maximumOutputTokens: Schema.Finite;
+    readonly minimumWinnerScoreGap: Schema.Finite;
+    readonly minimumWinnerAgreement: Schema.Finite;
+    readonly cases: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly prompt: Schema.String;
+        readonly context: Schema.optionalKey<Schema.String>;
+        readonly rubric: Schema.String;
+        readonly decomposition: Schema.Struct<{
+            readonly weights: Schema.$Array<Schema.Struct<{
+                readonly dimensionId: Schema.String;
+                readonly weight: Schema.Finite;
+            }>>;
+            readonly unknownWeight: Schema.Finite;
+        }>;
+        readonly requirements: Schema.Struct<{
+            readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+            readonly requiresTools: Schema.Boolean;
+            readonly requiresVision: Schema.Boolean;
+            readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+            readonly maxOutputTokens: Schema.optionalKey<Schema.Finite>;
+        }>;
+    }>>;
+}>;
+export type EvalCompositionSuite = typeof EvalCompositionSuite.Type;
+export declare const EvalEvaluationProposal: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly evaluationDigest: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly judgeModel: Schema.String;
+    readonly suites: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly dimensionId: Schema.String;
+        readonly maximumOutputTokens: Schema.Finite;
+        readonly cases: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly prompt: Schema.String;
+            readonly context: Schema.optionalKey<Schema.String>;
+            readonly rubric: Schema.String;
+        }>>;
+    }>>;
+    readonly decompositionBenchmark: Schema.Struct<{
+        readonly maximumVectorL1Error: Schema.Finite;
+        readonly cases: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly request: Schema.String;
+            readonly expected: Schema.Struct<{
+                readonly weights: Schema.$Array<Schema.Struct<{
+                    readonly dimensionId: Schema.String;
+                    readonly weight: Schema.Finite;
+                }>>;
+                readonly unknownWeight: Schema.Finite;
+            }>;
+        }>>;
+    }>;
+    readonly compositionSuite: Schema.Struct<{
+        readonly maximumOutputTokens: Schema.Finite;
+        readonly minimumWinnerScoreGap: Schema.Finite;
+        readonly minimumWinnerAgreement: Schema.Finite;
+        readonly cases: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly prompt: Schema.String;
+            readonly context: Schema.optionalKey<Schema.String>;
+            readonly rubric: Schema.String;
+            readonly decomposition: Schema.Struct<{
+                readonly weights: Schema.$Array<Schema.Struct<{
+                    readonly dimensionId: Schema.String;
+                    readonly weight: Schema.Finite;
+                }>>;
+                readonly unknownWeight: Schema.Finite;
+            }>;
+            readonly requirements: Schema.Struct<{
+                readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+                readonly requiresTools: Schema.Boolean;
+                readonly requiresVision: Schema.Boolean;
+                readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                readonly maxOutputTokens: Schema.optionalKey<Schema.Finite>;
+            }>;
+        }>>;
+    }>;
+}>;
+export type EvalEvaluationProposal = typeof EvalEvaluationProposal.Type;
+export declare const EvalArtifactApproval: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly kind: Schema.Literals<readonly ["routing-basis", "evaluations"]>;
+    readonly digest: Schema.String;
+    readonly approvedAt: Schema.String;
+}>;
+export type EvalArtifactApproval = typeof EvalArtifactApproval.Type;
+export declare const EvalPlanScope: Schema.Literals<readonly ["pilot", "full"]>;
+export type EvalPlanScope = typeof EvalPlanScope.Type;
+export declare const EvalExecutionPlan: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly planId: Schema.String;
+    readonly projectId: Schema.String;
+    readonly projectRevision: Schema.Finite;
+    readonly createdAt: Schema.String;
+    readonly scope: Schema.Literals<readonly ["pilot", "full"]>;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly candidateModels: Schema.$Array<Schema.String>;
+    readonly classifierModel: Schema.String;
+    readonly authorModel: Schema.String;
+    readonly judgeModel: Schema.String;
+    readonly selectedCaseIds: Schema.$Array<Schema.Struct<{
+        readonly dimensionId: Schema.String;
+        readonly caseIds: Schema.$Array<Schema.String>;
+    }>>;
+    readonly selectedDecompositionCaseIds: Schema.$Array<Schema.String>;
+    readonly selectedCompositionCaseIds: Schema.$Array<Schema.String>;
+    readonly maximumOutputTokens: Schema.Finite;
+    readonly expectedDimensionCandidateCalls: Schema.Finite;
+    readonly expectedDimensionJudgeCalls: Schema.Finite;
+    readonly expectedClassifierCalls: Schema.Finite;
+    readonly expectedCompositionCandidateCalls: Schema.Finite;
+    readonly expectedCompositionJudgeCalls: Schema.Finite;
+    readonly expectedCandidateCalls: Schema.Finite;
+    readonly expectedJudgeCalls: Schema.Finite;
+    readonly expectedCallCount: Schema.Finite;
+}>;
+export type EvalExecutionPlan = typeof EvalExecutionPlan.Type;
+export declare const EvalRunTarget: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["configured", "external"]>;
+    readonly identity: Schema.String;
+    readonly publishAllowed: Schema.Boolean;
+}>;
+export type EvalRunTarget = typeof EvalRunTarget.Type;
+export declare const EvalRunCleanup: Schema.Struct<{
+    readonly sessionOpened: Schema.Boolean;
+    readonly sessionClosed: Schema.Boolean;
+    readonly detail: Schema.optionalKey<Schema.String>;
+}>;
+export type EvalRunCleanup = typeof EvalRunCleanup.Type;
+export declare const EvalRunLedger: Schema.Struct<{
+    readonly expectedCalls: Schema.Finite;
+    readonly observedCalls: Schema.Finite;
+    readonly observedCandidateRows: Schema.Finite;
+    readonly knownInputTokens: Schema.Finite;
+    readonly knownOutputTokens: Schema.Finite;
+    readonly unknownTokenMeasurements: Schema.Finite;
+    readonly knownPricedSubtotalUsd: Schema.Finite;
+    readonly unpricedCalls: Schema.Finite;
+}>;
+export type EvalRunLedger = typeof EvalRunLedger.Type;
+export declare const EvalClassifierObservation: Schema.Struct<{
+    readonly caseId: Schema.String;
+    readonly weights: Schema.$Array<Schema.Struct<{
+        readonly dimensionId: Schema.String;
+        readonly weight: Schema.Finite;
+    }>>;
+    readonly unknownWeight: Schema.Finite;
+    readonly vectorL1Error: Schema.Finite;
+    readonly passed: Schema.Boolean;
+    readonly classifierCallId: Schema.optionalKey<Schema.String>;
+    readonly measurement: Schema.Struct<{
+        readonly costUsd: Schema.optionalKey<Schema.Finite>;
+        readonly durationMs: Schema.optionalKey<Schema.Finite>;
+        readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+        readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+    }>;
+}>;
+export type EvalClassifierObservation = typeof EvalClassifierObservation.Type;
+export declare const EvalCompositionCaseResult: Schema.Struct<{
+    readonly caseId: Schema.String;
+    readonly predictedWinner: Schema.String;
+    readonly observedWinner: Schema.String;
+    readonly predictedScoreGap: Schema.Finite;
+    readonly observedScoreGap: Schema.Finite;
+    readonly passed: Schema.Boolean;
+}>;
+export type EvalCompositionCaseResult = typeof EvalCompositionCaseResult.Type;
+export declare const EvalRunQualification: Schema.Struct<{
+    readonly decomposition: Schema.Struct<{
+        readonly expectedCases: Schema.Finite;
+        readonly passedCases: Schema.Finite;
+        readonly maximumObservedL1Error: Schema.Finite;
+        readonly observations: Schema.$Array<Schema.Struct<{
+            readonly caseId: Schema.String;
+            readonly weights: Schema.$Array<Schema.Struct<{
+                readonly dimensionId: Schema.String;
+                readonly weight: Schema.Finite;
+            }>>;
+            readonly unknownWeight: Schema.Finite;
+            readonly vectorL1Error: Schema.Finite;
+            readonly passed: Schema.Boolean;
+            readonly classifierCallId: Schema.optionalKey<Schema.String>;
+            readonly measurement: Schema.Struct<{
+                readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+            }>;
+        }>>;
+    }>;
+    readonly composition: Schema.Struct<{
+        readonly expectedCases: Schema.Finite;
+        readonly comparableCases: Schema.Finite;
+        readonly agreeingCases: Schema.Finite;
+        readonly winnerAgreement: Schema.Finite;
+        readonly cases: Schema.$Array<Schema.Struct<{
+            readonly caseId: Schema.String;
+            readonly predictedWinner: Schema.String;
+            readonly observedWinner: Schema.String;
+            readonly predictedScoreGap: Schema.Finite;
+            readonly observedScoreGap: Schema.Finite;
+            readonly passed: Schema.Boolean;
+        }>>;
+    }>;
+}>;
+export type EvalRunQualification = typeof EvalRunQualification.Type;
+export declare function summarizeEvalRunLedger(comparisons: readonly EvalComparisonResultType[], expectedCalls: number, classifierObservations?: readonly EvalClassifierObservation[]): EvalRunLedger;
+/**
+ * Sanitized durable result of one immutable execution plan.
+ *
+ * Prompts, model responses, credentials, headers, and raw child output are
+ * deliberately absent from this contract. Dollar totals are known-priced
+ * subtotals only; callers must render cost as unknown when
+ * `unpricedCalls` is non-zero.
+ */
+export declare const EvalRunReport: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"passed">;
+    readonly activation: Schema.Struct<{
+        readonly version: Schema.Literal<2>;
+        readonly generatedAt: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly evidenceDigest: Schema.String;
+        readonly classifierModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+        readonly dimensions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly includes: Schema.$Array<Schema.String>;
+            readonly excludes: Schema.$Array<Schema.String>;
+        }>>;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly dimensionId: Schema.String;
+            readonly suiteDigest: Schema.String;
+            readonly evidenceDigest: Schema.String;
+            readonly quality: Schema.Struct<{
+                readonly passRate: Schema.Finite;
+                readonly lowerConfidenceBound: Schema.Finite;
+                readonly sampleCount: Schema.Finite;
+            }>;
+            readonly failureRate: Schema.Finite;
+            readonly averageJudgeScore: Schema.optionalKey<Schema.Finite>;
+            readonly p95DurationMs: Schema.optionalKey<Schema.Finite>;
+            readonly averageCostUsd: Schema.optionalKey<Schema.Finite>;
+            readonly unpricedCalls: Schema.Finite;
+        }>>;
+    }>;
+    readonly version: Schema.Literal<1>;
+    readonly runId: Schema.String;
+    readonly planId: Schema.String;
+    readonly projectId: Schema.String;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["configured", "external"]>;
+        readonly identity: Schema.String;
+        readonly publishAllowed: Schema.Boolean;
+    }>;
+    readonly cleanup: Schema.Struct<{
+        readonly sessionOpened: Schema.Boolean;
+        readonly sessionClosed: Schema.Boolean;
+        readonly detail: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly comparisons: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly comparisonId: Schema.String;
+        readonly profileId: Schema.String;
+        readonly suiteDigest: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly startedAt: Schema.String;
+        readonly finishedAt: Schema.String;
+        readonly models: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["passed", "failed", "unknown", "cutoff"]>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+                readonly error: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>>;
+        readonly calls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["candidate", "judge"]>;
+            readonly model: Schema.String;
+            readonly caseId: Schema.String;
+            readonly measurement: Schema.Struct<{
+                readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+            }>;
+        }>>>;
+    }>>;
+    readonly qualification: Schema.optionalKey<Schema.Struct<{
+        readonly decomposition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly passedCases: Schema.Finite;
+            readonly maximumObservedL1Error: Schema.Finite;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly weights: Schema.$Array<Schema.Struct<{
+                    readonly dimensionId: Schema.String;
+                    readonly weight: Schema.Finite;
+                }>>;
+                readonly unknownWeight: Schema.Finite;
+                readonly vectorL1Error: Schema.Finite;
+                readonly passed: Schema.Boolean;
+                readonly classifierCallId: Schema.optionalKey<Schema.String>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+            }>>;
+        }>;
+        readonly composition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly comparableCases: Schema.Finite;
+            readonly agreeingCases: Schema.Finite;
+            readonly winnerAgreement: Schema.Finite;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly predictedWinner: Schema.String;
+                readonly observedWinner: Schema.String;
+                readonly predictedScoreGap: Schema.Finite;
+                readonly observedScoreGap: Schema.Finite;
+                readonly passed: Schema.Boolean;
+            }>>;
+        }>;
+    }>>;
+    readonly ledger: Schema.Struct<{
+        readonly expectedCalls: Schema.Finite;
+        readonly observedCalls: Schema.Finite;
+        readonly observedCandidateRows: Schema.Finite;
+        readonly knownInputTokens: Schema.Finite;
+        readonly knownOutputTokens: Schema.Finite;
+        readonly unknownTokenMeasurements: Schema.Finite;
+        readonly knownPricedSubtotalUsd: Schema.Finite;
+        readonly unpricedCalls: Schema.Finite;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"completed">;
+    readonly activation: Schema.Struct<{
+        readonly version: Schema.Literal<2>;
+        readonly generatedAt: Schema.String;
+        readonly basisDigest: Schema.String;
+        readonly evidenceDigest: Schema.String;
+        readonly classifierModel: Schema.String;
+        readonly objective: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"highest-quality">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-cost">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"lowest-latency">;
+            readonly minimumQuality: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"balanced">;
+            readonly minimumQuality: Schema.Finite;
+            readonly weights: Schema.Struct<{
+                readonly quality: Schema.Finite;
+                readonly cost: Schema.Finite;
+                readonly latency: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"pareto">;
+            readonly minimumQuality: Schema.Finite;
+            readonly preference: Schema.Literals<readonly ["quality", "cost", "latency"]>;
+        }>]>;
+        readonly maximumUnknownWeight: Schema.Finite;
+        readonly constraints: Schema.optionalKey<Schema.Struct<{
+            readonly minimumDimensionQuality: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Finite>>;
+            readonly maximumFailureRate: Schema.optionalKey<Schema.Finite>;
+        }>>;
+        readonly dimensions: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.String;
+            readonly includes: Schema.$Array<Schema.String>;
+            readonly excludes: Schema.$Array<Schema.String>;
+        }>>;
+        readonly candidateModels: Schema.$Array<Schema.String>;
+        readonly evidence: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly dimensionId: Schema.String;
+            readonly suiteDigest: Schema.String;
+            readonly evidenceDigest: Schema.String;
+            readonly quality: Schema.Struct<{
+                readonly passRate: Schema.Finite;
+                readonly lowerConfidenceBound: Schema.Finite;
+                readonly sampleCount: Schema.Finite;
+            }>;
+            readonly failureRate: Schema.Finite;
+            readonly averageJudgeScore: Schema.optionalKey<Schema.Finite>;
+            readonly p95DurationMs: Schema.optionalKey<Schema.Finite>;
+            readonly averageCostUsd: Schema.optionalKey<Schema.Finite>;
+            readonly unpricedCalls: Schema.Finite;
+        }>>;
+    }>;
+    readonly version: Schema.Literal<1>;
+    readonly runId: Schema.String;
+    readonly planId: Schema.String;
+    readonly projectId: Schema.String;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["configured", "external"]>;
+        readonly identity: Schema.String;
+        readonly publishAllowed: Schema.Boolean;
+    }>;
+    readonly cleanup: Schema.Struct<{
+        readonly sessionOpened: Schema.Boolean;
+        readonly sessionClosed: Schema.Boolean;
+        readonly detail: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly comparisons: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly comparisonId: Schema.String;
+        readonly profileId: Schema.String;
+        readonly suiteDigest: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly startedAt: Schema.String;
+        readonly finishedAt: Schema.String;
+        readonly models: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["passed", "failed", "unknown", "cutoff"]>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+                readonly error: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>>;
+        readonly calls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["candidate", "judge"]>;
+            readonly model: Schema.String;
+            readonly caseId: Schema.String;
+            readonly measurement: Schema.Struct<{
+                readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+            }>;
+        }>>>;
+    }>>;
+    readonly qualification: Schema.optionalKey<Schema.Struct<{
+        readonly decomposition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly passedCases: Schema.Finite;
+            readonly maximumObservedL1Error: Schema.Finite;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly weights: Schema.$Array<Schema.Struct<{
+                    readonly dimensionId: Schema.String;
+                    readonly weight: Schema.Finite;
+                }>>;
+                readonly unknownWeight: Schema.Finite;
+                readonly vectorL1Error: Schema.Finite;
+                readonly passed: Schema.Boolean;
+                readonly classifierCallId: Schema.optionalKey<Schema.String>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+            }>>;
+        }>;
+        readonly composition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly comparableCases: Schema.Finite;
+            readonly agreeingCases: Schema.Finite;
+            readonly winnerAgreement: Schema.Finite;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly predictedWinner: Schema.String;
+                readonly observedWinner: Schema.String;
+                readonly predictedScoreGap: Schema.Finite;
+                readonly observedScoreGap: Schema.Finite;
+                readonly passed: Schema.Boolean;
+            }>>;
+        }>;
+    }>>;
+    readonly ledger: Schema.Struct<{
+        readonly expectedCalls: Schema.Finite;
+        readonly observedCalls: Schema.Finite;
+        readonly observedCandidateRows: Schema.Finite;
+        readonly knownInputTokens: Schema.Finite;
+        readonly knownOutputTokens: Schema.Finite;
+        readonly unknownTokenMeasurements: Schema.Finite;
+        readonly knownPricedSubtotalUsd: Schema.Finite;
+        readonly unpricedCalls: Schema.Finite;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"failed">;
+    readonly failure: Schema.String;
+    readonly version: Schema.Literal<1>;
+    readonly runId: Schema.String;
+    readonly planId: Schema.String;
+    readonly projectId: Schema.String;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly evaluationDigest: Schema.String;
+    readonly target: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["configured", "external"]>;
+        readonly identity: Schema.String;
+        readonly publishAllowed: Schema.Boolean;
+    }>;
+    readonly cleanup: Schema.Struct<{
+        readonly sessionOpened: Schema.Boolean;
+        readonly sessionClosed: Schema.Boolean;
+        readonly detail: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly comparisons: Schema.$Array<Schema.Struct<{
+        readonly version: Schema.Literal<1>;
+        readonly comparisonId: Schema.String;
+        readonly profileId: Schema.String;
+        readonly suiteDigest: Schema.String;
+        readonly judgeModel: Schema.String;
+        readonly startedAt: Schema.String;
+        readonly finishedAt: Schema.String;
+        readonly models: Schema.$Array<Schema.Struct<{
+            readonly model: Schema.String;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly outcome: Schema.Literals<readonly ["passed", "failed", "unknown", "cutoff"]>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+                readonly error: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>>;
+        readonly calls: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly role: Schema.Literals<readonly ["candidate", "judge"]>;
+            readonly model: Schema.String;
+            readonly caseId: Schema.String;
+            readonly measurement: Schema.Struct<{
+                readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                readonly judgeScore: Schema.optionalKey<Schema.Finite>;
+                readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+            }>;
+        }>>>;
+    }>>;
+    readonly qualification: Schema.optionalKey<Schema.Struct<{
+        readonly decomposition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly passedCases: Schema.Finite;
+            readonly maximumObservedL1Error: Schema.Finite;
+            readonly observations: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly weights: Schema.$Array<Schema.Struct<{
+                    readonly dimensionId: Schema.String;
+                    readonly weight: Schema.Finite;
+                }>>;
+                readonly unknownWeight: Schema.Finite;
+                readonly vectorL1Error: Schema.Finite;
+                readonly passed: Schema.Boolean;
+                readonly classifierCallId: Schema.optionalKey<Schema.String>;
+                readonly measurement: Schema.Struct<{
+                    readonly costUsd: Schema.optionalKey<Schema.Finite>;
+                    readonly durationMs: Schema.optionalKey<Schema.Finite>;
+                    readonly inputTokens: Schema.optionalKey<Schema.Finite>;
+                    readonly outputTokens: Schema.optionalKey<Schema.Finite>;
+                }>;
+            }>>;
+        }>;
+        readonly composition: Schema.Struct<{
+            readonly expectedCases: Schema.Finite;
+            readonly comparableCases: Schema.Finite;
+            readonly agreeingCases: Schema.Finite;
+            readonly winnerAgreement: Schema.Finite;
+            readonly cases: Schema.$Array<Schema.Struct<{
+                readonly caseId: Schema.String;
+                readonly predictedWinner: Schema.String;
+                readonly observedWinner: Schema.String;
+                readonly predictedScoreGap: Schema.Finite;
+                readonly observedScoreGap: Schema.Finite;
+                readonly passed: Schema.Boolean;
+            }>>;
+        }>;
+    }>>;
+    readonly ledger: Schema.Struct<{
+        readonly expectedCalls: Schema.Finite;
+        readonly observedCalls: Schema.Finite;
+        readonly observedCandidateRows: Schema.Finite;
+        readonly knownInputTokens: Schema.Finite;
+        readonly knownOutputTokens: Schema.Finite;
+        readonly unknownTokenMeasurements: Schema.Finite;
+        readonly knownPricedSubtotalUsd: Schema.Finite;
+        readonly unpricedCalls: Schema.Finite;
+    }>;
+}>]>;
+export type EvalRunReport = typeof EvalRunReport.Type;
+export type EvalProjectArtifactsStatus = {
+    readonly basisProposalDigest?: string;
+    readonly basisApproved: boolean;
+    readonly evaluationProposalDigest?: string;
+    readonly evaluationsApproved: boolean;
+    readonly plans: readonly string[];
+};
+export type EvalProjectStatus = {
+    readonly state: EvalProjectState;
+    readonly question?: EvalProjectQuestion;
+    readonly artifacts?: EvalProjectArtifactsStatus;
+    readonly nextAction: "answer" | "propose-dimensions" | "approve-dimensions" | "propose-evaluations" | "approve-evaluations" | "run" | "publish" | "none";
+};