@openpond/evals 0.11.16 → 0.11.18

package/dist/types/human-review/comparison.d.ts

@@ -0,0 +1,1959 @@
+import { z } from 'zod';
+import { type ExperimentCaseIdentity } from '../experiments.js';
+import { ReviewReleaseSchema, type HumanReview, type HumanAttemptRefSchema } from './contracts.js';
+export declare const HumanComparisonRuleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"normalized_score">;
+    minimum: z.ZodNumber;
+    maximum: z.ZodNumber;
+    passThreshold: z.ZodOptional<z.ZodNumber>;
+    feedbackKey: z.ZodString;
+    criterionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"boolean">;
+    feedbackKey: z.ZodString;
+    criterionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"category">;
+    feedbackKey: z.ZodString;
+    criterionId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"preference_score">;
+    tieScore: z.ZodNullable<z.ZodNumber>;
+    feedbackKey: z.ZodString;
+    criterionId: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const HumanComparisonSelectionsSchema: z.ZodObject<{
+    rules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"normalized_score">;
+        minimum: z.ZodNumber;
+        maximum: z.ZodNumber;
+        passThreshold: z.ZodOptional<z.ZodNumber>;
+        feedbackKey: z.ZodString;
+        criterionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"boolean">;
+        feedbackKey: z.ZodString;
+        criterionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"category">;
+        feedbackKey: z.ZodString;
+        criterionId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"preference_score">;
+        tieScore: z.ZodNullable<z.ZodNumber>;
+        feedbackKey: z.ZodString;
+        criterionId: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    baseline: z.ZodObject<{
+        execution: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        resultHash: z.ZodString;
+        reviews: z.ZodArray<z.ZodObject<{
+            review: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            decision: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        execution: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        resultHash: z.ZodString;
+        reviews: z.ZodArray<z.ZodObject<{
+            review: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            decision: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type HumanComparisonSelections = z.infer<typeof HumanComparisonSelectionsSchema>;
+declare const Evidence: z.ZodObject<{
+    manifest: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.experimentManifest.v1">;
+        id: z.ZodString;
+        name: z.ZodString;
+        teamId: z.ZodString;
+        operationId: z.ZodString;
+        maximumCostUsd: z.ZodNullable<z.ZodNumber>;
+        dataset: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+            modelId: z.ZodString;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"harness">;
+            source: z.ZodObject<{
+                profileId: z.ZodString;
+                sourceRevision: z.ZodString;
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                catalogHash: z.ZodString;
+                definitionId: z.ZodString;
+                definitionHash: z.ZodString;
+                target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"profile">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"workflow">;
+                    workflowId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"skill">;
+                    skillPath: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent_action">;
+                    actionId: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                environmentHash: z.ZodString;
+                externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                    dataset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    packageHash: z.ZodString;
+                    profileId: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                    protectedProfileClosureHash: z.ZodString;
+                    recordedOrigin: z.ZodOptional<z.ZodObject<{
+                        execution: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        originalEvidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        members: z.ZodArray<z.ZodObject<{
+                            caseId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodString;
+                            sourceId: z.ZodString;
+                            snapshotHash: z.ZodString;
+                            boundaryRevisionHash: z.ZodString;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    gradingSource: z.ZodOptional<z.ZodObject<{
+                        pass: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        evidence: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                    }, z.core.$strict>>;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                    population: z.ZodArray<z.ZodObject<{
+                        taskId: z.ZodString;
+                        seed: z.ZodString;
+                        fixtureId: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    evaluators: z.ZodArray<z.ZodObject<{
+                        release: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                        }, z.core.$strict>;
+                        feedbackKey: z.ZodString;
+                        configurationHash: z.ZodString;
+                        output: z.ZodEnum<{
+                            boolean: "boolean";
+                            score: "score";
+                            category: "category";
+                        }>;
+                        categories: z.ZodArray<z.ZodString>;
+                    }, z.core.$strict>>;
+                    fieldMappingsHash: z.ZodString;
+                    fieldMappings: z.ZodArray<z.ZodObject<{
+                        graderId: z.ZodString;
+                        fields: z.ZodArray<z.ZodObject<{
+                            destination: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                            source: z.ZodEnum<{
+                                output: "output";
+                                input: "input";
+                                expectedOutput: "expectedOutput";
+                                evaluatorContext: "evaluatorContext";
+                            }>;
+                            sourcePath: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    environmentHash: z.ZodString;
+                    privateDatasetClosureHash: z.ZodString;
+                    criterion: z.ZodObject<{
+                        minimumPassRate: z.ZodNumber;
+                        requireComplete: z.ZodBoolean;
+                    }, z.core.$strict>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                sourceCandidate: z.ZodOptional<z.ZodObject<{
+                    candidateId: z.ZodString;
+                    frozenRevision: z.ZodNumber;
+                    frozenHash: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    protectedClosureHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            source: z.ZodObject<{
+                harnessRelease: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                agentSnapshot: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                sourcePackageHash: z.ZodString;
+            }, z.core.$strict>;
+            model: z.ZodObject<{
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"fixture">;
+            configurationHash: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        execution: z.ZodOptional<z.ZodObject<{
+            packageHash: z.ZodString;
+            runtimeTargetHash: z.ZodString;
+            metricPolicyHash: z.ZodString;
+            compatibility: z.ZodOptional<z.ZodObject<{
+                protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+                targetKind: z.ZodEnum<{
+                    agent: "agent";
+                    model: "model";
+                    fixture: "fixture";
+                    harness: "harness";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            definition: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            scoringPassId: z.ZodNullable<z.ZodString>;
+            humanProjection: z.ZodOptional<z.ZodObject<{
+                originalManifest: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                selectionHash: z.ZodString;
+                rulesHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        evaluators: z.ZodArray<z.ZodObject<{
+            release: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+            }, z.core.$strict>;
+            feedbackKey: z.ZodString;
+            configurationHash: z.ZodOptional<z.ZodString>;
+            output: z.ZodEnum<{
+                boolean: "boolean";
+                score: "score";
+                category: "category";
+            }>;
+            categories: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        population: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            seed: z.ZodString;
+            fixtureId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    result: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.experimentResult.v1">;
+        manifest: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            failed: "failed";
+            completed: "completed";
+        }>;
+        cases: z.ZodArray<z.ZodObject<{
+            identity: z.ZodObject<{
+                caseId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                completed: "completed";
+                unavailable: "unavailable";
+            }>;
+            output: z.ZodNullable<z.ZodUnknown>;
+            error: z.ZodNullable<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+            }, z.core.$strict>>;
+            feedback: z.ZodArray<z.ZodObject<{
+                feedbackKey: z.ZodString;
+                evaluator: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+                passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                reasoning: z.ZodNullable<z.ZodString>;
+                evidenceRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                totalTokens: z.ZodNullable<z.ZodNumber>;
+                costUsd: z.ZodNullable<z.ZodNumber>;
+                latencyMs: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>;
+            traceRef: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>;
+            startedAt: z.ZodNullable<z.ZodString>;
+            completedAt: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        completedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const HumanComparisonProjectionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.humanComparisonProjection.v1">;
+    teamId: z.ZodString;
+    projectId: z.ZodString;
+    selections: z.ZodObject<{
+        rules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"normalized_score">;
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+            passThreshold: z.ZodOptional<z.ZodNumber>;
+            feedbackKey: z.ZodString;
+            criterionId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"boolean">;
+            feedbackKey: z.ZodString;
+            criterionId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"category">;
+            feedbackKey: z.ZodString;
+            criterionId: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"preference_score">;
+            tieScore: z.ZodNullable<z.ZodNumber>;
+            feedbackKey: z.ZodString;
+            criterionId: z.ZodString;
+        }, z.core.$strict>], "kind">>;
+        baseline: z.ZodObject<{
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            resultHash: z.ZodString;
+            reviews: z.ZodArray<z.ZodObject<{
+                review: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            execution: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            resultHash: z.ZodString;
+            reviews: z.ZodArray<z.ZodObject<{
+                review: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    original: z.ZodObject<{
+        baseline: z.ZodObject<{
+            id: z.ZodString;
+            manifestHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            id: z.ZodString;
+            manifestHash: z.ZodString;
+            resultHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    humanResults: z.ZodObject<{
+        baseline: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.humanResultView.v1">;
+            executionId: z.ZodString;
+            executionHash: z.ZodString;
+            selection: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            coverage: z.ZodObject<{
+                pending: z.ZodNumber;
+                submitted: z.ZodNumber;
+                accepted: z.ZodNumber;
+                rejected: z.ZodNumber;
+                cancelled: z.ZodNumber;
+            }, z.core.$strict>;
+            results: z.ZodArray<z.ZodObject<{
+                review: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                attemptIds: z.ZodArray<z.ZodString>;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                origin: z.ZodEnum<{
+                    owner_attested_local: "owner_attested_local";
+                    native_local: "native_local";
+                    recorded_evidence: "recorded_evidence";
+                    hosted_retained: "hosted_retained";
+                }>;
+                status: z.ZodEnum<{
+                    submitted: "submitted";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                    cancelled: "cancelled";
+                    pending: "pending";
+                }>;
+                grader: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                answers: z.ZodArray<z.ZodObject<{
+                    criterionId: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString, z.ZodNull]>;
+                    abstain: z.ZodBoolean;
+                    note: z.ZodString;
+                    strength: z.ZodOptional<z.ZodEnum<{
+                        slight: "slight";
+                        moderate: "moderate";
+                        strong: "strong";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        candidate: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.humanResultView.v1">;
+            executionId: z.ZodString;
+            executionHash: z.ZodString;
+            selection: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            coverage: z.ZodObject<{
+                pending: z.ZodNumber;
+                submitted: z.ZodNumber;
+                accepted: z.ZodNumber;
+                rejected: z.ZodNumber;
+                cancelled: z.ZodNumber;
+            }, z.core.$strict>;
+            results: z.ZodArray<z.ZodObject<{
+                review: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                decision: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                attemptIds: z.ZodArray<z.ZodString>;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                origin: z.ZodEnum<{
+                    owner_attested_local: "owner_attested_local";
+                    native_local: "native_local";
+                    recorded_evidence: "recorded_evidence";
+                    hosted_retained: "hosted_retained";
+                }>;
+                status: z.ZodEnum<{
+                    submitted: "submitted";
+                    accepted: "accepted";
+                    rejected: "rejected";
+                    cancelled: "cancelled";
+                    pending: "pending";
+                }>;
+                grader: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                answers: z.ZodArray<z.ZodObject<{
+                    criterionId: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString, z.ZodNull]>;
+                    abstain: z.ZodBoolean;
+                    note: z.ZodString;
+                    strength: z.ZodOptional<z.ZodEnum<{
+                        slight: "slight";
+                        moderate: "moderate";
+                        strong: "strong";
+                    }>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    baseline: z.ZodObject<{
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.experimentManifest.v1">;
+            id: z.ZodString;
+            name: z.ZodString;
+            teamId: z.ZodString;
+            operationId: z.ZodString;
+            maximumCostUsd: z.ZodNullable<z.ZodNumber>;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"harness">;
+                source: z.ZodObject<{
+                    profileId: z.ZodString;
+                    sourceRevision: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    catalogHash: z.ZodString;
+                    definitionId: z.ZodString;
+                    definitionHash: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    environmentHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                        dataset: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        packageHash: z.ZodString;
+                        profileId: z.ZodString;
+                        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"profile">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"workflow">;
+                            workflowId: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"skill">;
+                            skillPath: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"agent_action">;
+                            actionId: z.ZodString;
+                        }, z.core.$strict>], "kind">;
+                        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                        protectedProfileClosureHash: z.ZodString;
+                        recordedOrigin: z.ZodOptional<z.ZodObject<{
+                            execution: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            originalEvidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            members: z.ZodArray<z.ZodObject<{
+                                caseId: z.ZodString;
+                                seed: z.ZodString;
+                                fixtureId: z.ZodString;
+                                sourceId: z.ZodString;
+                                snapshotHash: z.ZodString;
+                                boundaryRevisionHash: z.ZodString;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        gradingSource: z.ZodOptional<z.ZodObject<{
+                            pass: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            evidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>>;
+                        split: z.ZodEnum<{
+                            train: "train";
+                            validation: "validation";
+                            test: "test";
+                            frozen_eval: "frozen_eval";
+                        }>;
+                        population: z.ZodArray<z.ZodObject<{
+                            taskId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strict>>;
+                        evaluators: z.ZodArray<z.ZodObject<{
+                            release: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                            }, z.core.$strict>;
+                            feedbackKey: z.ZodString;
+                            configurationHash: z.ZodString;
+                            output: z.ZodEnum<{
+                                boolean: "boolean";
+                                score: "score";
+                                category: "category";
+                            }>;
+                            categories: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                        fieldMappingsHash: z.ZodString;
+                        fieldMappings: z.ZodArray<z.ZodObject<{
+                            graderId: z.ZodString;
+                            fields: z.ZodArray<z.ZodObject<{
+                                destination: z.ZodEnum<{
+                                    output: "output";
+                                    input: "input";
+                                    expectedOutput: "expectedOutput";
+                                    evaluatorContext: "evaluatorContext";
+                                }>;
+                                path: z.ZodArray<z.ZodString>;
+                                source: z.ZodEnum<{
+                                    output: "output";
+                                    input: "input";
+                                    expectedOutput: "expectedOutput";
+                                    evaluatorContext: "evaluatorContext";
+                                }>;
+                                sourcePath: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        environmentHash: z.ZodString;
+                        privateDatasetClosureHash: z.ZodString;
+                        criterion: z.ZodObject<{
+                            minimumPassRate: z.ZodNumber;
+                            requireComplete: z.ZodBoolean;
+                        }, z.core.$strict>;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                source: z.ZodObject<{
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    agentSnapshot: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    sourcePackageHash: z.ZodString;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            execution: z.ZodOptional<z.ZodObject<{
+                packageHash: z.ZodString;
+                runtimeTargetHash: z.ZodString;
+                metricPolicyHash: z.ZodString;
+                compatibility: z.ZodOptional<z.ZodObject<{
+                    protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+                    targetKind: z.ZodEnum<{
+                        agent: "agent";
+                        model: "model";
+                        fixture: "fixture";
+                        harness: "harness";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            lineage: z.ZodOptional<z.ZodObject<{
+                definition: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                execution: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                scoringPassId: z.ZodNullable<z.ZodString>;
+                humanProjection: z.ZodOptional<z.ZodObject<{
+                    originalManifest: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    selectionHash: z.ZodString;
+                    rulesHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            evaluators: z.ZodArray<z.ZodObject<{
+                release: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>;
+                feedbackKey: z.ZodString;
+                configurationHash: z.ZodOptional<z.ZodString>;
+                output: z.ZodEnum<{
+                    boolean: "boolean";
+                    score: "score";
+                    category: "category";
+                }>;
+                categories: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            population: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.experimentResult.v1">;
+            manifest: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            cases: z.ZodArray<z.ZodObject<{
+                identity: z.ZodObject<{
+                    caseId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    completed: "completed";
+                    unavailable: "unavailable";
+                }>;
+                output: z.ZodNullable<z.ZodUnknown>;
+                error: z.ZodNullable<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+                feedback: z.ZodArray<z.ZodObject<{
+                    feedbackKey: z.ZodString;
+                    evaluator: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        failed: "failed";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>;
+                    value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+                    passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                    reasoning: z.ZodNullable<z.ZodString>;
+                    evidenceRefs: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                usage: z.ZodObject<{
+                    inputTokens: z.ZodNullable<z.ZodNumber>;
+                    outputTokens: z.ZodNullable<z.ZodNumber>;
+                    totalTokens: z.ZodNullable<z.ZodNumber>;
+                    costUsd: z.ZodNullable<z.ZodNumber>;
+                    latencyMs: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>;
+                traceRef: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                }, z.core.$strict>>;
+                startedAt: z.ZodNullable<z.ZodString>;
+                completedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            completedAt: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        manifest: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.experimentManifest.v1">;
+            id: z.ZodString;
+            name: z.ZodString;
+            teamId: z.ZodString;
+            operationId: z.ZodString;
+            maximumCostUsd: z.ZodNullable<z.ZodNumber>;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"harness">;
+                source: z.ZodObject<{
+                    profileId: z.ZodString;
+                    sourceRevision: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    catalogHash: z.ZodString;
+                    definitionId: z.ZodString;
+                    definitionHash: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    environmentHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                        dataset: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        packageHash: z.ZodString;
+                        profileId: z.ZodString;
+                        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"profile">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"workflow">;
+                            workflowId: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"skill">;
+                            skillPath: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"agent_action">;
+                            actionId: z.ZodString;
+                        }, z.core.$strict>], "kind">;
+                        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                        protectedProfileClosureHash: z.ZodString;
+                        recordedOrigin: z.ZodOptional<z.ZodObject<{
+                            execution: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            originalEvidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            members: z.ZodArray<z.ZodObject<{
+                                caseId: z.ZodString;
+                                seed: z.ZodString;
+                                fixtureId: z.ZodString;
+                                sourceId: z.ZodString;
+                                snapshotHash: z.ZodString;
+                                boundaryRevisionHash: z.ZodString;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        gradingSource: z.ZodOptional<z.ZodObject<{
+                            pass: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            evidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>>;
+                        split: z.ZodEnum<{
+                            train: "train";
+                            validation: "validation";
+                            test: "test";
+                            frozen_eval: "frozen_eval";
+                        }>;
+                        population: z.ZodArray<z.ZodObject<{
+                            taskId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strict>>;
+                        evaluators: z.ZodArray<z.ZodObject<{
+                            release: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                            }, z.core.$strict>;
+                            feedbackKey: z.ZodString;
+                            configurationHash: z.ZodString;
+                            output: z.ZodEnum<{
+                                boolean: "boolean";
+                                score: "score";
+                                category: "category";
+                            }>;
+                            categories: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                        fieldMappingsHash: z.ZodString;
+                        fieldMappings: z.ZodArray<z.ZodObject<{
+                            graderId: z.ZodString;
+                            fields: z.ZodArray<z.ZodObject<{
+                                destination: z.ZodEnum<{
+                                    output: "output";
+                                    input: "input";
+                                    expectedOutput: "expectedOutput";
+                                    evaluatorContext: "evaluatorContext";
+                                }>;
+                                path: z.ZodArray<z.ZodString>;
+                                source: z.ZodEnum<{
+                                    output: "output";
+                                    input: "input";
+                                    expectedOutput: "expectedOutput";
+                                    evaluatorContext: "evaluatorContext";
+                                }>;
+                                sourcePath: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        environmentHash: z.ZodString;
+                        privateDatasetClosureHash: z.ZodString;
+                        criterion: z.ZodObject<{
+                            minimumPassRate: z.ZodNumber;
+                            requireComplete: z.ZodBoolean;
+                        }, z.core.$strict>;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                source: z.ZodObject<{
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    agentSnapshot: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    sourcePackageHash: z.ZodString;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            execution: z.ZodOptional<z.ZodObject<{
+                packageHash: z.ZodString;
+                runtimeTargetHash: z.ZodString;
+                metricPolicyHash: z.ZodString;
+                compatibility: z.ZodOptional<z.ZodObject<{
+                    protocol: z.ZodLiteral<"openpond.evaluation-execution.v1">;
+                    targetKind: z.ZodEnum<{
+                        agent: "agent";
+                        model: "model";
+                        fixture: "fixture";
+                        harness: "harness";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            lineage: z.ZodOptional<z.ZodObject<{
+                definition: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                execution: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                scoringPassId: z.ZodNullable<z.ZodString>;
+                humanProjection: z.ZodOptional<z.ZodObject<{
+                    originalManifest: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    selectionHash: z.ZodString;
+                    rulesHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            evaluators: z.ZodArray<z.ZodObject<{
+                release: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                }, z.core.$strict>;
+                feedbackKey: z.ZodString;
+                configurationHash: z.ZodOptional<z.ZodString>;
+                output: z.ZodEnum<{
+                    boolean: "boolean";
+                    score: "score";
+                    category: "category";
+                }>;
+                categories: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            population: z.ZodArray<z.ZodObject<{
+                caseId: z.ZodString;
+                seed: z.ZodString;
+                fixtureId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.experimentResult.v1">;
+            manifest: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                cancelled: "cancelled";
+                failed: "failed";
+                completed: "completed";
+            }>;
+            cases: z.ZodArray<z.ZodObject<{
+                identity: z.ZodObject<{
+                    caseId: z.ZodString;
+                    seed: z.ZodString;
+                    fixtureId: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    cancelled: "cancelled";
+                    failed: "failed";
+                    completed: "completed";
+                    unavailable: "unavailable";
+                }>;
+                output: z.ZodNullable<z.ZodUnknown>;
+                error: z.ZodNullable<z.ZodObject<{
+                    code: z.ZodString;
+                    message: z.ZodString;
+                }, z.core.$strict>>;
+                feedback: z.ZodArray<z.ZodObject<{
+                    feedbackKey: z.ZodString;
+                    evaluator: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                    }, z.core.$strict>;
+                    status: z.ZodEnum<{
+                        pending: "pending";
+                        failed: "failed";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>;
+                    value: z.ZodNullable<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+                    passed: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                    reasoning: z.ZodNullable<z.ZodString>;
+                    evidenceRefs: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                        sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                usage: z.ZodObject<{
+                    inputTokens: z.ZodNullable<z.ZodNumber>;
+                    outputTokens: z.ZodNullable<z.ZodNumber>;
+                    totalTokens: z.ZodNullable<z.ZodNumber>;
+                    costUsd: z.ZodNullable<z.ZodNumber>;
+                    latencyMs: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>;
+                traceRef: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    mediaType: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    sizeBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                }, z.core.$strict>>;
+                startedAt: z.ZodNullable<z.ZodString>;
+                completedAt: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            completedAt: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type HumanComparisonProjection = z.infer<typeof HumanComparisonProjectionSchema>;
+type Attempt = z.infer<typeof HumanAttemptRefSchema>;
+type Input = {
+    teamId: string;
+    projectId: string;
+    baseline: z.infer<typeof Evidence>;
+    candidate: z.infer<typeof Evidence>;
+    selections: HumanComparisonSelections;
+    authorize(): Promise<void>;
+    readReview(ref: z.infer<typeof ReviewReleaseSchema>): Promise<HumanReview>;
+    caseIdentity(attempt: Attempt): Promise<ExperimentCaseIdentity>;
+};
+/** The host supplies current resource/subject owners and real retained receipt
+ * identities. This creates another evidence view; it never changes a pass. */
+export declare function projectAcceptedHumanComparison(input: Input): Promise<HumanComparisonProjection>;
+export declare function verifyHumanComparisonProjection(raw: unknown, originals?: {
+    baseline: z.infer<typeof Evidence>;
+    candidate: z.infer<typeof Evidence>;
+}): {
+    schemaVersion: "openpond.humanComparisonProjection.v1";
+    teamId: string;
+    projectId: string;
+    selections: {
+        rules: ({
+            kind: "normalized_score";
+            minimum: number;
+            maximum: number;
+            feedbackKey: string;
+            criterionId: string;
+            passThreshold?: number | undefined;
+        } | {
+            kind: "boolean";
+            feedbackKey: string;
+            criterionId: string;
+        } | {
+            kind: "category";
+            feedbackKey: string;
+            criterionId: string;
+        } | {
+            kind: "preference_score";
+            tieScore: number | null;
+            feedbackKey: string;
+            criterionId: string;
+        })[];
+        baseline: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            resultHash: string;
+            reviews: {
+                review: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                decision: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+            }[];
+        };
+        candidate: {
+            execution: {
+                id: string;
+                contentHash: string;
+            };
+            resultHash: string;
+            reviews: {
+                review: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                decision: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+            }[];
+        };
+    };
+    original: {
+        baseline: {
+            id: string;
+            manifestHash: string;
+            resultHash: string;
+        };
+        candidate: {
+            id: string;
+            manifestHash: string;
+            resultHash: string;
+        };
+    };
+    humanResults: {
+        baseline: {
+            schemaVersion: "openpond.humanResultView.v1";
+            executionId: string;
+            executionHash: string;
+            selection: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            }[];
+            coverage: {
+                pending: number;
+                submitted: number;
+                accepted: number;
+                rejected: number;
+                cancelled: number;
+            };
+            results: {
+                review: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                decision: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                } | null;
+                attemptIds: string[];
+                mode: "individual" | "pairwise";
+                origin: "owner_attested_local" | "native_local" | "recorded_evidence" | "hosted_retained";
+                status: "submitted" | "accepted" | "rejected" | "cancelled" | "pending";
+                grader: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                answers: {
+                    criterionId: string;
+                    value: string | number | boolean | null;
+                    abstain: boolean;
+                    note: string;
+                    strength?: "slight" | "moderate" | "strong" | undefined;
+                }[];
+            }[];
+            contentHash: string;
+        };
+        candidate: {
+            schemaVersion: "openpond.humanResultView.v1";
+            executionId: string;
+            executionHash: string;
+            selection: {
+                id: string;
+                revision: number;
+                contentHash: string;
+            }[];
+            coverage: {
+                pending: number;
+                submitted: number;
+                accepted: number;
+                rejected: number;
+                cancelled: number;
+            };
+            results: {
+                review: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                decision: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                } | null;
+                attemptIds: string[];
+                mode: "individual" | "pairwise";
+                origin: "owner_attested_local" | "native_local" | "recorded_evidence" | "hosted_retained";
+                status: "submitted" | "accepted" | "rejected" | "cancelled" | "pending";
+                grader: {
+                    id: string;
+                    revision: number;
+                    contentHash: string;
+                };
+                answers: {
+                    criterionId: string;
+                    value: string | number | boolean | null;
+                    abstain: boolean;
+                    note: string;
+                    strength?: "slight" | "moderate" | "strong" | undefined;
+                }[];
+            }[];
+            contentHash: string;
+        };
+    };
+    baseline: {
+        manifest: {
+            schemaVersion: "openpond.experimentManifest.v1";
+            id: string;
+            name: string;
+            teamId: string;
+            operationId: string;
+            maximumCostUsd: number | null;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            target: {
+                kind: "model";
+                modelId: string;
+                configurationHash: string;
+            } | {
+                kind: "harness";
+                source: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "output" | "input" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "output" | "input" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "agent";
+                source: {
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    agentSnapshot: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    sourcePackageHash: string;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "fixture";
+                configurationHash: string;
+            };
+            evaluators: {
+                release: {
+                    id: string;
+                    contentHash: string;
+                    revision: string | number;
+                };
+                feedbackKey: string;
+                output: "boolean" | "score" | "category";
+                categories: string[];
+                configurationHash?: string | undefined;
+            }[];
+            population: {
+                caseId: string;
+                seed: string;
+                fixtureId: string | null;
+            }[];
+            createdAt: string;
+            contentHash: string;
+            execution?: {
+                packageHash: string;
+                runtimeTargetHash: string;
+                metricPolicyHash: string;
+                compatibility?: {
+                    protocol: "openpond.evaluation-execution.v1";
+                    targetKind: "agent" | "model" | "fixture" | "harness";
+                } | undefined;
+            } | undefined;
+            lineage?: {
+                definition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                execution: {
+                    id: string;
+                    contentHash: string;
+                };
+                scoringPassId: string | null;
+                humanProjection?: {
+                    originalManifest: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    selectionHash: string;
+                    rulesHash: string;
+                } | undefined;
+            } | undefined;
+        };
+        result: {
+            schemaVersion: "openpond.experimentResult.v1";
+            manifest: {
+                id: string;
+                contentHash: string;
+            };
+            status: "cancelled" | "failed" | "completed";
+            cases: {
+                identity: {
+                    caseId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                };
+                status: "cancelled" | "failed" | "completed" | "unavailable";
+                output: unknown;
+                error: {
+                    code: string;
+                    message: string;
+                } | null;
+                feedback: {
+                    feedbackKey: string;
+                    evaluator: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    status: "pending" | "failed" | "scored" | "unavailable";
+                    value: string | number | boolean | null;
+                    reasoning: string | null;
+                    evidenceRefs: {
+                        id: string;
+                        contentHash: string;
+                        mediaType: string | null;
+                        sizeBytes: number | null;
+                    }[];
+                    passed?: boolean | null | undefined;
+                }[];
+                usage: {
+                    inputTokens: number | null;
+                    outputTokens: number | null;
+                    totalTokens: number | null;
+                    costUsd: number | null;
+                    latencyMs: number | null;
+                };
+                traceRef: {
+                    id: string;
+                    contentHash: string;
+                    mediaType: string | null;
+                    sizeBytes: number | null;
+                } | null;
+                startedAt: string | null;
+                completedAt: string | null;
+            }[];
+            completedAt: string;
+            contentHash: string;
+        };
+    };
+    candidate: {
+        manifest: {
+            schemaVersion: "openpond.experimentManifest.v1";
+            id: string;
+            name: string;
+            teamId: string;
+            operationId: string;
+            maximumCostUsd: number | null;
+            dataset: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            target: {
+                kind: "model";
+                modelId: string;
+                configurationHash: string;
+            } | {
+                kind: "harness";
+                source: {
+                    profileId: string;
+                    sourceRevision: string;
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    catalogHash: string;
+                    definitionId: string;
+                    definitionHash: string;
+                    target: {
+                        kind: "profile";
+                    } | {
+                        kind: "workflow";
+                        workflowId: string;
+                    } | {
+                        kind: "skill";
+                        skillPath: string;
+                    } | {
+                        kind: "agent_action";
+                        actionId: string;
+                    };
+                    environmentHash: string;
+                    externalDatasetBinding?: {
+                        schemaVersion: "openpond.profileExternalDatasetBinding.v1";
+                        dataset: {
+                            id: string;
+                            contentHash: string;
+                            revision: number;
+                        };
+                        packageHash: string;
+                        profileId: string;
+                        target: {
+                            kind: "profile";
+                        } | {
+                            kind: "workflow";
+                            workflowId: string;
+                        } | {
+                            kind: "skill";
+                            skillPath: string;
+                        } | {
+                            kind: "agent_action";
+                            actionId: string;
+                        };
+                        declaredProfileCatalogHash: string | null;
+                        protectedProfileClosureHash: string;
+                        split: "train" | "validation" | "test" | "frozen_eval";
+                        population: {
+                            taskId: string;
+                            seed: string;
+                            fixtureId: string | null;
+                        }[];
+                        evaluators: {
+                            release: {
+                                id: string;
+                                contentHash: string;
+                                revision: string | number;
+                            };
+                            feedbackKey: string;
+                            configurationHash: string;
+                            output: "boolean" | "score" | "category";
+                            categories: string[];
+                        }[];
+                        fieldMappingsHash: string;
+                        fieldMappings: {
+                            graderId: string;
+                            fields: {
+                                destination: "output" | "input" | "expectedOutput" | "evaluatorContext";
+                                path: string[];
+                                source: "output" | "input" | "expectedOutput" | "evaluatorContext";
+                                sourcePath: string[];
+                            }[];
+                        }[];
+                        environmentHash: string;
+                        privateDatasetClosureHash: string;
+                        criterion: {
+                            minimumPassRate: number;
+                            requireComplete: boolean;
+                        };
+                        contentHash: string;
+                        recordedOrigin?: {
+                            execution: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            originalEvidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            members: {
+                                caseId: string;
+                                seed: string;
+                                fixtureId: string;
+                                sourceId: string;
+                                snapshotHash: string;
+                                boundaryRevisionHash: string;
+                            }[];
+                        } | undefined;
+                        gradingSource?: {
+                            pass: {
+                                id: string;
+                                contentHash: string;
+                            };
+                            evidence: {
+                                id: string;
+                                contentHash: string;
+                            };
+                        } | undefined;
+                    } | undefined;
+                    sourceCandidate?: {
+                        candidateId: string;
+                        frozenRevision: number;
+                        frozenHash: string;
+                        harnessRelease: {
+                            id: string;
+                            contentHash: string;
+                        };
+                        protectedClosureHash: string;
+                    } | undefined;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "agent";
+                source: {
+                    harnessRelease: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    agentSnapshot: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    sourcePackageHash: string;
+                };
+                model: {
+                    modelId: string;
+                    configurationHash: string;
+                };
+            } | {
+                kind: "fixture";
+                configurationHash: string;
+            };
+            evaluators: {
+                release: {
+                    id: string;
+                    contentHash: string;
+                    revision: string | number;
+                };
+                feedbackKey: string;
+                output: "boolean" | "score" | "category";
+                categories: string[];
+                configurationHash?: string | undefined;
+            }[];
+            population: {
+                caseId: string;
+                seed: string;
+                fixtureId: string | null;
+            }[];
+            createdAt: string;
+            contentHash: string;
+            execution?: {
+                packageHash: string;
+                runtimeTargetHash: string;
+                metricPolicyHash: string;
+                compatibility?: {
+                    protocol: "openpond.evaluation-execution.v1";
+                    targetKind: "agent" | "model" | "fixture" | "harness";
+                } | undefined;
+            } | undefined;
+            lineage?: {
+                definition: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                } | null;
+                execution: {
+                    id: string;
+                    contentHash: string;
+                };
+                scoringPassId: string | null;
+                humanProjection?: {
+                    originalManifest: {
+                        id: string;
+                        contentHash: string;
+                    };
+                    selectionHash: string;
+                    rulesHash: string;
+                } | undefined;
+            } | undefined;
+        };
+        result: {
+            schemaVersion: "openpond.experimentResult.v1";
+            manifest: {
+                id: string;
+                contentHash: string;
+            };
+            status: "cancelled" | "failed" | "completed";
+            cases: {
+                identity: {
+                    caseId: string;
+                    seed: string;
+                    fixtureId: string | null;
+                };
+                status: "cancelled" | "failed" | "completed" | "unavailable";
+                output: unknown;
+                error: {
+                    code: string;
+                    message: string;
+                } | null;
+                feedback: {
+                    feedbackKey: string;
+                    evaluator: {
+                        id: string;
+                        contentHash: string;
+                        revision: string | number;
+                    };
+                    status: "pending" | "failed" | "scored" | "unavailable";
+                    value: string | number | boolean | null;
+                    reasoning: string | null;
+                    evidenceRefs: {
+                        id: string;
+                        contentHash: string;
+                        mediaType: string | null;
+                        sizeBytes: number | null;
+                    }[];
+                    passed?: boolean | null | undefined;
+                }[];
+                usage: {
+                    inputTokens: number | null;
+                    outputTokens: number | null;
+                    totalTokens: number | null;
+                    costUsd: number | null;
+                    latencyMs: number | null;
+                };
+                traceRef: {
+                    id: string;
+                    contentHash: string;
+                    mediaType: string | null;
+                    sizeBytes: number | null;
+                } | null;
+                startedAt: string | null;
+                completedAt: string | null;
+            }[];
+            completedAt: string;
+            contentHash: string;
+        };
+    };
+    contentHash: string;
+};
+export {};
+//# sourceMappingURL=comparison.d.ts.map