@openpond/evals 0.6.0 → 0.7.1

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

@@ -0,0 +1,2173 @@
+import { z } from "zod";
+/** Run before recursive schema parsing, including for non-TypeScript producers. */
+export declare function assertLearningRequestJson(raw: unknown): void;
+/** Scope selection is never authorization; each host resolves its authenticated owner. */
+export declare const LearningCommandRequestSchema: z.ZodObject<{
+    scope: z.ZodString;
+    command: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"asset">;
+        content: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+            id: z.ZodString;
+            revision: z.ZodLiteral<1>;
+            asset: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            text: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"definition">;
+        content: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            name: z.ZodString;
+            description: z.ZodString;
+            instructions: z.ZodString;
+            category: z.ZodEnum<{
+                custom: "custom";
+                structured: "structured";
+                question_answering: "question_answering";
+                coding: "coding";
+                tool_workflow: "tool_workflow";
+            }>;
+            familyNamespace: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            rewardBinding: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            harness: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            execution: z.ZodObject<{
+                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<{
+                        text: "text";
+                        agent: "agent";
+                        work: "work";
+                        custom_program: "custom_program";
+                    }>;
+                    entrypoint: z.ZodString;
+                    stateful: z.ZodBoolean;
+                    deterministicSeeds: z.ZodBoolean;
+                    lifecycle: z.ZodArray<z.ZodEnum<{
+                        create: "create";
+                        reset: "reset";
+                        step: "step";
+                        collect: "collect";
+                        destroy: "destroy";
+                    }>>;
+                    networkPolicy: z.ZodEnum<{
+                        none: "none";
+                        declared_read_only: "declared_read_only";
+                        declared_scoped: "declared_scoped";
+                    }>;
+                    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<{
+                        portable: "portable";
+                        host_adapter: "host_adapter";
+                        local_only: "local_only";
+                        hosted_only: "hosted_only";
+                    }>;
+                }, z.core.$strict>>;
+                verifierSetRelease: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"reward">;
+        content: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            name: z.ZodString;
+            description: z.ZodString;
+            implementation: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    content: "content";
+                    schema: "schema";
+                    artifact: "artifact";
+                    runtime_event: "runtime_event";
+                    state: "state";
+                }>;
+                config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"model_judge">;
+                rubricRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                calibrationStatus: z.ZodEnum<{
+                    pending: "pending";
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                model: z.ZodOptional<z.ZodObject<{
+                    providerId: z.ZodString;
+                    modelId: z.ZodString;
+                    revision: z.ZodNullable<z.ZodString>;
+                }, z.core.$strict>>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"custom_verifier">;
+                networkPolicy: z.ZodLiteral<"none">;
+                verifierRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                exportName: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"human">;
+                rubricRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                reviewerRole: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"learned_model">;
+                modelVersion: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                inputContract: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>;
+            rawScore: z.ZodObject<{
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+            }, z.core.$strict>;
+            assets: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"binding">;
+        content: 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;
+                reward: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                role: z.ZodEnum<{
+                    evaluation: "evaluation";
+                    training: "training";
+                }>;
+                normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"identity">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"linear">;
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                    direction: z.ZodEnum<{
+                        higher: "higher";
+                        lower: "lower";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                weight: z.ZodNumber;
+                required: z.ZodBoolean;
+                hardGate: z.ZodBoolean;
+                privileged: z.ZodBoolean;
+                fixtureRefs: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            aggregation: z.ZodLiteral<"weighted_mean">;
+            unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"source">;
+        content: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                work: "work";
+                provider: "provider";
+                direct: "direct";
+                benchmark: "benchmark";
+                opentelemetry: "opentelemetry";
+            }>;
+            taskDefinition: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            enabled: z.ZodBoolean;
+            allowedSplits: z.ZodArray<z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>>;
+            mapping: z.ZodNullable<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
+                exampleId: z.ZodString;
+                attemptId: z.ZodString;
+                occurredAt: z.ZodString;
+                input: z.ZodString;
+                observedOutput: z.ZodNullable<z.ZodString>;
+                expected: z.ZodNullable<z.ZodString>;
+                evaluatorContext: z.ZodNullable<z.ZodString>;
+                familyKey: z.ZodString;
+                split: z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>;
+            }, z.core.$strict>>;
+            adapterVersion: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish">;
+        expectedRevision: z.ZodNumber;
+        kind: z.ZodLiteral<"policy">;
+        content: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            modelProjectId: z.ZodString;
+            executionOwner: z.ZodEnum<{
+                local: "local";
+                hosted: "hosted";
+            }>;
+            enabled: z.ZodBoolean;
+            sources: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+            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>;
+            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<{
+                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<{
+                    sft: "sft";
+                    dpo: "dpo";
+                    grpo: "grpo";
+                    ppo: "ppo";
+                    sdft: "sdft";
+                    opd: "opd";
+                    opsd: "opsd";
+                    sdpo: "sdpo";
+                }>;
+                recipe: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                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>>;
+            }, 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>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"publish_resources">;
+        resources: z.ZodArray<z.ZodUnion<(z.ZodObject<{
+            kind: z.ZodLiteral<"definition">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.taskDefinition.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                name: z.ZodString;
+                description: z.ZodString;
+                instructions: z.ZodString;
+                category: z.ZodEnum<{
+                    custom: "custom";
+                    structured: "structured";
+                    question_answering: "question_answering";
+                    coding: "coding";
+                    tool_workflow: "tool_workflow";
+                }>;
+                familyNamespace: z.ZodString;
+                inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                rewardBinding: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                harness: z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>>;
+                execution: z.ZodObject<{
+                    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<{
+                            text: "text";
+                            agent: "agent";
+                            work: "work";
+                            custom_program: "custom_program";
+                        }>;
+                        entrypoint: z.ZodString;
+                        stateful: z.ZodBoolean;
+                        deterministicSeeds: z.ZodBoolean;
+                        lifecycle: z.ZodArray<z.ZodEnum<{
+                            create: "create";
+                            reset: "reset";
+                            step: "step";
+                            collect: "collect";
+                            destroy: "destroy";
+                        }>>;
+                        networkPolicy: z.ZodEnum<{
+                            none: "none";
+                            declared_read_only: "declared_read_only";
+                            declared_scoped: "declared_scoped";
+                        }>;
+                        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<{
+                            portable: "portable";
+                            host_adapter: "host_adapter";
+                            local_only: "local_only";
+                            hosted_only: "hosted_only";
+                        }>;
+                    }, z.core.$strict>>;
+                    verifierSetRelease: z.ZodOptional<z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict> | z.ZodObject<{
+            kind: z.ZodLiteral<"asset">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+                id: z.ZodString;
+                revision: z.ZodLiteral<1>;
+                asset: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                text: z.ZodString;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict> | z.ZodObject<{
+            kind: z.ZodLiteral<"reward">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                name: z.ZodString;
+                description: z.ZodString;
+                implementation: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        content: "content";
+                        schema: "schema";
+                        artifact: "artifact";
+                        runtime_event: "runtime_event";
+                        state: "state";
+                    }>;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"model_judge">;
+                    rubricRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                    calibrationStatus: z.ZodEnum<{
+                        pending: "pending";
+                        passed: "passed";
+                        failed: "failed";
+                    }>;
+                    model: z.ZodOptional<z.ZodObject<{
+                        providerId: z.ZodString;
+                        modelId: z.ZodString;
+                        revision: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    temperature: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"custom_verifier">;
+                    networkPolicy: z.ZodLiteral<"none">;
+                    verifierRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                    exportName: z.ZodOptional<z.ZodString>;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"human">;
+                    rubricRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                    reviewerRole: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"learned_model">;
+                    modelVersion: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    inputContract: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>]>;
+                rawScore: z.ZodObject<{
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                }, z.core.$strict>;
+                assets: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict> | z.ZodObject<{
+            kind: z.ZodLiteral<"binding">;
+            content: 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;
+                    reward: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    role: z.ZodEnum<{
+                        evaluation: "evaluation";
+                        training: "training";
+                    }>;
+                    normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"identity">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"linear">;
+                        minimum: z.ZodNumber;
+                        maximum: z.ZodNumber;
+                        direction: z.ZodEnum<{
+                            higher: "higher";
+                            lower: "lower";
+                        }>;
+                    }, z.core.$strict>], "kind">;
+                    weight: z.ZodNumber;
+                    required: z.ZodBoolean;
+                    hardGate: z.ZodBoolean;
+                    privileged: z.ZodBoolean;
+                    fixtureRefs: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                aggregation: z.ZodLiteral<"weighted_mean">;
+                unscorable: z.ZodLiteral<"exclude_optional_require_all_required">;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict> | z.ZodObject<{
+            kind: z.ZodLiteral<"source">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    work: "work";
+                    provider: "provider";
+                    direct: "direct";
+                    benchmark: "benchmark";
+                    opentelemetry: "opentelemetry";
+                }>;
+                taskDefinition: z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>;
+                enabled: z.ZodBoolean;
+                allowedSplits: z.ZodArray<z.ZodEnum<{
+                    train: "train";
+                    validation: "validation";
+                    test: "test";
+                    frozen_eval: "frozen_eval";
+                }>>;
+                mapping: z.ZodNullable<z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
+                    exampleId: z.ZodString;
+                    attemptId: z.ZodString;
+                    occurredAt: z.ZodString;
+                    input: z.ZodString;
+                    observedOutput: z.ZodNullable<z.ZodString>;
+                    expected: z.ZodNullable<z.ZodString>;
+                    evaluatorContext: z.ZodNullable<z.ZodString>;
+                    familyKey: z.ZodString;
+                    split: z.ZodEnum<{
+                        train: "train";
+                        validation: "validation";
+                        test: "test";
+                        frozen_eval: "frozen_eval";
+                    }>;
+                }, z.core.$strict>>;
+                adapterVersion: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict> | z.ZodObject<{
+            kind: z.ZodLiteral<"policy">;
+            content: z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                modelProjectId: z.ZodString;
+                executionOwner: z.ZodEnum<{
+                    local: "local";
+                    hosted: "hosted";
+                }>;
+                enabled: z.ZodBoolean;
+                sources: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                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>;
+                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<{
+                    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<{
+                        sft: "sft";
+                        dpo: "dpo";
+                        grpo: "grpo";
+                        ppo: "ppo";
+                        sdft: "sdft";
+                        opd: "opd";
+                        opsd: "opsd";
+                        sdpo: "sdpo";
+                    }>;
+                    recipe: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    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>>;
+                }, 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>;
+            }, z.core.$strict>;
+            expectedRevision: z.ZodNumber;
+        }, z.core.$strict>)[]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"submit_example">;
+        example: 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<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            input: 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<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>;
+            provenance: z.ZodObject<{
+                sourceRecordRef: z.ZodNullable<z.ZodString>;
+                mappingHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"submit_feedback">;
+        feedback: 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<{
+                outcome: "outcome";
+                target_correction: "target_correction";
+                ground_truth_correction: "ground_truth_correction";
+                input_correction: "input_correction";
+                family_resolution: "family_resolution";
+            }>;
+            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            note: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"apply_correction">;
+        feedbackId: z.ZodString;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"resolve_feedback">;
+        feedbackId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        disposition: z.ZodEnum<{
+            applied: "applied";
+            superseded: "superseded";
+            rejected: "rejected";
+        }>;
+        decision: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        note: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"queue_grade">;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        target: z.ZodEnum<{
+            observed: "observed";
+            proposed_target: "proposed_target";
+        }>;
+        proposedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maximumSpendUsd: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"review">;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        expectedRevision: z.ZodNumber;
+        disposition: z.ZodEnum<{
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        targetApproval: z.ZodEnum<{
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+            not_required: "not_required";
+        }>;
+        approvedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        observedGradeId: z.ZodNullable<z.ZodString>;
+        targetGradeId: z.ZodNullable<z.ZodString>;
+        note: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"seal_batch">;
+        batchId: z.ZodString;
+        taskDefinition: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        purpose: z.ZodEnum<{
+            evaluation: "evaluation";
+            supervised_training: "supervised_training";
+            reward_training: "reward_training";
+        }>;
+        evidence: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        decisions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        operationId: z.ZodString;
+        action: z.ZodLiteral<"cancel_grade">;
+        gradeId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"inspect_evidence">;
+    scope: z.ZodString;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"get">;
+    scope: z.ZodString;
+    kind: z.ZodEnum<{
+        policy: "policy";
+        feedback: "feedback";
+        reward: "reward";
+        source: "source";
+        decision: "decision";
+        evidence: "evidence";
+        binding: "binding";
+        grade: "grade";
+        batch: "batch";
+        asset: "asset";
+        definition: "definition";
+        iteration: "iteration";
+        package: "package";
+    }>;
+    id: z.ZodString;
+    revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"list">;
+    scope: z.ZodString;
+    kind: z.ZodEnum<{
+        policy: "policy";
+        feedback: "feedback";
+        reward: "reward";
+        source: "source";
+        decision: "decision";
+        evidence: "evidence";
+        binding: "binding";
+        grade: "grade";
+        batch: "batch";
+        asset: "asset";
+        definition: "definition";
+        iteration: "iteration";
+        package: "package";
+    }>;
+    parentId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    afterId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>], "action">;
+export declare const TaskEvidenceInspectionResultSchema: z.ZodObject<{
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    definition: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    inspection: z.ZodObject<{
+        evidenceValidity: z.ZodEnum<{
+            valid: "valid";
+            invalid: "invalid";
+        }>;
+        taskReady: z.ZodBoolean;
+        observedOutputValid: z.ZodNullable<z.ZodBoolean>;
+        issues: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TaskEvidenceInspectionResult = z.infer<typeof TaskEvidenceInspectionResultSchema>;
+export declare const LearningOperationResultSchema: z.ZodObject<{
+    operationId: z.ZodString;
+    resources: z.ZodArray<z.ZodUnion<(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<{
+                text: "text";
+                agent: "agent";
+                work: "work";
+                custom_program: "custom_program";
+            }>;
+            entrypoint: z.ZodString;
+            stateful: z.ZodBoolean;
+            deterministicSeeds: z.ZodBoolean;
+            lifecycle: z.ZodArray<z.ZodEnum<{
+                create: "create";
+                reset: "reset";
+                step: "step";
+                collect: "collect";
+                destroy: "destroy";
+            }>>;
+            networkPolicy: z.ZodEnum<{
+                none: "none";
+                declared_read_only: "declared_read_only";
+                declared_scoped: "declared_scoped";
+            }>;
+            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<{
+                portable: "portable";
+                host_adapter: "host_adapter";
+                local_only: "local_only";
+                hosted_only: "hosted_only";
+            }>;
+        }, z.core.$strict>>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            clusterKey: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            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<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, 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<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>>;
+                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"custom_verifier">;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>]>>;
+        verifierSetRelease: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        implementation: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"custom_verifier">;
+            networkPolicy: z.ZodLiteral<"none">;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"learned_model">;
+            modelVersion: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            inputContract: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>;
+        rawScore: z.ZodObject<{
+            minimum: z.ZodNumber;
+            maximum: z.ZodNumber;
+        }, z.core.$strict>;
+        assets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            contentHash: z.ZodString;
+            sizeBytes: z.ZodNumber;
+            mediaType: z.ZodString;
+            visibility: z.ZodEnum<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>>;
+        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;
+            reward: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>;
+            role: z.ZodEnum<{
+                evaluation: "evaluation";
+                training: "training";
+            }>;
+            normalization: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"identity">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"linear">;
+                minimum: z.ZodNumber;
+                maximum: z.ZodNumber;
+                direction: z.ZodEnum<{
+                    higher: "higher";
+                    lower: "lower";
+                }>;
+            }, z.core.$strict>], "kind">;
+            weight: z.ZodNumber;
+            required: z.ZodBoolean;
+            hardGate: z.ZodBoolean;
+            privileged: z.ZodBoolean;
+            fixtureRefs: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        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.taskDefinition.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        description: z.ZodString;
+        instructions: z.ZodString;
+        category: z.ZodEnum<{
+            custom: "custom";
+            structured: "structured";
+            question_answering: "question_answering";
+            coding: "coding";
+            tool_workflow: "tool_workflow";
+        }>;
+        familyNamespace: z.ZodString;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        rewardBinding: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        harness: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        execution: z.ZodObject<{
+            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<{
+                    text: "text";
+                    agent: "agent";
+                    work: "work";
+                    custom_program: "custom_program";
+                }>;
+                entrypoint: z.ZodString;
+                stateful: z.ZodBoolean;
+                deterministicSeeds: z.ZodBoolean;
+                lifecycle: z.ZodArray<z.ZodEnum<{
+                    create: "create";
+                    reset: "reset";
+                    step: "step";
+                    collect: "collect";
+                    destroy: "destroy";
+                }>>;
+                networkPolicy: z.ZodEnum<{
+                    none: "none";
+                    declared_read_only: "declared_read_only";
+                    declared_scoped: "declared_scoped";
+                }>;
+                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<{
+                    portable: "portable";
+                    host_adapter: "host_adapter";
+                    local_only: "local_only";
+                    hosted_only: "hosted_only";
+                }>;
+            }, z.core.$strict>>;
+            verifierSetRelease: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningSource.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            work: "work";
+            provider: "provider";
+            direct: "direct";
+            benchmark: "benchmark";
+            opentelemetry: "opentelemetry";
+        }>;
+        taskDefinition: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        enabled: z.ZodBoolean;
+        allowedSplits: z.ZodArray<z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+            test: "test";
+            frozen_eval: "frozen_eval";
+        }>>;
+        mapping: z.ZodNullable<z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.taskSourceMapping.v1">;
+            exampleId: z.ZodString;
+            attemptId: z.ZodString;
+            occurredAt: z.ZodString;
+            input: z.ZodString;
+            observedOutput: z.ZodNullable<z.ZodString>;
+            expected: z.ZodNullable<z.ZodString>;
+            evaluatorContext: z.ZodNullable<z.ZodString>;
+            familyKey: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+        }, z.core.$strict>>;
+        adapterVersion: z.ZodNullable<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<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            input: 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<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, 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.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<{
+                outcome: "outcome";
+                target_correction: "target_correction";
+                ground_truth_correction: "ground_truth_correction";
+                input_correction: "input_correction";
+                family_resolution: "family_resolution";
+            }>;
+            value: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            note: z.ZodString;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            pending_example: "pending_example";
+            pending_review: "pending_review";
+            applied: "applied";
+            superseded: "superseded";
+            rejected: "rejected";
+        }>;
+        evidence: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        revision: z.ZodNumber;
+        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.taskAdmissionDecision.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        evidence: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        supersedes: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        actor: z.ZodObject<{
+            kind: z.ZodEnum<{
+                human: "human";
+                qualified_policy: "qualified_policy";
+            }>;
+            id: z.ZodString;
+            policy: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+                revision: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        evidenceValidity: z.ZodEnum<{
+            pending: "pending";
+            valid: "valid";
+            invalid: "invalid";
+        }>;
+        taskAdmissibility: z.ZodEnum<{
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+        }>;
+        observedQuality: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+            unavailable: "unavailable";
+            unscored: "unscored";
+        }>;
+        targetApproval: z.ZodEnum<{
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+            not_required: "not_required";
+        }>;
+        approvedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        grade: 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;
+            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<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                rawScore: z.ZodNullable<z.ZodNumber>;
+                normalizedScore: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+                evidenceHashes: z.ZodArray<z.ZodString>;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            training: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        targetGrade: 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;
+            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<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                rawScore: z.ZodNullable<z.ZodNumber>;
+                normalizedScore: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+                evidenceHashes: z.ZodArray<z.ZodString>;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            training: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                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";
+            supervised_training: "supervised_training";
+            reward_training: "reward_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<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+        }, z.core.$strict>>;
+        sealedAt: z.ZodString;
+        sealedBy: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningPolicy.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        modelProjectId: z.ZodString;
+        executionOwner: z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+        }>;
+        enabled: z.ZodBoolean;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        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>;
+        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<{
+            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<{
+                sft: "sft";
+                dpo: "dpo";
+                grpo: "grpo";
+                ppo: "ppo";
+                sdft: "sdft";
+                opd: "opd";
+                opsd: "opsd";
+                sdpo: "sdpo";
+            }>;
+            recipe: z.ZodObject<{
+                id: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>;
+            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>>;
+        }, 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>;
+        contentHash: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            failed: "failed";
+            cancelled: "cancelled";
+            accepted: "accepted";
+            training: "training";
+            rejected: "rejected";
+            waiting_for_data: "waiting_for_data";
+            waiting_for_review: "waiting_for_review";
+            ready: "ready";
+            evaluating: "evaluating";
+            candidate_ready: "candidate_ready";
+            paused: "paused";
+            cancelling: "cancelling";
+        }>;
+        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>;
+        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>>;
+        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<{
+            failed: "failed";
+            completed: "completed";
+            cancelled: "cancelled";
+            running: "running";
+            cancelling: "cancelling";
+            queued: "queued";
+        }>;
+        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;
+            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<{
+                    pending: "pending";
+                    failed: "failed";
+                    scored: "scored";
+                    unavailable: "unavailable";
+                }>;
+                rawScore: z.ZodNullable<z.ZodNumber>;
+                normalizedScore: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+                evidenceHashes: z.ZodArray<z.ZodString>;
+                message: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            training: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                score: z.ZodNullable<z.ZodNumber>;
+                passed: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strict>;
+            evaluation: z.ZodObject<{
+                status: z.ZodEnum<{
+                    scored: "scored";
+                    unscorable: "unscorable";
+                    not_configured: "not_configured";
+                }>;
+                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;
+        failure: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: 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<{
+                policy: "policy";
+                verifier: "verifier";
+                host_private: "host_private";
+            }>;
+        }, z.core.$strict>;
+        text: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>)[]>>;
+}, z.core.$strict>;
+//# sourceMappingURL=transport.d.ts.map