@openpond/evals 0.5.0 → 0.7.0

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

@@ -0,0 +1,2149 @@
+import { z } from "zod";
+export declare const LearningJsonObjectSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+export declare const LearningRevisionRefSchema: z.ZodObject<{
+    id: z.ZodString;
+    contentHash: z.ZodString;
+    revision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const LearningJsonPointerSchema: z.ZodString;
+export declare const TaskDefinitionContentSchema: 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>;
+export declare const TaskDefinitionSchema: 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>;
+export declare const TaskSourceMappingSchema: 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>;
+export declare const LearningSourceContentSchema: 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>;
+export declare const LearningSourceSchema: 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>;
+export declare const TaskExampleSubmissionSchema: 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>;
+export declare const TaskEvidenceContentSchema: 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;
+}, z.core.$strict>;
+export declare const TaskEvidenceSchema: 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>;
+export declare const TaskFeedbackSubmissionSchema: 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>;
+export declare const TaskFeedbackSchema: 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>;
+export declare const TaskAdmissionDecisionContentSchema: 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;
+}, z.core.$strict>;
+export declare const TaskAdmissionDecisionSchema: 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>;
+export declare const TaskBatchContentSchema: 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;
+}, z.core.$strict>;
+export declare const TaskBatchSchema: 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>;
+export declare const LearningPolicyContentSchema: 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>;
+export declare const LearningPolicySchema: 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>;
+export declare const LearningIterationStatusSchema: 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";
+}>;
+export declare const LearningIterationSchema: 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>;
+export declare const TaskGradeRunSchema: 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>;
+export declare const LearningResourceSchema: z.ZodUnion<readonly [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.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.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>]>;
+export type TaskDefinition = z.infer<typeof TaskDefinitionSchema>;
+export type LearningSource = z.infer<typeof LearningSourceSchema>;
+export type TaskExampleSubmission = z.infer<typeof TaskExampleSubmissionSchema>;
+export type TaskEvidence = z.infer<typeof TaskEvidenceSchema>;
+export type TaskFeedbackSubmission = z.infer<typeof TaskFeedbackSubmissionSchema>;
+export type TaskFeedback = z.infer<typeof TaskFeedbackSchema>;
+export type TaskAdmissionDecision = z.infer<typeof TaskAdmissionDecisionSchema>;
+export type TaskBatch = z.infer<typeof TaskBatchSchema>;
+export type LearningPolicy = z.infer<typeof LearningPolicySchema>;
+export type LearningIteration = z.infer<typeof LearningIterationSchema>;
+export type TaskGradeRun = z.infer<typeof TaskGradeRunSchema>;
+export type LearningResource = z.infer<typeof LearningResourceSchema>;
+export type LearningRevisionRef = z.infer<typeof LearningRevisionRefSchema>;
+export declare function learningRef(resource: {
+    id: string;
+    revision: number;
+    contentHash: string;
+}): LearningRevisionRef;
+export declare function sameLearningRef(left: LearningRevisionRef, right: LearningRevisionRef): boolean;
+export declare function sealLearningContent<T extends Record<string, unknown>>(content: T): T & {
+    contentHash: string;
+};
+export declare function assertLearningContentHash(resource: {
+    contentHash: string;
+}): void;
+//# sourceMappingURL=contracts.d.ts.map