npm - @openpond/evals - Versions diffs - 0.12.0 → 0.12.1 - Mend

@openpond/evals 0.12.0 → 0.12.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (277) hide show

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

@@ -15,10 +15,10 @@ declare const ContentSchema: z.ZodObject<{
         feedbackKey: z.ZodOptional<z.ZodString>;
         implementation: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
-                content: "content";
-                schema: "schema";
                 artifact: "artifact";
+                content: "content";
                 runtime_event: "runtime_event";
+                schema: "schema";
                 state: "state";
             }>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -31,15 +31,15 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
             calibrationStatus: z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
+                pending: "pending";
             }>;
             model: z.ZodOptional<z.ZodObject<{
                 providerId: z.ZodString;
@@ -48,9 +48,6 @@ declare const ContentSchema: z.ZodObject<{
             }, 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";
@@ -63,13 +60,29 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    host_private: "host_private";
+                    policy: "policy";
+                    verifier: "verifier";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
             form: z.ZodOptional<z.ZodObject<{
                 schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                 mode: z.ZodEnum<{
@@ -147,19 +160,6 @@ declare const ContentSchema: z.ZodObject<{
                     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<{
@@ -173,9 +173,9 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>]>;
@@ -190,9 +190,9 @@ declare const ContentSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         fixtureSetRef: z.ZodOptional<z.ZodObject<{
@@ -202,9 +202,9 @@ declare const ContentSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         calibrationCheckRef: z.ZodOptional<z.ZodObject<{
@@ -272,8 +272,8 @@ declare const ContentSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -299,15 +299,15 @@ declare const ContentSchema: z.ZodObject<{
             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";
+                content: "content";
                 custom_verifier: "custom_verifier";
                 human: "human";
                 learned_model: "learned_model";
+                model_judge: "model_judge";
+                runtime_event: "runtime_event";
+                schema: "schema";
+                state: "state";
             }>;
             fields: z.ZodString;
             outputField: z.ZodString;
@@ -346,8 +346,8 @@ declare const ContentSchema: z.ZodObject<{
                 runtimeEventRefs: z.ZodArray<z.ZodString>;
                 infrastructureError: z.ZodString;
                 expectedStatus: z.ZodEnum<{
-                    pending: "pending";
                     failed: "failed";
+                    pending: "pending";
                     scored: "scored";
                     unavailable: "unavailable";
                 }>;
@@ -355,8 +355,8 @@ declare const ContentSchema: z.ZodObject<{
                 maximumScore: z.ZodString;
                 expectedPassed: z.ZodEnum<{
                     any: "any";
-                    true: "true";
                     false: "false";
+                    true: "true";
                 }>;
                 sourceLabel: z.ZodOptional<z.ZodObject<{
                     evidence: z.ZodObject<{
@@ -374,8 +374,8 @@ declare const ContentSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -435,8 +435,8 @@ declare const ContentSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -457,10 +457,10 @@ declare const ContentSchema: z.ZodObject<{
         feedbackKey: z.ZodOptional<z.ZodString>;
         implementation: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
-                content: "content";
-                schema: "schema";
                 artifact: "artifact";
+                content: "content";
                 runtime_event: "runtime_event";
+                schema: "schema";
                 state: "state";
             }>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -473,15 +473,15 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
             calibrationStatus: z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
+                pending: "pending";
             }>;
             model: z.ZodOptional<z.ZodObject<{
                 providerId: z.ZodString;
@@ -490,9 +490,6 @@ declare const ContentSchema: z.ZodObject<{
             }, 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";
@@ -505,13 +502,29 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    host_private: "host_private";
+                    policy: "policy";
+                    verifier: "verifier";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
             form: z.ZodOptional<z.ZodObject<{
                 schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                 mode: z.ZodEnum<{
@@ -589,19 +602,6 @@ declare const ContentSchema: z.ZodObject<{
                     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<{
@@ -615,9 +615,9 @@ declare const ContentSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>]>;
@@ -632,9 +632,9 @@ declare const ContentSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         fixtureSetRef: z.ZodOptional<z.ZodObject<{
@@ -644,9 +644,9 @@ declare const ContentSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         calibrationCheckRef: z.ZodOptional<z.ZodObject<{
@@ -676,12 +676,12 @@ declare const ContentSchema: z.ZodObject<{
             contentHash: z.ZodString;
         }, z.core.$strict>>;
         status: z.ZodEnum<{
-            queued: "queued";
             cancelled: "cancelled";
-            failed: "failed";
+            cancelling: "cancelling";
             completed: "completed";
+            failed: "failed";
+            queued: "queued";
             running: "running";
-            cancelling: "cancelling";
         }>;
         runtime: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
@@ -705,11 +705,11 @@ declare const ContentSchema: z.ZodObject<{
                     training: "training";
                 }>;
                 status: z.ZodEnum<{
-                    pending: "pending";
                     failed: "failed";
+                    not_applicable: "not_applicable";
+                    pending: "pending";
                     scored: "scored";
                     unavailable: "unavailable";
-                    not_applicable: "not_applicable";
                 }>;
                 rawScore: z.ZodNullable<z.ZodNumber>;
                 normalizedScore: z.ZodNullable<z.ZodNumber>;
@@ -720,8 +720,8 @@ declare const ContentSchema: z.ZodObject<{
                     graderId: z.ZodString;
                     graderVersion: z.ZodString;
                     status: z.ZodOptional<z.ZodEnum<{
-                        pending: "pending";
                         failed: "failed";
+                        pending: "pending";
                         scored: "scored";
                         unavailable: "unavailable";
                     }>>;
@@ -729,12 +729,12 @@ declare const ContentSchema: z.ZodObject<{
                     passed: z.ZodBoolean;
                     rewardEligible: z.ZodBoolean;
                     failureClass: z.ZodNullable<z.ZodEnum<{
-                        policy_failure: "policy_failure";
-                        grader_failure: "grader_failure";
+                        cancelled: "cancelled";
                         environment_failure: "environment_failure";
+                        grader_failure: "grader_failure";
                         infrastructure_failure: "infrastructure_failure";
+                        policy_failure: "policy_failure";
                         timeout: "timeout";
-                        cancelled: "cancelled";
                     }>>;
                     feedback: z.ZodArray<z.ZodString>;
                     visibleEvidenceRefs: z.ZodArray<z.ZodString>;
@@ -754,12 +754,12 @@ declare const ContentSchema: z.ZodObject<{
                             schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                             responseFormat: z.ZodLiteral<"judgment_json_schema">;
                             reasoningEffort: z.ZodEnum<{
-                                off: "off";
+                                high: "high";
                                 low: "low";
+                                max: "max";
                                 medium: "medium";
-                                high: "high";
+                                off: "off";
                                 xhigh: "xhigh";
-                                max: "max";
                             }>;
                             maximumOutputTokens: z.ZodNumber;
                         }, z.core.$strict>>;
@@ -782,9 +782,9 @@ declare const ContentSchema: z.ZodObject<{
             requestHash: z.ZodString;
             reservedUsd: z.ZodNumber;
             status: z.ZodEnum<{
+                not_dispatched: "not_dispatched";
                 reserved: "reserved";
                 settled: "settled";
-                not_dispatched: "not_dispatched";
             }>;
             response: z.ZodNullable<z.ZodObject<{
                 text: z.ZodString;
@@ -817,9 +817,9 @@ declare const ContentSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>;
         text: z.ZodString;
@@ -837,10 +837,10 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
         feedbackKey: z.ZodOptional<z.ZodString>;
         implementation: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
-                content: "content";
-                schema: "schema";
                 artifact: "artifact";
+                content: "content";
                 runtime_event: "runtime_event";
+                schema: "schema";
                 state: "state";
             }>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -853,15 +853,15 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
             calibrationStatus: z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
+                pending: "pending";
             }>;
             model: z.ZodOptional<z.ZodObject<{
                 providerId: z.ZodString;
@@ -870,9 +870,6 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             }, 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";
@@ -885,13 +882,29 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    host_private: "host_private";
+                    policy: "policy";
+                    verifier: "verifier";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
             form: z.ZodOptional<z.ZodObject<{
                 schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                 mode: z.ZodEnum<{
@@ -969,19 +982,6 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                     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<{
@@ -995,9 +995,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>]>;
@@ -1012,9 +1012,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         fixtureSetRef: z.ZodOptional<z.ZodObject<{
@@ -1024,9 +1024,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         calibrationCheckRef: z.ZodOptional<z.ZodObject<{
@@ -1094,8 +1094,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -1121,15 +1121,15 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             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";
+                content: "content";
                 custom_verifier: "custom_verifier";
                 human: "human";
                 learned_model: "learned_model";
+                model_judge: "model_judge";
+                runtime_event: "runtime_event";
+                schema: "schema";
+                state: "state";
             }>;
             fields: z.ZodString;
             outputField: z.ZodString;
@@ -1168,8 +1168,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 runtimeEventRefs: z.ZodArray<z.ZodString>;
                 infrastructureError: z.ZodString;
                 expectedStatus: z.ZodEnum<{
-                    pending: "pending";
                     failed: "failed";
+                    pending: "pending";
                     scored: "scored";
                     unavailable: "unavailable";
                 }>;
@@ -1177,8 +1177,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 maximumScore: z.ZodString;
                 expectedPassed: z.ZodEnum<{
                     any: "any";
-                    true: "true";
                     false: "false";
+                    true: "true";
                 }>;
                 sourceLabel: z.ZodOptional<z.ZodObject<{
                     evidence: z.ZodObject<{
@@ -1196,8 +1196,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -1257,8 +1257,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.authoringDraft.v1">;
         revision: z.ZodNumber;
         status: z.ZodEnum<{
-            draft: "draft";
             archived: "archived";
+            draft: "draft";
             published: "published";
         }>;
         publishedRelease: z.ZodNullable<z.ZodObject<{
@@ -1279,10 +1279,10 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
         feedbackKey: z.ZodOptional<z.ZodString>;
         implementation: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
-                content: "content";
-                schema: "schema";
                 artifact: "artifact";
+                content: "content";
                 runtime_event: "runtime_event";
+                schema: "schema";
                 state: "state";
             }>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -1295,15 +1295,15 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
             calibrationStatus: z.ZodEnum<{
-                pending: "pending";
-                passed: "passed";
                 failed: "failed";
+                passed: "passed";
+                pending: "pending";
             }>;
             model: z.ZodOptional<z.ZodObject<{
                 providerId: z.ZodString;
@@ -1312,9 +1312,6 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             }, 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";
@@ -1327,13 +1324,29 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    host_private: "host_private";
+                    policy: "policy";
+                    verifier: "verifier";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
             form: z.ZodOptional<z.ZodObject<{
                 schemaVersion: z.ZodLiteral<"openpond.humanForm.v1">;
                 mode: z.ZodEnum<{
@@ -1411,19 +1424,6 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                     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<{
@@ -1437,9 +1437,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                 sizeBytes: z.ZodNumber;
                 mediaType: z.ZodString;
                 visibility: z.ZodEnum<{
+                    host_private: "host_private";
                     policy: "policy";
                     verifier: "verifier";
-                    host_private: "host_private";
                 }>;
             }, z.core.$strict>;
         }, z.core.$strict>]>;
@@ -1454,9 +1454,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         fixtureSetRef: z.ZodOptional<z.ZodObject<{
@@ -1466,9 +1466,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>>;
         calibrationCheckRef: z.ZodOptional<z.ZodObject<{
@@ -1498,12 +1498,12 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             contentHash: z.ZodString;
         }, z.core.$strict>>;
         status: z.ZodEnum<{
-            queued: "queued";
             cancelled: "cancelled";
-            failed: "failed";
+            cancelling: "cancelling";
             completed: "completed";
+            failed: "failed";
+            queued: "queued";
             running: "running";
-            cancelling: "cancelling";
         }>;
         runtime: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
@@ -1527,11 +1527,11 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                     training: "training";
                 }>;
                 status: z.ZodEnum<{
-                    pending: "pending";
                     failed: "failed";
+                    not_applicable: "not_applicable";
+                    pending: "pending";
                     scored: "scored";
                     unavailable: "unavailable";
-                    not_applicable: "not_applicable";
                 }>;
                 rawScore: z.ZodNullable<z.ZodNumber>;
                 normalizedScore: z.ZodNullable<z.ZodNumber>;
@@ -1542,8 +1542,8 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                     graderId: z.ZodString;
                     graderVersion: z.ZodString;
                     status: z.ZodOptional<z.ZodEnum<{
-                        pending: "pending";
                         failed: "failed";
+                        pending: "pending";
                         scored: "scored";
                         unavailable: "unavailable";
                     }>>;
@@ -1551,12 +1551,12 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                     passed: z.ZodBoolean;
                     rewardEligible: z.ZodBoolean;
                     failureClass: z.ZodNullable<z.ZodEnum<{
-                        policy_failure: "policy_failure";
-                        grader_failure: "grader_failure";
+                        cancelled: "cancelled";
                         environment_failure: "environment_failure";
+                        grader_failure: "grader_failure";
                         infrastructure_failure: "infrastructure_failure";
+                        policy_failure: "policy_failure";
                         timeout: "timeout";
-                        cancelled: "cancelled";
                     }>>;
                     feedback: z.ZodArray<z.ZodString>;
                     visibleEvidenceRefs: z.ZodArray<z.ZodString>;
@@ -1576,12 +1576,12 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
                             schemaVersion: z.ZodLiteral<"openpond.modelJudgeTransportPolicy.v1">;
                             responseFormat: z.ZodLiteral<"judgment_json_schema">;
                             reasoningEffort: z.ZodEnum<{
-                                off: "off";
+                                high: "high";
                                 low: "low";
+                                max: "max";
                                 medium: "medium";
-                                high: "high";
+                                off: "off";
                                 xhigh: "xhigh";
-                                max: "max";
                             }>;
                             maximumOutputTokens: z.ZodNumber;
                         }, z.core.$strict>>;
@@ -1604,9 +1604,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             requestHash: z.ZodString;
             reservedUsd: z.ZodNumber;
             status: z.ZodEnum<{
+                not_dispatched: "not_dispatched";
                 reserved: "reserved";
                 settled: "settled";
-                not_dispatched: "not_dispatched";
             }>;
             response: z.ZodNullable<z.ZodObject<{
                 text: z.ZodString;
@@ -1639,9 +1639,9 @@ export declare const RewardCalibrationClosureSchema: z.ZodObject<{
             sizeBytes: z.ZodNumber;
             mediaType: z.ZodString;
             visibility: z.ZodEnum<{
+                host_private: "host_private";
                 policy: "policy";
                 verifier: "verifier";
-                host_private: "host_private";
             }>;
         }, z.core.$strict>;
         text: z.ZodString;
@@ -1667,8 +1667,23 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         revision: number;
         name: string;
         description: string;
+        feedbackKey?: string | undefined;
         implementation: {
-            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+        } | {
+            kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
             config: Record<string, unknown>;
         } | {
             kind: "model_judge";
@@ -1678,9 +1693,9 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
-            calibrationStatus: "pending" | "passed" | "failed";
+            calibrationStatus: "failed" | "passed" | "pending";
             model?: {
                 providerId: string;
                 modelId: string;
@@ -1688,19 +1703,19 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             } | undefined;
             temperature?: number | undefined;
         } | {
-            timeoutMs: number;
-            networkPolicy: "none";
             kind: "custom_verifier";
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             verifierRef: {
                 id: string;
                 path: string;
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
             exportName?: string | undefined;
-            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+            timeoutMs: number;
+            networkPolicy: "none";
         } | {
             kind: "human";
             rubricRef: {
@@ -1709,7 +1724,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
             reviewerRole: string;
             form?: {
@@ -1722,84 +1737,70 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                     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;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
                 } | {
                     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;
+                    kind: "category";
+                    options: string[];
                 } | {
                     id: string;
                     label: string;
                     instructions: string;
                     required: boolean;
                     allowAbstain: boolean;
-                    kind: "boolean";
                     requireRationale?: boolean | undefined;
                     anchors?: {
                         value: string | number | boolean;
                         description: string;
                     }[] | undefined;
+                    kind: "boolean";
                 } | {
                     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;
+                    kind: "text";
                     minimumLength?: number | undefined;
+                    maximumLength: number;
                 } | {
                     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;
+                    kind: "preference";
                     requireStrength?: boolean | undefined;
+                    allowTie: boolean;
                 })[];
             } | 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;
@@ -1811,23 +1812,22 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             contentHash: string;
             sizeBytes: number;
             mediaType: string;
-            visibility: "policy" | "verifier" | "host_private";
+            visibility: "host_private" | "policy" | "verifier";
         }[];
-        contentHash: string;
-        feedbackKey?: string | undefined;
         fixtureSetRef?: {
             id: string;
             path: string;
             contentHash: string;
             sizeBytes: number;
             mediaType: string;
-            visibility: "policy" | "verifier" | "host_private";
+            visibility: "host_private" | "policy" | "verifier";
         } | undefined;
         calibrationCheckRef?: {
             id: string;
             contentHash: string;
             revision: number;
         } | undefined;
+        contentHash: string;
     };
     draft: {
         id: string;
@@ -1848,6 +1848,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             familyNamespace: string;
             sources: {
                 graderId: string;
+                taskIds?: string[] | undefined;
                 reward: {
                     id: string;
                     contentHash: string;
@@ -1870,7 +1871,6 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                     id: string;
                     contentHash: string;
                 }[];
-                taskIds?: string[] | undefined;
             }[];
             recipeRef?: {
                 id: string;
@@ -1880,7 +1880,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         };
         schemaVersion: "openpond.authoringDraft.v1";
         revision: number;
-        status: "draft" | "archived" | "published";
+        status: "archived" | "draft" | "published";
         publishedRelease: {
             id: string;
             contentHash: string;
@@ -1902,7 +1902,8 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         fields: {
             name: string;
             description: string;
-            kind: "content" | "schema" | "artifact" | "runtime_event" | "state" | "model_judge" | "custom_verifier" | "human" | "learned_model";
+            feedbackKey?: string | undefined;
+            kind: "artifact" | "content" | "custom_verifier" | "human" | "learned_model" | "model_judge" | "runtime_event" | "schema" | "state";
             fields: string;
             outputField: string;
             expectedField: string;
@@ -1913,20 +1914,19 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             code: string;
             exportName: string;
             timeout: string;
+            verifierRuntime?: "isolated_javascript" | "sandbox_process" | undefined;
             rubric: string;
             providerId: string;
             modelId: string;
             modelRevision: string;
             temperature: string;
             reviewerRole: string;
+            humanForm?: string | undefined;
             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;
@@ -1937,10 +1937,10 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                 artifactRefs: string[];
                 runtimeEventRefs: string[];
                 infrastructureError: string;
-                expectedStatus: "pending" | "failed" | "scored" | "unavailable";
+                expectedStatus: "failed" | "pending" | "scored" | "unavailable";
                 minimumScore: string;
                 maximumScore: string;
-                expectedPassed: "any" | "true" | "false";
+                expectedPassed: "any" | "false" | "true";
                 sourceLabel?: {
                     evidence: {
                         id: string;
@@ -1956,7 +1956,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         };
         schemaVersion: "openpond.authoringDraft.v1";
         revision: number;
-        status: "draft" | "archived" | "published";
+        status: "archived" | "draft" | "published";
         publishedRelease: {
             id: string;
             contentHash: string;
@@ -1980,6 +1980,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             description: string;
             sources: {
                 graderId: string;
+                taskIds?: string[] | undefined;
                 reward: {
                     id: string;
                     contentHash: string;
@@ -2002,12 +2003,11 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                     id: string;
                     contentHash: string;
                 }[];
-                taskIds?: string[] | undefined;
             }[];
         };
         schemaVersion: "openpond.authoringDraft.v1";
         revision: number;
-        status: "draft" | "archived" | "published";
+        status: "archived" | "draft" | "published";
         publishedRelease: {
             id: string;
             contentHash: string;
@@ -2023,8 +2023,23 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         revision: number;
         name: string;
         description: string;
+        feedbackKey?: string | undefined;
         implementation: {
-            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            kind: "learned_model";
+            modelVersion: {
+                id: string;
+                contentHash: string;
+            };
+            inputContract: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "host_private" | "policy" | "verifier";
+            };
+        } | {
+            kind: "artifact" | "content" | "runtime_event" | "schema" | "state";
             config: Record<string, unknown>;
         } | {
             kind: "model_judge";
@@ -2034,9 +2049,9 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
-            calibrationStatus: "pending" | "passed" | "failed";
+            calibrationStatus: "failed" | "passed" | "pending";
             model?: {
                 providerId: string;
                 modelId: string;
@@ -2044,19 +2059,19 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             } | undefined;
             temperature?: number | undefined;
         } | {
-            timeoutMs: number;
-            networkPolicy: "none";
             kind: "custom_verifier";
+            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
             verifierRef: {
                 id: string;
                 path: string;
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
             exportName?: string | undefined;
-            runtime?: "isolated_javascript" | "sandbox_process" | undefined;
+            timeoutMs: number;
+            networkPolicy: "none";
         } | {
             kind: "human";
             rubricRef: {
@@ -2065,7 +2080,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                 contentHash: string;
                 sizeBytes: number;
                 mediaType: string;
-                visibility: "policy" | "verifier" | "host_private";
+                visibility: "host_private" | "policy" | "verifier";
             };
             reviewerRole: string;
             form?: {
@@ -2078,84 +2093,70 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                     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;
+                    kind: "score";
+                    minimum: number;
+                    maximum: number;
+                    step: number;
                 } | {
                     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;
+                    kind: "category";
+                    options: string[];
                 } | {
                     id: string;
                     label: string;
                     instructions: string;
                     required: boolean;
                     allowAbstain: boolean;
-                    kind: "boolean";
                     requireRationale?: boolean | undefined;
                     anchors?: {
                         value: string | number | boolean;
                         description: string;
                     }[] | undefined;
+                    kind: "boolean";
                 } | {
                     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;
+                    kind: "text";
                     minimumLength?: number | undefined;
+                    maximumLength: number;
                 } | {
                     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;
+                    kind: "preference";
                     requireStrength?: boolean | undefined;
+                    allowTie: boolean;
                 })[];
             } | 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;
@@ -2167,23 +2168,22 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             contentHash: string;
             sizeBytes: number;
             mediaType: string;
-            visibility: "policy" | "verifier" | "host_private";
+            visibility: "host_private" | "policy" | "verifier";
         }[];
-        contentHash: string;
-        feedbackKey?: string | undefined;
         fixtureSetRef?: {
             id: string;
             path: string;
             contentHash: string;
             sizeBytes: number;
             mediaType: string;
-            visibility: "policy" | "verifier" | "host_private";
+            visibility: "host_private" | "policy" | "verifier";
         } | undefined;
         calibrationCheckRef?: {
             id: string;
             contentHash: string;
             revision: number;
         } | undefined;
+        contentHash: string;
     } | null;
     check: {
         schemaVersion: "openpond.rewardCheckRun.v1";
@@ -2204,7 +2204,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             id: string;
             contentHash: string;
         }[];
-        status: "queued" | "cancelled" | "failed" | "completed" | "running" | "cancelling";
+        status: "cancelled" | "cancelling" | "completed" | "failed" | "queued" | "running";
         runtime: {
             id: string;
             packageVersion: string;
@@ -2223,25 +2223,23 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                     revision: number;
                 };
                 role: "evaluation" | "training";
-                status: "pending" | "failed" | "scored" | "unavailable" | "not_applicable";
+                status: "failed" | "not_applicable" | "pending" | "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;
+                    status?: "failed" | "pending" | "scored" | "unavailable" | undefined;
                     score: number | null;
                     passed: boolean;
                     rewardEligible: boolean;
-                    failureClass: "cancelled" | "policy_failure" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "timeout" | null;
+                    failureClass: "cancelled" | "environment_failure" | "grader_failure" | "infrastructure_failure" | "policy_failure" | "timeout" | null;
                     feedback: string[];
                     visibleEvidenceRefs: string[];
                     privilegedEvidenceRefs: string[];
-                    contentHash: string;
-                    status?: "pending" | "failed" | "scored" | "unavailable" | undefined;
                     modelJudgeReceipt?: {
                         schemaVersion: "openpond.modelJudgeReceipt.v1";
                         providerId: string;
@@ -2256,14 +2254,16 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
                         transportPolicy?: {
                             schemaVersion: "openpond.modelJudgeTransportPolicy.v1";
                             responseFormat: "judgment_json_schema";
-                            reasoningEffort: "off" | "low" | "medium" | "high" | "xhigh" | "max";
+                            reasoningEffort: "high" | "low" | "max" | "medium" | "off" | "xhigh";
                             maximumOutputTokens: number;
                         } | undefined;
                         effectiveRequestHash?: string | undefined;
                         finishReason?: string | null | undefined;
                         reasoningTokens?: number | null | undefined;
                     } | undefined;
+                    contentHash: string;
                 } | undefined;
+                message: string | null;
             };
             matchesExpectation: boolean;
         }[];
@@ -2271,16 +2271,11 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
         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";
+            status: "not_dispatched" | "reserved" | "settled";
             response: {
                 text: string;
                 modelId: string;
@@ -2295,6 +2290,11 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             } | null;
         }[] | undefined;
         requestedBy?: string | undefined;
+        leaseOwner: string | null;
+        leaseExpiresAt: string | null;
+        attemptCount: number;
+        createdAt: string;
+        updatedAt: string;
     };
     assets: {
         schemaVersion: "openpond.learningTextAsset.v1";
@@ -2306,7 +2306,7 @@ export declare function exportRewardCalibrationClosure(tx: LearningTransaction,
             contentHash: string;
             sizeBytes: number;
             mediaType: string;
-            visibility: "policy" | "verifier" | "host_private";
+            visibility: "host_private" | "policy" | "verifier";
         };
         text: string;
         contentHash: string;
@@ -2323,7 +2323,7 @@ export declare function rewardCalibrationClosureAsset(raw: unknown): {
         contentHash: string;
         sizeBytes: number;
         mediaType: string;
-        visibility: "policy" | "verifier" | "host_private";
+        visibility: "host_private" | "policy" | "verifier";
     };
     text: string;
     contentHash: string;