@openpond/evals 0.11.16 → 0.11.18

package/dist/learning/contracts.js

@@ -1,15 +1,20 @@
+import { TrainingHandoffOriginSchema } from "./training-handoff.js";
 import { LearningDomainError } from "./errors.js";
 import { z } from "zod";
-import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash } from "@openpond/harness";
-import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, RewardReleaseSchema } from "../rewards.js";
+import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash, } from "@openpond/harness";
+import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, RewardReleaseSchema, } from "../rewards.js";
 import { TaskRecordSchema, TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.js";
 import { JudgeCallReservationSchema } from "./judge-budget.js";
 import { NightlyScheduleSchema } from "./nightly-schedule.js";
 export const LearningJsonObjectSchema = z.record(z.string(), z.json());
 export const LearningRevisionRefSchema = RewardReleaseRefSchema;
-export const LearningJsonPointerSchema = z.string().max(2_000).refine((value) => value === "" || (value.startsWith("/") && !/~(?![01])/u.test(value)), "Use an RFC 6901 JSON pointer.");
-export const TaskDefinitionContentSchema = z.object({
+export const LearningJsonPointerSchema = z
+    .string()
+    .max(2_000)
+    .refine((value) => value === "" || (value.startsWith("/") && !/~(?![01])/u.test(value)), "Use an RFC 6901 JSON pointer.");
+export const TaskDefinitionContentSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskDefinition.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -24,21 +29,42 @@ export const TaskDefinitionContentSchema = z.object({
     contextRequirements: z.array(z.string().trim().min(1).max(2_000)).max(100).optional(),
     rewardBinding: LearningRevisionRefSchema,
     harness: ImmutableReleaseRefSchema.nullable(),
-    execution: TasksetReleaseContentSchema.pick({ policy: true, environment: true, environmentRelease: true, tools: true, capabilities: true, verifierSetRelease: true }).strict(),
-}).strict().superRefine((definition, context) => {
+    execution: TasksetReleaseContentSchema.pick({
+        policy: true,
+        environment: true,
+        environmentRelease: true,
+        tools: true,
+        capabilities: true,
+        verifierSetRelease: true,
+    }).strict(),
+})
+    .strict()
+    .superRefine((definition, context) => {
     for (const field of ["inputSchema", "outputSchema"]) {
         const schema = definition[field];
         if (schema.type !== "object")
-            context.addIssue({ code: "custom", path: [field], message: "Task input/output use object envelopes; declare type: object." });
+            context.addIssue({
+                code: "custom",
+                path: [field],
+                message: "Task input/output use object envelopes; declare type: object.",
+            });
         const report = validateTaskSchema(schema);
         if (!report.valid)
             context.addIssue({ code: "custom", path: [field], message: report.issues[0].message });
     }
-    if (Boolean(definition.execution.environmentRelease) !== Boolean(definition.execution.verifierSetRelease))
-        context.addIssue({ code: "custom", path: ["execution"], message: "Bind both the environment and verifier-set releases." });
+    if (Boolean(definition.execution.environmentRelease) !==
+        Boolean(definition.execution.verifierSetRelease))
+        context.addIssue({
+            code: "custom",
+            path: ["execution"],
+            message: "Bind both the environment and verifier-set releases.",
+        });
 });
-export const TaskDefinitionSchema = TaskDefinitionContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
-export const TaskSourceMappingSchema = z.object({
+export const TaskDefinitionSchema = TaskDefinitionContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const TaskSourceMappingSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskSourceMapping.v1"),
     exampleId: LearningJsonPointerSchema,
     attemptId: LearningJsonPointerSchema,
@@ -49,17 +75,21 @@ export const TaskSourceMappingSchema = z.object({
     evaluatorContext: LearningJsonPointerSchema.nullable(),
     familyKey: LearningJsonPointerSchema,
     split: TaskSplitSchema,
-}).strict();
+})
+    .strict();
 /** An explicit Model edit starts new evidence; the original admissions remain
  * in the exact parent package and are never approvals for this source. */
-export const LearningReviewOriginSchema = z.object({
+export const LearningReviewOriginSchema = z
+    .object({
     modelId: ReleaseIdSchema,
     packageHash: ReleaseHashSchema,
     taskset: LearningRevisionRefSchema,
     batch: LearningRevisionRefSchema,
     rewardBinding: LearningRevisionRefSchema,
-}).strict();
-export const LearningSourceContentSchema = z.object({
+})
+    .strict();
+export const LearningSourceContentSchema = z
+    .object({
     schemaVersion: z.literal("openpond.learningSource.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -71,16 +101,33 @@ export const LearningSourceContentSchema = z.object({
     mapping: TaskSourceMappingSchema.nullable(),
     adapterVersion: z.string().trim().min(1).max(200).nullable(),
     reviewOrigin: LearningReviewOriginSchema.optional(),
-}).strict().superRefine((source, context) => {
+})
+    .strict()
+    .superRefine((source, context) => {
     if (source.kind !== "direct" && !source.mapping)
-        context.addIssue({ code: "custom", path: ["mapping"], message: "Mapped sources require an explicit mapping." });
+        context.addIssue({
+            code: "custom",
+            path: ["mapping"],
+            message: "Mapped sources require an explicit mapping.",
+        });
     if (source.mapping && !source.allowedSplits.includes(source.mapping.split))
-        context.addIssue({ code: "custom", path: ["allowedSplits"], message: "The mapping split must be allowed by this source." });
+        context.addIssue({
+            code: "custom",
+            path: ["allowedSplits"],
+            message: "The mapping split must be allowed by this source.",
+        });
     if (["opentelemetry", "provider"].includes(source.kind) && !source.adapterVersion)
-        context.addIssue({ code: "custom", path: ["adapterVersion"], message: "Trace adapters require a pinned version." });
+        context.addIssue({
+            code: "custom",
+            path: ["adapterVersion"],
+            message: "Trace adapters require a pinned version.",
+        });
 });
-export const LearningSourceSchema = LearningSourceContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
-export const TaskExampleSubmissionSchema = z.object({
+export const LearningSourceSchema = LearningSourceContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const TaskExampleSubmissionSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskExample.v1"),
     sourceId: ReleaseIdSchema,
     idempotencyKey: ReleaseIdSchema,
@@ -96,9 +143,16 @@ export const TaskExampleSubmissionSchema = z.object({
     evaluatorContext: LearningJsonObjectSchema.nullable(),
     assets: z.array(ImmutableAssetRefSchema).max(1_000),
     requiredOutputs: TaskRecordSchema.shape.requiredOutputs,
-    provenance: z.object({ sourceRecordRef: z.string().max(2_000).nullable(), mappingHash: ReleaseHashSchema.nullable() }).strict(),
-}).strict();
-export const TaskEvidenceContentSchema = z.object({
+    provenance: z
+        .object({
+        sourceRecordRef: z.string().max(2_000).nullable(),
+        mappingHash: ReleaseHashSchema.nullable(),
+    })
+        .strict(),
+})
+    .strict();
+export const TaskEvidenceContentSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskEvidence.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -107,23 +161,38 @@ export const TaskEvidenceContentSchema = z.object({
     supersedes: LearningRevisionRefSchema.nullable(),
     correctionFeedbackId: ReleaseIdSchema.nullable(),
     receivedAt: ReleaseTimestampSchema,
+})
+    .strict();
+export const TaskEvidenceSchema = TaskEvidenceContentSchema.extend({
+    contentHash: ReleaseHashSchema,
 }).strict();
-export const TaskEvidenceSchema = TaskEvidenceContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
 /** A retained judgment of this exact attempt, separate from task admission. */
-export const TaskRatingSchema = z.object({
+export const TaskRatingSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskRating.v1"),
     criteria: z.string().trim().min(1).max(20_000),
     scale: z.object({ minimum: z.number().finite(), maximum: z.number().finite() }).strict(),
     score: z.number().finite(),
     evidence: z.string().max(20_000),
     explanation: z.string().max(20_000),
-}).strict().superRefine((rating, context) => {
+})
+    .strict()
+    .superRefine((rating, context) => {
     if (rating.scale.minimum >= rating.scale.maximum)
-        context.addIssue({ code: "custom", path: ["scale"], message: "The score scale must have an increasing range." });
+        context.addIssue({
+            code: "custom",
+            path: ["scale"],
+            message: "The score scale must have an increasing range.",
+        });
     if (rating.score < rating.scale.minimum || rating.score > rating.scale.maximum)
-        context.addIssue({ code: "custom", path: ["score"], message: "The score must be within its declared scale." });
+        context.addIssue({
+            code: "custom",
+            path: ["score"],
+            message: "The score must be within its declared scale.",
+        });
 });
-export const TaskFeedbackSubmissionSchema = z.object({
+export const TaskFeedbackSubmissionSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskFeedback.v1"),
     sourceId: ReleaseIdSchema,
     idempotencyKey: ReleaseIdSchema,
@@ -131,22 +200,43 @@ export const TaskFeedbackSubmissionSchema = z.object({
     attemptId: ReleaseIdSchema,
     expectedEvidenceHash: ReleaseHashSchema.nullable(),
     occurredAt: ReleaseTimestampSchema,
-    kind: z.enum(["outcome", "target_correction", "ground_truth_correction", "input_correction", "family_resolution"]),
+    kind: z.enum([
+        "outcome",
+        "target_correction",
+        "ground_truth_correction",
+        "input_correction",
+        "family_resolution",
+    ]),
     value: LearningJsonObjectSchema,
     note: z.string().max(20_000),
-}).strict().superRefine((submission, context) => {
+})
+    .strict()
+    .superRefine((submission, context) => {
     if (submission.value.schemaVersion !== "openpond.taskRating.v1")
         return;
     if (submission.expectedEvidenceHash === null)
-        context.addIssue({ code: "custom", path: ["expectedEvidenceHash"], message: "A rating must identify the exact evidence revision." });
+        context.addIssue({
+            code: "custom",
+            path: ["expectedEvidenceHash"],
+            message: "A rating must identify the exact evidence revision.",
+        });
     if (submission.kind !== "outcome")
-        context.addIssue({ code: "custom", path: ["kind"], message: "Ratings must be submitted as outcomes." });
+        context.addIssue({
+            code: "custom",
+            path: ["kind"],
+            message: "Ratings must be submitted as outcomes.",
+        });
     const rating = TaskRatingSchema.safeParse(submission.value);
     if (!rating.success)
         for (const issue of rating.error.issues)
-            context.addIssue({ code: "custom", path: ["value", ...issue.path], message: issue.message });
+            context.addIssue({
+                code: "custom",
+                path: ["value", ...issue.path],
+                message: issue.message,
+            });
 });
-export const TaskFeedbackSchema = z.object({
+export const TaskFeedbackSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskFeedbackRecord.v1"),
     id: ReleaseIdSchema,
     submission: TaskFeedbackSubmissionSchema,
@@ -154,16 +244,41 @@ export const TaskFeedbackSchema = z.object({
     evidence: LearningRevisionRefSchema.nullable(),
     createdAt: ReleaseTimestampSchema,
     revision: z.number().int().positive(),
-    submittedBy: z.object({ id: ReleaseIdSchema, role: z.enum(["editor", "reviewer", "source"]), sourceId: ReleaseIdSchema.nullable() }).strict().nullable().default(null),
-    review: z.object({ actorId: ReleaseIdSchema, decision: LearningRevisionRefSchema.nullable(), note: z.string().max(20_000), resolvedAt: ReleaseTimestampSchema }).strict().nullable().default(null),
-}).strict();
-export const TaskAdmissionDecisionContentSchema = z.object({
+    submittedBy: z
+        .object({
+        id: ReleaseIdSchema,
+        role: z.enum(["editor", "reviewer", "source"]),
+        sourceId: ReleaseIdSchema.nullable(),
+    })
+        .strict()
+        .nullable()
+        .default(null),
+    review: z
+        .object({
+        actorId: ReleaseIdSchema,
+        decision: LearningRevisionRefSchema.nullable(),
+        note: z.string().max(20_000),
+        resolvedAt: ReleaseTimestampSchema,
+    })
+        .strict()
+        .nullable()
+        .default(null),
+})
+    .strict();
+export const TaskAdmissionDecisionContentSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskAdmissionDecision.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
     evidence: LearningRevisionRefSchema,
     supersedes: LearningRevisionRefSchema.nullable(),
-    actor: z.object({ kind: z.enum(["human", "qualified_policy"]), id: ReleaseIdSchema, policy: LearningRevisionRefSchema.nullable() }).strict(),
+    actor: z
+        .object({
+        kind: z.enum(["human", "qualified_policy"]),
+        id: ReleaseIdSchema,
+        policy: LearningRevisionRefSchema.nullable(),
+    })
+        .strict(),
     evidenceValidity: z.enum(["valid", "invalid", "pending"]),
     taskAdmissibility: z.enum(["approved", "rejected", "pending"]),
     observedQuality: z.enum(["passed", "failed", "unscored", "unavailable"]),
@@ -173,43 +288,93 @@ export const TaskAdmissionDecisionContentSchema = z.object({
     targetGrade: RewardCompositionSchema.nullable(),
     note: z.string().max(20_000),
     decidedAt: ReleaseTimestampSchema,
-}).strict().superRefine((decision, context) => {
+})
+    .strict()
+    .superRefine((decision, context) => {
     if (decision.targetApproval === "approved" && decision.approvedTarget === null)
-        context.addIssue({ code: "custom", path: ["approvedTarget"], message: "Target approval requires an actual target." });
+        context.addIssue({
+            code: "custom",
+            path: ["approvedTarget"],
+            message: "Target approval requires an actual target.",
+        });
     if (decision.targetApproval !== "approved" && decision.approvedTarget !== null)
-        context.addIssue({ code: "custom", path: ["approvedTarget"], message: "Only approved targets may be selected for supervised learning." });
+        context.addIssue({
+            code: "custom",
+            path: ["approvedTarget"],
+            message: "Only approved targets may be selected for supervised learning.",
+        });
     if (decision.actor.kind === "qualified_policy" && !decision.actor.policy)
-        context.addIssue({ code: "custom", path: ["actor"], message: "Automatic admission must pin its qualified policy." });
+        context.addIssue({
+            code: "custom",
+            path: ["actor"],
+            message: "Automatic admission must pin its qualified policy.",
+        });
     if (decision.taskAdmissibility === "approved" && decision.evidenceValidity !== "valid")
-        context.addIssue({ code: "custom", path: ["taskAdmissibility"], message: "Only valid evidence can produce an approved task." });
+        context.addIssue({
+            code: "custom",
+            path: ["taskAdmissibility"],
+            message: "Only valid evidence can produce an approved task.",
+        });
 });
-export const TaskAdmissionDecisionSchema = TaskAdmissionDecisionContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
-export const TaskBatchContentSchema = z.object({
+export const TaskAdmissionDecisionSchema = TaskAdmissionDecisionContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const TaskBatchContentSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskBatch.v1"),
     id: ReleaseIdSchema,
     revision: z.literal(1),
     taskDefinition: LearningRevisionRefSchema,
     rewardBinding: LearningRevisionRefSchema,
     purpose: z.enum(["supervised_training", "reward_training", "evaluation"]),
-    examples: z.array(z.object({ evidence: LearningRevisionRefSchema, decision: LearningRevisionRefSchema, familyKey: ReleaseIdSchema, inputHash: ReleaseHashSchema, split: TaskSplitSchema }).strict()).min(1).max(10_000),
+    examples: z
+        .array(z
+        .object({
+        evidence: LearningRevisionRefSchema,
+        decision: LearningRevisionRefSchema,
+        familyKey: ReleaseIdSchema,
+        inputHash: ReleaseHashSchema,
+        split: TaskSplitSchema,
+    })
+        .strict())
+        .min(1)
+        .max(10_000),
     sealedAt: ReleaseTimestampSchema,
     sealedBy: ReleaseIdSchema,
-}).strict().superRefine((batch, context) => {
+})
+    .strict()
+    .superRefine((batch, context) => {
     if (new Set(batch.examples.map((entry) => entry.evidence.id)).size !== batch.examples.length)
-        context.addIssue({ code: "custom", path: ["examples"], message: "Each evidence identity can occur only once in a batch." });
+        context.addIssue({
+            code: "custom",
+            path: ["examples"],
+            message: "Each evidence identity can occur only once in a batch.",
+        });
     const splits = new Map();
     for (const [index, entry] of batch.examples.entries()) {
         if ((batch.purpose === "evaluation") === (entry.split === "train"))
-            context.addIssue({ code: "custom", path: ["examples", index, "split"], message: "Training uses train examples; evaluation uses held-out examples." });
+            context.addIssue({
+                code: "custom",
+                path: ["examples", index, "split"],
+                message: "Training uses train examples; evaluation uses held-out examples.",
+            });
         for (const key of [`family:${entry.familyKey}`, `input:${entry.inputHash}`]) {
             if (splits.has(key) && splits.get(key) !== entry.split)
-                context.addIssue({ code: "custom", path: ["examples", index], message: "A task family or identical input cannot cross splits." });
+                context.addIssue({
+                    code: "custom",
+                    path: ["examples", index],
+                    message: "A task family or identical input cannot cross splits.",
+                });
             splits.set(key, entry.split);
         }
     }
 });
-export const TaskBatchSchema = TaskBatchContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
-export const LearningPolicyContentSchema = z.object({
+export const TaskBatchSchema = TaskBatchContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const LearningPolicyContentSchema = z
+    .object({
+    origin: TrainingHandoffOriginSchema.optional(),
     schemaVersion: z.literal("openpond.learningPolicy.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -219,44 +384,127 @@ export const LearningPolicyContentSchema = z.object({
     sources: z.array(LearningRevisionRefSchema).min(1).max(100),
     taskDefinition: LearningRevisionRefSchema,
     rewardBinding: LearningRevisionRefSchema,
-    admission: z.object({ mode: z.enum(["human", "qualified_automatic"]), qualification: ImmutableReleaseRefSchema.nullable(), minimumApprovedExamples: z.number().int().positive().max(100_000) }).strict(),
+    admission: z
+        .object({
+        mode: z.enum(["human", "qualified_automatic"]),
+        qualification: ImmutableReleaseRefSchema.nullable(),
+        minimumApprovedExamples: z.number().int().positive().max(100_000),
+    })
+        .strict(),
     trigger: z.discriminatedUnion("kind", [
         z.object({ kind: z.literal("manual") }).strict(),
         z.object({ kind: z.literal("approved_count") }).strict(),
-        z.object({ kind: z.literal("schedule"), intervalSeconds: z.number().int().min(60).max(31_536_000) }).strict(),
+        z
+            .object({
+            kind: z.literal("schedule"),
+            intervalSeconds: z.number().int().min(60).max(31_536_000),
+        })
+            .strict(),
         NightlyScheduleSchema.extend({ kind: z.literal("nightly") }).strict(),
         z.object({ kind: z.literal("upstream_accepted"), modelProjectId: ReleaseIdSchema }).strict(),
     ]),
     trainingParent: ImmutableReleaseRefSchema,
     teacher: ImmutableReleaseRefSchema.nullable(),
-    training: z.object({ method: z.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]), recipe: ImmutableReleaseRefSchema, retentionEvaluation: ImmutableReleaseRefSchema, replayBatches: z.array(ImmutableReleaseRefSchema).max(100) }).strict(),
-    limits: z.object({ maxIterationSpendUsd: z.number().positive().max(100_000), maxDailySpendUsd: z.number().positive().max(1_000_000), cooldownSeconds: z.number().int().nonnegative().max(31_536_000), maxRetries: z.number().int().nonnegative().max(10), maxBatchExamples: z.number().int().positive().max(10_000), maxBacklogExamples: z.number().int().positive().max(1_000_000) }).strict(),
-    automation: z.object({ collect: z.boolean(), train: z.boolean(), accept: z.boolean(), serve: z.boolean() }).strict(),
-    acceptance: z.object({ minimumScore: z.number().min(0).max(1), maximumRetentionRegression: z.number().min(0).max(1), requireImprovement: z.boolean(), rollbackVersion: ImmutableReleaseRefSchema.nullable() }).strict(),
-}).strict().superRefine((policy, context) => {
+    training: z
+        .object({
+        method: z.enum(["sft", "dpo", "grpo", "ppo", "sdft", "opd", "opsd", "sdpo"]),
+        recipe: ImmutableReleaseRefSchema,
+        retentionEvaluation: ImmutableReleaseRefSchema,
+        replayBatches: z.array(ImmutableReleaseRefSchema).max(100),
+    })
+        .strict(),
+    limits: z
+        .object({
+        maxIterationSpendUsd: z.number().positive().max(100_000),
+        maxDailySpendUsd: z.number().positive().max(1_000_000),
+        cooldownSeconds: z.number().int().nonnegative().max(31_536_000),
+        maxRetries: z.number().int().nonnegative().max(10),
+        maxBatchExamples: z.number().int().positive().max(10_000),
+        maxBacklogExamples: z.number().int().positive().max(1_000_000),
+    })
+        .strict(),
+    automation: z
+        .object({ collect: z.boolean(), train: z.boolean(), accept: z.boolean(), serve: z.boolean() })
+        .strict(),
+    acceptance: z
+        .object({
+        minimumScore: z.number().min(0).max(1),
+        maximumRetentionRegression: z.number().min(0).max(1),
+        requireImprovement: z.boolean(),
+        rollbackVersion: ImmutableReleaseRefSchema.nullable(),
+    })
+        .strict(),
+})
+    .strict()
+    .superRefine((policy, context) => {
     if (policy.admission.mode === "qualified_automatic" && !policy.admission.qualification)
-        context.addIssue({ code: "custom", path: ["admission"], message: "Automatic admission requires qualification evidence." });
+        context.addIssue({
+            code: "custom",
+            path: ["admission"],
+            message: "Automatic admission requires qualification evidence.",
+        });
     if (policy.automation.serve && !policy.automation.accept)
-        context.addIssue({ code: "custom", path: ["automation"], message: "Automatic serving requires configured acceptance." });
+        context.addIssue({
+            code: "custom",
+            path: ["automation"],
+            message: "Automatic serving requires configured acceptance.",
+        });
     if (policy.automation.accept && !policy.acceptance.rollbackVersion)
-        context.addIssue({ code: "custom", path: ["acceptance"], message: "Automatic acceptance requires a rollback version." });
-    if (policy.trigger.kind === "upstream_accepted" && policy.trigger.modelProjectId === policy.modelProjectId)
-        context.addIssue({ code: "custom", path: ["trigger"], message: "A model cannot trigger itself through upstream acceptance." });
+        context.addIssue({
+            code: "custom",
+            path: ["acceptance"],
+            message: "Automatic acceptance requires a rollback version.",
+        });
+    if (policy.trigger.kind === "upstream_accepted" &&
+        policy.trigger.modelProjectId === policy.modelProjectId)
+        context.addIssue({
+            code: "custom",
+            path: ["trigger"],
+            message: "A model cannot trigger itself through upstream acceptance.",
+        });
     if (policy.limits.maxBatchExamples < policy.admission.minimumApprovedExamples)
-        context.addIssue({ code: "custom", path: ["limits"], message: "The batch limit must permit the minimum approved example count." });
+        context.addIssue({
+            code: "custom",
+            path: ["limits"],
+            message: "The batch limit must permit the minimum approved example count.",
+        });
     if (policy.limits.maxDailySpendUsd < policy.limits.maxIterationSpendUsd)
-        context.addIssue({ code: "custom", path: ["limits"], message: "Daily spend must permit the iteration budget." });
+        context.addIssue({
+            code: "custom",
+            path: ["limits"],
+            message: "Daily spend must permit the iteration budget.",
+        });
 });
-export const LearningPolicySchema = LearningPolicyContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
-export const LearningAcceptedParentSchema = z.object({
+export const LearningPolicySchema = LearningPolicyContentSchema.safeExtend({
+    contentHash: ReleaseHashSchema,
+}).strict();
+export const LearningAcceptedParentSchema = z
+    .object({
     iterationId: ReleaseIdSchema,
     iterationRevision: z.number().int().positive(),
     candidate: ImmutableReleaseRefSchema,
     decision: LearningRevisionRefSchema,
     decidedAt: ReleaseTimestampSchema,
-}).strict();
-export const LearningIterationStatusSchema = z.enum(["waiting_for_data", "waiting_for_review", "ready", "dispatching", "training", "evaluating", "candidate_ready", "accepted", "rejected", "paused", "failed", "cancelling", "cancelled", "completed_without_candidate"]);
-export const LearningIterationSchema = z.object({
+})
+    .strict();
+export const LearningIterationStatusSchema = z.enum([
+    "waiting_for_data",
+    "waiting_for_review",
+    "ready",
+    "dispatching",
+    "training",
+    "evaluating",
+    "candidate_ready",
+    "accepted",
+    "rejected",
+    "paused",
+    "failed",
+    "cancelling",
+    "cancelled",
+    "completed_without_candidate",
+]);
+export const LearningIterationSchema = z
+    .object({
     schemaVersion: z.literal("openpond.learningIteration.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -277,11 +525,16 @@ export const LearningIterationSchema = z.object({
     dispatchId: ReleaseIdSchema,
     retryCount: z.number().int().nonnegative(),
     spendUsd: z.number().nonnegative(),
-    failure: z.object({ code: ReleaseIdSchema, message: z.string().max(20_000) }).strict().nullable(),
+    failure: z
+        .object({ code: ReleaseIdSchema, message: z.string().max(20_000) })
+        .strict()
+        .nullable(),
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,
-}).strict();
-export const TaskGradeRunSchema = z.object({
+})
+    .strict();
+export const TaskGradeRunSchema = z
+    .object({
     schemaVersion: z.literal("openpond.taskGradeRun.v1"),
     id: ReleaseIdSchema,
     revision: z.number().int().positive(),
@@ -301,13 +554,32 @@ export const TaskGradeRunSchema = z.object({
     failure: z.string().max(20_000).nullable(),
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,
-}).strict();
-export const LearningResourceSchema = z.union([TaskDefinitionSchema, RewardReleaseSchema, RewardBindingSchema, LearningSourceSchema, TaskEvidenceSchema, TaskFeedbackSchema, TaskAdmissionDecisionSchema, TaskBatchSchema, LearningPolicySchema, LearningIterationSchema, TaskGradeRunSchema]);
+})
+    .strict();
+export const LearningResourceSchema = z.union([
+    TaskDefinitionSchema,
+    RewardReleaseSchema,
+    RewardBindingSchema,
+    LearningSourceSchema,
+    TaskEvidenceSchema,
+    TaskFeedbackSchema,
+    TaskAdmissionDecisionSchema,
+    TaskBatchSchema,
+    LearningPolicySchema,
+    LearningIterationSchema,
+    TaskGradeRunSchema,
+]);
 export function learningRef(resource) {
-    return LearningRevisionRefSchema.parse({ id: resource.id, revision: resource.revision, contentHash: resource.contentHash });
+    return LearningRevisionRefSchema.parse({
+        id: resource.id,
+        revision: resource.revision,
+        contentHash: resource.contentHash,
+    });
 }
 export function sameLearningRef(left, right) {
-    return left.id === right.id && left.revision === right.revision && left.contentHash === right.contentHash;
+    return (left.id === right.id &&
+        left.revision === right.revision &&
+        left.contentHash === right.contentHash);
 }
 export function sealLearningContent(content) {
     assertBoundedTaskJson(content, 16_777_216);

package/dist/learning/index.js

@@ -34,3 +34,4 @@ export * from "./policy-inspection.js";
 export * from "./task-queue-inspection.js";
 export * from "./acceptance-plan.js";
 export * from "./acceptance-group.js";
+export { TrainingHandoffOriginSchema } from "./training-handoff.js";

package/dist/learning/reward-authoring.js

@@ -4,6 +4,7 @@ import { RewardAuthoringFieldsSchema, RewardFixtureAuthoringFieldsSchema } from
 import { createLearningTextAsset, verifyLearningTextAsset } from "./assets.js";
 import { LearningJsonObjectSchema } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
+import { HumanFormSchema } from "../human-review/contracts.js";
 export const DEFAULT_REWARD_VERIFIER_SOURCE = `export function verify({ output, expectedOutput }) {
   if (!expectedOutput || !Object.hasOwn(expectedOutput, "answer")) {
     throw new Error("An expected answer is required.");
@@ -25,14 +26,14 @@ export function compileRewardAuthoring(input) {
     if (fields.kind === "custom_verifier") {
         asset = createLearningTextAsset({ text: fields.code, path: "verifier.mjs", mediaType: "application/javascript", visibility: "verifier" });
         implementation = { kind: fields.kind, verifierRef: asset.asset, exportName: fields.exportName, timeoutMs: authoringNumber(fields.timeout, "Time limit"), networkPolicy: "none",
-            ...(base?.implementation.kind === "custom_verifier" && base.implementation.runtime !== undefined ? { runtime: base.implementation.runtime } : {}) };
+            ...((fields.verifierRuntime ?? (base?.implementation.kind === "custom_verifier" ? base.implementation.runtime : undefined)) ? { runtime: fields.verifierRuntime ?? (base?.implementation.kind === "custom_verifier" ? base.implementation.runtime : undefined) } : {}) };
     }
     else if (fields.kind === "model_judge" || fields.kind === "human") {
         if (!fields.rubric.trim())
             throw new LearningDomainError("reward_rubric_required", 422, "Write the rubric before checking or publishing this Reward.");
         asset = createLearningTextAsset({ text: fields.rubric, path: "rubric.md", mediaType: "text/markdown", visibility: "verifier" });
         if (fields.kind === "human")
-            implementation = { kind: fields.kind, rubricRef: asset.asset, reviewerRole: fields.reviewerRole };
+            implementation = { kind: fields.kind, rubricRef: asset.asset, reviewerRole: fields.reviewerRole, form: HumanFormSchema.parse(JSON.parse(fields.humanForm || JSON.stringify({ schemaVersion: "openpond.humanForm.v1", mode: "individual", instructions: fields.rubric, criteria: [{ id: "quality", label: "Quality", instructions: fields.rubric, required: true, allowAbstain: true, kind: "score", minimum: 0, maximum: 1, step: 0.1 }] }))) };
         else {
             const model = { providerId: fields.providerId, modelId: fields.modelId, revision: fields.modelRevision.trim() || null };
             const temperature = authoringNumber(fields.temperature, "Temperature");
@@ -89,6 +90,7 @@ export function rewardAuthoringFields(reward, sourceAsset, fixtureAsset = null)
         schema: JSON.stringify(config.jsonSchema ?? { type: "object", properties: { answer: { type: "string" } }, required: ["answer"] }, null, 2),
         reference: text(config.refIncludes), events: strings(config.requiredEvents).join(", "),
         code: implementation?.kind === "custom_verifier" ? source : DEFAULT_REWARD_VERIFIER_SOURCE,
+        verifierRuntime: implementation?.kind === "custom_verifier" ? implementation.runtime ?? "isolated_javascript" : "isolated_javascript",
         exportName: implementation?.kind === "custom_verifier" ? implementation.exportName ?? "verify" : "verify",
         timeout: String(implementation?.kind === "custom_verifier" ? implementation.timeoutMs : 5_000),
         rubric: implementation?.kind === "model_judge" || implementation?.kind === "human" ? source : "",
@@ -97,6 +99,7 @@ export function rewardAuthoringFields(reward, sourceAsset, fixtureAsset = null)
         modelRevision: implementation?.kind === "model_judge" ? implementation.model?.revision ?? "" : "",
         temperature: String(implementation?.kind === "model_judge" ? implementation.temperature ?? 0 : 0),
         reviewerRole: implementation?.kind === "human" ? implementation.reviewerRole : "Subject matter reviewer",
+        humanForm: implementation?.kind === "human" && implementation.form ? JSON.stringify(implementation.form, null, 2) : "",
         learnedId: implementation?.kind === "learned_model" ? implementation.modelVersion.id : "",
         learnedHash: implementation?.kind === "learned_model" ? implementation.modelVersion.contentHash : "",
         inputContract: implementation?.kind === "learned_model" ? source : "{}",