@openpond/evals 0.10.8 → 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/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(),

package/dist/learning/index.js

@@ -10,6 +10,8 @@ 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/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());

package/dist/rewards.js

@@ -59,14 +59,16 @@ export const RewardBindingContentSchema = z.object({
     name: z.string().trim().min(1).max(500).optional(),
     description: z.string().max(10_000).optional(),
     recipeRef: RewardReleaseRefSchema.optional(),
-    sources: z.array(RewardBindingSourceSchema).min(1).max(100),
+    // An empty binding retains attempts before a scorer is chosen. Admission
+    // still requires a positively weighted training source for reward training.
+    sources: z.array(RewardBindingSourceSchema).max(100),
     aggregation: z.literal("weighted_mean"),
     unscorable: z.literal("exclude_optional_require_all_required"),
 }).strict().superRefine((binding, context) => {
     if (new Set(binding.sources.map((source) => source.graderId)).size !== binding.sources.length)
         context.addIssue({ code: "custom", path: ["sources"], message: "Bound grader identities must be unique." });
-    if (!binding.sources.some((source) => source.weight > 0))
-        context.addIssue({ code: "custom", path: ["sources"], message: "A binding needs at least one positively weighted source." });
+    if (binding.sources.length && !binding.sources.some((source) => source.weight > 0))
+        context.addIssue({ code: "custom", path: ["sources"], message: "A configured binding needs at least one positively weighted source." });
     for (const [index, source] of binding.sources.entries()) {
         if (source.hardGate && !source.required)
             context.addIssue({ code: "custom", path: ["sources", index], message: "A hard gate must be required." });
@@ -91,7 +93,7 @@ export const RewardCompositionContentSchema = z.object({
     binding: RewardReleaseRefSchema,
     taskHash: ReleaseHashSchema,
     outputHash: ReleaseHashSchema,
-    results: z.array(BoundRewardResultSchema).min(1).max(100),
+    results: z.array(BoundRewardResultSchema).max(100),
     training: z.object({ status: z.enum(["scored", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
     evaluation: z.object({ status: z.enum(["scored", "unscorable", "not_configured"]), score: z.number().min(0).max(1).nullable(), passed: z.boolean().nullable() }).strict(),
 }).strict();

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

@@ -97,6 +97,7 @@ export declare const TaskBatchPackageMetadataSchema: z.ZodObject<{
             maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
             metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strict>>>;
+        contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
         rewardBinding: z.ZodObject<{
             id: z.ZodString;
             contentHash: z.ZodString;

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

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

package/dist/types/learning/batch-service.d.ts

@@ -326,6 +326,7 @@ export declare function prepareLearningBatch(transaction: LearningTransaction, i
             maxBytes: number | null;
             metadata: Record<string, unknown>;
         }[] | undefined;
+        contextRequirements?: string[] | undefined;
     };
 }>;
 export declare function requireCurrentLearningEvidence(transaction: LearningTransaction, ref: LearningRevisionRef): Promise<TaskEvidence>;

package/dist/types/learning/batch-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAQ3M;AAED,kGAAkG;AAClG,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzK;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}
+{"version":3,"file":"batch-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/batch-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAA8E,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAErK,wBAAsB,iBAAiB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAQ3M;AAED,kGAAkG;AAClG,wBAAsB,oBAAoB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBzK;AAED,wBAAsB,8BAA8B,CAAC,WAAW,EAAE,mBAAmB,EAAE,GAAG,EAAE,mBAAmB,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtI"}

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

@@ -41,6 +41,7 @@ export declare const TaskDefinitionContentSchema: z.ZodObject<{
         maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
+    contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
     rewardBinding: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
@@ -149,6 +150,7 @@ export declare const TaskDefinitionSchema: z.ZodObject<{
         maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
+    contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
     rewardBinding: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
@@ -1471,6 +1473,7 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
         maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
         metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strict>>>;
+    contextRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
     rewardBinding: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;

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

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

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

@@ -10,6 +10,8 @@ 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";