@openpond/evals 0.10.8 → 0.10.10

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
@@ -117,6 +143,12 @@ runtime/package identity and settles only after cleanup. The isolated adapter ru
 portable deterministic checks and authored JavaScript with the supplied interpreter.
 Human review remains pending; missing judge/learned-model adapters remain unavailable.
 No fixture result implicitly calibrates a judge or qualifies a training runtime.
+`publish_checked_reward` explicitly publishes the exact saved judge draft after a
+completed check covers both passing and failing examples. The service revalidates
+fixture hashes and persisted provider receipts, records `calibrationCheckRef`, and
+closes the draft in the same transaction. Generic publication cannot manufacture
+a passed calibration or reuse that check after changing the model, temperature,
+rubric or fixtures. Metadata-only edits may retain the same calibration evidence.
 Per-fixture results distinguish a scored rejection, unavailable grading and grader
 failure, and record whether each outcome matched its authored expectation.
 
@@ -125,6 +157,15 @@ readable after publication. Editing source or fixtures must mark prior checks as
 historical. `cancel_reward_check` requests cancellation with revision concurrency;
 the worker publishes terminal cancellation only after execution-owner cleanup.
 
+`createBudgetedRewardFixtureExecutor` and `createTaskGradeJudgeBudgetStore` retain
+judge calls in the owning run. Reserve the full charge ceiling before dispatch;
+late settlement survives cancellation and expired ownership. Missing/partial
+usage leaves the full reservation committed, and an uncertain request cannot be
+retried under the same call identity. Hosts inject a `BoundJudgeProvider` that
+prepares without inference and dispatches once. The local OpenPond transport uses
+catalog pricing/context limits, exact model IDs and bounded output; it rejects
+revision pins because OpChat does not currently expose revision enforcement.
+
 ### Source and execution ownership
 
 Authored verifier code and rubrics use immutable `asset` resources. Publish source

package/dist/graders.js

@@ -2,6 +2,18 @@ import { z } from "zod";
 import { FailureClassSchema, ReleaseHashSchema, ReleaseIdSchema, contentHash } from "@openpond/harness";
 import { evaluateDeterministicGrader } from "./deterministic-graders.js";
 export { evaluateDeterministicGrader, portableDeterministicCheck } from "./deterministic-graders.js";
+export const ModelJudgeReceiptSchema = z.object({
+    schemaVersion: z.literal("openpond.modelJudgeReceipt.v1"),
+    providerId: z.string().trim().min(1).max(200),
+    modelId: z.string().trim().min(1).max(500),
+    modelRevision: z.string().trim().min(1).max(500).nullable(),
+    responseId: z.string().trim().min(1).max(500).nullable(),
+    requestHash: ReleaseHashSchema,
+    responseHash: ReleaseHashSchema,
+    inputTokens: z.number().int().nonnegative().nullable(),
+    outputTokens: z.number().int().nonnegative().nullable(),
+    costUsd: z.number().finite().nonnegative().nullable(),
+}).strict();
 export const GraderEvidenceContentSchema = z.object({
     schemaVersion: z.literal("openpond.graderEvidence.v1"),
     graderId: ReleaseIdSchema,
@@ -13,6 +25,7 @@ export const GraderEvidenceContentSchema = z.object({
     feedback: z.array(z.string().max(20_000)).max(1_000),
     visibleEvidenceRefs: z.array(ReleaseIdSchema).max(10_000),
     privilegedEvidenceRefs: z.array(ReleaseIdSchema).max(10_000),
+    modelJudgeReceipt: ModelJudgeReceiptSchema.optional(),
 }).strict();
 export const GraderEvidenceSchema = GraderEvidenceContentSchema.extend({ contentHash: ReleaseHashSchema }).strict();
 export async function gradeEvidence(input) {
@@ -29,9 +42,11 @@ export async function gradeEvidence(input) {
     }
     return Promise.all(input.graders.map(async (grader) => {
         if (grader.kind === "model_judge") {
-            if (!input.modelJudge || grader.calibrationStatus !== "passed")
+            if (!input.modelJudge || (grader.calibrationStatus !== "passed" && input.purpose !== "fixture_calibration"))
                 return evidence(grader, unavailable("Model judge is unavailable or uncalibrated."));
-            return evidence(grader, await input.modelJudge({ grader, task: input.task, evidence: input.evidence }));
+            input.signal?.throwIfAborted();
+            const result = await input.modelJudge({ grader, task: input.task, evidence: input.evidence, signal: input.signal });
+            return evidence(grader, { ...result, rewardEligible: input.purpose === "fixture_calibration" ? false : result.rewardEligible });
         }
         if (grader.kind === "custom_verifier") {
             if (!input.customVerifier)
@@ -111,11 +126,11 @@ export function aggregateGraderScores(input) {
         failureClass: infrastructure ? "infrastructure_failure" : score === null ? "grader_failure" : passed ? null : "policy_failure",
         gradingStatus: !input.graders.length && !infrastructure ? "not_configured" : score === null ? "unscorable" : "scored" });
 }
-export const TaskGradeSchema = GradeSummarySchema.extend({
+export const TaskGradeSchema = /* @__PURE__ */ (() => GradeSummarySchema.extend({
     schemaVersion: z.literal("openpond.taskGrade.v1"),
     taskHash: ReleaseHashSchema, evidenceHash: ReleaseHashSchema, graderSetHash: ReleaseHashSchema,
     components: z.array(GraderEvidenceSchema).max(1_000), contentHash: ReleaseHashSchema,
-}).strict();
+}).strict())();
 export async function gradeTaskEvidence(input) {
     const components = await gradeEvidence(input);
     const content = { schemaVersion: "openpond.taskGrade.v1",

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/budgeted-reward-fixtures.js

@@ -0,0 +1,34 @@
+import { contentHash } from "@openpond/harness";
+import { verifyLearningTextAsset } from "./assets.js";
+import { createBudgetedJudgeExecutor } from "./judge-budget.js";
+import { createBoundModelJudgeRunner } from "./model-judge.js";
+import { createRewardCheckJudgeBudgetStore } from "./reward-check-budget.js";
+import { createIsolatedRewardFixtureExecutor } from "./reward-fixture-executor.js";
+import { requireLearningResource } from "./repository.js";
+export function createBudgetedRewardFixtureExecutor(options) {
+    return createIsolatedRewardFixtureExecutor({
+        runtime: options.runtime, executeJavaScript: options.executeJavaScript,
+        async cancelModelJudge(input) {
+            const run = await options.repository.transaction(input.scope, tx => requireLearningResource(tx, "reward_check", input.run.id));
+            if (run.judgeCalls?.some(call => call.status === "reserved"))
+                return false;
+            return options.provider.cancel({ ...input, run });
+        },
+        async createModelJudge(input) {
+            const budget = createRewardCheckJudgeBudgetStore({ repository: options.repository, scope: input.scope, run: input.run });
+            return createBoundModelJudgeRunner({
+                async readRubric(reference) {
+                    const asset = input.assets.find(asset => asset.id === reference.id);
+                    if (!asset)
+                        throw new Error("reward_check_rubric_missing");
+                    return verifyLearningTextAsset(asset, reference);
+                },
+                async executeBudgeted(request, signal) {
+                    const prepared = await options.provider.prepare(request, { scope: input.scope, run: input.run });
+                    const execute = createBudgetedJudgeExecutor({ store: budget, maximumCharge: () => prepared.maximumChargeUsd, dispatch: (_request, signal) => prepared.dispatch(signal) });
+                    return execute(`fixture-${contentHash([input.fixture, input.reward.contentHash])}`, request, signal);
+                },
+            });
+        },
+    });
+}

package/dist/learning/contracts.js

@@ -4,6 +4,7 @@ import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema,
 import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, RewardReleaseSchema } from "../rewards.js";
 import { TaskRecordSchema, TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.js";
+import { JudgeCallReservationSchema } from "./judge-budget.js";
 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.");
@@ -19,6 +20,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(),
@@ -291,6 +293,8 @@ export const TaskGradeRunSchema = z.object({
     attemptCount: z.number().int().nonnegative(),
     timeoutMs: z.number().int().min(100).max(300_000),
     maximumSpendUsd: z.number().nonnegative().max(1_000),
+    judgeCalls: z.array(JudgeCallReservationSchema).max(10_000).optional(),
+    requestedBy: ReleaseIdSchema.optional(),
     failure: z.string().max(20_000).nullable(),
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,

package/dist/learning/grade-judge-budget.js

@@ -0,0 +1,26 @@
+import { contentHash } from "@openpond/harness";
+import { requireLearningResource } from "./repository.js";
+import { TaskGradeRunSchema } from "./contracts.js";
+export function createTaskGradeJudgeBudgetStore(input) {
+    const now = input.now ?? (() => new Date().toISOString());
+    const identity = (run) => contentHash([run.evidence, run.binding, run.target, run.output]);
+    return {
+        transaction(intent, update) {
+            return input.repository.transaction(input.scope, async (tx) => {
+                const current = await requireLearningResource(tx, "grade", input.run.id);
+                if (identity(current) !== identity(input.run))
+                    throw new Error("model_judge_budget_snapshot_changed");
+                if (intent === "dispatch" && (current.status !== "running" || !current.leaseOwner || current.leaseOwner !== input.run.leaseOwner
+                    || current.attemptCount !== input.run.attemptCount || !current.leaseExpiresAt || Date.parse(current.leaseExpiresAt) <= Date.parse(now())))
+                    throw new Error("model_judge_budget_owner_inactive");
+                const calls = current.judgeCalls ?? [];
+                const next = update({ maximumSpendUsd: current.maximumSpendUsd, calls });
+                if (contentHash(next.calls) !== contentHash(calls)) {
+                    const updated = TaskGradeRunSchema.parse({ ...current, revision: current.revision + 1, judgeCalls: next.calls, updatedAt: now() });
+                    await tx.put("grade", updated, current.revision, { parentId: current.evidence.id, status: current.status });
+                }
+                return next.result;
+            });
+        },
+    };
+}

package/dist/learning/index.js

@@ -10,7 +10,15 @@ 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 "./model-judge.js";
+export * from "./judge-budget.js";
+export * from "./reward-check-budget.js";
+export * from "./grade-judge-budget.js";
+export * from "./budgeted-reward-fixtures.js";
 export * from "./reward-checks.js";
+export * from "./reward-calibration.js";
 export * from "./reward-check-worker.js";
 export * from "./reward-fixture-executor.js";
 export * from "./iteration-reservation-contracts.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,87 @@
+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";
+import { structuredIntakeText } from "./intake-text.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 structuredIntakeText(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-text.js

@@ -0,0 +1,14 @@
+/** Preserve the original UTF-8 bytes, including a leading BOM. Binary or invalid
+ * UTF-8 input must not silently turn into replacement characters in evidence. */
+export function decodeTaskIntakeText(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        throw new Error("Import files must contain valid UTF-8 text. Binary attachments are not supported by this import format.");
+    }
+}
+/** A BOM is a transport marker only at the start of a structured text file. */
+export function structuredIntakeText(text) {
+    return text.startsWith("\uFEFF") ? text.slice(1) : text;
+}

package/dist/learning/intake.js

@@ -0,0 +1,115 @@
+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 { structuredIntakeText } from "./intake-text.js";
+export { decodeTaskIntakeText } from "./intake-text.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) {
+            const text = structuredIntakeText(file.text);
+            if (format === "jsonl" || format === "hermes") {
+                for (const [index, line] of 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(text) : JSON.parse(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 });
+}