@openpond/evals 0.6.0 → 0.7.0

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

@@ -0,0 +1,1143 @@
+import { z } from "zod";
+import { type LearningRevisionRef } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+export declare const learningResourceSchemas: {
+    readonly asset: 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>;
+    readonly definition: 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>;
+    readonly reward: 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>;
+    readonly binding: 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>;
+    readonly source: 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>;
+    readonly evidence: 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>;
+    readonly feedback: 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>;
+    readonly decision: 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>;
+    readonly 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>;
+    readonly policy: 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>;
+    readonly iteration: 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>;
+    readonly grade: 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>;
+    readonly package: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.tasksetRelease.v2">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            policyVisibleFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            privilegedFields: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            hiddenGraderRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            connectedAppScopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+        environment: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<"openpond.environment.v1">;
+            kind: z.ZodEnum<{
+                text: "text";
+                agent: "agent";
+                work: "work";
+                custom_program: "custom_program";
+            }>;
+            entrypoint: z.ZodString;
+            stateful: z.ZodBoolean;
+            deterministicSeeds: z.ZodBoolean;
+            lifecycle: z.ZodArray<z.ZodEnum<{
+                create: "create";
+                reset: "reset";
+                step: "step";
+                collect: "collect";
+                destroy: "destroy";
+            }>>;
+            networkPolicy: z.ZodEnum<{
+                none: "none";
+                declared_read_only: "declared_read_only";
+                declared_scoped: "declared_scoped";
+            }>;
+            defaultTimeoutMs: z.ZodNumber;
+        }, z.core.$strict>;
+        environmentRelease: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            inputSchemaHash: z.ZodString;
+            sideEffect: z.ZodEnum<{
+                read: "read";
+                write: "write";
+            }>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        capabilities: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            required: z.ZodBoolean;
+            scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            portability: z.ZodEnum<{
+                portable: "portable";
+                host_adapter: "host_adapter";
+                local_only: "local_only";
+                hosted_only: "hosted_only";
+            }>;
+        }, z.core.$strict>>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            clusterKey: z.ZodString;
+            split: z.ZodEnum<{
+                train: "train";
+                validation: "validation";
+                test: "test";
+                frozen_eval: "frozen_eval";
+            }>;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            expectedOutput: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            policyVisibleContext: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            privilegedContextRef: z.ZodNullable<z.ZodString>;
+            artifactRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>>;
+            requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                mediaType: z.ZodString;
+                schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                    id: z.ZodString;
+                    path: z.ZodString;
+                    contentHash: z.ZodString;
+                    sizeBytes: z.ZodNumber;
+                    mediaType: z.ZodString;
+                    visibility: z.ZodEnum<{
+                        policy: "policy";
+                        verifier: "verifier";
+                        host_private: "host_private";
+                    }>;
+                }, z.core.$strict>>>;
+                maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+                metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        graders: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodEnum<{
+                content: "content";
+                schema: "schema";
+                artifact: "artifact";
+                runtime_event: "runtime_event";
+                state: "state";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"model_judge">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            calibrationStatus: z.ZodEnum<{
+                pending: "pending";
+                passed: "passed";
+                failed: "failed";
+            }>;
+            model: z.ZodOptional<z.ZodObject<{
+                providerId: z.ZodString;
+                modelId: z.ZodString;
+                revision: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"custom_verifier">;
+            verifierRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            exportName: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+            networkPolicy: z.ZodLiteral<"none">;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            weight: z.ZodDefault<z.ZodNumber>;
+            hardGate: z.ZodDefault<z.ZodBoolean>;
+            rewardEligible: z.ZodDefault<z.ZodBoolean>;
+            privileged: z.ZodDefault<z.ZodBoolean>;
+            kind: z.ZodLiteral<"human">;
+            rubricRef: z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>;
+            reviewerRole: z.ZodString;
+        }, z.core.$strict>]>>;
+        verifierSetRelease: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+};
+export type LearningResourceKind = keyof typeof learningResourceSchemas;
+export declare const LearningResourceKindSchema: z.ZodEnum<{
+    policy: "policy";
+    feedback: "feedback";
+    reward: "reward";
+    source: "source";
+    decision: "decision";
+    evidence: "evidence";
+    binding: "binding";
+    grade: "grade";
+    batch: "batch";
+    asset: "asset";
+    definition: "definition";
+    iteration: "iteration";
+    package: "package";
+}>;
+export type LearningResourceFor<K extends LearningResourceKind> = z.infer<(typeof learningResourceSchemas)[K]>;
+export type LearningStoredResource = LearningResourceFor<LearningResourceKind>;
+export type LearningResourcePointer = {
+    kind: LearningResourceKind;
+    id: string;
+    revision: number;
+};
+export type LearningOperationReceipt = {
+    requestHash: string;
+    resources: LearningResourcePointer[];
+};
+export type LearningResourceQuery = {
+    parentId?: string;
+    status?: string;
+    afterId?: string;
+    limit: number;
+};
+export type LearningResourcePage<K extends LearningResourceKind> = {
+    items: LearningResourceFor<K>[];
+    nextCursor: string | null;
+};
+/** Transactions must serialize mutations within a scope and roll back atomically. */
+export interface LearningTransaction {
+    get<K extends LearningResourceKind>(kind: K, id: string, revision?: number): Promise<LearningResourceFor<K> | null>;
+    put<K extends LearningResourceKind>(kind: K, resource: LearningResourceFor<K>, expectedRevision: number, index?: {
+        parentId?: string;
+        status?: string;
+    }): Promise<void>;
+    list<K extends LearningResourceKind>(kind: K, query: LearningResourceQuery): Promise<LearningResourcePage<K>>;
+    operation(id: string): Promise<LearningOperationReceipt | null>;
+    saveOperation(id: string, receipt: LearningOperationReceipt): Promise<void>;
+    familySplit(namespace: string, kind: "family" | "input", key: string): Promise<string | null>;
+    reserveFamilySplit(namespace: string, kind: "family" | "input", key: string, split: string): Promise<void>;
+}
+export interface LearningRepository {
+    transaction<T>(scope: string, callback: (transaction: LearningTransaction) => Promise<T>): Promise<T>;
+}
+export declare class LearningConflictError extends LearningDomainError {
+    readonly kind: string;
+    readonly id: string;
+    readonly expectedRevision: number;
+    readonly currentRevision: number;
+    constructor(kind: string, id: string, expectedRevision: number, currentRevision: number);
+}
+export declare function requireLearningResource<K extends LearningResourceKind>(transaction: LearningTransaction, kind: K, id: string, revision?: number): Promise<LearningResourceFor<K>>;
+export declare function requireLearningRelease<K extends LearningResourceKind>(transaction: LearningTransaction, kind: K, ref: LearningRevisionRef): Promise<LearningResourceFor<K>>;
+export declare function learningEvidenceId(sourceId: string, exampleId: string, attemptId: string): string;
+export declare function learningOperationId(actorId: string, operationId: string): string;
+//# sourceMappingURL=repository.d.ts.map