@openpond/evals 0.12.6 → 0.12.8

package/dist/types/learning/transport.d.ts

@@ -2535,163 +2535,24 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
         updatedAt: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict>], "targetKind"> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.taskFeedbackRecord.v1">;
-        id: z.ZodString;
-        submission: z.ZodObject<{
-            schemaVersion: z.ZodLiteral<"openpond.taskFeedback.v1">;
-            sourceId: z.ZodString;
-            idempotencyKey: z.ZodString;
-            exampleId: z.ZodString;
-            attemptId: z.ZodString;
-            expectedEvidenceHash: z.ZodNullable<z.ZodString>;
-            occurredAt: z.ZodString;
-            kind: z.ZodEnum<{
-                family_resolution: "family_resolution";
-                ground_truth_correction: "ground_truth_correction";
-                input_correction: "input_correction";
-                outcome: "outcome";
-                target_correction: "target_correction";
-            }>;
-            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            note: z.ZodString;
-        }, z.core.$strict>;
-        status: z.ZodEnum<{
-            applied: "applied";
-            pending_example: "pending_example";
-            pending_review: "pending_review";
-            rejected: "rejected";
-            superseded: "superseded";
-        }>;
-        evidence: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>>;
-        createdAt: z.ZodString;
-        revision: z.ZodNumber;
-        submittedBy: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            role: z.ZodEnum<{
-                editor: "editor";
-                reviewer: "reviewer";
-                source: "source";
-            }>;
-            sourceId: z.ZodNullable<z.ZodString>;
-        }, z.core.$strict>>>;
-        review: z.ZodDefault<z.ZodNullable<z.ZodObject<{
-            actorId: z.ZodString;
-            decision: z.ZodNullable<z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>>;
-            note: z.ZodString;
-            resolvedAt: z.ZodString;
-        }, z.core.$strict>>>;
-    }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
+        schemaVersion: z.ZodLiteral<"openpond.rewardCheckRun.v1">;
         id: z.ZodString;
         revision: z.ZodNumber;
-        policy: z.ZodObject<{
+        draft: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
             revision: z.ZodNumber;
         }, z.core.$strict>;
-        status: z.ZodEnum<{
-            accepted: "accepted";
-            cancelled: "cancelled";
-            cancelling: "cancelling";
-            candidate_ready: "candidate_ready";
-            completed_without_candidate: "completed_without_candidate";
-            dispatching: "dispatching";
-            evaluating: "evaluating";
-            failed: "failed";
-            paused: "paused";
-            ready: "ready";
-            rejected: "rejected";
-            training: "training";
-            waiting_for_data: "waiting_for_data";
-            waiting_for_review: "waiting_for_review";
-        }>;
-        triggerIdentity: z.ZodString;
-        batch: z.ZodNullable<z.ZodObject<{
+        reward: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
             revision: z.ZodNumber;
-        }, z.core.$strict>>;
-        sourceWatermarks: z.ZodRecord<z.ZodString, z.ZodNumber>;
-        trainingParent: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
         }, z.core.$strict>;
-        trainingParentSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-            iterationId: z.ZodString;
-            iterationRevision: z.ZodNumber;
-            candidate: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-            }, z.core.$strict>;
-            decision: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-            decidedAt: z.ZodString;
-        }, z.core.$strict>>>;
-        teacher: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        upstreamEvent: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        trainingJob: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        evaluationJob: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        candidateVersion: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        candidateDecision: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        snapshotHash: z.ZodString;
+        fixtureRefs: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>>>;
-        candidateDecisionAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        dispatchId: z.ZodString;
-        retryCount: z.ZodNumber;
-        spendUsd: z.ZodNumber;
-        failure: z.ZodNullable<z.ZodObject<{
-            code: z.ZodString;
-            message: z.ZodString;
         }, z.core.$strict>>;
-        createdAt: z.ZodString;
-        updatedAt: z.ZodString;
-    }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.taskGradeRun.v1">;
-        id: z.ZodString;
-        revision: z.ZodNumber;
-        evidence: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>;
-        binding: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>;
-        target: z.ZodEnum<{
-            observed: "observed";
-            proposed_target: "proposed_target";
-        }>;
-        output: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
         status: z.ZodEnum<{
             cancelled: "cancelled";
             cancelling: "cancelling";
@@ -2700,17 +2561,17 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
             queued: "queued";
             running: "running";
         }>;
-        composition: z.ZodNullable<z.ZodObject<{
-            schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
-            binding: z.ZodObject<{
+        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;
-                revision: z.ZodNumber;
             }, z.core.$strict>;
-            taskHash: z.ZodString;
-            taskId: z.ZodOptional<z.ZodString>;
-            outputHash: z.ZodString;
-            results: z.ZodArray<z.ZodObject<{
+            result: z.ZodObject<{
                 graderId: z.ZodString;
                 reward: z.ZodObject<{
                     id: z.ZodString;
@@ -2787,32 +2648,11 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
                     contentHash: z.ZodString;
                 }, z.core.$strict>>;
                 message: z.ZodNullable<z.ZodString>;
-            }, z.core.$strict>>;
-            training: z.ZodObject<{
-                status: z.ZodEnum<{
-                    not_configured: "not_configured";
-                    pending: "pending";
-                    scored: "scored";
-                    unscorable: "unscorable";
-                }>;
-                score: z.ZodNullable<z.ZodNumber>;
-                passed: z.ZodNullable<z.ZodBoolean>;
-            }, z.core.$strict>;
-            evaluation: z.ZodObject<{
-                status: z.ZodEnum<{
-                    not_configured: "not_configured";
-                    pending: "pending";
-                    scored: "scored";
-                    unscorable: "unscorable";
-                }>;
-                score: z.ZodNullable<z.ZodNumber>;
-                passed: z.ZodNullable<z.ZodBoolean>;
             }, z.core.$strict>;
-            contentHash: z.ZodString;
+            matchesExpectation: z.ZodBoolean;
         }, z.core.$strict>>;
-        leaseOwner: z.ZodNullable<z.ZodString>;
-        leaseExpiresAt: z.ZodNullable<z.ZodString>;
-        attemptCount: z.ZodNumber;
+        matchesExpectations: z.ZodNullable<z.ZodBoolean>;
+        failure: z.ZodNullable<z.ZodString>;
         timeoutMs: z.ZodNumber;
         maximumSpendUsd: z.ZodNumber;
         judgeCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -2838,158 +2678,65 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
             }, z.core.$strict>>;
         }, z.core.$strict>>>;
         requestedBy: z.ZodOptional<z.ZodString>;
-        failure: z.ZodNullable<z.ZodString>;
+        leaseOwner: z.ZodNullable<z.ZodString>;
+        leaseExpiresAt: z.ZodNullable<z.ZodString>;
+        attemptCount: z.ZodNumber;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.rewardCheckRun.v1">;
+        schemaVersion: z.ZodLiteral<"openpond.taskFeedbackRecord.v1">;
         id: z.ZodString;
-        revision: z.ZodNumber;
-        draft: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
+        submission: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.taskFeedback.v1">;
+            sourceId: z.ZodString;
+            idempotencyKey: z.ZodString;
+            exampleId: z.ZodString;
+            attemptId: z.ZodString;
+            expectedEvidenceHash: z.ZodNullable<z.ZodString>;
+            occurredAt: z.ZodString;
+            kind: z.ZodEnum<{
+                family_resolution: "family_resolution";
+                ground_truth_correction: "ground_truth_correction";
+                input_correction: "input_correction";
+                outcome: "outcome";
+                target_correction: "target_correction";
+            }>;
+            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            note: z.ZodString;
         }, z.core.$strict>;
-        reward: z.ZodObject<{
+        status: z.ZodEnum<{
+            applied: "applied";
+            pending_example: "pending_example";
+            pending_review: "pending_review";
+            rejected: "rejected";
+            superseded: "superseded";
+        }>;
+        evidence: z.ZodNullable<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<{
-            cancelled: "cancelled";
-            cancelling: "cancelling";
-            completed: "completed";
-            failed: "failed";
-            queued: "queued";
-            running: "running";
-        }>;
-        runtime: z.ZodNullable<z.ZodObject<{
+        createdAt: z.ZodString;
+        revision: z.ZodNumber;
+        submittedBy: z.ZodDefault<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<{
-                    failed: "failed";
-                    not_applicable: "not_applicable";
-                    pending: "pending";
-                    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<{
-                        failed: "failed";
-                        pending: "pending";
-                        scored: "scored";
-                        unavailable: "unavailable";
-                    }>>;
-                    score: z.ZodNullable<z.ZodNumber>;
-                    passed: z.ZodBoolean;
-                    rewardEligible: z.ZodBoolean;
-                    failureClass: z.ZodNullable<z.ZodEnum<{
-                        cancelled: "cancelled";
-                        environment_failure: "environment_failure";
-                        grader_failure: "grader_failure";
-                        infrastructure_failure: "infrastructure_failure";
-                        policy_failure: "policy_failure";
-                        timeout: "timeout";
-                    }>>;
-                    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<{
-                                high: "high";
-                                low: "low";
-                                max: "max";
-                                medium: "medium";
-                                off: "off";
-                                xhigh: "xhigh";
-                            }>;
-                            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<{
-                not_dispatched: "not_dispatched";
-                reserved: "reserved";
-                settled: "settled";
+            role: z.ZodEnum<{
+                editor: "editor";
+                reviewer: "reviewer";
+                source: "source";
             }>;
-            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>>;
+            sourceId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        review: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            actorId: z.ZodString;
+            decision: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
             }, z.core.$strict>>;
+            note: z.ZodString;
+            resolvedAt: z.ZodString;
         }, 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> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.learningChain.v1">;
         id: z.ZodString;
@@ -3016,7 +2763,7 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.learningConsumption.v1">;
         id: z.ZodString;
-        revision: z.ZodLiteral<1>;
+        revision: z.ZodNumber;
         chainId: z.ZodString;
         iterationId: z.ZodString;
         evidence: z.ZodObject<{
@@ -3030,6 +2777,16 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
             revision: z.ZodNumber;
         }, z.core.$strict>;
         reservedAt: z.ZodString;
+        exposure: z.ZodOptional<z.ZodEnum<{
+            exposed: "exposed";
+            reserved: "reserved";
+            trained: "trained";
+            unexposed: "unexposed";
+        }>>;
+        executionReceipt: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>>;
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.learningIterationReservation.v1">;
         id: z.ZodString;
@@ -3204,95 +2961,348 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
         createdAt: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.tasksetRelease.v2">;
+        schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
         id: z.ZodString;
         revision: z.ZodNumber;
         policy: z.ZodObject<{
-            policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
         }, z.core.$strict>;
-        environment: z.ZodObject<{
-            protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
-            kind: z.ZodEnum<{
-                agent: "agent";
-                custom_program: "custom_program";
-                text: "text";
-                work: "work";
-            }>;
-            entrypoint: z.ZodString;
-            stateful: z.ZodBoolean;
-            deterministicSeeds: z.ZodBoolean;
-            lifecycle: z.ZodArray<z.ZodEnum<{
-                collect: "collect";
-                create: "create";
-                destroy: "destroy";
-                reset: "reset";
-                step: "step";
-            }>>;
-            networkPolicy: z.ZodEnum<{
-                declared_read_only: "declared_read_only";
-                declared_scoped: "declared_scoped";
-                none: "none";
-            }>;
-            defaultTimeoutMs: z.ZodNumber;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            cancelled: "cancelled";
+            cancelling: "cancelling";
+            candidate_ready: "candidate_ready";
+            completed_without_candidate: "completed_without_candidate";
+            dispatching: "dispatching";
+            evaluating: "evaluating";
+            failed: "failed";
+            paused: "paused";
+            ready: "ready";
+            rejected: "rejected";
+            training: "training";
+            waiting_for_data: "waiting_for_data";
+            waiting_for_review: "waiting_for_review";
+        }>;
+        triggerIdentity: z.ZodString;
+        batch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        sourceWatermarks: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        trainingParent: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
         }, z.core.$strict>;
-        environmentRelease: z.ZodOptional<z.ZodObject<{
+        trainingParentSelection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            iterationId: z.ZodString;
+            iterationRevision: z.ZodNumber;
+            candidate: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            decision: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            decidedAt: z.ZodString;
+        }, z.core.$strict>>>;
+        teacher: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
         }, z.core.$strict>>;
-        tools: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            description: z.ZodString;
-            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            inputSchemaHash: z.ZodString;
-            sideEffect: z.ZodEnum<{
-                read: "read";
-                write: "write";
-            }>;
-            timeoutMs: z.ZodNumber;
+        upstreamEvent: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
         }, z.core.$strict>>;
-        capabilities: z.ZodArray<z.ZodObject<{
+        trainingJob: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
-            required: z.ZodBoolean;
-            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            portability: z.ZodEnum<{
-                host_adapter: "host_adapter";
-                hosted_only: "hosted_only";
-                local_only: "local_only";
-                portable: "portable";
-            }>;
+            contentHash: z.ZodString;
         }, z.core.$strict>>;
-        tasks: z.ZodArray<z.ZodObject<{
+        evaluationJob: z.ZodNullable<z.ZodObject<{
             id: z.ZodString;
-            clusterKey: z.ZodString;
-            split: z.ZodEnum<{
-                frozen_eval: "frozen_eval";
-                test: "test";
-                train: "train";
-                validation: "validation";
-            }>;
-            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            privilegedContextRef: z.ZodNullable<z.ZodString>;
-            artifactRefs: z.ZodDefault<z.ZodArray<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>>>;
-            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                mediaType: z.ZodString;
-                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        candidateVersion: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        candidateDecision: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>>;
+        candidateDecisionAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        dispatchId: z.ZodString;
+        retryCount: z.ZodNumber;
+        spendUsd: z.ZodNumber;
+        failure: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskGradeRun.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        binding: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        target: z.ZodEnum<{
+            observed: "observed";
+            proposed_target: "proposed_target";
+        }>;
+        output: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            cancelling: "cancelling";
+            completed: "completed";
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+        }>;
+        composition: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.rewardComposition.v1">;
+            binding: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            taskHash: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
+            outputHash: z.ZodString;
+            results: 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";
+                }>;
+                status: z.ZodEnum<{
+                    failed: "failed";
+                    not_applicable: "not_applicable";
+                    pending: "pending";
+                    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<{
+                        failed: "failed";
+                        pending: "pending";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>>;
+                    score: z.ZodNullable<z.ZodNumber>;
+                    passed: z.ZodBoolean;
+                    rewardEligible: z.ZodBoolean;
+                    failureClass: z.ZodNullable<z.ZodEnum<{
+                        cancelled: "cancelled";
+                        environment_failure: "environment_failure";
+                        grader_failure: "grader_failure";
+                        infrastructure_failure: "infrastructure_failure";
+                        policy_failure: "policy_failure";
+                        timeout: "timeout";
+                    }>>;
+                    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<{
+                                high: "high";
+                                low: "low";
+                                max: "max";
+                                medium: "medium";
+                                off: "off";
+                                xhigh: "xhigh";
+                            }>;
+                            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>>;
+            training: z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_configured: "not_configured";
+                    pending: "pending";
+                    scored: "scored";
+                    unscorable: "unscorable";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_configured: "not_configured";
+                    pending: "pending";
+                    scored: "scored";
+                    unscorable: "unscorable";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        leaseOwner: z.ZodNullable<z.ZodString>;
+        leaseExpiresAt: z.ZodNullable<z.ZodString>;
+        attemptCount: z.ZodNumber;
+        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<{
+                not_dispatched: "not_dispatched";
+                reserved: "reserved";
+                settled: "settled";
+            }>;
+            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>;
+        failure: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.tasksetRelease.v2">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
+            kind: z.ZodEnum<{
+                agent: "agent";
+                custom_program: "custom_program";
+                text: "text";
+                work: "work";
+            }>;
+            entrypoint: z.ZodString;
+            stateful: z.ZodBoolean;
+            deterministicSeeds: z.ZodBoolean;
+            lifecycle: z.ZodArray<z.ZodEnum<{
+                collect: "collect";
+                create: "create";
+                destroy: "destroy";
+                reset: "reset";
+                step: "step";
+            }>>;
+            networkPolicy: z.ZodEnum<{
+                declared_read_only: "declared_read_only";
+                declared_scoped: "declared_scoped";
+                none: "none";
+            }>;
+            defaultTimeoutMs: z.ZodNumber;
+        }, z.core.$strict>;
+        environmentRelease: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            inputSchemaHash: z.ZodString;
+            sideEffect: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        capabilities: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            required: z.ZodBoolean;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            portability: z.ZodEnum<{
+                host_adapter: "host_adapter";
+                hosted_only: "hosted_only";
+                local_only: "local_only";
+                portable: "portable";
+            }>;
+        }, z.core.$strict>>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            clusterKey: z.ZodString;
+            split: z.ZodEnum<{
+                frozen_eval: "frozen_eval";
+                test: "test";
+                train: "train";
+                validation: "validation";
+            }>;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            privilegedContextRef: z.ZodNullable<z.ZodString>;
+            artifactRefs: z.ZodDefault<z.ZodArray<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>>>;
+            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                mediaType: z.ZodString;
+                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
                     id: z.ZodString;
                     path: z.ZodString;
                     contentHash: z.ZodString;
@@ -3514,6 +3524,101 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
         }, z.core.$strict>>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         contentHash: z.ZodString;
+    }, z.core.$strict> | 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<{
+                host_private: "host_private";
+                policy: "policy";
+                verifier: "verifier";
+            }>;
+        }, z.core.$strict>;
+        text: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        submission: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
+            sourceId: z.ZodString;
+            idempotencyKey: z.ZodString;
+            taskDefinition: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            exampleId: z.ZodString;
+            attemptId: z.ZodString;
+            occurredAt: z.ZodString;
+            familyKey: z.ZodNullable<z.ZodString>;
+            split: z.ZodEnum<{
+                frozen_eval: "frozen_eval";
+                test: "test";
+                train: "train";
+                validation: "validation";
+            }>;
+            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            assets: z.ZodArray<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>>;
+            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                mediaType: z.ZodString;
+                schemaRef: z.ZodDefault<z.ZodNullable<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>>>;
+                submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
+                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            provenance: z.ZodObject<{
+                sourceRecordRef: z.ZodNullable<z.ZodString>;
+                mappingHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        supersedes: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        correctionFeedbackId: z.ZodNullable<z.ZodString>;
+        receivedAt: z.ZodString;
+        contentHash: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
         id: z.ZodString;
@@ -3690,98 +3795,21 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
             packageHash: z.ZodString;
             taskset: z.ZodObject<{
                 id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-        }, z.core.$strict>>;
-        capturedOrigin: z.ZodOptional<z.ZodObject<{
-            receiptId: z.ZodString;
-            ownerUserId: z.ZodString;
-            modelId: z.ZodString;
-            packageHash: z.ZodString;
-            taskset: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-        }, z.core.$strict>>;
-        contentHash: z.ZodString;
-    }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.taskEvidence.v1">;
-        id: z.ZodString;
-        revision: z.ZodNumber;
-        source: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>;
-        submission: z.ZodObject<{
-            schemaVersion: z.ZodLiteral<"openpond.taskExample.v1">;
-            sourceId: z.ZodString;
-            idempotencyKey: z.ZodString;
-            taskDefinition: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-            exampleId: z.ZodString;
-            attemptId: z.ZodString;
-            occurredAt: z.ZodString;
-            familyKey: z.ZodNullable<z.ZodString>;
-            split: z.ZodEnum<{
-                frozen_eval: "frozen_eval";
-                test: "test";
-                train: "train";
-                validation: "validation";
-            }>;
-            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
-            policyVisibleContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            observedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            expected: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            evaluatorContext: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-            assets: z.ZodArray<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>>;
-            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                path: z.ZodString;
-                mediaType: z.ZodString;
-                schemaRef: z.ZodDefault<z.ZodNullable<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>>>;
-                submissionMode: z.ZodOptional<z.ZodLiteral<"structured_json">>;
-                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strict>>>;
-            provenance: z.ZodObject<{
-                sourceRecordRef: z.ZodNullable<z.ZodString>;
-                mappingHash: z.ZodNullable<z.ZodString>;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        capturedOrigin: z.ZodOptional<z.ZodObject<{
+            receiptId: z.ZodString;
+            ownerUserId: z.ZodString;
+            modelId: z.ZodString;
+            packageHash: z.ZodString;
+            taskset: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
             }, z.core.$strict>;
-        }, z.core.$strict>;
-        supersedes: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
         }, z.core.$strict>>;
-        correctionFeedbackId: z.ZodNullable<z.ZodString>;
-        receivedAt: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.taskAdmissionDecision.v1">;
@@ -3981,335 +4009,84 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
                     status: z.ZodOptional<z.ZodEnum<{
                         failed: "failed";
                         pending: "pending";
-                        scored: "scored";
-                        unavailable: "unavailable";
-                    }>>;
-                    score: z.ZodNullable<z.ZodNumber>;
-                    passed: z.ZodBoolean;
-                    rewardEligible: z.ZodBoolean;
-                    failureClass: z.ZodNullable<z.ZodEnum<{
-                        cancelled: "cancelled";
-                        environment_failure: "environment_failure";
-                        grader_failure: "grader_failure";
-                        infrastructure_failure: "infrastructure_failure";
-                        policy_failure: "policy_failure";
-                        timeout: "timeout";
-                    }>>;
-                    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<{
-                                high: "high";
-                                low: "low";
-                                max: "max";
-                                medium: "medium";
-                                off: "off";
-                                xhigh: "xhigh";
-                            }>;
-                            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>>;
-            training: z.ZodObject<{
-                status: z.ZodEnum<{
-                    not_configured: "not_configured";
-                    pending: "pending";
-                    scored: "scored";
-                    unscorable: "unscorable";
-                }>;
-                score: z.ZodNullable<z.ZodNumber>;
-                passed: z.ZodNullable<z.ZodBoolean>;
-            }, z.core.$strict>;
-            evaluation: z.ZodObject<{
-                status: z.ZodEnum<{
-                    not_configured: "not_configured";
-                    pending: "pending";
-                    scored: "scored";
-                    unscorable: "unscorable";
-                }>;
-                score: z.ZodNullable<z.ZodNumber>;
-                passed: z.ZodNullable<z.ZodBoolean>;
-            }, z.core.$strict>;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        note: z.ZodString;
-        decidedAt: z.ZodString;
-        contentHash: z.ZodString;
-    }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.taskBatch.v1">;
-        id: z.ZodString;
-        revision: z.ZodLiteral<1>;
-        taskDefinition: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>;
-        rewardBinding: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>;
-        purpose: z.ZodEnum<{
-            evaluation: "evaluation";
-            reward_training: "reward_training";
-            supervised_training: "supervised_training";
-        }>;
-        examples: z.ZodArray<z.ZodObject<{
-            evidence: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-            decision: z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-                revision: z.ZodNumber;
-            }, z.core.$strict>;
-            familyKey: z.ZodString;
-            inputHash: z.ZodString;
-            split: z.ZodEnum<{
-                frozen_eval: "frozen_eval";
-                test: "test";
-                train: "train";
-                validation: "validation";
-            }>;
-        }, z.core.$strict>>;
-        sealedAt: z.ZodString;
-        sealedBy: z.ZodString;
-        contentHash: z.ZodString;
-    }, z.core.$strict> | z.ZodObject<{
-        origin: z.ZodOptional<z.ZodObject<{
-            schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
-            teamId: z.ZodString;
-            projectId: z.ZodNullable<z.ZodString>;
-            configurationId: z.ZodString;
-            source: z.ZodObject<{
-                executionId: z.ZodString;
-                passId: z.ZodNullable<z.ZodString>;
-                manifestHash: z.ZodString;
-                resultHash: z.ZodString;
-            }, z.core.$strict>;
-            dataset: z.ZodObject<{
-                id: z.ZodString;
-                revision: z.ZodNumber;
-                contentHash: z.ZodString;
-            }, z.core.$strict>;
-            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"model">;
-                modelId: z.ZodString;
-                configurationHash: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"harness">;
-                source: z.ZodObject<{
-                    profileId: z.ZodString;
-                    sourceRevision: z.ZodString;
-                    harnessRelease: z.ZodObject<{
-                        id: z.ZodString;
-                        contentHash: z.ZodString;
-                    }, z.core.$strict>;
-                    catalogHash: z.ZodString;
-                    definitionId: z.ZodString;
-                    definitionHash: z.ZodString;
-                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                        kind: z.ZodLiteral<"profile">;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"workflow">;
-                        workflowId: z.ZodString;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"skill">;
-                        skillPath: z.ZodString;
-                    }, z.core.$strict>, z.ZodObject<{
-                        kind: z.ZodLiteral<"agent_action">;
-                        actionId: z.ZodString;
-                    }, z.core.$strict>], "kind">;
-                    environmentHash: z.ZodString;
-                    externalDatasetBinding: z.ZodOptional<z.ZodObject<{
-                        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
-                        dataset: z.ZodObject<{
-                            id: z.ZodString;
-                            contentHash: z.ZodString;
-                            revision: z.ZodNumber;
-                        }, z.core.$strict>;
-                        packageHash: z.ZodString;
-                        profileId: z.ZodString;
-                        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                            kind: z.ZodLiteral<"profile">;
-                        }, z.core.$strict>, z.ZodObject<{
-                            kind: z.ZodLiteral<"workflow">;
-                            workflowId: z.ZodString;
-                        }, z.core.$strict>, z.ZodObject<{
-                            kind: z.ZodLiteral<"skill">;
-                            skillPath: z.ZodString;
-                        }, z.core.$strict>, z.ZodObject<{
-                            kind: z.ZodLiteral<"agent_action">;
-                            actionId: z.ZodString;
-                        }, z.core.$strict>], "kind">;
-                        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
-                        protectedProfileClosureHash: z.ZodString;
-                        recordedOrigin: z.ZodOptional<z.ZodObject<{
-                            execution: z.ZodObject<{
-                                id: z.ZodString;
-                                contentHash: z.ZodString;
-                            }, z.core.$strict>;
-                            originalEvidence: z.ZodObject<{
-                                id: z.ZodString;
-                                contentHash: z.ZodString;
-                            }, z.core.$strict>;
-                            members: z.ZodArray<z.ZodObject<{
-                                caseId: z.ZodString;
-                                seed: z.ZodString;
-                                fixtureId: z.ZodString;
-                                sourceId: z.ZodString;
-                                snapshotHash: z.ZodString;
-                                boundaryRevisionHash: z.ZodString;
-                            }, z.core.$strict>>;
-                        }, z.core.$strict>>;
-                        gradingSource: z.ZodOptional<z.ZodObject<{
-                            pass: z.ZodObject<{
-                                id: z.ZodString;
-                                contentHash: z.ZodString;
-                            }, z.core.$strict>;
-                            evidence: z.ZodObject<{
-                                id: z.ZodString;
-                                contentHash: z.ZodString;
-                            }, z.core.$strict>;
-                        }, z.core.$strict>>;
-                        split: z.ZodEnum<{
-                            frozen_eval: "frozen_eval";
-                            test: "test";
-                            train: "train";
-                            validation: "validation";
-                        }>;
-                        population: z.ZodArray<z.ZodObject<{
-                            taskId: z.ZodString;
-                            seed: z.ZodString;
-                            fixtureId: z.ZodNullable<z.ZodString>;
-                        }, z.core.$strict>>;
-                        evaluators: z.ZodArray<z.ZodObject<{
-                            release: z.ZodObject<{
-                                id: z.ZodString;
-                                contentHash: z.ZodString;
-                                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
-                            }, z.core.$strict>;
-                            feedbackKey: z.ZodString;
-                            configurationHash: z.ZodString;
-                            output: z.ZodEnum<{
-                                boolean: "boolean";
-                                category: "category";
-                                score: "score";
+                        scored: "scored";
+                        unavailable: "unavailable";
+                    }>>;
+                    score: z.ZodNullable<z.ZodNumber>;
+                    passed: z.ZodBoolean;
+                    rewardEligible: z.ZodBoolean;
+                    failureClass: z.ZodNullable<z.ZodEnum<{
+                        cancelled: "cancelled";
+                        environment_failure: "environment_failure";
+                        grader_failure: "grader_failure";
+                        infrastructure_failure: "infrastructure_failure";
+                        policy_failure: "policy_failure";
+                        timeout: "timeout";
+                    }>>;
+                    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<{
+                                high: "high";
+                                low: "low";
+                                max: "max";
+                                medium: "medium";
+                                off: "off";
+                                xhigh: "xhigh";
                             }>;
-                            categories: z.ZodArray<z.ZodString>;
-                        }, z.core.$strict>>;
-                        fieldMappingsHash: z.ZodString;
-                        fieldMappings: z.ZodArray<z.ZodObject<{
-                            graderId: z.ZodString;
-                            fields: z.ZodArray<z.ZodObject<{
-                                destination: z.ZodEnum<{
-                                    evaluatorContext: "evaluatorContext";
-                                    expectedOutput: "expectedOutput";
-                                    input: "input";
-                                    output: "output";
-                                }>;
-                                path: z.ZodArray<z.ZodString>;
-                                source: z.ZodEnum<{
-                                    evaluatorContext: "evaluatorContext";
-                                    expectedOutput: "expectedOutput";
-                                    input: "input";
-                                    output: "output";
-                                }>;
-                                sourcePath: z.ZodArray<z.ZodString>;
-                            }, z.core.$strict>>;
+                            maximumOutputTokens: z.ZodNumber;
                         }, z.core.$strict>>;
-                        environmentHash: z.ZodString;
-                        privateDatasetClosureHash: z.ZodString;
-                        criterion: z.ZodObject<{
-                            minimumPassRate: z.ZodNumber;
-                            requireComplete: z.ZodBoolean;
-                        }, z.core.$strict>;
-                        contentHash: z.ZodString;
-                    }, z.core.$strict>>;
-                    sourceCandidate: z.ZodOptional<z.ZodObject<{
-                        candidateId: z.ZodString;
-                        frozenRevision: z.ZodNumber;
-                        frozenHash: z.ZodString;
-                        harnessRelease: z.ZodObject<{
-                            id: z.ZodString;
-                            contentHash: z.ZodString;
-                        }, z.core.$strict>;
-                        protectedClosureHash: z.ZodString;
+                        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>;
-                model: z.ZodObject<{
-                    modelId: z.ZodString;
-                    configurationHash: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"agent">;
-                source: z.ZodObject<{
-                    harnessRelease: z.ZodObject<{
-                        id: z.ZodString;
-                        contentHash: z.ZodString;
-                    }, z.core.$strict>;
-                    agentSnapshot: z.ZodObject<{
-                        id: z.ZodString;
-                        contentHash: z.ZodString;
-                    }, z.core.$strict>;
-                    sourcePackageHash: z.ZodString;
-                }, z.core.$strict>;
-                model: z.ZodObject<{
-                    modelId: z.ZodString;
-                    configurationHash: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"fixture">;
-                configurationHash: z.ZodString;
-            }, z.core.$strict>], "kind">;
-            graders: z.ZodArray<z.ZodObject<{
-                feedbackKey: z.ZodString;
-                evaluator: z.ZodObject<{
-                    id: z.ZodString;
                     contentHash: z.ZodString;
-                }, z.core.$strict>;
-                expectedCount: z.ZodNumber;
-                scoredCount: z.ZodNumber;
-                score: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>>;
+                message: z.ZodNullable<z.ZodString>;
             }, z.core.$strict>>;
+            training: z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_configured: "not_configured";
+                    pending: "pending";
+                    scored: "scored";
+                    unscorable: "unscorable";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    not_configured: "not_configured";
+                    pending: "pending";
+                    scored: "scored";
+                    unscorable: "unscorable";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
             contentHash: z.ZodString;
         }, z.core.$strict>>;
-        schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+        note: z.ZodString;
+        decidedAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.taskBatch.v1">;
         id: z.ZodString;
-        revision: z.ZodNumber;
-        modelProjectId: z.ZodString;
-        executionOwner: z.ZodEnum<{
-            hosted: "hosted";
-            local: "local";
-        }>;
-        enabled: z.ZodBoolean;
-        sources: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-            revision: z.ZodNumber;
-        }, z.core.$strict>>;
+        revision: z.ZodLiteral<1>;
         taskDefinition: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
@@ -4320,99 +4097,79 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
             contentHash: z.ZodString;
             revision: z.ZodNumber;
         }, z.core.$strict>;
-        admission: z.ZodObject<{
-            mode: z.ZodEnum<{
-                human: "human";
-                qualified_automatic: "qualified_automatic";
-            }>;
-            qualification: z.ZodNullable<z.ZodObject<{
-                id: z.ZodString;
-                contentHash: z.ZodString;
-            }, z.core.$strict>>;
-            minimumApprovedExamples: z.ZodNumber;
-        }, z.core.$strict>;
-        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"manual">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"approved_count">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"schedule">;
-            intervalSeconds: z.ZodNumber;
-        }, z.core.$strict>, z.ZodObject<{
-            localTime: z.ZodString;
-            timeZone: z.ZodString;
-            kind: z.ZodLiteral<"nightly">;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"upstream_accepted">;
-            modelProjectId: z.ZodString;
-        }, z.core.$strict>], "kind">;
-        trainingParent: z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>;
-        teacher: z.ZodNullable<z.ZodObject<{
-            id: z.ZodString;
-            contentHash: z.ZodString;
-        }, z.core.$strict>>;
-        training: z.ZodObject<{
-            method: z.ZodEnum<{
-                dpo: "dpo";
-                grpo: "grpo";
-                opd: "opd";
-                opsd: "opsd";
-                ppo: "ppo";
-                sdft: "sdft";
-                sdpo: "sdpo";
-                sft: "sft";
-            }>;
-            recipe: z.ZodObject<{
+        purpose: z.ZodEnum<{
+            evaluation: "evaluation";
+            reward_training: "reward_training";
+            supervised_training: "supervised_training";
+        }>;
+        examples: z.ZodArray<z.ZodObject<{
+            evidence: z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
+                revision: z.ZodNumber;
             }, z.core.$strict>;
-            retentionEvaluation: z.ZodObject<{
+            decision: z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
+                revision: z.ZodNumber;
             }, z.core.$strict>;
-            replayBatches: z.ZodArray<z.ZodObject<{
+            familyKey: z.ZodString;
+            inputHash: z.ZodString;
+            split: z.ZodEnum<{
+                frozen_eval: "frozen_eval";
+                test: "test";
+                train: "train";
+                validation: "validation";
+            }>;
+        }, z.core.$strict>>;
+        sealedAt: z.ZodString;
+        sealedBy: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        recipeRef: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        sources: z.ZodArray<z.ZodObject<{
+            graderId: z.ZodString;
+            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            reward: z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
-            }, z.core.$strict>>;
-            continuationMode: z.ZodOptional<z.ZodObject<{
-                adapterMode: z.ZodEnum<{
-                    residual_append: "residual_append";
-                    sequential_merge: "sequential_merge";
-                    shared: "shared";
+                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";
                 }>;
-                sourceConfiguration: z.ZodObject<{
-                    id: z.ZodString;
-                    revision: z.ZodNumber;
-                    etag: z.ZodString;
-                }, z.core.$strict>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        limits: z.ZodObject<{
-            maxIterationSpendUsd: z.ZodNumber;
-            maxDailySpendUsd: z.ZodNumber;
-            cooldownSeconds: z.ZodNumber;
-            maxRetries: z.ZodNumber;
-            maxBatchExamples: z.ZodNumber;
-            maxBacklogExamples: z.ZodNumber;
-        }, z.core.$strict>;
-        automation: z.ZodObject<{
-            collect: z.ZodBoolean;
-            train: z.ZodBoolean;
-            accept: z.ZodBoolean;
-            serve: z.ZodBoolean;
-        }, z.core.$strict>;
-        acceptance: z.ZodObject<{
-            minimumScore: z.ZodNumber;
-            maximumRetentionRegression: z.ZodNumber;
-            requireImprovement: z.ZodBoolean;
-            rollbackVersion: z.ZodNullable<z.ZodObject<{
+            }, 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>>;
+        aggregation: z.ZodLiteral<"weighted_mean">;
+        unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
         contentHash: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
@@ -4554,136 +4311,389 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
                     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">>;
+                    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>>;
+        }, 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<{
+                    host_private: "host_private";
+                    policy: "policy";
+                    verifier: "verifier";
+                }>;
+            }, 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<{
+                host_private: "host_private";
+                policy: "policy";
+                verifier: "verifier";
+            }>;
+        }, 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<{
+                host_private: "host_private";
+                policy: "policy";
+                verifier: "verifier";
+            }>;
+        }, 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> | z.ZodObject<{
+        origin: z.ZodOptional<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.trainingHandoffOrigin.v1">;
+            teamId: z.ZodString;
+            projectId: z.ZodNullable<z.ZodString>;
+            configurationId: z.ZodString;
+            source: z.ZodObject<{
+                executionId: z.ZodString;
+                passId: z.ZodNullable<z.ZodString>;
+                manifestHash: z.ZodString;
+                resultHash: z.ZodString;
+            }, z.core.$strict>;
+            dataset: z.ZodObject<{
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"harness">;
+                source: z.ZodObject<{
+                    profileId: z.ZodString;
+                    sourceRevision: z.ZodString;
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    catalogHash: z.ZodString;
+                    definitionId: z.ZodString;
+                    definitionHash: z.ZodString;
+                    target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"profile">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"workflow">;
+                        workflowId: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"skill">;
+                        skillPath: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"agent_action">;
+                        actionId: z.ZodString;
+                    }, z.core.$strict>], "kind">;
+                    environmentHash: z.ZodString;
+                    externalDatasetBinding: z.ZodOptional<z.ZodObject<{
+                        schemaVersion: z.ZodLiteral<"openpond.profileExternalDatasetBinding.v1">;
+                        dataset: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                            revision: z.ZodNumber;
+                        }, z.core.$strict>;
+                        packageHash: z.ZodString;
+                        profileId: z.ZodString;
+                        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"profile">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"workflow">;
+                            workflowId: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"skill">;
+                            skillPath: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"agent_action">;
+                            actionId: z.ZodString;
+                        }, z.core.$strict>], "kind">;
+                        declaredProfileCatalogHash: z.ZodNullable<z.ZodString>;
+                        protectedProfileClosureHash: z.ZodString;
+                        recordedOrigin: z.ZodOptional<z.ZodObject<{
+                            execution: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            originalEvidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            members: z.ZodArray<z.ZodObject<{
+                                caseId: z.ZodString;
+                                seed: z.ZodString;
+                                fixtureId: z.ZodString;
+                                sourceId: z.ZodString;
+                                snapshotHash: z.ZodString;
+                                boundaryRevisionHash: z.ZodString;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        gradingSource: z.ZodOptional<z.ZodObject<{
+                            pass: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                            evidence: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                            }, z.core.$strict>;
+                        }, z.core.$strict>>;
+                        split: z.ZodEnum<{
+                            frozen_eval: "frozen_eval";
+                            test: "test";
+                            train: "train";
+                            validation: "validation";
+                        }>;
+                        population: z.ZodArray<z.ZodObject<{
+                            taskId: z.ZodString;
+                            seed: z.ZodString;
+                            fixtureId: z.ZodNullable<z.ZodString>;
+                        }, z.core.$strict>>;
+                        evaluators: z.ZodArray<z.ZodObject<{
+                            release: z.ZodObject<{
+                                id: z.ZodString;
+                                contentHash: z.ZodString;
+                                revision: z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>;
+                            }, z.core.$strict>;
+                            feedbackKey: z.ZodString;
+                            configurationHash: z.ZodString;
+                            output: z.ZodEnum<{
+                                boolean: "boolean";
+                                category: "category";
+                                score: "score";
+                            }>;
+                            categories: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                        fieldMappingsHash: z.ZodString;
+                        fieldMappings: z.ZodArray<z.ZodObject<{
+                            graderId: z.ZodString;
+                            fields: z.ZodArray<z.ZodObject<{
+                                destination: z.ZodEnum<{
+                                    evaluatorContext: "evaluatorContext";
+                                    expectedOutput: "expectedOutput";
+                                    input: "input";
+                                    output: "output";
+                                }>;
+                                path: z.ZodArray<z.ZodString>;
+                                source: z.ZodEnum<{
+                                    evaluatorContext: "evaluatorContext";
+                                    expectedOutput: "expectedOutput";
+                                    input: "input";
+                                    output: "output";
+                                }>;
+                                sourcePath: z.ZodArray<z.ZodString>;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>>;
+                        environmentHash: z.ZodString;
+                        privateDatasetClosureHash: z.ZodString;
+                        criterion: z.ZodObject<{
+                            minimumPassRate: z.ZodNumber;
+                            requireComplete: z.ZodBoolean;
+                        }, z.core.$strict>;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>>;
+                    sourceCandidate: z.ZodOptional<z.ZodObject<{
+                        candidateId: z.ZodString;
+                        frozenRevision: z.ZodNumber;
+                        frozenHash: z.ZodString;
+                        harnessRelease: z.ZodObject<{
+                            id: z.ZodString;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>;
+                        protectedClosureHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+                source: z.ZodObject<{
+                    harnessRelease: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    agentSnapshot: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    sourcePackageHash: z.ZodString;
+                }, z.core.$strict>;
+                model: z.ZodObject<{
+                    modelId: z.ZodString;
+                    configurationHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"fixture">;
+                configurationHash: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            graders: z.ZodArray<z.ZodObject<{
+                feedbackKey: z.ZodString;
+                evaluator: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                expectedCount: z.ZodNumber;
+                scoredCount: z.ZodNumber;
+                score: z.ZodNullable<z.ZodNumber>;
             }, z.core.$strict>>;
-        }, 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<{
-                    host_private: "host_private";
-                    policy: "policy";
-                    verifier: "verifier";
-                }>;
-            }, 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<{
-                host_private: "host_private";
-                policy: "policy";
-                verifier: "verifier";
-            }>;
         }, z.core.$strict>>;
-        fixtureSetRef: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelProjectId: z.ZodString;
+        executionOwner: z.ZodEnum<{
+            hosted: "hosted";
+            local: "local";
+        }>;
+        enabled: z.ZodBoolean;
+        sources: z.ZodArray<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";
-            }>;
+            revision: z.ZodNumber;
         }, z.core.$strict>>;
-        calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+        taskDefinition: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
             revision: z.ZodNumber;
-        }, z.core.$strict>>;
-        contentHash: z.ZodString;
-    }, z.core.$strict> | z.ZodObject<{
-        schemaVersion: z.ZodLiteral<"openpond.rewardBinding.v1">;
-        id: z.ZodString;
-        revision: z.ZodNumber;
-        name: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        recipeRef: z.ZodOptional<z.ZodObject<{
+        }, z.core.$strict>;
+        rewardBinding: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;
             revision: z.ZodNumber;
+        }, z.core.$strict>;
+        admission: z.ZodObject<{
+            mode: z.ZodEnum<{
+                human: "human";
+                qualified_automatic: "qualified_automatic";
+            }>;
+            qualification: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            minimumApprovedExamples: z.ZodNumber;
+        }, z.core.$strict>;
+        trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"manual">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"approved_count">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"schedule">;
+            intervalSeconds: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            localTime: z.ZodString;
+            timeZone: z.ZodString;
+            kind: z.ZodLiteral<"nightly">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"upstream_accepted">;
+            modelProjectId: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        trainingParent: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        teacher: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
         }, z.core.$strict>>;
-        sources: z.ZodArray<z.ZodObject<{
-            graderId: z.ZodString;
-            taskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            reward: z.ZodObject<{
+        training: z.ZodObject<{
+            method: z.ZodEnum<{
+                dpo: "dpo";
+                grpo: "grpo";
+                opd: "opd";
+                opsd: "opsd";
+                ppo: "ppo";
+                sdft: "sdft";
+                sdpo: "sdpo";
+                sft: "sft";
+            }>;
+            recipe: 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";
+            retentionEvaluation: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            replayBatches: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            continuationMode: z.ZodOptional<z.ZodObject<{
+                adapterMode: z.ZodEnum<{
+                    residual_append: "residual_append";
+                    sequential_merge: "sequential_merge";
+                    shared: "shared";
                 }>;
-            }, z.core.$strict>], "kind">;
-            weight: z.ZodNumber;
-            required: z.ZodBoolean;
-            hardGate: z.ZodBoolean;
-            privileged: z.ZodBoolean;
-            fixtureRefs: z.ZodArray<z.ZodObject<{
+                sourceConfiguration: z.ZodObject<{
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    etag: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        limits: z.ZodObject<{
+            maxIterationSpendUsd: z.ZodNumber;
+            maxDailySpendUsd: z.ZodNumber;
+            cooldownSeconds: z.ZodNumber;
+            maxRetries: z.ZodNumber;
+            maxBatchExamples: z.ZodNumber;
+            maxBacklogExamples: z.ZodNumber;
+        }, z.core.$strict>;
+        automation: z.ZodObject<{
+            collect: z.ZodBoolean;
+            train: z.ZodBoolean;
+            accept: z.ZodBoolean;
+            serve: z.ZodBoolean;
+        }, z.core.$strict>;
+        acceptance: z.ZodObject<{
+            minimumScore: z.ZodNumber;
+            maximumRetentionRegression: z.ZodNumber;
+            requireImprovement: z.ZodBoolean;
+            rollbackVersion: z.ZodNullable<z.ZodObject<{
                 id: z.ZodString;
                 contentHash: z.ZodString;
             }, z.core.$strict>>;
-        }, z.core.$strict>>;
-        aggregation: z.ZodLiteral<"weighted_mean">;
-        unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
-        contentHash: z.ZodString;
-    }, z.core.$strict> | 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<{
-                host_private: "host_private";
-                policy: "policy";
-                verifier: "verifier";
-            }>;
         }, z.core.$strict>;
-        text: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict>)[]>>;
 }, z.core.$strict>;