@openpond/evals 0.11.17 → 0.11.19

package/dist/types/learning/reward-calibration-closure.d.ts

@@ -0,0 +1,2323 @@
+import { z } from "zod";
+import { type LearningRevisionRef } from "./contracts.js";
+import { type LearningTransaction } from "./repository.js";
+export { learningRef, LearningRevisionRefSchema } from "./contracts.js";
+export { RewardFixtureSchema } from "./reward-checks.js";
+export declare const MAX_REWARD_CALIBRATION_CLOSURE_BYTES = 524288;
+declare const ContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardCalibrationClosure.v1">;
+    reward: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        feedbackKey: z.ZodOptional<z.ZodString>;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+            kind: z.ZodLiteral<"custom_verifier">;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            form: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                instructions: z.ZodString;
+                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"score">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    step: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"category">;
+                    options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"boolean">;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"text">;
+                    minimumLength: z.ZodOptional<z.ZodNumber>;
+                    maximumLength: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"preference">;
+                    requireStrength: z.ZodOptional<z.ZodBoolean>;
+                    allowTie: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    draft: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"definition">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            input: z.ZodString;
+            output: z.ZodString;
+            familyNamespace: z.ZodString;
+            sources: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"identity">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"linear">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    direction: z.ZodEnum<{
+                        higher: "higher";
+                        lower: "lower";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                weight: z.ZodNumber;
+                required: z.ZodBoolean;
+                hardGate: z.ZodBoolean;
+                privileged: z.ZodBoolean;
+                fixtureRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            recipeRef: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"reward">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            feedbackKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+                model_judge: "model_judge";
+                custom_verifier: "custom_verifier";
+                human: "human";
+                learned_model: "learned_model";
+            }>;
+            fields: z.ZodString;
+            outputField: z.ZodString;
+            expectedField: z.ZodString;
+            expectedValue: z.ZodString;
+            schema: z.ZodString;
+            reference: z.ZodString;
+            events: z.ZodString;
+            code: z.ZodString;
+            exportName: z.ZodString;
+            timeout: z.ZodString;
+            verifierRuntime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            rubric: z.ZodString;
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            modelRevision: z.ZodString;
+            temperature: z.ZodString;
+            reviewerRole: z.ZodString;
+            humanForm: z.ZodOptional<z.ZodString>;
+            learnedId: z.ZodString;
+            learnedHash: z.ZodString;
+            inputContract: z.ZodString;
+            minimum: z.ZodString;
+            maximum: z.ZodString;
+            fixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodString;
+                output: z.ZodString;
+                expectedOutput: z.ZodString;
+                evaluatorContext: z.ZodString;
+                artifactRefs: z.ZodArray<z.ZodString>;
+                runtimeEventRefs: z.ZodArray<z.ZodString>;
+                infrastructureError: z.ZodString;
+                expectedStatus: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                minimumScore: z.ZodString;
+                maximumScore: z.ZodString;
+                expectedPassed: z.ZodEnum<{
+                    any: "any";
+                    true: "true";
+                    false: "false";
+                }>;
+                sourceLabel: z.ZodOptional<z.ZodObject<{
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    feedback: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"binding">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            sources: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"identity">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"linear">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    direction: z.ZodEnum<{
+                        higher: "higher";
+                        lower: "lower";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                weight: z.ZodNumber;
+                required: z.ZodBoolean;
+                hardGate: z.ZodBoolean;
+                privileged: z.ZodBoolean;
+                fixtureRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>], "targetKind">;
+    base: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        feedbackKey: z.ZodOptional<z.ZodString>;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+            kind: z.ZodLiteral<"custom_verifier">;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            form: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                instructions: z.ZodString;
+                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"score">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    step: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"category">;
+                    options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"boolean">;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"text">;
+                    minimumLength: z.ZodOptional<z.ZodNumber>;
+                    maximumLength: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"preference">;
+                    requireStrength: z.ZodOptional<z.ZodBoolean>;
+                    allowTie: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    check: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardCheckRun.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        draft: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        snapshotHash: z.ZodString;
+        fixtureRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            queued: "queued";
+            cancelled: "cancelled";
+            failed: "failed";
+            completed: "completed";
+            running: "running";
+            cancelling: "cancelling";
+        }>;
+        runtime: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            packageVersion: z.ZodString;
+            engine: z.ZodString;
+        }, z.core.$strict>>;
+        results: z.ZodArray<z.ZodObject<{
+            fixture: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            result: z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                rawScore: z.ZodNullable<z.ZodNumber>;
+                normalizedScore: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+                evidenceHashes: z.ZodArray<z.ZodString>;
+                graderEvidence: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
+                    graderId: z.ZodString;
+                    graderVersion: z.ZodString;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        pending: "pending";
+                        failed: "failed";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>>;
+                    score: z.ZodNullable<z.ZodNumber>;
+                    passed: z.ZodBoolean;
+                    rewardEligible: z.ZodBoolean;
+                    failureClass: z.ZodNullable<z.ZodEnum<{
+                        policy_failure: "policy_failure";
+                        grader_failure: "grader_failure";
+                        environment_failure: "environment_failure";
+                        infrastructure_failure: "infrastructure_failure";
+                        timeout: "timeout";
+                        cancelled: "cancelled";
+                    }>>;
+                    feedback: z.ZodArray<z.ZodString>;
+                    visibleEvidenceRefs: z.ZodArray<z.ZodString>;
+                    privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
+                    modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
+                        providerId: z.ZodString;
+                        modelId: z.ZodString;
+                        modelRevision: z.ZodNullable<z.ZodString>;
+                        responseId: z.ZodNullable<z.ZodString>;
+                        requestHash: z.ZodString;
+                        responseHash: z.ZodString;
+                        inputTokens: z.ZodNullable<z.ZodNumber>;
+                        outputTokens: z.ZodNullable<z.ZodNumber>;
+                        costUsd: z.ZodNullable<z.ZodNumber>;
+                        transportPolicy: z.ZodOptional<z.ZodObject<{
+                            schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
+                            responseFormat: z.ZodLiteral<"judgment_json_schema">;
+                            reasoningEffort: z.ZodEnum<{
+                                off: "off";
+                                low: "low";
+                                medium: "medium";
+                                high: "high";
+                                xhigh: "xhigh";
+                                max: "max";
+                            }>;
+                            maximumOutputTokens: z.ZodNumber;
+                        }, z.core.$strict>>;
+                        effectiveRequestHash: z.ZodOptional<z.ZodString>;
+                        finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            matchesExpectation: z.ZodBoolean;
+        }, z.core.$strict>>;
+        matchesExpectations: z.ZodNullable<z.ZodBoolean>;
+        failure: z.ZodNullable<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+        maximumSpendUsd: z.ZodNumber;
+        judgeCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            requestHash: z.ZodString;
+            reservedUsd: z.ZodNumber;
+            status: z.ZodEnum<{
+                reserved: "reserved";
+                settled: "settled";
+                not_dispatched: "not_dispatched";
+            }>;
+            response: z.ZodNullable<z.ZodObject<{
+                text: z.ZodString;
+                modelId: z.ZodString;
+                modelRevision: z.ZodNullable<z.ZodString>;
+                responseId: z.ZodNullable<z.ZodString>;
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                costUsd: z.ZodNullable<z.ZodNumber>;
+                effectiveRequestHash: z.ZodOptional<z.ZodString>;
+                finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        requestedBy: z.ZodOptional<z.ZodString>;
+        leaseOwner: z.ZodNullable<z.ZodString>;
+        leaseExpiresAt: z.ZodNullable<z.ZodString>;
+        attemptCount: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    assets: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+        id: z.ZodString;
+        revision: z.ZodLiteral<1>;
+        asset: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        text: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const RewardCalibrationClosureSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardCalibrationClosure.v1">;
+    reward: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        feedbackKey: z.ZodOptional<z.ZodString>;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+            kind: z.ZodLiteral<"custom_verifier">;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            form: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                instructions: z.ZodString;
+                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"score">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    step: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"category">;
+                    options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"boolean">;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"text">;
+                    minimumLength: z.ZodOptional<z.ZodNumber>;
+                    maximumLength: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"preference">;
+                    requireStrength: z.ZodOptional<z.ZodBoolean>;
+                    allowTie: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    draft: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"definition">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            input: z.ZodString;
+            output: z.ZodString;
+            familyNamespace: z.ZodString;
+            sources: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"identity">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"linear">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    direction: z.ZodEnum<{
+                        higher: "higher";
+                        lower: "lower";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                weight: z.ZodNumber;
+                required: z.ZodBoolean;
+                hardGate: z.ZodBoolean;
+                privileged: z.ZodBoolean;
+                fixtureRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            recipeRef: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"reward">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            feedbackKey: z.ZodOptional<z.ZodString>;
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+                model_judge: "model_judge";
+                custom_verifier: "custom_verifier";
+                human: "human";
+                learned_model: "learned_model";
+            }>;
+            fields: z.ZodString;
+            outputField: z.ZodString;
+            expectedField: z.ZodString;
+            expectedValue: z.ZodString;
+            schema: z.ZodString;
+            reference: z.ZodString;
+            events: z.ZodString;
+            code: z.ZodString;
+            exportName: z.ZodString;
+            timeout: z.ZodString;
+            verifierRuntime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            rubric: z.ZodString;
+            providerId: z.ZodString;
+            modelId: z.ZodString;
+            modelRevision: z.ZodString;
+            temperature: z.ZodString;
+            reviewerRole: z.ZodString;
+            humanForm: z.ZodOptional<z.ZodString>;
+            learnedId: z.ZodString;
+            learnedHash: z.ZodString;
+            inputContract: z.ZodString;
+            minimum: z.ZodString;
+            maximum: z.ZodString;
+            fixtures: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                input: z.ZodString;
+                output: z.ZodString;
+                expectedOutput: z.ZodString;
+                evaluatorContext: z.ZodString;
+                artifactRefs: z.ZodArray<z.ZodString>;
+                runtimeEventRefs: z.ZodArray<z.ZodString>;
+                infrastructureError: z.ZodString;
+                expectedStatus: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                minimumScore: z.ZodString;
+                maximumScore: z.ZodString;
+                expectedPassed: z.ZodEnum<{
+                    any: "any";
+                    true: "true";
+                    false: "false";
+                }>;
+                sourceLabel: z.ZodOptional<z.ZodObject<{
+                    evidence: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    feedback: z.ZodObject<{
+                        id: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        targetId: z.ZodString;
+        baseRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        editorVersion: z.ZodLiteral<"openpond.modelsEditor.v1">;
+        targetKind: z.ZodLiteral<"binding">;
+        fields: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            sources: z.ZodArray<z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"identity">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"linear">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    direction: z.ZodEnum<{
+                        higher: "higher";
+                        lower: "lower";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                weight: z.ZodNumber;
+                required: z.ZodBoolean;
+                hardGate: z.ZodBoolean;
+                privileged: z.ZodBoolean;
+                fixtureRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
+        revision: z.ZodNumber;
+        status: z.ZodEnum<{
+            draft: "draft";
+            archived: "archived";
+            published: "published";
+        }>;
+        publishedRelease: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>], "targetKind">;
+    base: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        feedbackKey: z.ZodOptional<z.ZodString>;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+            kind: z.ZodLiteral<"custom_verifier">;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                isolated_javascript: "isolated_javascript";
+                sandbox_process: "sandbox_process";
+            }>>;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            form: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
+                mode: z.ZodEnum<{
+                    individual: "individual";
+                    pairwise: "pairwise";
+                }>;
+                instructions: z.ZodString;
+                criteria: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"score">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    step: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"category">;
+                    options: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"boolean">;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"text">;
+                    minimumLength: z.ZodOptional<z.ZodNumber>;
+                    maximumLength: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    instructions: z.ZodString;
+                    required: z.ZodBoolean;
+                    allowAbstain: z.ZodBoolean;
+                    requireRationale: z.ZodOptional<z.ZodBoolean>;
+                    anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        value: z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>;
+                        description: z.ZodString;
+                    }, z.core.$strict>>>;
+                    kind: z.ZodLiteral<"preference">;
+                    requireStrength: z.ZodOptional<z.ZodBoolean>;
+                    allowTie: z.ZodBoolean;
+                }, z.core.$strict>], "kind">>;
+            }, z.core.$strict>>;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    check: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardCheckRun.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        draft: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        reward: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        snapshotHash: z.ZodString;
+        fixtureRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        status: z.ZodEnum<{
+            queued: "queued";
+            cancelled: "cancelled";
+            failed: "failed";
+            completed: "completed";
+            running: "running";
+            cancelling: "cancelling";
+        }>;
+        runtime: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            packageVersion: z.ZodString;
+            engine: z.ZodString;
+        }, z.core.$strict>>;
+        results: z.ZodArray<z.ZodObject<{
+            fixture: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            result: z.ZodObject<{
+                graderId: z.ZodString;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                rawScore: z.ZodNullable<z.ZodNumber>;
+                normalizedScore: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+                evidenceHashes: z.ZodArray<z.ZodString>;
+                graderEvidence: z.ZodOptional<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
+                    graderId: z.ZodString;
+                    graderVersion: z.ZodString;
+                    status: z.ZodOptional<z.ZodEnum<{
+                        pending: "pending";
+                        failed: "failed";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>>;
+                    score: z.ZodNullable<z.ZodNumber>;
+                    passed: z.ZodBoolean;
+                    rewardEligible: z.ZodBoolean;
+                    failureClass: z.ZodNullable<z.ZodEnum<{
+                        policy_failure: "policy_failure";
+                        grader_failure: "grader_failure";
+                        environment_failure: "environment_failure";
+                        infrastructure_failure: "infrastructure_failure";
+                        timeout: "timeout";
+                        cancelled: "cancelled";
+                    }>>;
+                    feedback: z.ZodArray<z.ZodString>;
+                    visibleEvidenceRefs: z.ZodArray<z.ZodString>;
+                    privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
+                    modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
+                        providerId: z.ZodString;
+                        modelId: z.ZodString;
+                        modelRevision: z.ZodNullable<z.ZodString>;
+                        responseId: z.ZodNullable<z.ZodString>;
+                        requestHash: z.ZodString;
+                        responseHash: z.ZodString;
+                        inputTokens: z.ZodNullable<z.ZodNumber>;
+                        outputTokens: z.ZodNullable<z.ZodNumber>;
+                        costUsd: z.ZodNullable<z.ZodNumber>;
+                        transportPolicy: z.ZodOptional<z.ZodObject<{
+                            schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
+                            responseFormat: z.ZodLiteral<"judgment_json_schema">;
+                            reasoningEffort: z.ZodEnum<{
+                                off: "off";
+                                low: "low";
+                                medium: "medium";
+                                high: "high";
+                                xhigh: "xhigh";
+                                max: "max";
+                            }>;
+                            maximumOutputTokens: z.ZodNumber;
+                        }, z.core.$strict>>;
+                        effectiveRequestHash: z.ZodOptional<z.ZodString>;
+                        finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                        reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                    }, z.core.$strict>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            matchesExpectation: z.ZodBoolean;
+        }, z.core.$strict>>;
+        matchesExpectations: z.ZodNullable<z.ZodBoolean>;
+        failure: z.ZodNullable<z.ZodString>;
+        timeoutMs: z.ZodNumber;
+        maximumSpendUsd: z.ZodNumber;
+        judgeCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            requestHash: z.ZodString;
+            reservedUsd: z.ZodNumber;
+            status: z.ZodEnum<{
+                reserved: "reserved";
+                settled: "settled";
+                not_dispatched: "not_dispatched";
+            }>;
+            response: z.ZodNullable<z.ZodObject<{
+                text: z.ZodString;
+                modelId: z.ZodString;
+                modelRevision: z.ZodNullable<z.ZodString>;
+                responseId: z.ZodNullable<z.ZodString>;
+                inputTokens: z.ZodNullable<z.ZodNumber>;
+                outputTokens: z.ZodNullable<z.ZodNumber>;
+                costUsd: z.ZodNullable<z.ZodNumber>;
+                effectiveRequestHash: z.ZodOptional<z.ZodString>;
+                finishReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reasoningTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        requestedBy: z.ZodOptional<z.ZodString>;
+        leaseOwner: z.ZodNullable<z.ZodString>;
+        leaseExpiresAt: z.ZodNullable<z.ZodString>;
+        attemptCount: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    assets: z.ZodArray<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+        id: z.ZodString;
+        revision: z.ZodLiteral<1>;
+        asset: z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        text: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type RewardCalibrationClosure = z.infer<typeof RewardCalibrationClosureSchema>;
+/** Integrity verification of retained owner evidence, not provider attestation
+ * or a grant. The host authorizes the source before export and before use. */
+export declare function verifyRewardCalibrationClosure(raw: unknown): RewardCalibrationClosure;
+export declare function createRewardCalibrationClosure(input: z.input<typeof ContentSchema>): RewardCalibrationClosure;
+/** Only call inside an already-authorized source transaction. No qualification
+ * is fabricated, replayed, or imported into a different repository scope. */
+export declare function exportRewardCalibrationClosure(tx: LearningTransaction, input: {
+    reward: LearningRevisionRef;
+    check: LearningRevisionRef;
+}): Promise<{
+    schemaVersion: "openpond.rewardCalibrationClosure.v1";
+    reward: {
+        schemaVersion: "openpond.rewardRelease.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        implementation: {
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            config: Record<string, unknown>;
+        } | {
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            timeoutMs: number;
+            networkPolicy: "none";
+            kind: "custom_verifier";
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            exportName?: string | undefined;
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+        } | {
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
+        } | {
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+        };
+        rawScore: {
+            minimum: number;
+            maximum: number;
+        };
+        assets: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        }[];
+        contentHash: string;
+        feedbackKey?: string | undefined;
+        fixtureSetRef?: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        } | undefined;
+        calibrationCheckRef?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | undefined;
+    };
+    draft: {
+        id: string;
+        targetId: string;
+        baseRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        editorVersion: "openpond.modelsEditor.v1";
+        targetKind: "definition";
+        fields: {
+            name: string;
+            description: string;
+            instructions: string;
+            input: string;
+            output: string;
+            familyNamespace: string;
+            sources: {
+                graderId: string;
+                reward: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                role: "evaluation" | "training";
+                normalization: {
+                    kind: "identity";
+                } | {
+                    kind: "linear";
+                    minimum: number;
+                    maximum: number;
+                    direction: "higher" | "lower";
+                };
+                weight: number;
+                required: boolean;
+                hardGate: boolean;
+                privileged: boolean;
+                fixtureRefs: {
+                    id: string;
+                    contentHash: string;
+                }[];
+            }[];
+            recipeRef?: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            } | undefined;
+        };
+        schemaVersion: "openpond.authoringDraft.v1";
+        revision: number;
+        status: "draft" | "archived" | "published";
+        publishedRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+        contentHash: string;
+    } | {
+        id: string;
+        targetId: string;
+        baseRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        editorVersion: "openpond.modelsEditor.v1";
+        targetKind: "reward";
+        fields: {
+            name: string;
+            description: string;
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state" | "model_judge" | "custom_verifier" | "human" | "learned_model";
+            fields: string;
+            outputField: string;
+            expectedField: string;
+            expectedValue: string;
+            schema: string;
+            reference: string;
+            events: string;
+            code: string;
+            exportName: string;
+            timeout: string;
+            rubric: string;
+            providerId: string;
+            modelId: string;
+            modelRevision: string;
+            temperature: string;
+            reviewerRole: string;
+            learnedId: string;
+            learnedHash: string;
+            inputContract: string;
+            minimum: string;
+            maximum: string;
+            feedbackKey?: string | undefined;
+            verifierRuntime?: "isolated_javascript" | "sandbox_process" | undefined;
+            humanForm?: string | undefined;
+            fixtures?: {
+                id: string;
+                name: string;
+                input: string;
+                output: string;
+                expectedOutput: string;
+                evaluatorContext: string;
+                artifactRefs: string[];
+                runtimeEventRefs: string[];
+                infrastructureError: string;
+                expectedStatus: "pending" | "failed" | "scored" | "unavailable";
+                minimumScore: string;
+                maximumScore: string;
+                expectedPassed: "any" | "true" | "false";
+                sourceLabel?: {
+                    evidence: {
+                        id: string;
+                        contentHash: string;
+                        revision: number;
+                    };
+                    feedback: {
+                        id: string;
+                        revision: number;
+                    };
+                } | undefined;
+            }[] | undefined;
+        };
+        schemaVersion: "openpond.authoringDraft.v1";
+        revision: number;
+        status: "draft" | "archived" | "published";
+        publishedRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+        contentHash: string;
+    } | {
+        id: string;
+        targetId: string;
+        baseRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        editorVersion: "openpond.modelsEditor.v1";
+        targetKind: "binding";
+        fields: {
+            name: string;
+            description: string;
+            sources: {
+                graderId: string;
+                reward: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                role: "evaluation" | "training";
+                normalization: {
+                    kind: "identity";
+                } | {
+                    kind: "linear";
+                    minimum: number;
+                    maximum: number;
+                    direction: "higher" | "lower";
+                };
+                weight: number;
+                required: boolean;
+                hardGate: boolean;
+                privileged: boolean;
+                fixtureRefs: {
+                    id: string;
+                    contentHash: string;
+                }[];
+            }[];
+        };
+        schemaVersion: "openpond.authoringDraft.v1";
+        revision: number;
+        status: "draft" | "archived" | "published";
+        publishedRelease: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        createdAt: string;
+        updatedAt: string;
+        contentHash: string;
+    };
+    base: {
+        schemaVersion: "openpond.rewardRelease.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        implementation: {
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            config: Record<string, unknown>;
+        } | {
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            timeoutMs: number;
+            networkPolicy: "none";
+            kind: "custom_verifier";
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            exportName?: string | undefined;
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+        } | {
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            reviewerRole: string;
+            form?: {
+                schemaVersion: "openpond.humanForm.v1";
+                mode: "individual" | "pairwise";
+                instructions: string;
+                criteria: ({
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "category";
+                    options: string[];
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "boolean";
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "text";
+                    maximumLength: number;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    minimumLength?: number | undefined;
+                } | {
+                    id: string;
+                    label: string;
+                    instructions: string;
+                    required: boolean;
+                    allowAbstain: boolean;
+                    kind: "preference";
+                    allowTie: boolean;
+                    requireRationale?: boolean | undefined;
+                    anchors?: {
+                        value: string | number | boolean;
+                        description: string;
+                    }[] | undefined;
+                    requireStrength?: boolean | undefined;
+                })[];
+            } | undefined;
+        } | {
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+        };
+        rawScore: {
+            minimum: number;
+            maximum: number;
+        };
+        assets: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        }[];
+        contentHash: string;
+        feedbackKey?: string | undefined;
+        fixtureSetRef?: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        } | undefined;
+        calibrationCheckRef?: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | undefined;
+    } | null;
+    check: {
+        schemaVersion: "openpond.rewardCheckRun.v1";
+        id: string;
+        revision: number;
+        draft: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        reward: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        snapshotHash: string;
+        fixtureRefs: {
+            id: string;
+            contentHash: string;
+        }[];
+        status: "queued" | "cancelled" | "failed" | "completed" | "running" | "cancelling";
+        runtime: {
+            id: string;
+            packageVersion: string;
+            engine: string;
+        } | null;
+        results: {
+            fixture: {
+                id: string;
+                contentHash: string;
+            };
+            result: {
+                graderId: string;
+                reward: {
+                    id: string;
+                    contentHash: string;
+                    revision: number;
+                };
+                role: "evaluation" | "training";
+                status: "pending" | "failed" | "scored" | "unavailable";
+                rawScore: number | null;
+                normalizedScore: number | null;
+                passed: boolean | null;
+                evidenceHashes: string[];
+                message: string | null;
+                graderEvidence?: {
+                    schemaVersion: "openpond.graderEvidence.v1";
+                    graderId: string;
+                    graderVersion: string;
+                    score: number | null;
+                    passed: boolean;
+                    rewardEligible: boolean;
+                    failureClass: "cancelled" | "policy_failure" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "timeout" | null;
+                    feedback: string[];
+                    visibleEvidenceRefs: string[];
+                    privilegedEvidenceRefs: string[];
+                    contentHash: string;
+                    status?: "pending" | "failed" | "scored" | "unavailable" | undefined;
+                    modelJudgeReceipt?: {
+                        schemaVersion: "openpond.modelJudgeReceipt.v1";
+                        providerId: string;
+                        modelId: string;
+                        modelRevision: string | null;
+                        responseId: string | null;
+                        requestHash: string;
+                        responseHash: string;
+                        inputTokens: number | null;
+                        outputTokens: number | null;
+                        costUsd: number | null;
+                        transportPolicy?: {
+                            schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
+                            responseFormat: "judgment_json_schema";
+                            reasoningEffort: "off" | "low" | "medium" | "high" | "xhigh" | "max";
+                            maximumOutputTokens: number;
+                        } | undefined;
+                        effectiveRequestHash?: string | undefined;
+                        finishReason?: string | null | undefined;
+                        reasoningTokens?: number | null | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+            matchesExpectation: boolean;
+        }[];
+        matchesExpectations: boolean | null;
+        failure: string | null;
+        timeoutMs: number;
+        maximumSpendUsd: number;
+        leaseOwner: string | null;
+        leaseExpiresAt: string | null;
+        attemptCount: number;
+        createdAt: string;
+        updatedAt: string;
+        judgeCalls?: {
+            id: string;
+            requestHash: string;
+            reservedUsd: number;
+            status: "reserved" | "settled" | "not_dispatched";
+            response: {
+                text: string;
+                modelId: string;
+                modelRevision: string | null;
+                responseId: string | null;
+                inputTokens: number | null;
+                outputTokens: number | null;
+                costUsd: number | null;
+                effectiveRequestHash?: string | undefined;
+                finishReason?: string | null | undefined;
+                reasoningTokens?: number | null | undefined;
+            } | null;
+        }[] | undefined;
+        requestedBy?: string | undefined;
+    };
+    assets: {
+        schemaVersion: "openpond.learningTextAsset.v1";
+        id: string;
+        revision: 1;
+        asset: {
+            id: string;
+            path: string;
+            contentHash: string;
+            sizeBytes: number;
+            mediaType: string;
+            visibility: "policy" | "verifier" | "host_private";
+        };
+        text: string;
+        contentHash: string;
+    }[];
+    contentHash: string;
+}>;
+export declare function rewardCalibrationClosureAsset(raw: unknown): {
+    schemaVersion: "openpond.learningTextAsset.v1";
+    id: string;
+    revision: 1;
+    asset: {
+        id: string;
+        path: string;
+        contentHash: string;
+        sizeBytes: number;
+        mediaType: string;
+        visibility: "policy" | "verifier" | "host_private";
+    };
+    text: string;
+    contentHash: string;
+};
+//# sourceMappingURL=reward-calibration-closure.d.ts.map