openpond-sdk 0.9.8 → 0.10.0

package/dist/types/packages/sdk/src/taskset-package-client.d.ts

@@ -4775,6 +4775,1468 @@ export declare const TasksetPackageReadbackSchema: z.ZodObject<{
         contentHash: z.ZodString;
     }, z.core.$strict>;
 }, z.core.$strict>;
+export declare const TasksetReleasePackageReadbackSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.tasksetReleasePackageReadback.v1">;
+    teamId: z.ZodString;
+    release: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    package: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.tasksetPackage.v1">;
+        taskset: 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">;
+                runtime: z.ZodOptional<z.ZodEnum<{
+                    isolated_javascript: "isolated_javascript";
+                    sandbox_process: "sandbox_process";
+                }>>;
+                verifierRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                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>>;
+            metrics: z.ZodOptional<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.tasksetMetricPolicy.v1">;
+                primaryMetric: z.ZodString;
+                aggregation: z.ZodEnum<{
+                    mean_score: "mean_score";
+                    pass_rate: "pass_rate";
+                    weighted_mean: "weighted_mean";
+                    custom: "custom";
+                }>;
+                missingReward: z.ZodEnum<{
+                    zero: "zero";
+                    exclude: "exclude";
+                }>;
+                taskWeights: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+                customAggregator: z.ZodNullable<z.ZodObject<{
+                    module: z.ZodString;
+                    exportName: z.ZodString;
+                    contentHash: z.ZodString;
+                    timeoutMs: z.ZodNumber;
+                    networkPolicy: z.ZodLiteral<"none">;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contract: 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>;
+            actionSchemaRef: 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>>;
+            observationSchemaRef: 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>>;
+            stateSchemaRef: 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>>;
+            artifactCollection: z.ZodObject<{
+                maxArtifacts: z.ZodNumber;
+                maxTotalBytes: z.ZodNumber;
+            }, z.core.$strict>;
+            adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        verifierSet: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            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">;
+                runtime: z.ZodOptional<z.ZodEnum<{
+                    isolated_javascript: "isolated_javascript";
+                    sandbox_process: "sandbox_process";
+                }>>;
+                verifierRef: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                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>]>>;
+            isolation: z.ZodObject<{
+                processBoundary: z.ZodEnum<{
+                    same_process: "same_process";
+                    isolated_process: "isolated_process";
+                    container: "container";
+                }>;
+                networkPolicy: z.ZodLiteral<"none">;
+                defaultTimeoutMs: z.ZodNumber;
+            }, z.core.$strict>;
+            calibrationReceiptRefs: z.ZodArray<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>;
+        files: z.ZodArray<z.ZodObject<{
+            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>;
+            base64: z.ZodString;
+        }, z.core.$strict>>;
+        modelResources: z.ZodOptional<z.ZodObject<{
+            execution: z.ZodOptional<z.ZodObject<{
+                environment: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.environmentRelease.v1">;
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    contract: 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>;
+                    actionSchemaRef: 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>>;
+                    observationSchemaRef: 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>>;
+                    stateSchemaRef: 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>>;
+                    artifactCollection: z.ZodObject<{
+                        maxArtifacts: z.ZodNumber;
+                        maxTotalBytes: z.ZodNumber;
+                    }, z.core.$strict>;
+                    adapterConformanceHashes: z.ZodRecord<z.ZodString, z.ZodString>;
+                    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+                verifierSet: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.verifierSetRelease.v1">;
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    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">;
+                        runtime: z.ZodOptional<z.ZodEnum<{
+                            isolated_javascript: "isolated_javascript";
+                            sandbox_process: "sandbox_process";
+                        }>>;
+                        verifierRef: z.ZodObject<{
+                            id: z.ZodString;
+                            path: z.ZodString;
+                            contentHash: z.ZodString;
+                            sizeBytes: z.ZodNumber;
+                            mediaType: z.ZodString;
+                            visibility: z.ZodEnum<{
+                                policy: "policy";
+                                verifier: "verifier";
+                                host_private: "host_private";
+                            }>;
+                        }, z.core.$strict>;
+                        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>]>>;
+                    isolation: z.ZodObject<{
+                        processBoundary: z.ZodEnum<{
+                            same_process: "same_process";
+                            isolated_process: "isolated_process";
+                            container: "container";
+                        }>;
+                        networkPolicy: z.ZodLiteral<"none">;
+                        defaultTimeoutMs: z.ZodNumber;
+                    }, z.core.$strict>;
+                    calibrationReceiptRefs: z.ZodArray<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>;
+                javascript: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<"openpond.javascriptEnvironment.v1">;
+                    id: z.ZodString;
+                    revision: z.ZodNumber;
+                    module: 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>;
+                    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>>;
+                    maxSteps: z.ZodNumber;
+                    maxStateBytes: z.ZodNumber;
+                    maxObservationBytes: z.ZodNumber;
+                    operationTimeoutMs: z.ZodNumber;
+                    executionServices: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"sqlite.v1">;
+                        sql: z.ZodObject<{
+                            scope: z.ZodEnum<{
+                                input: "input";
+                                state: "state";
+                                initialState: "initialState";
+                                arguments: "arguments";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>;
+                        snapshot: z.ZodObject<{
+                            scope: z.ZodEnum<{
+                                input: "input";
+                                state: "state";
+                                initialState: "initialState";
+                                arguments: "arguments";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>;
+                        maxRows: z.ZodNumber;
+                        maxResultBytes: z.ZodNumber;
+                        id: z.ZodString;
+                        operation: z.ZodEnum<{
+                            step: "step";
+                            collect: "collect";
+                        }>;
+                        toolName: z.ZodOptional<z.ZodString>;
+                        timeoutMs: z.ZodNumber;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"javascript.v1">;
+                        source: z.ZodObject<{
+                            scope: z.ZodEnum<{
+                                input: "input";
+                                state: "state";
+                                initialState: "initialState";
+                                arguments: "arguments";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>;
+                        cases: z.ZodObject<{
+                            scope: z.ZodEnum<{
+                                input: "input";
+                                state: "state";
+                                initialState: "initialState";
+                                arguments: "arguments";
+                            }>;
+                            path: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>;
+                        exportName: z.ZodString;
+                        maxCases: z.ZodNumber;
+                        maxResultBytes: z.ZodNumber;
+                        id: z.ZodString;
+                        operation: z.ZodEnum<{
+                            step: "step";
+                            collect: "collect";
+                        }>;
+                        toolName: z.ZodOptional<z.ZodString>;
+                        timeoutMs: z.ZodNumber;
+                    }, z.core.$strict>], "kind">>>;
+                    contentHash: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            taskDefinition: 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>;
+                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>>>;
+                contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                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>;
+            assets: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+                id: z.ZodString;
+                revision: z.ZodLiteral<1>;
+                asset: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                text: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            rewards: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.rewardRelease.v1">;
+                id: z.ZodString;
+                revision: z.ZodNumber;
+                name: z.ZodString;
+                description: z.ZodString;
+                feedbackKey: z.ZodOptional<z.ZodString>;
+                implementation: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        content: "content";
+                        schema: "schema";
+                        artifact: "artifact";
+                        runtime_event: "runtime_event";
+                        state: "state";
+                    }>;
+                    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"model_judge">;
+                    rubricRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                    calibrationStatus: z.ZodEnum<{
+                        pending: "pending";
+                        passed: "passed";
+                        failed: "failed";
+                    }>;
+                    model: z.ZodOptional<z.ZodObject<{
+                        providerId: z.ZodString;
+                        modelId: z.ZodString;
+                        revision: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strict>>;
+                    temperature: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>, z.ZodObject<{
+                    exportName: z.ZodOptional<z.ZodString>;
+                    timeoutMs: z.ZodNumber;
+                    networkPolicy: z.ZodLiteral<"none">;
+                    kind: z.ZodLiteral<"custom_verifier">;
+                    runtime: z.ZodOptional<z.ZodEnum<{
+                        isolated_javascript: "isolated_javascript";
+                        sandbox_process: "sandbox_process";
+                    }>>;
+                    verifierRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"human">;
+                    rubricRef: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                    reviewerRole: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"learned_model">;
+                    modelVersion: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                    }, z.core.$strict>;
+                    inputContract: z.ZodObject<{
+                        id: z.ZodString;
+                        path: z.ZodString;
+                        contentHash: z.ZodString;
+                        sizeBytes: z.ZodNumber;
+                        mediaType: z.ZodString;
+                        visibility: z.ZodEnum<{
+                            policy: "policy";
+                            verifier: "verifier";
+                            host_private: "host_private";
+                        }>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>]>;
+                rawScore: z.ZodObject<{
+                    minimum: z.ZodNumber;
+                    maximum: z.ZodNumber;
+                }, z.core.$strict>;
+                assets: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                fixtureSetRef: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>;
+                calibrationCheckRef: z.ZodOptional<z.ZodObject<{
+                    id: z.ZodString;
+                    contentHash: z.ZodString;
+                    revision: z.ZodNumber;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            rewardBinding: 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>;
+            instructionMode: z.ZodOptional<z.ZodLiteral<"per_task">>;
+        }, z.core.$strict>>;
+        learningResources: z.ZodOptional<z.ZodObject<{
+            batch: 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>;
+            evidence: z.ZodArray<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>>;
+                    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>>>;
+                    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>>;
+            decisions: z.ZodArray<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";
+                    rejected: "rejected";
+                    approved: "approved";
+                }>;
+                observedQuality: z.ZodEnum<{
+                    passed: "passed";
+                    failed: "failed";
+                    unavailable: "unavailable";
+                    unscored: "unscored";
+                }>;
+                targetApproval: z.ZodEnum<{
+                    pending: "pending";
+                    rejected: "rejected";
+                    approved: "approved";
+                    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>;
+                        graderEvidence: z.ZodOptional<z.ZodObject<{
+                            schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
+                            graderId: z.ZodString;
+                            graderVersion: z.ZodString;
+                            score: z.ZodNullable<z.ZodNumber>;
+                            passed: z.ZodBoolean;
+                            rewardEligible: z.ZodBoolean;
+                            failureClass: z.ZodNullable<z.ZodEnum<{
+                                policy_failure: "policy_failure";
+                                grader_failure: "grader_failure";
+                                environment_failure: "environment_failure";
+                                infrastructure_failure: "infrastructure_failure";
+                                timeout: "timeout";
+                                cancelled: "cancelled";
+                            }>>;
+                            feedback: z.ZodArray<z.ZodString>;
+                            visibleEvidenceRefs: z.ZodArray<z.ZodString>;
+                            privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
+                            modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
+                                schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
+                                providerId: z.ZodString;
+                                modelId: z.ZodString;
+                                modelRevision: z.ZodNullable<z.ZodString>;
+                                responseId: z.ZodNullable<z.ZodString>;
+                                requestHash: z.ZodString;
+                                responseHash: z.ZodString;
+                                inputTokens: z.ZodNullable<z.ZodNumber>;
+                                outputTokens: z.ZodNullable<z.ZodNumber>;
+                                costUsd: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strict>>;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        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>;
+                        graderEvidence: z.ZodOptional<z.ZodObject<{
+                            schemaVersion: z.ZodLiteral<"openpond.graderEvidence.v1">;
+                            graderId: z.ZodString;
+                            graderVersion: z.ZodString;
+                            score: z.ZodNullable<z.ZodNumber>;
+                            passed: z.ZodBoolean;
+                            rewardEligible: z.ZodBoolean;
+                            failureClass: z.ZodNullable<z.ZodEnum<{
+                                policy_failure: "policy_failure";
+                                grader_failure: "grader_failure";
+                                environment_failure: "environment_failure";
+                                infrastructure_failure: "infrastructure_failure";
+                                timeout: "timeout";
+                                cancelled: "cancelled";
+                            }>>;
+                            feedback: z.ZodArray<z.ZodString>;
+                            visibleEvidenceRefs: z.ZodArray<z.ZodString>;
+                            privilegedEvidenceRefs: z.ZodArray<z.ZodString>;
+                            modelJudgeReceipt: z.ZodOptional<z.ZodObject<{
+                                schemaVersion: z.ZodLiteral<"openpond.modelJudgeReceipt.v1">;
+                                providerId: z.ZodString;
+                                modelId: z.ZodString;
+                                modelRevision: z.ZodNullable<z.ZodString>;
+                                responseId: z.ZodNullable<z.ZodString>;
+                                requestHash: z.ZodString;
+                                responseHash: z.ZodString;
+                                inputTokens: z.ZodNullable<z.ZodNumber>;
+                                outputTokens: z.ZodNullable<z.ZodNumber>;
+                                costUsd: z.ZodNullable<z.ZodNumber>;
+                            }, z.core.$strict>>;
+                            contentHash: z.ZodString;
+                        }, z.core.$strict>>;
+                        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>>;
+            sources: z.ZodArray<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>;
+                reviewOrigin: z.ZodOptional<z.ZodObject<{
+                    modelId: z.ZodString;
+                    packageHash: z.ZodString;
+                    taskset: z.ZodObject<{
+                        id: z.ZodString;
+                        contentHash: z.ZodString;
+                        revision: z.ZodNumber;
+                    }, z.core.$strict>;
+                    batch: 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>;
+                }, z.core.$strict>>;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+            assets: z.ZodArray<z.ZodObject<{
+                schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+                id: z.ZodString;
+                revision: z.ZodLiteral<1>;
+                asset: z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>;
+                text: z.ZodString;
+                contentHash: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
 export type TasksetPackagePublication = z.infer<typeof TasksetPackagePublicationSchema>;
 export type TasksetPackageReceipt = z.infer<typeof TasksetPackageReceiptSchema>;
 export type TasksetPackageModelConfiguration = z.infer<typeof TasksetPackageModelConfigurationSchema>;
@@ -4796,6 +6258,12 @@ export declare class OpenPondTasksetPackageClient {
     publish(input: TasksetPackagePublication, options?: {
         signal?: AbortSignal;
     }): Promise<TasksetPackageReceipt>;
+    /** Owner-authorized independent Dataset transfer. Callers retain private
+     * bytes at the evaluator/server boundary, never in a policy-facing picker. */
+    getByRelease(reference: z.infer<typeof TasksetCatalogReleaseRefSchema>, options?: {
+        signal?: AbortSignal;
+        expectedPackageHash?: string;
+    }): Promise<TasksetPackage>;
     get(modelProjectId: string, reference: z.infer<typeof TasksetCatalogReleaseRefSchema>, options?: {
         signal?: AbortSignal;
         expectedPackageHash?: string;