@openpond/evals 0.5.0 → 0.7.0

package/dist/types/learned-preference.d.ts

@@ -0,0 +1,282 @@
+import { z } from "zod";
+import { type ComparisonAssignment, type PreferenceComparisonRelease, type PreferenceReceipt } from "./preferences.js";
+import type { TasksetRelease } from "./tasksets.js";
+declare const PreferenceDatasetPartitionSchema: z.ZodEnum<{
+    reward_train: "reward_train";
+    reward_validation: "reward_validation";
+    reward_qualification: "reward_qualification";
+}>;
+export declare const PreferenceEvidenceAuthoritySchema: z.ZodEnum<{
+    human: "human";
+    synthetic_fixture: "synthetic_fixture";
+}>;
+export declare const RewardModelQualificationKindSchema: z.ZodEnum<{
+    synthetic_smoke: "synthetic_smoke";
+    human_heldout: "human_heldout";
+}>;
+export declare const PreferenceDatasetReleaseContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preferenceDatasetRelease.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    tasksetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    comparisonRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    authority: z.ZodEnum<{
+        human: "human";
+        synthetic_fixture: "synthetic_fixture";
+    }>;
+    qualificationEligibility: z.ZodEnum<{
+        smoke_only: "smoke_only";
+        human_heldout: "human_heldout";
+    }>;
+    fixtureRelease: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        assignmentRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scenarioRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSplit: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+        }>;
+        preferenceResultRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        receiptRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        attemptRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        artifactManifestRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        orderedBuckets: z.ZodArray<z.ZodArray<z.ZodString>>;
+        rejectAll: z.ZodBoolean;
+        partition: z.ZodEnum<{
+            reward_train: "reward_train";
+            reward_validation: "reward_validation";
+            reward_qualification: "reward_qualification";
+        }>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    derivedPairs: z.ZodArray<z.ZodObject<{
+        groupId: z.ZodString;
+        preferredAttemptRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        dispreferredAttemptRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        relation: z.ZodEnum<{
+            preferred: "preferred";
+            tie: "tie";
+        }>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const PreferenceDatasetReleaseSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.preferenceDatasetRelease.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    tasksetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    comparisonRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    authority: z.ZodEnum<{
+        human: "human";
+        synthetic_fixture: "synthetic_fixture";
+    }>;
+    qualificationEligibility: z.ZodEnum<{
+        smoke_only: "smoke_only";
+        human_heldout: "human_heldout";
+    }>;
+    fixtureRelease: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        assignmentRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scenarioRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        scenarioSplit: z.ZodEnum<{
+            train: "train";
+            validation: "validation";
+        }>;
+        preferenceResultRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        receiptRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        attemptRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        artifactManifestRefs: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>>;
+        orderedBuckets: z.ZodArray<z.ZodArray<z.ZodString>>;
+        rejectAll: z.ZodBoolean;
+        partition: z.ZodEnum<{
+            reward_train: "reward_train";
+            reward_validation: "reward_validation";
+            reward_qualification: "reward_qualification";
+        }>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    derivedPairs: z.ZodArray<z.ZodObject<{
+        groupId: z.ZodString;
+        preferredAttemptRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        dispreferredAttemptRef: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+        }, z.core.$strict>;
+        relation: z.ZodEnum<{
+            preferred: "preferred";
+            tie: "tie";
+        }>;
+    }, z.core.$strict>>;
+    createdAt: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare const RewardModelQualificationReportContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardModelQualificationReport.v1">;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        synthetic_smoke: "synthetic_smoke";
+        human_heldout: "human_heldout";
+    }>;
+    rewardModelVersion: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    preferenceDatasetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    tasksetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    processorRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    metrics: z.ZodObject<{
+        sampleCount: z.ZodNumber;
+        finiteScoreRate: z.ZodNumber;
+        scoreVariance: z.ZodNumber;
+        checkpointReloadPassed: z.ZodBoolean;
+        processorCompatibilityPassed: z.ZodBoolean;
+        invalidAttemptExclusionPassed: z.ZodBoolean;
+        orderedPairAccuracy: z.ZodNullable<z.ZodNumber>;
+        bucketAccuracy: z.ZodNullable<z.ZodNumber>;
+        tieAgreement: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    passed: z.ZodBoolean;
+    productionRewardEligible: z.ZodBoolean;
+    createdAt: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export declare const RewardModelQualificationReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.rewardModelQualificationReport.v1">;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        synthetic_smoke: "synthetic_smoke";
+        human_heldout: "human_heldout";
+    }>;
+    rewardModelVersion: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    preferenceDatasetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    tasksetRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    processorRelease: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    metrics: z.ZodObject<{
+        sampleCount: z.ZodNumber;
+        finiteScoreRate: z.ZodNumber;
+        scoreVariance: z.ZodNumber;
+        checkpointReloadPassed: z.ZodBoolean;
+        processorCompatibilityPassed: z.ZodBoolean;
+        invalidAttemptExclusionPassed: z.ZodBoolean;
+        orderedPairAccuracy: z.ZodNullable<z.ZodNumber>;
+        bucketAccuracy: z.ZodNullable<z.ZodNumber>;
+        tieAgreement: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>;
+    passed: z.ZodBoolean;
+    productionRewardEligible: z.ZodBoolean;
+    createdAt: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export declare function createPreferenceDatasetRelease(input: z.input<typeof PreferenceDatasetReleaseContentSchema>): PreferenceDatasetRelease;
+export declare function materializePreferenceDatasetRelease(input: {
+    id: string;
+    revision: number;
+    tasksetRelease: TasksetRelease;
+    comparisonRelease: PreferenceComparisonRelease;
+    authority: "human" | "synthetic_fixture";
+    groups: ReadonlyArray<{
+        assignment: ComparisonAssignment;
+        receipt: PreferenceReceipt;
+        partition: z.infer<typeof PreferenceDatasetPartitionSchema>;
+    }>;
+    createdAt: string;
+    metadata?: Record<string, unknown>;
+}): PreferenceDatasetRelease;
+export declare function verifyPreferenceDatasetRelease(value: unknown): value is PreferenceDatasetRelease;
+export declare function createRewardModelQualificationReport(input: z.input<typeof RewardModelQualificationReportContentSchema>): RewardModelQualificationReport;
+export declare function verifyRewardModelQualificationReport(value: unknown): value is RewardModelQualificationReport;
+export type PreferenceEvidenceAuthority = z.infer<typeof PreferenceEvidenceAuthoritySchema>;
+export type PreferenceDatasetRelease = z.infer<typeof PreferenceDatasetReleaseSchema>;
+export type RewardModelQualificationKind = z.infer<typeof RewardModelQualificationKindSchema>;
+export type RewardModelQualificationReport = z.infer<typeof RewardModelQualificationReportSchema>;
+export {};
+//# sourceMappingURL=learned-preference.d.ts.map

package/dist/types/learned-preference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"learned-preference.d.ts","sourceRoot":"","sources":["../../../../src/learned-preference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,QAAA,MAAM,gCAAgC;;;;EAIpC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;EAG5C,CAAC;AAEH,eAAO,MAAM,kCAAkC;;;EAG7C,CAAC;AAwEH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuEhD,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEhC,CAAC;AAcZ,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA+BtD,CAAC;AAEH,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGpC,CAAC;AAEd,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,GAC3D,wBAAwB,CAM1B;AAED,wBAAgB,mCAAmC,CAAC,KAAK,EAAE;IACzD,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,cAAc,CAAC;IAC/B,iBAAiB,EAAE,2BAA2B,CAAC;IAC/C,SAAS,EAAE,OAAO,GAAG,mBAAmB,CAAC;IACzC,MAAM,EAAE,aAAa,CAAC;QACpB,UAAU,EAAE,oBAAoB,CAAC;QACjC,OAAO,EAAE,iBAAiB,CAAC;QAC3B,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;KAC7D,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,GAAG,wBAAwB,CA4E3B;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,wBAAwB,CAMnC;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,2CAA2C,CAAC,GACjE,8BAA8B,CAMhC;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,8BAA8B,CAMzC;AAgED,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,kCAAkC,CAC1C,CAAC;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,oCAAoC,CAC5C,CAAC"}

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

@@ -0,0 +1,335 @@
+import { z } from "zod";
+import { type RewardBinding, type RewardComposition, type RewardRelease } from "../rewards.js";
+import { type TaskRecord, type TasksetRelease } from "../tasksets.js";
+import { type TaskSchemaIssue } from "../task-schema.js";
+import { type LearningSource, type TaskAdmissionDecision, type TaskBatch, type TaskDefinition, type TaskEvidence, type TaskExampleSubmission } from "./contracts.js";
+export type TaskEvidenceInspection = {
+    evidenceValidity: "valid" | "invalid";
+    taskReady: boolean;
+    observedOutputValid: boolean | null;
+    issues: TaskSchemaIssue[];
+};
+export type TaskFamilySplit = {
+    namespace: string;
+    key: string;
+    kind: "family" | "input";
+    split: TaskExampleSubmission["split"];
+};
+export declare function inspectTaskEvidence(evidence: TaskEvidence, definition: TaskDefinition): TaskEvidenceInspection;
+export declare function validateSourceSubmission(sourceInput: LearningSource, submissionInput: TaskExampleSubmission): TaskExampleSubmission;
+export declare function mapTaskSourceRecord(input: {
+    source: LearningSource;
+    record: unknown;
+    idempotencyKey: string;
+}): {
+    status: "mapped";
+    example: TaskExampleSubmission;
+} | {
+    status: "pending";
+    missing: string[];
+};
+export declare function readTaskJsonPointer(value: unknown, pointer: string): unknown;
+export declare function taskRecordFromEvidence(evidence: TaskEvidence, definition: TaskDefinition): TaskRecord;
+export declare function taskAttemptEvidence(evidence: TaskEvidence, output: Record<string, unknown>): {
+    output: Record<string, unknown>;
+    runtimeEventRefs: string[];
+    artifactRefs: string[];
+};
+export declare function assertAdmissionDecision(input: {
+    decision: TaskAdmissionDecision;
+    evidence: TaskEvidence;
+    definition: TaskDefinition;
+    purpose: TaskBatch["purpose"];
+}): void;
+export declare function assertGradeIdentity(grade: RewardComposition, evidence: TaskEvidence, definition: TaskDefinition, output: Record<string, unknown>): void;
+export declare function taskFamilyReservations(evidence: TaskEvidence, definition: TaskDefinition): TaskFamilySplit[];
+export declare function sealTaskBatch(input: {
+    id: string;
+    definition: TaskDefinition;
+    binding: RewardBinding;
+    rewards: RewardRelease[];
+    purpose: TaskBatch["purpose"];
+    evidence: TaskEvidence[];
+    decisions: TaskAdmissionDecision[];
+    priorSplits: TaskFamilySplit[];
+    actorId: string;
+    now: string;
+}): TaskBatch;
+export declare const TaskBatchPackageMetadataSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.taskBatchPackage.v1">;
+    batch: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    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>;
+    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>;
+    rewards: z.ZodArray<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>>;
+    admissions: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        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>;
+        supervisedTarget: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare function compileTaskBatch(input: {
+    batch: TaskBatch;
+    definition: TaskDefinition;
+    binding: RewardBinding;
+    rewards: RewardRelease[];
+    evidence: TaskEvidence[];
+    decisions: TaskAdmissionDecision[];
+}): TasksetRelease;
+export declare function taskBatchPackageMetadata(release: TasksetRelease): z.infer<typeof TaskBatchPackageMetadataSchema>;
+//# sourceMappingURL=admission.d.ts.map

package/dist/types/learning/admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission.d.ts","sourceRoot":"","sources":["../../../../../src/learning/admission.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { type ImmutableAssetRef } from "@openpond/harness";
+/** Small authored source files. Large binary evidence uses the host asset API. */
+export declare const LearningTextAssetContentSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningTextAsset.v1">;
+    id: z.ZodString;
+    revision: z.ZodLiteral<1>;
+    asset: z.ZodObject<{
+        id: z.ZodString;
+        path: z.ZodString;
+        contentHash: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        mediaType: z.ZodString;
+        visibility: z.ZodEnum<{
+            policy: "policy";
+            verifier: "verifier";
+            host_private: "host_private";
+        }>;
+    }, z.core.$strict>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export declare const LearningTextAssetSchema: 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>;
+export type LearningTextAsset = z.infer<typeof LearningTextAssetSchema>;
+export declare function createLearningTextAsset(input: {
+    text: string;
+    path: string;
+    mediaType: string;
+    visibility: ImmutableAssetRef["visibility"];
+}): LearningTextAsset;
+export declare function verifyLearningTextAsset(asset: LearningTextAsset, reference: ImmutableAssetRef): string;
+//# sourceMappingURL=assets.d.ts.map

package/dist/types/learning/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../../../../src/learning/assets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAoF,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAI7I,kFAAkF;AAClF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;kBAUzC,CAAC;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;kBAAyF,CAAC;AAC9H,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,wBAAgB,uBAAuB,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAA;CAAE,GAAG,iBAAiB,CAUhK;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,iBAAiB,GAAG,MAAM,CAItG"}