@openpond/evals 0.10.4 → 0.10.6

package/LEARNING.md

@@ -232,6 +232,23 @@ owns it. Duplicate observations are idempotent, older decision revisions cannot
 overwrite newer ones, and contradictory observations at the same revision fail.
 This operation does not change the training parent or activate serving.
 
+### Policy readiness reads
+
+`client.inspectPolicy({ id, revision, contentHash })` sends the read payload
+`{ "action": "inspect_policy", "scope": "<profile-or-team>", "policy": { "id": "...", "revision": 1, "contentHash": "..." } }`.
+The authenticated owner reads a scope-serialized snapshot of the current policy's
+eligible, awaiting-review, excluded and consumed counts, chain identity, cooldown
+and daily budget. It uses the same eligibility, complete batch validation and
+budget accounting as manual or scheduled reservation. A stale policy reference is
+rejected; source-only credentials cannot read it.
+
+`canReserve` describes shared reservation readiness at `inspectedAt`. The actual
+command rechecks current state and execution-owner preparation still validates
+its training configuration. `blockers` explains unmet constraints. `counts: null`
+means inspection could not count valid sources or supported admission, not that
+the backlog is empty. Reads never write an iteration, timer fire, family
+reservation, batch, consumption or operation record and never launch training.
+
 ### Durable learning schedules
 
 Policy publication atomically synchronizes a `schedule` resource. Enabling
@@ -257,3 +274,9 @@ retained diagnostic; a new reviewed policy revision may resume it. Hosts must
 poll due timers for their execution owner and supply an authorized actor. This
 worker does not execute a Work prompt or submit a provider Job; the existing
 iteration dispatch worker owns that next transition.
+
+Task Definitions may declare `requiredOutputs`. These optional contracts use
+Taskset output paths, media types, schema references and size bounds. Evidence
+conversion copies them into every task before grading or sealing a batch, so a
+changed output contract requires a new definition and new matching evidence and
+review receipts. Definitions without this field retain their existing hashes.

package/dist/learning/admission.js

@@ -85,6 +85,7 @@ export function taskRecordFromEvidence(evidence, definition) {
         policyVisibleContext: { instructions: definition.instructions },
         privilegedContextRef: evidence.submission.evaluatorContext === null ? null : `task-evidence:${evidence.contentHash}`,
         artifactRefs: evidence.submission.assets, tags: [definition.category],
+        ...(definition.requiredOutputs ? { requiredOutputs: definition.requiredOutputs } : {}),
     });
 }
 export function taskAttemptEvidence(evidence, output) {

package/dist/learning/batch-service.js

@@ -4,6 +4,17 @@ import { learningRef, sameLearningRef } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
 export async function sealLearningBatch(transaction, input, actorId, timestamp) {
+    const { batch, release, evidence, definition } = await prepareLearningBatch(transaction, input, actorId, timestamp);
+    for (const item of evidence) {
+        for (const reservation of taskFamilyReservations(item, definition))
+            await transaction.reserveFamilySplit(reservation.namespace, reservation.kind, reservation.key, reservation.split);
+    }
+    await transaction.put("batch", batch, 0, { parentId: definition.id });
+    await transaction.put("package", release, 0, { parentId: batch.id });
+    return [pointer("batch", batch), pointer("package", release)];
+}
+/** Performs the complete shared validation without reserving families or publishing resources. */
+export async function prepareLearningBatch(transaction, input, actorId, timestamp) {
     const definition = await requireLearningRelease(transaction, "definition", input.taskDefinition);
     const binding = await requireLearningRelease(transaction, "binding", definition.rewardBinding);
     const rewards = await Promise.all(binding.sources.map((source) => requireLearningRelease(transaction, "reward", source.reward)));
@@ -26,13 +37,7 @@ export async function sealLearningBatch(transaction, input, actorId, timestamp)
     }
     const batch = sealTaskBatch({ id: input.batchId, definition, binding, rewards, purpose: input.purpose, evidence, decisions, priorSplits, actorId, now: timestamp });
     const release = compileTaskBatch({ batch, definition, binding, rewards, evidence, decisions });
-    for (const item of evidence) {
-        for (const reservation of taskFamilyReservations(item, definition))
-            await transaction.reserveFamilySplit(reservation.namespace, reservation.kind, reservation.key, reservation.split);
-    }
-    await transaction.put("batch", batch, 0, { parentId: definition.id });
-    await transaction.put("package", release, 0, { parentId: batch.id });
-    return [pointer("batch", batch), pointer("package", release)];
+    return { batch, release, evidence, definition };
 }
 export async function requireCurrentLearningEvidence(transaction, ref) {
     const evidence = await requireLearningRelease(transaction, "evidence", ref);

package/dist/learning/contracts.js

@@ -2,7 +2,7 @@ import { LearningDomainError } from "./errors.js";
 import { z } from "zod";
 import { ImmutableAssetRefSchema, ImmutableReleaseRefSchema, ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema, contentHash } from "@openpond/harness";
 import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, RewardReleaseSchema } from "../rewards.js";
-import { TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
+import { TaskRecordSchema, TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.js";
 export const LearningJsonObjectSchema = z.record(z.string(), z.json());
 export const LearningRevisionRefSchema = RewardReleaseRefSchema;
@@ -18,6 +18,7 @@ export const TaskDefinitionContentSchema = z.object({
     familyNamespace: ReleaseIdSchema,
     inputSchema: z.record(z.string(), z.unknown()),
     outputSchema: z.record(z.string(), z.unknown()),
+    requiredOutputs: TaskRecordSchema.shape.requiredOutputs,
     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

@@ -19,3 +19,4 @@ export * from "./iteration-candidate-decision.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./policy-inspection.js";

package/dist/learning/iteration-budget.js

@@ -0,0 +1,17 @@
+/** Outstanding reservations survive midnight; settled spend belongs to its UTC day. */
+export async function readLearningIterationBudget(transaction, chainId, now) {
+    const day = new Date(now).toISOString().slice(0, 10);
+    let reservedSpendUsd = 0;
+    let settledSpendUsd = 0;
+    let afterId;
+    do {
+        const page = await transaction.list("reservation", { parentId: chainId, limit: 100, ...(afterId ? { afterId } : {}) });
+        for (const { budget } of page.items) {
+            reservedSpendUsd += budget.reservedSpendUsd;
+            if (budget.settledAt && new Date(budget.settledAt).toISOString().slice(0, 10) === day)
+                settledSpendUsd += budget.settledSpendUsd;
+        }
+        afterId = page.nextCursor ?? undefined;
+    } while (afterId);
+    return { reservedSpendUsd, settledSpendUsd, committedSpendUsd: reservedSpendUsd + settledSpendUsd };
+}

package/dist/learning/iteration-reservation-service.js

@@ -3,6 +3,7 @@ import { sealLearningBatch } from "./batch-service.js";
 import { LearningIterationSchema, learningRef, sameLearningRef } from "./contracts.js";
 import { LearningDomainError } from "./errors.js";
 import { inspectIterationEligibility, learningChainId, learningConsumptionId } from "./iteration-eligibility.js";
+import { readLearningIterationBudget } from "./iteration-budget.js";
 import { LearningChainSchema, LearningConsumptionSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
 import { requireLearningRelease, requireLearningResource } from "./repository.js";
 /** The caller owns one scope-serialized transaction. This never submits a Job. */
@@ -89,18 +90,7 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     return [{ kind: "iteration", id, revision: 1 }, { kind: "reservation", id, revision: 1 }, ...pointers];
 }
 async function assertAvailableBudget(transaction, chainId, now, requested, maximum) {
-    let committed = 0;
-    let afterId;
-    do {
-        const page = await transaction.list("reservation", { parentId: chainId, limit: 100, ...(afterId ? { afterId } : {}) });
-        for (const { budget } of page.items) {
-            // Unsettled reservations carry across midnight and worker restarts.
-            committed += budget.reservedSpendUsd;
-            if (budget.settledAt && new Date(budget.settledAt).toISOString().slice(0, 10) === new Date(now).toISOString().slice(0, 10))
-                committed += budget.settledSpendUsd;
-        }
-        afterId = page.nextCursor ?? undefined;
-    } while (afterId);
-    if (committed + requested > maximum)
+    const budget = await readLearningIterationBudget(transaction, chainId, now);
+    if (budget.committedSpendUsd + requested > maximum)
         throw new LearningDomainError("learning_daily_budget_exhausted", 409);
 }

package/dist/learning/policy-inspection.js

@@ -0,0 +1,82 @@
+import { ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { z } from "zod";
+import { LearningRevisionRefSchema, learningRef, sameLearningRef } from "./contracts.js";
+import { prepareLearningBatch } from "./batch-service.js";
+import { LearningDomainError } from "./errors.js";
+import { readLearningIterationBudget } from "./iteration-budget.js";
+import { inspectIterationEligibility, learningChainId } from "./iteration-eligibility.js";
+import { LearningChainSchema, LearningEligibilityCountsSchema } from "./iteration-reservation-contracts.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
+/** A scope-serialized snapshot of shared reservation readiness, not a Job guarantee.
+ * No iteration, timer, batch, consumption or operation record is written. */
+export const LearningPolicyInspectionResultSchema = z.object({
+    policy: LearningRevisionRefSchema,
+    modelProjectId: ReleaseIdSchema,
+    inspectedAt: ReleaseTimestampSchema,
+    chain: LearningChainSchema.nullable(),
+    counts: LearningEligibilityCountsSchema.nullable(),
+    minimumApprovedExamples: z.number().int().positive(),
+    canReserve: z.boolean(),
+    blockers: z.array(z.object({ code: z.string().min(1).max(200), message: z.string().min(1).max(20_000) }).strict()).max(20),
+    cooldownUntil: ReleaseTimestampSchema.nullable(),
+    budget: z.object({
+        reservedSpendUsd: z.number().nonnegative(), settledSpendUsd: z.number().nonnegative(), committedSpendUsd: z.number().nonnegative(),
+        maximumIterationSpendUsd: z.number().nonnegative(), maximumDailySpendUsd: z.number().nonnegative(),
+    }).strict(),
+}).strict();
+export async function inspectLearningPolicy(transaction, reference, actorId, now) {
+    const policy = await requireLearningRelease(transaction, "policy", reference);
+    const current = await requireLearningResource(transaction, "policy", policy.id);
+    if (!sameLearningRef(learningRef(current), reference))
+        throw new LearningDomainError("learning_policy_revision_stale", 409);
+    const chainId = learningChainId(policy.modelProjectId);
+    const chain = await transaction.get("chain", chainId);
+    const budget = await readLearningIterationBudget(transaction, chainId, now);
+    const blockers = [];
+    const block = (code, message) => { blockers.push({ code, message }); };
+    if (!policy.enabled)
+        block("learning_policy_paused", "Learning is paused.");
+    if (policy.automation.accept || policy.automation.serve)
+        block("learning_automatic_acceptance_not_available", "Candidates require explicit acceptance and serving selection.");
+    if (chain?.activeIterationId)
+        block("learning_iteration_active", "An iteration is already active.");
+    const cooldownUntil = chain?.lastReservedAt && Date.parse(now) - Date.parse(chain.lastReservedAt) < policy.limits.cooldownSeconds * 1_000
+        ? new Date(Date.parse(chain.lastReservedAt) + policy.limits.cooldownSeconds * 1_000).toISOString() : null;
+    if (cooldownUntil)
+        block("learning_iteration_cooldown", "The training cooldown has not elapsed.");
+    if (budget.committedSpendUsd + policy.limits.maxIterationSpendUsd > policy.limits.maxDailySpendUsd) {
+        block("learning_daily_budget_exhausted", "The daily budget cannot cover another iteration's maximum spend.");
+    }
+    let counts = null;
+    try {
+        const eligibility = await inspectIterationEligibility(transaction, policy);
+        counts = eligibility.counts;
+        if (counts.eligible < policy.admission.minimumApprovedExamples) {
+            if (counts.awaitingReview > 0)
+                block("learning_waiting_for_review", "More approved tasks are required before training.");
+            else
+                block("learning_waiting_for_data", "More eligible new tasks are required before training.");
+        }
+        else {
+            await prepareLearningBatch(transaction, {
+                action: "seal_batch", operationId: "policy-inspection", batchId: "policy-inspection",
+                taskDefinition: policy.taskDefinition, purpose: eligibility.purpose,
+                evidence: eligibility.selected.map(item => learningRef(item.evidence)),
+                decisions: eligibility.selected.map(item => learningRef(item.decision)),
+            }, actorId, now);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof LearningDomainError))
+            throw error;
+        // An unavailable count is not zero. Invalid sources or unsupported admission
+        // must remain visible while the Model's settings and history can still load.
+        block(error.code, error.message.slice(0, 20_000));
+    }
+    return LearningPolicyInspectionResultSchema.parse({
+        policy: learningRef(policy), modelProjectId: policy.modelProjectId, inspectedAt: now, chain,
+        counts, minimumApprovedExamples: policy.admission.minimumApprovedExamples, canReserve: blockers.length === 0,
+        blockers, cooldownUntil,
+        budget: { ...budget, maximumIterationSpendUsd: policy.limits.maxIterationSpendUsd, maximumDailySpendUsd: policy.limits.maxDailySpendUsd },
+    });
+}

package/dist/learning/service.js

@@ -2,6 +2,7 @@ import { cancelLearningIterationReservation } from "./iteration-reservation-canc
 import { commandLearningIterationDispatch } from "./iteration-dispatch-commands.js";
 import { reserveLearningIteration } from "./iteration-reservation-service.js";
 import { synchronizeLearningSchedule } from "./schedule-service.js";
+import { inspectLearningPolicy } from "./policy-inspection.js";
 import { requireCurrentLearningEvidence as currentEvidence, sealLearningBatch } from "./batch-service.js";
 import { saveAuthoringDraft, archiveAuthoringDraft, finalizeAuthoringDraft } from "./authoring-service.js";
 import { queueRewardCheck, cancelRewardCheck } from "./reward-check-service.js";
@@ -327,6 +328,11 @@ export function createLearningService(repository, options = {}) {
     }
     return {
         command,
+        async inspectPolicy(context, reference) {
+            authorizeRead(context);
+            const ref = LearningRevisionRefSchema.parse(reference);
+            return repository.transaction(context.scope, transaction => inspectLearningPolicy(transaction, ref, context.actor.id, now()));
+        },
         async inspectEvidence(context, reference) {
             authorizeRead(context);
             const ref = LearningRevisionRefSchema.parse(reference);

package/dist/learning/transport.js

@@ -17,6 +17,7 @@ export function assertLearningRequestJson(raw) {
 /** Scope selection is never authorization; each host resolves its authenticated owner. */
 export const LearningCommandRequestSchema = z.object({ scope: ReleaseIdSchema, command: LearningCommandSchema }).strict();
 export const LearningReadRequestSchema = z.discriminatedUnion("action", [
+    z.object({ action: z.literal("inspect_policy"), scope: ReleaseIdSchema, policy: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("inspect_evidence"), scope: ReleaseIdSchema, evidence: LearningRevisionRefSchema }).strict(),
     z.object({ action: z.literal("get"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, id: ReleaseIdSchema, revision: z.number().int().positive().optional() }).strict(),
     z.object({ action: z.literal("list"), scope: ReleaseIdSchema, kind: LearningResourceKindSchema, parentId: ReleaseIdSchema.optional(), status: z.string().min(1).max(200).optional(), afterId: ReleaseIdSchema.optional(), limit: z.number().int().min(1).max(100).default(50) }).strict(),

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

@@ -79,6 +79,24 @@ export declare const TaskBatchPackageMetadataSchema: z.ZodObject<{
         familyNamespace: z.ZodString;
         inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         outputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        requiredOutputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            schemaRef: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                path: z.ZodString;
+                contentHash: z.ZodString;
+                sizeBytes: z.ZodNumber;
+                mediaType: z.ZodString;
+                visibility: z.ZodEnum<{
+                    policy: "policy";
+                    verifier: "verifier";
+                    host_private: "host_private";
+                }>;
+            }, z.core.$strict>>>;
+            maxBytes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
         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

@@ -4,5 +4,329 @@ import { type LearningResourcePointer, type LearningTransaction } from "./reposi
 export declare function sealLearningBatch(transaction: LearningTransaction, input: Extract<LearningCommand, {
     action: "seal_batch";
 }>, actorId: string, timestamp: string): Promise<LearningResourcePointer[]>;
+/** Performs the complete shared validation without reserving families or publishing resources. */
+export declare function prepareLearningBatch(transaction: LearningTransaction, input: Extract<LearningCommand, {
+    action: "seal_batch";
+}>, actorId: string, timestamp: string): Promise<{
+    batch: {
+        schemaVersion: "openpond.taskBatch.v1";
+        id: string;
+        revision: 1;
+        taskDefinition: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        rewardBinding: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        purpose: "evaluation" | "supervised_training" | "reward_training";
+        examples: {
+            evidence: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            decision: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            familyKey: string;
+            inputHash: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+        }[];
+        sealedAt: string;
+        sealedBy: string;
+        contentHash: string;
+    };
+    release: {
+        schemaVersion: "openpond.tasksetRelease.v2";
+        id: string;
+        revision: number;
+        policy: {
+            policyVisibleFields: string[];
+            privilegedFields: string[];
+            hiddenGraderRefs: string[];
+            connectedAppScopes: string[];
+        };
+        environment: {
+            protocolVersion: "openpond.environment.v1";
+            kind: "text" | "agent" | "work" | "custom_program";
+            entrypoint: string;
+            stateful: boolean;
+            deterministicSeeds: boolean;
+            lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+            networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+            defaultTimeoutMs: number;
+        };
+        tools: {
+            name: string;
+            description: string;
+            inputSchema: Record<string, unknown>;
+            inputSchemaHash: string;
+            sideEffect: "read" | "write";
+            timeoutMs: number;
+        }[];
+        capabilities: {
+            id: string;
+            required: boolean;
+            scopes: string[];
+            portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+        }[];
+        tasks: {
+            id: string;
+            clusterKey: string;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, unknown>;
+            expectedOutput: Record<string, unknown> | null;
+            policyVisibleContext: Record<string, unknown>;
+            privilegedContextRef: string | null;
+            artifactRefs: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            tags: string[];
+            requiredOutputs?: {
+                path: string;
+                mediaType: string;
+                schemaRef: {
+                    id: string;
+                    path: string;
+                    contentHash: string;
+                    sizeBytes: number;
+                    mediaType: string;
+                    visibility: "policy" | "verifier" | "host_private";
+                } | null;
+                maxBytes: number | null;
+                metadata: Record<string, unknown>;
+            }[] | undefined;
+        }[];
+        graders: ({
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "content" | "schema" | "artifact" | "runtime_event" | "state";
+            config: Record<string, unknown>;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "model_judge";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            calibrationStatus: "pending" | "passed" | "failed";
+            model?: {
+                providerId: string;
+                modelId: string;
+                revision: string | null;
+            } | undefined;
+            temperature?: number | undefined;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "custom_verifier";
+            verifierRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            timeoutMs: number;
+            networkPolicy: "none";
+            exportName?: string | undefined;
+        } | {
+            id: string;
+            version: string;
+            weight: number;
+            hardGate: boolean;
+            rewardEligible: boolean;
+            privileged: boolean;
+            kind: "human";
+            rubricRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            };
+            reviewerRole: string;
+        })[];
+        metadata: Record<string, unknown>;
+        contentHash: string;
+        environmentRelease?: {
+            id: string;
+            contentHash: string;
+        } | undefined;
+        verifierSetRelease?: {
+            id: string;
+            contentHash: string;
+        } | undefined;
+        metrics?: {
+            schemaVersion: "openpond.tasksetMetricPolicy.v1";
+            primaryMetric: string;
+            aggregation: "mean_score" | "pass_rate" | "weighted_mean" | "custom";
+            missingReward: "zero" | "exclude";
+            customAggregator: {
+                module: string;
+                exportName: string;
+                contentHash: string;
+                timeoutMs: number;
+                networkPolicy: "none";
+            } | null;
+            taskWeights?: Record<string, number> | undefined;
+        } | undefined;
+    };
+    evidence: {
+        schemaVersion: "openpond.taskEvidence.v1";
+        id: string;
+        revision: number;
+        source: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        submission: {
+            schemaVersion: "openpond.taskExample.v1";
+            sourceId: string;
+            idempotencyKey: string;
+            taskDefinition: {
+                id: string;
+                contentHash: string;
+                revision: number;
+            };
+            exampleId: string;
+            attemptId: string;
+            occurredAt: string;
+            familyKey: string | null;
+            split: "train" | "validation" | "test" | "frozen_eval";
+            input: Record<string, import("zod").JSONType>;
+            observedOutput: Record<string, import("zod").JSONType> | null;
+            expected: Record<string, import("zod").JSONType> | null;
+            evaluatorContext: Record<string, import("zod").JSONType> | null;
+            assets: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            }[];
+            provenance: {
+                sourceRecordRef: string | null;
+                mappingHash: string | null;
+            };
+        };
+        supersedes: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        } | null;
+        correctionFeedbackId: string | null;
+        receivedAt: string;
+        contentHash: string;
+    }[];
+    definition: {
+        schemaVersion: "openpond.taskDefinition.v1";
+        id: string;
+        revision: number;
+        name: string;
+        description: string;
+        instructions: string;
+        category: "custom" | "structured" | "question_answering" | "coding" | "tool_workflow";
+        familyNamespace: string;
+        inputSchema: Record<string, unknown>;
+        outputSchema: Record<string, unknown>;
+        rewardBinding: {
+            id: string;
+            contentHash: string;
+            revision: number;
+        };
+        harness: {
+            id: string;
+            contentHash: string;
+        } | null;
+        execution: {
+            policy: {
+                policyVisibleFields: string[];
+                privilegedFields: string[];
+                hiddenGraderRefs: string[];
+                connectedAppScopes: string[];
+            };
+            environment: {
+                protocolVersion: "openpond.environment.v1";
+                kind: "text" | "agent" | "work" | "custom_program";
+                entrypoint: string;
+                stateful: boolean;
+                deterministicSeeds: boolean;
+                lifecycle: ("create" | "reset" | "step" | "collect" | "destroy")[];
+                networkPolicy: "none" | "declared_read_only" | "declared_scoped";
+                defaultTimeoutMs: number;
+            };
+            tools: {
+                name: string;
+                description: string;
+                inputSchema: Record<string, unknown>;
+                inputSchemaHash: string;
+                sideEffect: "read" | "write";
+                timeoutMs: number;
+            }[];
+            capabilities: {
+                id: string;
+                required: boolean;
+                scopes: string[];
+                portability: "portable" | "host_adapter" | "local_only" | "hosted_only";
+            }[];
+            environmentRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+            verifierSetRelease?: {
+                id: string;
+                contentHash: string;
+            } | undefined;
+        };
+        contentHash: string;
+        requiredOutputs?: {
+            path: string;
+            mediaType: string;
+            schemaRef: {
+                id: string;
+                path: string;
+                contentHash: string;
+                sizeBytes: number;
+                mediaType: string;
+                visibility: "policy" | "verifier" | "host_private";
+            } | null;
+            maxBytes: number | null;
+            metadata: Record<string, unknown>;
+        }[] | undefined;
+    };
+}>;
 export declare function requireCurrentLearningEvidence(transaction: LearningTransaction, ref: LearningRevisionRef): Promise<TaskEvidence>;
 //# sourceMappingURL=batch-service.d.ts.map

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,CA2B3M;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"}