@openpond/evals 0.10.7 → 0.10.9

package/LEARNING.md

@@ -28,6 +28,32 @@ and approval operations still validate their authoritative inputs independently.
 
 ## Data flow
 
+### File and agent-history intake
+
+`previewTaskIntake({ format, files })` validates JSON, JSONL, CSV, Hermes native
+session JSONL, or an OpenClaw trajectory folder. Each file has a relative `path`
+and its UTF-8 `text`. Previews report invalid rows separately and retain stable
+source, attempt, family and split identities. Treat imported labels as source
+metadata until a reviewer creates authenticated feedback.
+
+For recorded attempts, submit `import_intake` with the same files and format,
+`expectedPreviewHash`, a collection `name`, and up to 90 selected `recordIds`.
+The owner reparses the files, verifies the preview hash, retains source text in
+private assets and deduplicates retries. Source-producer credentials cannot use
+this workspace import operation. Inputs are limited to 100 files, 5 MiB and
+1,000 preview records; callers can submit selection chunks with stable operation
+IDs. Histories remain in Labeling with unresolved context requirements, and an
+empty Reward binding reports `not_configured`. They cannot be admitted or sealed
+for training until their context and Reward configuration are resolved.
+
+Plain task records can be added to a draft with
+`appendTaskIntake(draft, preview, recordIds)` from `openpond-sdk/taskset-drafts`.
+This preserves private references and source metadata, rejects attempts and
+unresolved histories, and rejects cross-split family or identical-input overlap.
+Repeating identical tasks is idempotent; imports never overwrite edited tasks.
+
+### Reviewed task lifecycle
+
 1. Publish a Reward, then a binding, task definition and source. Use
    `publish_resources` to publish dependent resources atomically. Pin an existing
    release by `{ id, revision, contentHash }`; edits create the next revision with

package/dist/learning/admission.js

@@ -19,6 +19,8 @@ export function inspectTaskEvidence(evidence, definition) {
         issues.push(...expected.issues.map((issue) => ({ ...issue, path: `/expected${issue.path}` })));
     }
     const evidenceValidity = issues.length ? "invalid" : "valid";
+    for (const requirement of definition.contextRequirements ?? [])
+        issues.push({ path: "/taskDefinition/contextRequirements", code: "context_required", message: requirement });
     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 };
@@ -133,6 +135,8 @@ export function taskFamilyReservations(evidence, definition) {
 export function sealTaskBatch(input) {
     const definition = TaskDefinitionSchema.parse(input.definition);
     assertLearningContentHash(definition);
+    if (definition.contextRequirements?.length)
+        throw new LearningDomainError("task_context_not_configured", 422, definition.contextRequirements.join(" "));
     if (!sameLearningRef(definition.rewardBinding, learningRef(input.binding)))
         throw new LearningDomainError("task_definition_reward_binding_mismatch", 422);
     resolveBoundRewards(input.binding, input.rewards);

package/dist/learning/authoring-service.js

@@ -2,7 +2,7 @@ import { assertBoundedTaskJson } from "../task-schema.js";
 import { AuthoringDraftSchema } from "./authoring.js";
 import { LearningDomainError } from "./errors.js";
 import { learningRef, sameLearningRef, sealLearningContent } from "./contracts.js";
-import { requireLearningRelease } from "./repository.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
 export async function saveAuthoringDraft(tx, input, now) {
     // A 100-record page remains below the common 16 MiB response limit.
     assertBoundedTaskJson(input.draft, 131_072);
@@ -14,6 +14,16 @@ export async function saveAuthoringDraft(tx, input, now) {
             throw new LearningDomainError("authoring_draft_base_mismatch", 422);
         await requireLearningRelease(tx, input.draft.targetKind, input.draft.baseRelease);
     }
+    if (input.draft.targetKind === "reward")
+        for (const fixture of input.draft.fields.fixtures ?? []) {
+            if (!fixture.sourceLabel)
+                continue;
+            const { evidence, feedback } = fixture.sourceLabel;
+            await requireLearningRelease(tx, "evidence", evidence);
+            const label = await requireLearningResource(tx, "feedback", feedback.id, feedback.revision);
+            if (!label.evidence || !sameLearningRef(label.evidence, evidence))
+                throw new LearningDomainError("reward_fixture_label_mismatch", 422);
+        }
     const draft = AuthoringDraftSchema.parse(sealLearningContent({ ...input.draft, schemaVersion: "openpond.authoringDraft.v1", revision: input.expectedRevision + 1, status: "draft", publishedRelease: null, createdAt: previous?.createdAt ?? now, updatedAt: now }));
     await tx.put("draft", draft, input.expectedRevision, { parentId: draft.targetKind, status: draft.status });
     return { kind: "draft", id: draft.id, revision: draft.revision };

package/dist/learning/authoring.js

@@ -10,6 +10,7 @@ export const RewardFixtureAuthoringFieldsSchema = z.object({
     infrastructureError: z.string().max(20_000),
     expectedStatus: z.enum(["scored", "pending", "unavailable", "failed"]),
     minimumScore: z.string(), maximumScore: z.string(), expectedPassed: z.enum(["true", "false", "any"]),
+    sourceLabel: z.object({ evidence: LearningRevisionRefSchema, feedback: z.object({ id: ReleaseIdSchema, revision: z.number().int().positive() }).strict() }).strict().optional(),
 }).strict();
 export const RewardAuthoringFieldsSchema = z.object({
     name: z.string().max(500), description: z.string().max(10_000),

package/dist/learning/contracts.js

@@ -19,6 +19,7 @@ export const TaskDefinitionContentSchema = z.object({
     inputSchema: z.record(z.string(), z.unknown()),
     outputSchema: z.record(z.string(), z.unknown()),
     requiredOutputs: TaskRecordSchema.shape.requiredOutputs,
+    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(),
@@ -105,6 +106,20 @@ export const TaskEvidenceContentSchema = z.object({
     receivedAt: ReleaseTimestampSchema,
 }).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({
+    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) => {
+    if (rating.scale.minimum >= rating.scale.maximum)
+        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." });
+});
 export const TaskFeedbackSubmissionSchema = z.object({
     schemaVersion: z.literal("openpond.taskFeedback.v1"),
     sourceId: ReleaseIdSchema,
@@ -116,7 +131,18 @@ export const TaskFeedbackSubmissionSchema = z.object({
     kind: z.enum(["outcome", "target_correction", "ground_truth_correction", "input_correction", "family_resolution"]),
     value: LearningJsonObjectSchema,
     note: z.string().max(20_000),
-}).strict();
+}).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." });
+    if (submission.kind !== "outcome")
+        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 });
+});
 export const TaskFeedbackSchema = z.object({
     schemaVersion: z.literal("openpond.taskFeedbackRecord.v1"),
     id: ReleaseIdSchema,
@@ -125,6 +151,7 @@ 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({

package/dist/learning/index.js

@@ -9,6 +9,9 @@ export * from "./transport.js";
 export * from "./errors.js";
 export * from "./authoring.js";
 export * from "./reward-authoring.js";
+export * from "./rating-reward-fixture.js";
+export * from "./intake-contracts.js";
+export * from "./intake.js";
 export * from "./reward-checks.js";
 export * from "./reward-check-worker.js";
 export * from "./reward-fixture-executor.js";

package/dist/learning/intake-contracts.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { LearningJsonObjectSchema } from "./contracts.js";
+import { TaskSplitSchema } from "../tasksets.js";
+export const TASK_INTAKE_LIMITS = { bytes: 5 * 1024 * 1024, records: 1_000, files: 100, messages: 2_000 };
+export const TaskIntakeFormatSchema = z.enum(["json", "jsonl", "csv", "hermes", "openclaw"]);
+export const TaskIntakeFileSchema = z.object({ path: z.string().min(1).max(500), text: z.string() }).strict();
+export const TaskIntakeRecordSchema = z.object({
+    id: z.string().min(1).max(200), familyKey: z.string().min(1).max(200), split: TaskSplitSchema,
+    kind: z.enum(["task", "attempt"]), input: LearningJsonObjectSchema,
+    observedOutput: LearningJsonObjectSchema.nullable(), expected: LearningJsonObjectSchema.nullable(),
+    sourceId: z.string().min(1).max(2_000), sourceHash: z.string().length(64),
+    occurredAt: z.string().datetime().nullable(),
+    // Imported labels and metadata are retained evidence, never admissions or
+    // executable Rewards. Hosts store these outside policy-visible fields.
+    metadata: LearningJsonObjectSchema, warnings: z.array(z.string().max(2_000)).max(100),
+    needsContext: z.boolean(),
+}).strict();
+export const TaskIntakePreviewSchema = z.object({
+    schemaVersion: z.literal("openpond.taskIntakePreview.v1"), format: TaskIntakeFormatSchema,
+    contentHash: z.string().length(64), records: z.array(TaskIntakeRecordSchema).max(TASK_INTAKE_LIMITS.records),
+    issues: z.array(z.object({ file: z.string(), row: z.number().int().positive().nullable(), message: z.string() }).strict()).max(1_000),
+}).strict();
+export function intakeId(source, identity) { return `${source}-${contentHash(identity)}`; }
+export function intakeDate(value) {
+    if (typeof value !== "string" && typeof value !== "number")
+        return null;
+    const date = new Date(typeof value === "number" ? value * 1_000 : value);
+    return Number.isFinite(date.getTime()) ? date.toISOString() : null;
+}

package/dist/learning/intake-csv.js

@@ -0,0 +1,59 @@
+import { TASK_INTAKE_LIMITS } from "./intake-contracts.js";
+/** RFC 4180-style quoting; newlines inside a quoted field remain content. */
+export function parseTaskIntakeCsv(text) {
+    const rows = [];
+    let row = [], field = "", quoted = false, closed = false;
+    const finishField = () => { row.push(field); field = ""; closed = false; };
+    const finishRow = () => {
+        finishField();
+        if (row.some(value => value.length))
+            rows.push(row);
+        row = [];
+        if (rows.length > TASK_INTAKE_LIMITS.records + 1)
+            throw new Error("CSV exceeds the 1,000-record limit.");
+    };
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (quoted) {
+            if (char === '"' && text[index + 1] === '"') {
+                field += '"';
+                index++;
+            }
+            else if (char === '"') {
+                quoted = false;
+                closed = true;
+            }
+            else
+                field += char;
+        }
+        else if (char === ",")
+            finishField();
+        else if (char === "\n" || char === "\r") {
+            if (char === "\r" && text[index + 1] === "\n")
+                index++;
+            finishRow();
+        }
+        else if (char === '"' && !field && !closed)
+            quoted = true;
+        else {
+            if (closed || char === '"')
+                throw new Error("CSV has an invalid quoted field.");
+            field += char;
+        }
+    }
+    if (quoted)
+        throw new Error("CSV has an unterminated quoted field.");
+    if (field || row.length || closed)
+        finishRow();
+    const header = rows.shift()?.map(value => value.trim().replace(/^\uFEFF/u, ""));
+    if (!header?.includes("instruction"))
+        throw new Error("CSV requires an instruction column.");
+    const allowed = new Set(["instruction", "context", "reference", "labels", "id", "familyKey", "split"]);
+    if (header.some(value => !allowed.has(value)) || new Set(header).size !== header.length)
+        throw new Error("CSV has duplicate or unsupported columns. Use instruction, context, reference, labels, id, familyKey and split.");
+    return rows.map((values, index) => {
+        if (values.length !== header.length)
+            throw new Error(`CSV record ${index + 2} has a different number of columns from its header.`);
+        return Object.fromEntries(header.map((name, column) => [name, values[column]]).filter(([, value]) => value !== ""));
+    });
+}

package/dist/learning/intake-history.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { assertBoundedTaskJson } from "../task-schema.js";
+import { LearningJsonObjectSchema } from "./contracts.js";
+import { intakeDate, intakeId, TASK_INTAKE_LIMITS, TaskIntakeRecordSchema } from "./intake-contracts.js";
+const messageSchema = z.object({ role: z.string().min(1), content: z.json().nullable().optional() }).catchall(z.json());
+const hermesSchema = z.object({ id: z.string().min(1), messages: z.array(messageSchema).min(1).max(TASK_INTAKE_LIMITS.messages),
+    lineage_session_ids: z.array(z.string()).optional(), parent_session_id: z.string().nullable().optional() }).catchall(z.json());
+export function parseHermesSession(value) {
+    const session = hermesSchema.parse(value);
+    const family = session.lineage_session_ids?.[0] ?? session.parent_session_id ?? session.id;
+    const { messages: _messages, segments: _segments, ...metadata } = session;
+    return historyRecords("hermes", session.id, family, session.messages, {
+        sourceHash: contentHash(value), metadata: { session: metadata },
+        warnings: ["Imported session context and tools need review before this can become an executable task."],
+    });
+}
+const manifestSchema = z.object({ traceSchema: z.literal("openclaw-trajectory"), schemaVersion: z.literal(1),
+    traceId: z.string().min(1), sessionId: z.string().min(1), leafId: z.string().nullable(),
+    eventCount: z.number().int().nonnegative(), warnings: z.array(LearningJsonObjectSchema).optional() }).catchall(z.json());
+const eventSchema = z.object({ traceSchema: z.literal("openclaw-trajectory"), schemaVersion: z.literal(1),
+    traceId: z.string(), sessionId: z.string(), seq: z.number().int().nonnegative(), type: z.string(), ts: z.string() }).catchall(z.json());
+const branchSchema = z.object({ header: LearningJsonObjectSchema.nullable(), leafId: z.string().nullable(),
+    entries: z.array(z.object({ id: z.string().min(1), type: z.string().min(1), parentId: z.string().nullable().optional(),
+        message: messageSchema.optional() }).catchall(z.json())).max(TASK_INTAKE_LIMITS.messages) }).strict();
+/** Takes named bundle files; never extracts paths or runs uploaded code. */
+export function parseOpenClawBundle(files) {
+    const read = (path) => {
+        const file = files.find(file => file.path === path);
+        if (!file)
+            throw new Error(`OpenClaw bundle is missing ${path}.`);
+        return file.text;
+    };
+    const manifest = manifestSchema.parse(JSON.parse(read("manifest.json")));
+    const branch = branchSchema.parse(JSON.parse(read("session-branch.json")));
+    if (branch.leafId !== manifest.leafId)
+        throw new Error("OpenClaw manifest and session branch identify different leaves.");
+    const events = read("events.jsonl").split(/\r?\n/u).filter(line => line.trim()).map(line => eventSchema.parse(JSON.parse(line)));
+    if (events.length !== manifest.eventCount || events.some(event => event.traceId !== manifest.traceId || event.sessionId !== manifest.sessionId))
+        throw new Error("OpenClaw events do not match the manifest identity or count.");
+    if (branch.header && branch.header.id !== manifest.sessionId)
+        throw new Error("OpenClaw session header does not match the manifest.");
+    const ids = new Set();
+    for (const [index, entry] of branch.entries.entries()) {
+        if (ids.has(entry.id))
+            throw new Error("OpenClaw branch contains duplicate entry IDs.");
+        if (index && entry.parentId !== branch.entries[index - 1].id)
+            throw new Error("OpenClaw branch is incomplete or out of order.");
+        ids.add(entry.id);
+    }
+    if (branch.entries.length && branch.entries.at(-1).id !== branch.leafId)
+        throw new Error("OpenClaw branch does not reach its declared leaf.");
+    const messages = branch.entries.filter(entry => entry.type === "message" && entry.message).map(entry => ({ ...entry.message, entryId: entry.id,
+        timestamp: typeof entry.timestamp === "string" ? entry.timestamp : typeof entry.message.timestamp === "number" ? new Date(entry.message.timestamp).toISOString() : null }));
+    return historyRecords("openclaw", manifest.sessionId, manifest.sessionId, messages, {
+        sourceHash: contentHash(files), metadata: { manifest, sourceFiles: files.map(file => file.path) },
+        warnings: ["Imported trajectory context and tools need review before this can become an executable task.",
+            ...(manifest.warnings ?? []).map(warning => typeof warning.message === "string" ? warning.message.slice(0, 2_000) : "The source exporter reported incomplete context.")],
+    });
+}
+function historyRecords(format, sessionId, family, messages, source) {
+    const starts = messages.flatMap((message, index) => message.role === "user" ? [index] : []);
+    if (!starts.length)
+        throw new Error("This history contains no user request. Supply a session with its request context.");
+    let normalizedBytes = 0;
+    return starts.map((start, position) => {
+        const end = starts[position + 1] ?? messages.length;
+        const responses = messages.slice(start + 1, end);
+        const assistant = responses.filter(message => message.role === "assistant").at(-1);
+        const request = messages[start];
+        const identity = request.entryId ?? request.message_id ?? request.id ?? contentHash({ start, request });
+        const record = {
+            id: intakeId(format, [sessionId, identity]), familyKey: intakeId(format, family), split: "train", kind: "attempt",
+            input: { request: request.content ?? null, messages: messages.slice(0, start + 1) },
+            observedOutput: assistant ? { response: assistant.content ?? null, messages: responses } : null, expected: null,
+            sourceId: `${format}:${sessionId}:${String(identity)}`, sourceHash: source.sourceHash,
+            occurredAt: intakeDate(assistant?.timestamp ?? request.timestamp), metadata: source.metadata,
+            warnings: [...source.warnings, ...(!assistant ? ["No assistant response was recorded for this request."] : [])], needsContext: true,
+        };
+        assertBoundedTaskJson(record);
+        normalizedBytes += new TextEncoder().encode(JSON.stringify(record)).length;
+        if (normalizedBytes > TASK_INTAKE_LIMITS.bytes)
+            throw new Error("Expanded history exceeds the 5 MiB preview limit. Export a smaller session selection.");
+        return TaskIntakeRecordSchema.parse(record);
+    });
+}

package/dist/learning/intake-service.js

@@ -0,0 +1,79 @@
+import { createRewardBinding } from "../rewards.js";
+import { previewTaskIntake } from "./intake.js";
+import { intakeId } from "./intake-contracts.js";
+import { LearningDomainError } from "./errors.js";
+import { LearningSourceSchema, TaskDefinitionSchema, TaskExampleSubmissionSchema, learningRef, sealLearningContent } from "./contracts.js";
+import { learningEvidenceId } from "./repository.js";
+import { createLearningTextAsset, verifyLearningTextAsset } from "./assets.js";
+export async function importTaskIntake(transaction, input, now, submit) {
+    const preview = previewTaskIntake(input);
+    if (preview.contentHash !== input.expectedPreviewHash)
+        throw new LearningDomainError("task_intake_preview_changed", 409);
+    if (new Set(input.recordIds).size !== input.recordIds.length)
+        throw new LearningDomainError("task_intake_duplicate_selection", 422);
+    const selected = input.recordIds.map(id => {
+        const record = preview.records.find(record => record.id === id);
+        if (!record)
+            throw new LearningDomainError("task_intake_record_missing", 422, "Choose only valid records from the current preview.");
+        return record;
+    });
+    const id = `intake-${preview.contentHash}`;
+    // Keep the exact uploaded text once, privately, instead of duplicating a
+    // complete session/bundle in every normalized turn. Parts concatenate in
+    // path/index order and never split a UTF-16 surrogate pair.
+    const sourceAssets = [];
+    for (const file of input.files) {
+        let start = 0, part = 0;
+        do {
+            let end = Math.min(start + 131_072, file.text.length);
+            if (end < file.text.length && file.text.charCodeAt(end - 1) >= 0xd800 && file.text.charCodeAt(end - 1) <= 0xdbff)
+                end--;
+            const asset = createLearningTextAsset({ text: file.text.slice(start, end), path: `${id}/${file.path}.part-${String(part++).padStart(4, "0")}`,
+                mediaType: "text/plain", visibility: "host_private" });
+            const existing = await transaction.get("asset", asset.id, 1);
+            if (existing)
+                verifyLearningTextAsset(existing, asset.asset);
+            else
+                await transaction.put("asset", asset, 0);
+            sourceAssets.push(asset.asset);
+            start = end;
+        } while (start < file.text.length);
+    }
+    let source = await transaction.get("source", id);
+    if (!source) {
+        const binding = createRewardBinding({ schemaVersion: "openpond.rewardBinding.v1", id: `${id}-binding`, revision: 1,
+            sources: [], aggregation: "weighted_mean", unscorable: "exclude_optional_require_all_required" }, []);
+        const definition = TaskDefinitionSchema.parse(sealLearningContent({
+            schemaVersion: "openpond.taskDefinition.v1", id: `${id}-definition`, revision: 1, name: input.name,
+            description: `Imported ${input.format} records. Labels and task admission remain separate.`,
+            instructions: "Respond to the retained request using its supplied context.", category: "custom", familyNamespace: `intake-${input.format}`,
+            inputSchema: { type: "object" }, outputSchema: { type: "object" }, rewardBinding: learningRef(binding), harness: null,
+            contextRequirements: preview.records.some(record => record.needsContext) ? ["Review the imported history and configure its reusable input, tools and runtime before admitting tasks."] : [],
+            execution: { policy: { policyVisibleFields: ["input"], privilegedFields: ["expectedOutput", "evaluatorContext"], hiddenGraderRefs: [], connectedAppScopes: [] },
+                environment: { protocolVersion: "openpond.environment.v1", kind: "text", entrypoint: "openpond.text.v1", stateful: false,
+                    deterministicSeeds: true, lifecycle: ["create", "reset", "step", "collect", "destroy"], networkPolicy: "none", defaultTimeoutMs: 30_000 }, tools: [], capabilities: [] },
+        }));
+        source = LearningSourceSchema.parse(sealLearningContent({ schemaVersion: "openpond.learningSource.v1", id, revision: 1, name: input.name,
+            kind: "direct", taskDefinition: learningRef(definition), enabled: true, allowedSplits: ["train", "validation", "test", "frozen_eval"],
+            mapping: null, adapterVersion: `openpond.intake.${input.format}.v1` }));
+        await transaction.put("binding", binding, 0);
+        await transaction.put("definition", definition, 0);
+        await transaction.put("source", source, 0);
+    }
+    const pointers = [{ kind: "source", id: source.id, revision: source.revision }];
+    for (const record of selected) {
+        const attemptId = intakeId("attempt", [record.id, record.sourceHash]);
+        const existing = await transaction.get("evidence", learningEvidenceId(source.id, record.id, attemptId), 1);
+        pointers.push(await submit(transaction, { action: "submit_example", operationId: input.operationId,
+            example: TaskExampleSubmissionSchema.parse({ schemaVersion: "openpond.taskExample.v1", sourceId: source.id,
+                idempotencyKey: intakeId("record", [preview.contentHash, record.id]), taskDefinition: source.taskDefinition,
+                exampleId: record.id, attemptId, occurredAt: record.occurredAt ?? existing?.submission.occurredAt ?? now,
+                familyKey: record.familyKey, split: record.split, input: record.input, observedOutput: record.observedOutput, expected: record.expected,
+                evaluatorContext: { intake: { format: preview.format, uploadHash: preview.contentHash, sourceHash: record.sourceHash,
+                        needsContext: record.needsContext, warnings: record.warnings, timestampOrigin: record.occurredAt ? "source" : "import_time", metadata: record.metadata } },
+                assets: sourceAssets, provenance: { sourceRecordRef: record.sourceId, mappingHash: null },
+            }),
+        }));
+    }
+    return pointers;
+}

package/dist/learning/intake.js

@@ -0,0 +1,112 @@
+import { z } from "zod";
+import { contentHash } from "@openpond/harness";
+import { assertBoundedTaskJson } from "../task-schema.js";
+import { TaskSplitSchema } from "../tasksets.js";
+import { LearningJsonObjectSchema } from "./contracts.js";
+import { parseTaskIntakeCsv } from "./intake-csv.js";
+import { parseHermesSession, parseOpenClawBundle } from "./intake-history.js";
+import { intakeDate, intakeId, TASK_INTAKE_LIMITS, TaskIntakeFileSchema, TaskIntakeFormatSchema, TaskIntakeRecordSchema, TaskIntakePreviewSchema } from "./intake-contracts.js";
+const taskSchema = z.object({
+    instruction: z.string().trim().min(1).max(100_000), context: z.union([z.string(), LearningJsonObjectSchema]).optional(),
+    reference: z.union([z.string(), LearningJsonObjectSchema]).optional(), labels: z.union([z.string(), z.array(z.string()), LearningJsonObjectSchema]).optional(),
+    id: z.string().min(1).max(200).optional(), familyKey: z.string().min(1).max(200).optional(), split: TaskSplitSchema.optional(),
+}).strict();
+const structuredTaskSchema = z.object({
+    input: LearningJsonObjectSchema, observedOutput: LearningJsonObjectSchema.nullable().optional(), expectedOutput: LearningJsonObjectSchema.nullable().optional(),
+    id: z.string().min(1).max(200).optional(), familyKey: z.string().min(1).max(200).optional(), split: TaskSplitSchema.optional(),
+    occurredAt: z.string().datetime().optional(), labels: LearningJsonObjectSchema.optional(),
+}).strict();
+export function previewTaskIntake(input) {
+    const format = TaskIntakeFormatSchema.parse(input.format);
+    const files = z.array(TaskIntakeFileSchema).min(1).max(TASK_INTAKE_LIMITS.files).parse(input.files);
+    if (files.reduce((size, file) => size + new TextEncoder().encode(file.text).length, 0) > TASK_INTAKE_LIMITS.bytes)
+        throw new Error("Import exceeds the 5 MiB size limit.");
+    if (files.some(file => file.path.startsWith("/") || file.path.includes("\\") || file.path.split("/").some(part => !part || part === "." || part === "..")) || new Set(files.map(file => file.path)).size !== files.length)
+        throw new Error("Import contains an unsafe or duplicate file path.");
+    const records = [], issues = [];
+    const seen = new Map();
+    const splits = new Map();
+    let normalizedBytes = 0;
+    function attempt(file, row, parse) {
+        try {
+            const parsed = parse();
+            if (records.length + parsed.length > TASK_INTAKE_LIMITS.records)
+                throw new Error("Import exceeds the 1,000-record limit.");
+            const nextSeen = new Map(seen), nextSplits = new Map(splits);
+            let addedBytes = 0;
+            for (const record of parsed) {
+                assertBoundedTaskJson(record);
+                const hash = contentHash(record);
+                const existing = nextSeen.get(record.id);
+                if (existing && existing !== hash)
+                    throw new Error("The same record identity has different content in this upload.");
+                if (!existing)
+                    addedBytes += new TextEncoder().encode(JSON.stringify(record)).length;
+                nextSeen.set(record.id, hash);
+                for (const key of [`family:${record.familyKey}`, `input:${contentHash(record.input)}`]) {
+                    if (nextSplits.has(key) && nextSplits.get(key) !== record.split)
+                        throw new Error("The same task family or request occurs in different splits.");
+                    nextSplits.set(key, record.split);
+                }
+            }
+            if (normalizedBytes + addedBytes > TASK_INTAKE_LIMITS.bytes * 2)
+                throw new Error("Expanded import exceeds the 10 MiB preview limit. Select fewer source files.");
+            for (const record of parsed) {
+                if (!seen.has(record.id))
+                    records.push(record);
+                seen.set(record.id, contentHash(record));
+            }
+            for (const [key, split] of nextSplits)
+                splits.set(key, split);
+            normalizedBytes += addedBytes;
+        }
+        catch (error) {
+            issues.push({ file, row, message: error instanceof z.ZodError ? `Unsupported record fields or values (${error.issues.slice(0, 3).map(issue => issue.path.join(".") || "record").join(", ")}).` : error instanceof SyntaxError ? "Invalid JSON." : error instanceof Error ? error.message : "Invalid import record." });
+        }
+    }
+    if (format === "openclaw")
+        attempt("manifest.json", null, () => parseOpenClawBundle(files));
+    else
+        for (const file of files) {
+            if (format === "jsonl" || format === "hermes") {
+                for (const [index, line] of file.text.split(/\r?\n/u).entries()) {
+                    if (!line.trim())
+                        continue;
+                    if (issues.length >= TASK_INTAKE_LIMITS.records)
+                        break;
+                    attempt(file.path, index + 1, () => format === "hermes" ? parseHermesSession(JSON.parse(line)) : [normalizeTask(JSON.parse(line))]);
+                }
+            }
+            else {
+                let values;
+                try {
+                    const value = format === "csv" ? parseTaskIntakeCsv(file.text) : JSON.parse(file.text);
+                    values = Array.isArray(value) ? value : [value];
+                }
+                catch (error) {
+                    attempt(file.path, null, () => { throw error; });
+                    continue;
+                }
+                if (values.length > TASK_INTAKE_LIMITS.records) {
+                    attempt(file.path, null, () => { throw new Error("Import exceeds the 1,000-record limit."); });
+                    continue;
+                }
+                values.forEach((value, index) => attempt(file.path, index + (format === "csv" ? 2 : 1), () => [normalizeTask(value)]));
+            }
+        }
+    return TaskIntakePreviewSchema.parse({ schemaVersion: "openpond.taskIntakePreview.v1", format, contentHash: contentHash({ format, files }), records, issues: issues.slice(0, 1_000) });
+}
+function normalizeTask(value) {
+    const parsed = z.union([taskSchema, structuredTaskSchema]).parse(value);
+    const simple = "instruction" in parsed;
+    const input = simple ? { instruction: parsed.instruction, ...(parsed.context === undefined ? {} : { context: parsed.context }) } : parsed.input;
+    const expected = simple ? parsed.reference === undefined ? null : typeof parsed.reference === "string" ? { text: parsed.reference } : parsed.reference : parsed.expectedOutput ?? null;
+    const observedOutput = simple ? null : parsed.observedOutput ?? null;
+    // Without an explicit family, identical requests stay together even when
+    // their imported labels or reference answers differ.
+    const familyKey = parsed.familyKey ?? intakeId("family", input);
+    const id = parsed.id ?? intakeId("task", { input, expected, observedOutput });
+    return TaskIntakeRecordSchema.parse({ id, familyKey, split: parsed.split ?? "train", kind: observedOutput ? "attempt" : "task", input,
+        expected, observedOutput, sourceId: id, sourceHash: contentHash(value), occurredAt: simple ? null : intakeDate(parsed.occurredAt),
+        metadata: parsed.labels === undefined ? {} : { importedLabels: parsed.labels, labelOrigin: "unverified_import" }, warnings: [], needsContext: false });
+}

package/dist/learning/operations.js

@@ -5,7 +5,12 @@ import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceCont
 import { RewardBindingContentSchema, RewardReleaseContentSchema } from "../rewards.js";
 import { AuthoringDraftInputSchema, AuthoringDraftFinalizationSchema } from "./authoring.js";
 import { LearningTextAssetContentSchema } from "./assets.js";
+import { TaskIntakeFileSchema, TaskIntakeFormatSchema } from "./intake-contracts.js";
 const command = z.object({ operationId: ReleaseIdSchema });
+export const ImportTaskIntakeCommandSchema = command.extend({ action: z.literal("import_intake"), format: TaskIntakeFormatSchema,
+    files: z.array(TaskIntakeFileSchema).min(1).max(100), expectedPreviewHash: z.string().length(64),
+    name: z.string().trim().min(1).max(500), recordIds: z.array(z.string().min(1).max(200)).min(1).max(90),
+}).strict();
 const publish = command.extend({ action: z.literal("publish"), expectedRevision: z.number().int().nonnegative(), finalizeDraft: AuthoringDraftFinalizationSchema.optional() });
 export const PublishLearningResourceCommandSchema = z.discriminatedUnion("kind", [
     publish.extend({ kind: z.literal("asset"), content: LearningTextAssetContentSchema }).strict(),
@@ -41,4 +46,4 @@ export const ReserveLearningIterationCommandSchema = command.extend({ action: z.
 export const CancelLearningIterationReservationCommandSchema = command.extend({ action: z.literal("cancel_iteration_reservation"), iterationId: ReleaseIdSchema, expectedRevision: z.number().int().positive() }).strict();
 export const CancelLearningIterationCommandSchema = command.extend({ action: z.literal("cancel_iteration"), iterationId: ReleaseIdSchema, expectedRevision: z.number().int().positive() }).strict();
 export const RetryLearningIterationDispatchCommandSchema = command.extend({ action: z.literal("retry_iteration_dispatch"), iterationId: ReleaseIdSchema, expectedRevision: z.number().int().positive() }).strict();
-export const LearningCommandSchema = z.union([CancelLearningIterationCommandSchema, RetryLearningIterationDispatchCommandSchema, CancelLearningIterationReservationCommandSchema, ReserveLearningIterationCommandSchema, QueueRewardCheckCommandSchema, CancelRewardCheckCommandSchema, SaveAuthoringDraftCommandSchema, ArchiveAuthoringDraftCommandSchema, PublishLearningResourceCommandSchema, PublishLearningResourcesCommandSchema, SubmitTaskExampleCommandSchema, SubmitTaskFeedbackCommandSchema, ApplyTaskCorrectionCommandSchema, ResolveTaskFeedbackCommandSchema, QueueTaskGradeCommandSchema, ReviewTaskEvidenceCommandSchema, SealTaskBatchCommandSchema, CancelTaskGradeCommandSchema]);
+export const LearningCommandSchema = z.union([ImportTaskIntakeCommandSchema, CancelLearningIterationCommandSchema, RetryLearningIterationDispatchCommandSchema, CancelLearningIterationReservationCommandSchema, ReserveLearningIterationCommandSchema, QueueRewardCheckCommandSchema, CancelRewardCheckCommandSchema, SaveAuthoringDraftCommandSchema, ArchiveAuthoringDraftCommandSchema, PublishLearningResourceCommandSchema, PublishLearningResourcesCommandSchema, SubmitTaskExampleCommandSchema, SubmitTaskFeedbackCommandSchema, ApplyTaskCorrectionCommandSchema, ResolveTaskFeedbackCommandSchema, QueueTaskGradeCommandSchema, ReviewTaskEvidenceCommandSchema, SealTaskBatchCommandSchema, CancelTaskGradeCommandSchema]);

package/dist/learning/rating-reward-fixture.js

@@ -0,0 +1,19 @@
+import { learningRef, sameLearningRef, TaskRatingSchema } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+/** Copy a retained label into editable check data while preserving its exact origin. */
+export function rewardFixtureFromRating(evidence, feedback, scale = { minimum: 0, maximum: 1 }) {
+    if (!feedback.evidence || !sameLearningRef(feedback.evidence, learningRef(evidence)) || feedback.submission.expectedEvidenceHash !== evidence.contentHash || feedback.submission.kind !== "outcome" || !evidence.submission.observedOutput)
+        throw new LearningDomainError("rating_fixture_evidence_mismatch", 422);
+    const rating = TaskRatingSchema.parse(feedback.submission.value);
+    if (!Number.isFinite(scale.minimum) || !Number.isFinite(scale.maximum) || scale.minimum >= scale.maximum)
+        throw new LearningDomainError("rating_fixture_scale_invalid", 422);
+    const score = scale.minimum + (rating.score - rating.scale.minimum) / (rating.scale.maximum - rating.scale.minimum) * (scale.maximum - scale.minimum);
+    return {
+        id: `label-${feedback.id}-${feedback.revision}`, name: evidence.submission.exampleId,
+        input: JSON.stringify(evidence.submission.input, null, 2), output: JSON.stringify(evidence.submission.observedOutput, null, 2),
+        expectedOutput: evidence.submission.expected ? JSON.stringify(evidence.submission.expected, null, 2) : "",
+        evaluatorContext: evidence.submission.evaluatorContext ? JSON.stringify(evidence.submission.evaluatorContext, null, 2) : "",
+        artifactRefs: [], runtimeEventRefs: [], infrastructureError: "", expectedStatus: "scored", minimumScore: String(score), maximumScore: String(score), expectedPassed: "any",
+        sourceLabel: { evidence: learningRef(evidence), feedback: { id: feedback.id, revision: feedback.revision } },
+    };
+}

package/dist/learning/service.js

@@ -17,6 +17,7 @@ import { LearningConflictError, learningEvidenceId, learningOperationId, require
 import { validateSourceSubmission } from "./admission.js";
 import { LearningTextAssetSchema, verifyLearningTextAsset } from "./assets.js";
 import { LearningRevisionRefSchema } from "./contracts.js";
+import { importTaskIntake } from "./intake-service.js";
 export function createLearningService(repository, options = {}) {
     const now = options.now ?? (() => new Date().toISOString());
     async function command(context, raw) {
@@ -35,6 +36,9 @@ export function createLearningService(repository, options = {}) {
             }
             let pointers;
             switch (input.action) {
+                case "import_intake":
+                    pointers = await importTaskIntake(transaction, input, now(), submit);
+                    break;
                 case "cancel_iteration":
                 case "retry_iteration_dispatch":
                     pointers = await commandLearningIterationDispatch(transaction, input, now());
@@ -70,7 +74,7 @@ export function createLearningService(repository, options = {}) {
                     pointers = [await submit(transaction, input)];
                     break;
                 case "submit_feedback":
-                    pointers = [await feedback(transaction, input)];
+                    pointers = [await feedback(transaction, input, context.actor)];
                     break;
                 case "apply_correction":
                     pointers = await correct(transaction, input, context.actor.id);
@@ -193,16 +197,19 @@ export function createLearningService(repository, options = {}) {
         } while (afterId);
         return pointer("evidence", evidence);
     }
-    async function feedback(transaction, input) {
+    async function feedback(transaction, input, actor) {
         const source = await requireLearningResource(transaction, "source", input.feedback.sourceId);
         if (!source.enabled)
             throw new LearningDomainError("learning_source_disabled", 409);
         const evidenceId = learningEvidenceId(source.id, input.feedback.exampleId, input.feedback.attemptId);
         const evidence = await transaction.get("evidence", evidenceId);
+        if (input.feedback.value.schemaVersion === "openpond.taskRating.v1" && (!evidence || evidence.contentHash !== input.feedback.expectedEvidenceHash || !evidence.submission.observedOutput))
+            throw new LearningDomainError("task_rating_evidence_stale", 409, "Open the current observed response before submitting a rating.");
         const record = TaskFeedbackSchema.parse({
             schemaVersion: "openpond.taskFeedbackRecord.v1", id: `feedback-${contentHash([source.id, input.feedback.idempotencyKey])}`,
             submission: input.feedback, status: evidence ? "pending_review" : "pending_example",
             evidence: evidence ? learningRef(evidence) : null, createdAt: now(), revision: 1,
+            submittedBy: { id: actor.id, role: actor.role, sourceId: actor.sourceId ?? null },
         });
         await transaction.put("feedback", record, 0, { parentId: evidenceId, status: record.status });
         return pointer("feedback", record);
@@ -348,6 +355,8 @@ export function createLearningService(repository, options = {}) {
         },
         async list(context, kind, query = {}) {
             authorizeRead(context);
+            if (query.reviewState !== undefined && (kind !== "evidence" || !["inbox", "reviewed"].includes(query.reviewState)))
+                throw new LearningDomainError("learning_review_filter_invalid", 400);
             const limit = Math.max(1, Math.min(100, Math.trunc(query.limit ?? 50)));
             return repository.transaction(context.scope, (transaction) => transaction.list(kind, { ...query, limit }));
         },