@openpond/evals 0.6.0 → 0.7.0

package/dist/javascript-verifier-worker.js

@@ -0,0 +1,6 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { executeJavaScriptVerifier } from "./javascript-verifier.js";
+// Only this trusted host program runs in Node. Authored source is interpreter data.
+if (!parentPort)
+    throw new Error("Verifier worker requires its execution owner.");
+void executeJavaScriptVerifier(workerData).then((result) => parentPort.postMessage({ ok: true, result }), (error) => parentPort.postMessage({ ok: false, error: error instanceof Error ? error.message : "Verifier execution failed." })).finally(() => parentPort.close());

package/dist/javascript-verifier.js

@@ -0,0 +1,64 @@
+import { newQuickJSWASMModuleFromVariant, Scope } from "quickjs-emscripten-core";
+import variant from "@jitl/quickjs-singlefile-cjs-release-sync";
+import { assertBoundedTaskJson } from "./task-schema.js";
+import { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
+export { JavaScriptVerifierResultSchema } from "./javascript-verifier-contract.js";
+/**
+ * A fresh WebAssembly interpreter with no host functions, filesystem, network,
+ * timers, or module loader. Hosts should run this on a worker to remain responsive
+ * and terminate that worker when cancellation is requested.
+ */
+export async function executeJavaScriptVerifier(input) {
+    if (!Number.isInteger(input.timeoutMs) || input.timeoutMs < 1 || input.timeoutMs > 300_000)
+        throw new Error("verifier_timeout_invalid");
+    if (new TextEncoder().encode(input.source).byteLength > 524_288)
+        throw new Error("verifier_source_too_large");
+    assertBoundedTaskJson(input.value, 4_194_304);
+    input.signal?.throwIfAborted();
+    const deadline = Date.now() + input.timeoutMs;
+    const module = await newQuickJSWASMModuleFromVariant(variant);
+    input.signal?.throwIfAborted();
+    return Scope.withScope((scope) => {
+        const runtime = scope.manage(module.newRuntime());
+        runtime.setMemoryLimit(33_554_432);
+        runtime.setMaxStackSize(262_144);
+        runtime.setInterruptHandler(() => Date.now() >= deadline || input.signal?.aborted === true);
+        const context = scope.manage(runtime.newContext());
+        const stringify = scope.manage(context.unwrapResult(context.evalCode("JSON.stringify")));
+        const argument = scope.manage(context.unwrapResult(context.evalCode(`JSON.parse(${JSON.stringify(JSON.stringify(input.value))})`)));
+        const exported = scope.manage(context.unwrapResult(context.evalCode(input.source, "verifier.mjs", { type: "module" })));
+        const namespace = scope.manage(settle(context, exported, deadline, input.signal));
+        const fn = scope.manage(context.getProp(namespace, input.exportName ?? "verify"));
+        if (context.typeof(fn) !== "function")
+            throw new Error("verifier_function_export_missing");
+        const returned = scope.manage(context.unwrapResult(context.callFunction(fn, context.undefined, argument)));
+        const result = scope.manage(settle(context, returned, deadline, input.signal));
+        const serialized = scope.manage(context.unwrapResult(context.callFunction(stringify, context.undefined, result)));
+        if (context.typeof(serialized) !== "string")
+            throw new Error("verifier_result_not_json");
+        const json = context.getString(serialized);
+        if (new TextEncoder().encode(json).byteLength > 65_536)
+            throw new Error("verifier_result_too_large");
+        input.signal?.throwIfAborted();
+        if (Date.now() >= deadline)
+            throw new Error("verifier_timeout");
+        const value = JSON.parse(json);
+        assertBoundedTaskJson(value, 65_536);
+        return JavaScriptVerifierResultSchema.parse(value);
+    });
+}
+function settle(context, handle, deadline, signal) {
+    for (;;) {
+        signal?.throwIfAborted();
+        if (Date.now() >= deadline)
+            throw new Error("verifier_timeout");
+        const state = context.getPromiseState(handle);
+        if (state.type === "fulfilled")
+            return state.notAPromise ? state.value.dup() : state.value;
+        if (state.type === "rejected")
+            return context.unwrapResult(state);
+        const jobs = context.runtime.executePendingJobs(1);
+        if (jobs.unwrap() === 0)
+            throw new Error("verifier_unresolved_promise");
+    }
+}

package/dist/learning/admission.js

@@ -0,0 +1,209 @@
+import { LearningDomainError } from "./errors.js";
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { compileBoundGraders, resolveBoundRewards, RewardBindingSchema, RewardReleaseSchema } from "../rewards.js";
+import { TaskRecordSchema, TasksetReleaseContentSchema, TasksetReleaseSchema } from "../tasksets.js";
+import { assertBoundedTaskJson, validateTaskValue } from "../task-schema.js";
+import { assertLearningContentHash, LearningJsonObjectSchema, learningRef, LearningRevisionRefSchema, LearningSourceSchema, sameLearningRef, sealLearningContent, TaskAdmissionDecisionSchema, TaskBatchContentSchema, TaskBatchSchema, TaskDefinitionSchema, TaskEvidenceSchema, TaskExampleSubmissionSchema } from "./contracts.js";
+export function inspectTaskEvidence(evidence, definition) {
+    assertLearningContentHash(TaskEvidenceSchema.parse(evidence));
+    assertLearningContentHash(TaskDefinitionSchema.parse(definition));
+    const example = evidence.submission;
+    const issues = [];
+    if (!sameLearningRef(example.taskDefinition, learningRef(definition)))
+        issues.push({ path: "/taskDefinition", code: "definition_mismatch", message: "Evidence must pin this exact task definition." });
+    const input = validateTaskValue(definition.inputSchema, example.input);
+    issues.push(...input.issues.map((issue) => ({ ...issue, path: `/input${issue.path}` })));
+    if (example.expected !== null) {
+        const expected = validateTaskValue(definition.outputSchema, example.expected);
+        issues.push(...expected.issues.map((issue) => ({ ...issue, path: `/expected${issue.path}` })));
+    }
+    const evidenceValidity = issues.length ? "invalid" : "valid";
+    if (!example.familyKey)
+        issues.push({ path: "/familyKey", code: "family_unresolved", message: "Resolve the source family before admitting this task." });
+    return { evidenceValidity, taskReady: issues.length === 0, observedOutputValid: example.observedOutput === null ? null : validateTaskValue(definition.outputSchema, example.observedOutput).valid, issues };
+}
+export function validateSourceSubmission(sourceInput, submissionInput) {
+    const source = LearningSourceSchema.parse(sourceInput);
+    assertLearningContentHash(source);
+    assertBoundedTaskJson(submissionInput);
+    const submission = TaskExampleSubmissionSchema.parse(submissionInput);
+    if (!source.enabled)
+        throw new LearningDomainError("learning_source_disabled", 409);
+    if (source.id !== submission.sourceId || !sameLearningRef(source.taskDefinition, submission.taskDefinition))
+        throw new LearningDomainError("learning_source_definition_mismatch", 422);
+    if (!source.allowedSplits.includes(submission.split))
+        throw new LearningDomainError("learning_source_split_not_allowed", 422);
+    const mappingHash = source.mapping ? contentHash(source.mapping) : null;
+    if (mappingHash !== submission.provenance.mappingHash)
+        throw new LearningDomainError("learning_source_mapping_mismatch", 422);
+    return submission;
+}
+export function mapTaskSourceRecord(input) {
+    assertBoundedTaskJson(input.record);
+    const source = LearningSourceSchema.parse(input.source);
+    assertLearningContentHash(source);
+    if (!source.mapping)
+        throw new LearningDomainError("learning_source_mapping_required", 422);
+    const mapping = source.mapping;
+    const fields = ["exampleId", "attemptId", "occurredAt", "input", "familyKey"];
+    const values = Object.fromEntries(fields.map((field) => [field, readTaskJsonPointer(input.record, mapping[field])]));
+    const missing = fields.filter((field) => values[field] === undefined || values[field] === null).map(String);
+    if (missing.length)
+        return { status: "pending", missing };
+    const example = TaskExampleSubmissionSchema.parse({
+        schemaVersion: "openpond.taskExample.v1", sourceId: source.id, idempotencyKey: input.idempotencyKey,
+        taskDefinition: source.taskDefinition, ...values, split: mapping.split,
+        observedOutput: mapping.observedOutput === null ? null : readTaskJsonPointer(input.record, mapping.observedOutput) ?? null,
+        expected: mapping.expected === null ? null : readTaskJsonPointer(input.record, mapping.expected) ?? null,
+        evaluatorContext: mapping.evaluatorContext === null ? null : readTaskJsonPointer(input.record, mapping.evaluatorContext) ?? null,
+        assets: [], provenance: { sourceRecordRef: null, mappingHash: contentHash(mapping) },
+    });
+    return { status: "mapped", example: validateSourceSubmission(source, example) };
+}
+export function readTaskJsonPointer(value, pointer) {
+    if (pointer === "")
+        return value;
+    if (!pointer.startsWith("/") || /~(?![01])/u.test(pointer))
+        throw new LearningDomainError("task_json_pointer_invalid", 422);
+    let current = value;
+    for (const part of pointer.slice(1).split("/")) {
+        const key = part.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!current || typeof current !== "object" || !Object.hasOwn(current, key))
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+export function taskRecordFromEvidence(evidence, definition) {
+    const inspection = inspectTaskEvidence(evidence, definition);
+    if (!inspection.taskReady)
+        throw new LearningDomainError("task_evidence_not_ready", 422, inspection.issues[0].code);
+    return TaskRecordSchema.parse({
+        id: evidence.id, clusterKey: evidence.submission.familyKey, split: evidence.submission.split,
+        input: evidence.submission.input, expectedOutput: evidence.submission.expected,
+        policyVisibleContext: { instructions: definition.instructions },
+        privilegedContextRef: evidence.submission.evaluatorContext === null ? null : `task-evidence:${evidence.contentHash}`,
+        artifactRefs: evidence.submission.assets, tags: [definition.category],
+    });
+}
+export function taskAttemptEvidence(evidence, output) {
+    return { output, runtimeEventRefs: [], artifactRefs: evidence.submission.assets.map((asset) => asset.id) };
+}
+export function assertAdmissionDecision(input) {
+    const decision = TaskAdmissionDecisionSchema.parse(input.decision);
+    assertLearningContentHash(decision);
+    if (!sameLearningRef(decision.evidence, learningRef(input.evidence)))
+        throw new LearningDomainError("task_admission_evidence_mismatch", 422);
+    const inspection = inspectTaskEvidence(input.evidence, input.definition);
+    if (!inspection.taskReady || decision.evidenceValidity !== "valid" || decision.taskAdmissibility !== "approved")
+        throw new LearningDomainError("task_admission_not_approved", 422);
+    if (input.purpose === "supervised_training") {
+        if (decision.targetApproval !== "approved" || decision.approvedTarget === null)
+            throw new LearningDomainError("supervised_target_not_approved", 422);
+        if (!validateTaskValue(input.definition.outputSchema, decision.approvedTarget).valid)
+            throw new LearningDomainError("supervised_target_schema_invalid", 422);
+        if (!decision.targetGrade)
+            throw new LearningDomainError("supervised_target_grade_required", 422);
+        assertGradeIdentity(decision.targetGrade, input.evidence, input.definition, decision.approvedTarget);
+        const scores = [decision.targetGrade.training, decision.targetGrade.evaluation].filter((score) => score.status !== "not_configured");
+        if (!scores.length || scores.some((score) => score.status !== "scored" || score.passed !== true))
+            throw new LearningDomainError("supervised_target_checks_not_passed", 422);
+    }
+    if (decision.grade) {
+        if (!input.evidence.submission.observedOutput)
+            throw new LearningDomainError("observed_grade_without_output", 422);
+        assertGradeIdentity(decision.grade, input.evidence, input.definition, input.evidence.submission.observedOutput);
+    }
+}
+export function assertGradeIdentity(grade, evidence, definition, output) {
+    assertLearningContentHash(grade);
+    if (!sameLearningRef(grade.binding, definition.rewardBinding) || grade.taskHash !== contentHash(taskRecordFromEvidence(evidence, definition)) || grade.outputHash !== contentHash(taskAttemptEvidence(evidence, output)))
+        throw new LearningDomainError("task_grade_identity_mismatch", 422);
+}
+export function taskFamilyReservations(evidence, definition) {
+    if (!evidence.submission.familyKey)
+        throw new LearningDomainError("task_family_unresolved", 422);
+    return [
+        { namespace: definition.familyNamespace, kind: "family", key: evidence.submission.familyKey, split: evidence.submission.split },
+        { namespace: definition.familyNamespace, kind: "input", key: contentHash(evidence.submission.input), split: evidence.submission.split },
+    ];
+}
+export function sealTaskBatch(input) {
+    const definition = TaskDefinitionSchema.parse(input.definition);
+    assertLearningContentHash(definition);
+    if (!sameLearningRef(definition.rewardBinding, learningRef(input.binding)))
+        throw new LearningDomainError("task_definition_reward_binding_mismatch", 422);
+    resolveBoundRewards(input.binding, input.rewards);
+    if (input.purpose === "reward_training" && !input.binding.sources.some((source) => source.role === "training" && source.weight > 0))
+        throw new LearningDomainError("training_reward_not_configured", 422);
+    if (!input.evidence.length || new Set(input.evidence.map((evidence) => evidence.id)).size !== input.evidence.length)
+        throw new LearningDomainError("task_batch_evidence_set_invalid", 422);
+    const splits = new Map(input.priorSplits.map((reservation) => [contentHash([reservation.namespace, reservation.kind, reservation.key]), reservation.split]));
+    const examples = input.evidence.map((evidence) => {
+        const decision = input.decisions.find((candidate) => sameLearningRef(candidate.evidence, learningRef(evidence)));
+        if (!decision)
+            throw new LearningDomainError("task_admission_missing", 422, evidence.id);
+        assertAdmissionDecision({ decision, evidence, definition, purpose: input.purpose });
+        if ((input.purpose === "evaluation") === (evidence.submission.split === "train"))
+            throw new LearningDomainError("task_batch_split_not_allowed", 422);
+        for (const reservation of taskFamilyReservations(evidence, definition)) {
+            const key = contentHash([reservation.namespace, reservation.kind, reservation.key]);
+            const prior = splits.get(key);
+            if (prior !== undefined && prior !== reservation.split)
+                throw new LearningDomainError("task_family_split_contamination", 409);
+            splits.set(key, reservation.split);
+        }
+        return { evidence: learningRef(evidence), decision: learningRef(decision), familyKey: evidence.submission.familyKey, inputHash: contentHash(evidence.submission.input), split: evidence.submission.split };
+    });
+    const content = TaskBatchContentSchema.parse({ schemaVersion: "openpond.taskBatch.v1", id: input.id, revision: 1, taskDefinition: learningRef(definition), rewardBinding: learningRef(input.binding), purpose: input.purpose, examples, sealedAt: input.now, sealedBy: input.actorId });
+    return TaskBatchSchema.parse(sealLearningContent(content));
+}
+export const TaskBatchPackageMetadataSchema = z.object({
+    schemaVersion: z.literal("openpond.taskBatchPackage.v1"),
+    batch: LearningRevisionRefSchema,
+    definition: TaskDefinitionSchema,
+    binding: RewardBindingSchema,
+    rewards: z.array(RewardReleaseSchema).min(1).max(100),
+    admissions: z.array(z.object({ taskId: z.string(), evidence: LearningRevisionRefSchema, decision: LearningRevisionRefSchema, supervisedTarget: LearningJsonObjectSchema.nullable() }).strict()).min(1).max(10_000),
+}).strict();
+export function compileTaskBatch(input) {
+    assertLearningContentHash(TaskBatchSchema.parse(input.batch));
+    assertLearningContentHash(TaskDefinitionSchema.parse(input.definition));
+    if (!sameLearningRef(input.definition.rewardBinding, learningRef(input.binding)))
+        throw new LearningDomainError("task_definition_reward_binding_mismatch", 422);
+    if (!sameLearningRef(input.batch.taskDefinition, learningRef(input.definition)) || !sameLearningRef(input.batch.rewardBinding, learningRef(input.binding)))
+        throw new LearningDomainError("task_batch_release_mismatch", 422);
+    const tasks = [];
+    const admissions = [];
+    for (const entry of input.batch.examples) {
+        const evidence = input.evidence.find((candidate) => sameLearningRef(learningRef(candidate), entry.evidence));
+        const decision = input.decisions.find((candidate) => sameLearningRef(learningRef(candidate), entry.decision));
+        if (!evidence || !decision)
+            throw new LearningDomainError("task_batch_admission_revision_missing", 422);
+        assertAdmissionDecision({ decision, evidence, definition: input.definition, purpose: input.batch.purpose });
+        if (entry.familyKey !== evidence.submission.familyKey || entry.inputHash !== contentHash(evidence.submission.input) || entry.split !== evidence.submission.split)
+            throw new LearningDomainError("task_batch_evidence_snapshot_mismatch", 422);
+        tasks.push(taskRecordFromEvidence(evidence, input.definition));
+        admissions.push({ taskId: evidence.id, evidence: entry.evidence, decision: entry.decision, supervisedTarget: input.batch.purpose === "supervised_training" ? decision.approvedTarget : null });
+    }
+    const learning = TaskBatchPackageMetadataSchema.parse({ schemaVersion: "openpond.taskBatchPackage.v1", batch: learningRef(input.batch), definition: input.definition, binding: input.binding, rewards: input.rewards, admissions });
+    const content = TasksetReleaseContentSchema.parse({
+        schemaVersion: "openpond.tasksetRelease.v2", id: `task-batch-${input.batch.id}`, revision: 1,
+        ...input.definition.execution, tasks, graders: compileBoundGraders(input.binding, input.rewards),
+        metadata: { learning },
+    });
+    return TasksetReleaseSchema.parse(sealLearningContent(content));
+}
+export function taskBatchPackageMetadata(release) {
+    assertLearningContentHash(TasksetReleaseSchema.parse(release));
+    const metadata = TaskBatchPackageMetadataSchema.parse(release.metadata.learning);
+    assertLearningContentHash(metadata.definition);
+    if (!sameLearningRef(metadata.definition.rewardBinding, learningRef(metadata.binding)))
+        throw new LearningDomainError("task_definition_reward_binding_mismatch", 422);
+    if (contentHash(release.graders) !== contentHash(compileBoundGraders(metadata.binding, metadata.rewards)))
+        throw new LearningDomainError("taskset_reward_snapshot_mismatch", 422);
+    if (metadata.admissions.length !== release.tasks.length || new Set(metadata.admissions.map((entry) => entry.taskId)).size !== release.tasks.length || metadata.admissions.some((entry) => !release.tasks.some((task) => task.id === entry.taskId)))
+        throw new LearningDomainError("taskset_admission_inventory_mismatch", 422);
+    return metadata;
+}

package/dist/learning/assets.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { ImmutableAssetRefSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash, sha256 } from "@openpond/harness";
+import { assertBoundedTaskJson } from "../task-schema.js";
+import { LearningDomainError } from "./errors.js";
+/** Small authored source files. Large binary evidence uses the host asset API. */
+export const LearningTextAssetContentSchema = z.object({
+    schemaVersion: z.literal("openpond.learningTextAsset.v1"),
+    id: ReleaseIdSchema,
+    revision: z.literal(1),
+    asset: ImmutableAssetRefSchema,
+    text: z.string().max(524_288),
+}).strict().superRefine((value, context) => {
+    if (value.asset.id !== value.id)
+        context.addIssue({ code: "custom", path: ["asset", "id"], message: "Asset identity must match the stored resource." });
+    if (value.asset.sizeBytes !== new TextEncoder().encode(value.text).byteLength || value.asset.sizeBytes > 524_288)
+        context.addIssue({ code: "custom", path: ["asset", "sizeBytes"], message: "Authored source must match its byte count and fit within 512 KiB." });
+    if (value.asset.contentHash !== sha256(value.text))
+        context.addIssue({ code: "custom", path: ["asset", "contentHash"], message: "Asset source does not match its SHA-256." });
+});
+export const LearningTextAssetSchema = LearningTextAssetContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export function createLearningTextAsset(input) {
+    assertBoundedTaskJson(input);
+    const { text, ...attributes } = input;
+    const hash = sha256(text);
+    const id = `asset-${hash}-${contentHash(attributes).slice(0, 16)}`;
+    const content = LearningTextAssetContentSchema.parse({
+        schemaVersion: "openpond.learningTextAsset.v1", id, revision: 1,
+        asset: { ...attributes, id, contentHash: hash, sizeBytes: new TextEncoder().encode(text).byteLength }, text,
+    });
+    return LearningTextAssetSchema.parse({ ...content, contentHash: contentHash(content) });
+}
+export function verifyLearningTextAsset(asset, reference) {
+    const { contentHash: hash, ...content } = LearningTextAssetSchema.parse(asset);
+    if (contentHash(content) !== hash || contentHash(content.asset) !== contentHash(reference))
+        throw new LearningDomainError("learning_asset_reference_mismatch", 409);
+    return content.text;
+}

package/dist/learning/contracts.js

@@ -0,0 +1,267 @@
+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 { TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
+import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.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({
+    schemaVersion: z.literal("openpond.taskDefinition.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    name: z.string().trim().min(1).max(500),
+    description: z.string().max(10_000),
+    instructions: z.string().trim().min(1).max(20_000),
+    category: z.enum(["structured", "question_answering", "coding", "tool_workflow", "custom"]),
+    familyNamespace: ReleaseIdSchema,
+    inputSchema: z.record(z.string(), z.unknown()),
+    outputSchema: z.record(z.string(), z.unknown()),
+    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) => {
+    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." });
+        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." });
+});
+export const TaskDefinitionSchema = TaskDefinitionContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const TaskSourceMappingSchema = z.object({
+    schemaVersion: z.literal("openpond.taskSourceMapping.v1"),
+    exampleId: LearningJsonPointerSchema,
+    attemptId: LearningJsonPointerSchema,
+    occurredAt: LearningJsonPointerSchema,
+    input: LearningJsonPointerSchema,
+    observedOutput: LearningJsonPointerSchema.nullable(),
+    expected: LearningJsonPointerSchema.nullable(),
+    evaluatorContext: LearningJsonPointerSchema.nullable(),
+    familyKey: LearningJsonPointerSchema,
+    split: TaskSplitSchema,
+}).strict();
+export const LearningSourceContentSchema = z.object({
+    schemaVersion: z.literal("openpond.learningSource.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    name: z.string().trim().min(1).max(500),
+    kind: z.enum(["direct", "benchmark", "work", "opentelemetry", "provider"]),
+    taskDefinition: LearningRevisionRefSchema,
+    enabled: z.boolean(),
+    allowedSplits: z.array(TaskSplitSchema).min(1).max(4),
+    mapping: TaskSourceMappingSchema.nullable(),
+    adapterVersion: z.string().trim().min(1).max(200).nullable(),
+}).strict().superRefine((source, context) => {
+    if (source.kind !== "direct" && !source.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." });
+    if (["opentelemetry", "provider"].includes(source.kind) && !source.adapterVersion)
+        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({
+    schemaVersion: z.literal("openpond.taskExample.v1"),
+    sourceId: ReleaseIdSchema,
+    idempotencyKey: ReleaseIdSchema,
+    taskDefinition: LearningRevisionRefSchema,
+    exampleId: ReleaseIdSchema,
+    attemptId: ReleaseIdSchema,
+    occurredAt: ReleaseTimestampSchema,
+    familyKey: ReleaseIdSchema.nullable(),
+    split: TaskSplitSchema,
+    input: LearningJsonObjectSchema,
+    observedOutput: LearningJsonObjectSchema.nullable(),
+    expected: LearningJsonObjectSchema.nullable(),
+    evaluatorContext: LearningJsonObjectSchema.nullable(),
+    assets: z.array(ImmutableAssetRefSchema).max(1_000),
+    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(),
+    source: LearningRevisionRefSchema,
+    submission: TaskExampleSubmissionSchema,
+    supersedes: LearningRevisionRefSchema.nullable(),
+    correctionFeedbackId: ReleaseIdSchema.nullable(),
+    receivedAt: ReleaseTimestampSchema,
+}).strict();
+export const TaskEvidenceSchema = TaskEvidenceContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
+export const TaskFeedbackSubmissionSchema = z.object({
+    schemaVersion: z.literal("openpond.taskFeedback.v1"),
+    sourceId: ReleaseIdSchema,
+    idempotencyKey: ReleaseIdSchema,
+    exampleId: ReleaseIdSchema,
+    attemptId: ReleaseIdSchema,
+    expectedEvidenceHash: ReleaseHashSchema.nullable(),
+    occurredAt: ReleaseTimestampSchema,
+    kind: z.enum(["outcome", "target_correction", "ground_truth_correction", "input_correction", "family_resolution"]),
+    value: LearningJsonObjectSchema,
+    note: z.string().max(20_000),
+}).strict();
+export const TaskFeedbackSchema = z.object({
+    schemaVersion: z.literal("openpond.taskFeedbackRecord.v1"),
+    id: ReleaseIdSchema,
+    submission: TaskFeedbackSubmissionSchema,
+    status: z.enum(["pending_example", "pending_review", "applied", "superseded", "rejected"]),
+    evidence: LearningRevisionRefSchema.nullable(),
+    createdAt: ReleaseTimestampSchema,
+    revision: z.number().int().positive(),
+    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(),
+    evidenceValidity: z.enum(["valid", "invalid", "pending"]),
+    taskAdmissibility: z.enum(["approved", "rejected", "pending"]),
+    observedQuality: z.enum(["passed", "failed", "unscored", "unavailable"]),
+    targetApproval: z.enum(["approved", "rejected", "pending", "not_required"]),
+    approvedTarget: LearningJsonObjectSchema.nullable(),
+    grade: RewardCompositionSchema.nullable(),
+    targetGrade: RewardCompositionSchema.nullable(),
+    note: z.string().max(20_000),
+    decidedAt: ReleaseTimestampSchema,
+}).strict().superRefine((decision, context) => {
+    if (decision.targetApproval === "approved" && decision.approvedTarget === null)
+        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." });
+    if (decision.actor.kind === "qualified_policy" && !decision.actor.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." });
+});
+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),
+    sealedAt: ReleaseTimestampSchema,
+    sealedBy: ReleaseIdSchema,
+}).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." });
+    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." });
+        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." });
+            splits.set(key, entry.split);
+        }
+    }
+});
+export const TaskBatchSchema = TaskBatchContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const LearningPolicyContentSchema = z.object({
+    schemaVersion: z.literal("openpond.learningPolicy.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    modelProjectId: ReleaseIdSchema,
+    executionOwner: z.enum(["local", "hosted"]),
+    enabled: z.boolean(),
+    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(),
+    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("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) => {
+    if (policy.admission.mode === "qualified_automatic" && !policy.admission.qualification)
+        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." });
+    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." });
+    if (policy.limits.maxBatchExamples < policy.admission.minimumApprovedExamples)
+        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." });
+});
+export const LearningPolicySchema = LearningPolicyContentSchema.safeExtend({ contentHash: ReleaseHashSchema }).strict();
+export const LearningIterationStatusSchema = z.enum(["waiting_for_data", "waiting_for_review", "ready", "training", "evaluating", "candidate_ready", "accepted", "rejected", "paused", "failed", "cancelling", "cancelled"]);
+export const LearningIterationSchema = z.object({
+    schemaVersion: z.literal("openpond.learningIteration.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    policy: LearningRevisionRefSchema,
+    status: LearningIterationStatusSchema,
+    triggerIdentity: ReleaseIdSchema,
+    batch: LearningRevisionRefSchema.nullable(),
+    sourceWatermarks: z.record(ReleaseIdSchema, z.number().int().nonnegative()),
+    trainingParent: ImmutableReleaseRefSchema,
+    teacher: ImmutableReleaseRefSchema.nullable(),
+    upstreamEvent: ImmutableReleaseRefSchema.nullable(),
+    trainingJob: ImmutableReleaseRefSchema.nullable(),
+    evaluationJob: ImmutableReleaseRefSchema.nullable(),
+    candidateVersion: ImmutableReleaseRefSchema.nullable(),
+    dispatchId: ReleaseIdSchema,
+    retryCount: z.number().int().nonnegative(),
+    spendUsd: z.number().nonnegative(),
+    failure: z.object({ code: ReleaseIdSchema, message: z.string().max(20_000) }).strict().nullable(),
+    createdAt: ReleaseTimestampSchema,
+    updatedAt: ReleaseTimestampSchema,
+}).strict();
+export const TaskGradeRunSchema = z.object({
+    schemaVersion: z.literal("openpond.taskGradeRun.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    evidence: LearningRevisionRefSchema,
+    binding: LearningRevisionRefSchema,
+    target: z.enum(["observed", "proposed_target"]),
+    output: LearningJsonObjectSchema,
+    status: z.enum(["queued", "running", "completed", "failed", "cancelling", "cancelled"]),
+    composition: RewardCompositionSchema.nullable(),
+    leaseOwner: ReleaseIdSchema.nullable(),
+    leaseExpiresAt: ReleaseTimestampSchema.nullable(),
+    attemptCount: z.number().int().nonnegative(),
+    timeoutMs: z.number().int().min(100).max(300_000),
+    maximumSpendUsd: z.number().nonnegative().max(1_000),
+    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]);
+export function learningRef(resource) {
+    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;
+}
+export function sealLearningContent(content) {
+    assertBoundedTaskJson(content, 16_777_216);
+    return { ...content, contentHash: contentHash(content) };
+}
+export function assertLearningContentHash(resource) {
+    const { contentHash: hash, ...content } = resource;
+    assertBoundedTaskJson(content, 16_777_216);
+    if (contentHash(content) !== hash)
+        throw new LearningDomainError("learning_content_hash_mismatch", 422);
+}

package/dist/learning/errors.js

@@ -0,0 +1,12 @@
+/** Stable domain failures that hosts may expose without treating rejected work
+ * as an infrastructure failure. Unexpected exceptions remain server errors. */
+export class LearningDomainError extends Error {
+    code;
+    status;
+    constructor(code, status = 422, description) {
+        super(description ? `${code}: ${description}` : code);
+        this.code = code;
+        this.status = status;
+        this.name = "LearningDomainError";
+    }
+}