@openpond/evals 0.10.1 → 0.10.3

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { LearningRevisionRefSchema } from "./contracts.js";
+export const LearningIterationTriggerSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("manual"), identity: ReleaseIdSchema }).strict(),
+    z.object({ kind: z.literal("schedule"), scheduledAt: ReleaseTimestampSchema }).strict(),
+]);
+/** Stable across policy edits: a Model owns one learning chain in its scope. */
+export const LearningChainSchema = z.object({
+    schemaVersion: z.literal("openpond.learningChain.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    modelProjectId: ReleaseIdSchema,
+    activeIterationId: ReleaseIdSchema.nullable(),
+    latestIterationId: ReleaseIdSchema,
+    lastReservedAt: ReleaseTimestampSchema.nullable(),
+    updatedAt: ReleaseTimestampSchema,
+}).strict();
+export const LearningEligibilityCountsSchema = z.object({
+    eligible: z.number().int().nonnegative(),
+    awaitingReview: z.number().int().nonnegative(),
+    excluded: z.number().int().nonnegative(),
+    consumed: z.number().int().nonnegative(),
+}).strict();
+/** Immutable evidence consumption survives rejection and policy revision changes.
+ * A corrected evidence revision is new data; reapproving the same revision isn't. */
+export const LearningConsumptionSchema = z.object({
+    schemaVersion: z.literal("openpond.learningConsumption.v1"),
+    id: ReleaseIdSchema,
+    revision: z.literal(1),
+    chainId: ReleaseIdSchema,
+    iterationId: ReleaseIdSchema,
+    evidence: LearningRevisionRefSchema,
+    decision: LearningRevisionRefSchema,
+    reservedAt: ReleaseTimestampSchema,
+}).strict();
+/** Dispatch must reconcile this reservation, never reserve a second batch on retry. */
+export const LearningIterationReservationSchema = z.object({
+    schemaVersion: z.literal("openpond.learningIterationReservation.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    chainId: ReleaseIdSchema,
+    iterationId: ReleaseIdSchema,
+    policy: LearningRevisionRefSchema,
+    trigger: LearningIterationTriggerSchema,
+    requestHash: ReleaseHashSchema,
+    outcome: z.enum(["reserved", "waiting_for_data", "waiting_for_review"]),
+    counts: LearningEligibilityCountsSchema,
+    budget: z.object({
+        maximumSpendUsd: z.number().nonnegative(),
+        reservedSpendUsd: z.number().nonnegative(),
+        settledSpendUsd: z.number().nonnegative(),
+        settledAt: ReleaseTimestampSchema.nullable(),
+    }).strict(),
+    createdAt: ReleaseTimestampSchema,
+    updatedAt: ReleaseTimestampSchema,
+}).strict();

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

@@ -0,0 +1,106 @@
+import { contentHash } from "@openpond/harness";
+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 { 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. */
+export async function reserveLearningIteration(transaction, input, actorId, now) {
+    const policy = await requireLearningRelease(transaction, "policy", input.policy);
+    const chainId = learningChainId(policy.modelProjectId);
+    const trigger = input.trigger.kind === "schedule" ? { ...input.trigger, scheduledAt: new Date(input.trigger.scheduledAt).toISOString() } : input.trigger;
+    const triggerIdentity = contentHash([input.policy.id, trigger]);
+    const id = `iteration-${contentHash([chainId, triggerIdentity])}`;
+    const requestHash = contentHash({ policy: input.policy, trigger });
+    const previous = await transaction.get("reservation", id);
+    if (previous) {
+        if (previous.requestHash !== requestHash)
+            throw new LearningDomainError("learning_trigger_identity_conflict", 409);
+        // Fire identity is independent of actor and transport operation identity.
+        return [{ kind: "iteration", id, revision: (await requireLearningResource(transaction, "iteration", id)).revision }, { kind: "reservation", id, revision: previous.revision }];
+    }
+    const current = await requireLearningResource(transaction, "policy", policy.id);
+    if (!sameLearningRef(learningRef(current), input.policy))
+        throw new LearningDomainError("learning_policy_revision_stale", 409);
+    if (!policy.enabled)
+        throw new LearningDomainError("learning_policy_paused", 409);
+    if (policy.automation.accept || policy.automation.serve)
+        throw new LearningDomainError("learning_automatic_acceptance_not_available", 422);
+    if (input.trigger.kind === "schedule") {
+        if (policy.trigger.kind !== "schedule" || !policy.automation.train)
+            throw new LearningDomainError("learning_schedule_not_enabled", 409);
+        if (Date.parse(input.trigger.scheduledAt) > Date.parse(now))
+            throw new LearningDomainError("learning_schedule_not_due", 409);
+    }
+    const chain = await transaction.get("chain", chainId);
+    if (chain?.activeIterationId)
+        throw new LearningDomainError("learning_iteration_active", 409, chain.activeIterationId);
+    if (chain?.lastReservedAt && Date.parse(now) - Date.parse(chain.lastReservedAt) < policy.limits.cooldownSeconds * 1_000) {
+        throw new LearningDomainError("learning_iteration_cooldown", 409);
+    }
+    const eligibility = await inspectIterationEligibility(transaction, policy);
+    const ready = eligibility.counts.eligible >= policy.admission.minimumApprovedExamples;
+    const status = ready ? "ready" : eligibility.counts.awaitingReview > 0 ? "waiting_for_review" : "waiting_for_data";
+    const pointers = [];
+    let batch = null;
+    if (ready) {
+        await assertAvailableBudget(transaction, chainId, now, policy.limits.maxIterationSpendUsd, policy.limits.maxDailySpendUsd);
+        const sealed = await sealLearningBatch(transaction, {
+            action: "seal_batch", operationId: input.operationId, batchId: `batch-${contentHash(id)}`,
+            taskDefinition: policy.taskDefinition, purpose: eligibility.purpose,
+            evidence: eligibility.selected.map((item) => learningRef(item.evidence)),
+            decisions: eligibility.selected.map((item) => learningRef(item.decision)),
+        }, actorId, now);
+        pointers.push(...sealed);
+        batch = learningRef(await requireLearningResource(transaction, "batch", sealed[0].id));
+        for (const item of eligibility.selected) {
+            const consumption = LearningConsumptionSchema.parse({
+                schemaVersion: "openpond.learningConsumption.v1", id: learningConsumptionId(chainId, item.evidence), revision: 1,
+                chainId, iterationId: id, evidence: learningRef(item.evidence), decision: learningRef(item.decision), reservedAt: now,
+            });
+            await transaction.put("consumption", consumption, 0, { parentId: chainId });
+        }
+    }
+    const iteration = LearningIterationSchema.parse({
+        schemaVersion: "openpond.learningIteration.v1", id, revision: 1, policy: input.policy, status,
+        triggerIdentity, batch,
+        // Existing evidence has no ordered ingress sequence. Consumption records,
+        // not a count or lexicographic ID cursor, decide whether an example is new.
+        sourceWatermarks: {}, trainingParent: policy.trainingParent, teacher: policy.teacher, upstreamEvent: null,
+        trainingJob: null, evaluationJob: null, candidateVersion: null, dispatchId: `dispatch-${contentHash(id)}`,
+        retryCount: 0, spendUsd: 0, failure: null, createdAt: now, updatedAt: now,
+    });
+    const reservation = LearningIterationReservationSchema.parse({
+        schemaVersion: "openpond.learningIterationReservation.v1", id, revision: 1, chainId, iterationId: id,
+        policy: input.policy, trigger, requestHash, outcome: ready ? "reserved" : status,
+        counts: eligibility.counts,
+        budget: { maximumSpendUsd: ready ? policy.limits.maxIterationSpendUsd : 0, reservedSpendUsd: ready ? policy.limits.maxIterationSpendUsd : 0, settledSpendUsd: 0, settledAt: ready ? null : now },
+        createdAt: now, updatedAt: now,
+    });
+    const updatedChain = LearningChainSchema.parse({
+        schemaVersion: "openpond.learningChain.v1", id: chainId, revision: (chain?.revision ?? 0) + 1,
+        modelProjectId: policy.modelProjectId, activeIterationId: ready ? id : null, latestIterationId: id,
+        lastReservedAt: ready ? now : chain?.lastReservedAt ?? null, updatedAt: now,
+    });
+    await transaction.put("iteration", iteration, 0, { parentId: chainId, status });
+    await transaction.put("reservation", reservation, 0, { parentId: chainId, status: reservation.outcome });
+    await transaction.put("chain", updatedChain, chain?.revision ?? 0, { parentId: policy.modelProjectId });
+    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)
+        throw new LearningDomainError("learning_daily_budget_exhausted", 409);
+}

package/dist/learning/operations.js

@@ -1,3 +1,4 @@
+import { LearningIterationTriggerSchema } from "./iteration-reservation-contracts.js";
 import { z } from "zod";
 import { ReleaseIdSchema } from "@openpond/harness";
 import { LearningJsonObjectSchema, LearningRevisionRefSchema, LearningSourceContentSchema, TaskDefinitionContentSchema, TaskExampleSubmissionSchema, TaskFeedbackSubmissionSchema, LearningPolicyContentSchema } from "./contracts.js";
@@ -36,4 +37,8 @@ export const SaveAuthoringDraftCommandSchema = command.extend({ action: z.litera
 export const ArchiveAuthoringDraftCommandSchema = command.extend({ action: z.literal("archive_draft"), draft: LearningRevisionRefSchema }).strict();
 export const QueueRewardCheckCommandSchema = command.extend({ action: z.literal("queue_reward_check"), draft: LearningRevisionRefSchema, timeoutMs: z.number().int().min(100).max(300_000).default(30_000), maximumSpendUsd: z.number().nonnegative().max(1_000).default(0) }).strict();
 export const CancelRewardCheckCommandSchema = command.extend({ action: z.literal("cancel_reward_check"), checkId: ReleaseIdSchema, expectedRevision: z.number().int().positive() }).strict();
-export const LearningCommandSchema = z.union([QueueRewardCheckCommandSchema, CancelRewardCheckCommandSchema, SaveAuthoringDraftCommandSchema, ArchiveAuthoringDraftCommandSchema, PublishLearningResourceCommandSchema, PublishLearningResourcesCommandSchema, SubmitTaskExampleCommandSchema, SubmitTaskFeedbackCommandSchema, ApplyTaskCorrectionCommandSchema, ResolveTaskFeedbackCommandSchema, QueueTaskGradeCommandSchema, ReviewTaskEvidenceCommandSchema, SealTaskBatchCommandSchema, CancelTaskGradeCommandSchema]);
+export const ReserveLearningIterationCommandSchema = command.extend({ action: z.literal("reserve_iteration"), policy: LearningRevisionRefSchema, trigger: LearningIterationTriggerSchema }).strict();
+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]);

package/dist/learning/repository.js

@@ -1,3 +1,5 @@
+import { LearningChainSchema, LearningConsumptionSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
+import { LearningIterationDispatchSchema } from "./iteration-dispatch-contracts.js";
 import { z } from "zod";
 import { contentHash } from "@openpond/harness";
 import { assertLearningContentHash, LearningSourceSchema, TaskAdmissionDecisionSchema, TaskBatchSchema, TaskDefinitionSchema, TaskEvidenceSchema, TaskFeedbackSchema, TaskGradeRunSchema, LearningPolicySchema, LearningIterationSchema } from "./contracts.js";
@@ -14,6 +16,8 @@ export const learningResourceSchemas = {
     definition: TaskDefinitionSchema, reward: RewardReleaseSchema, binding: RewardBindingSchema,
     source: LearningSourceSchema, evidence: TaskEvidenceSchema, feedback: TaskFeedbackSchema,
     decision: TaskAdmissionDecisionSchema, batch: TaskBatchSchema, policy: LearningPolicySchema,
+    chain: LearningChainSchema, consumption: LearningConsumptionSchema, reservation: LearningIterationReservationSchema,
+    dispatch: LearningIterationDispatchSchema,
     iteration: LearningIterationSchema, grade: TaskGradeRunSchema, package: TasksetReleaseSchema,
 };
 export const LearningResourceKindSchema = z.enum(Object.keys(learningResourceSchemas));

package/dist/learning/service.js

@@ -1,10 +1,14 @@
+import { cancelLearningIterationReservation } from "./iteration-reservation-cancellation.js";
+import { commandLearningIterationDispatch } from "./iteration-dispatch-commands.js";
+import { reserveLearningIteration } from "./iteration-reservation-service.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";
 import { LearningDomainError } from "./errors.js";
 import { contentHash } from "@openpond/harness";
-import { createRewardBinding, createRewardRelease, resolveBoundRewards } from "../rewards.js";
+import { createRewardBinding, createRewardRelease } from "../rewards.js";
 import { assertBoundedTaskJson, validateTaskValue } from "../task-schema.js";
-import { assertAdmissionDecision, assertGradeIdentity, compileTaskBatch, inspectTaskEvidence, sealTaskBatch, taskFamilyReservations } from "./admission.js";
+import { assertAdmissionDecision, assertGradeIdentity, inspectTaskEvidence } from "./admission.js";
 import { learningRef, LearningSourceSchema, LearningPolicySchema, sameLearningRef, sealLearningContent, TaskAdmissionDecisionContentSchema, TaskAdmissionDecisionSchema, TaskDefinitionSchema, TaskEvidenceContentSchema, TaskEvidenceSchema, TaskFeedbackSchema, TaskGradeRunSchema } from "./contracts.js";
 import { LearningCommandSchema } from "./operations.js";
 import { LearningConflictError, learningEvidenceId, learningOperationId, requireLearningRelease, requireLearningResource } from "./repository.js";
@@ -29,6 +33,16 @@ export function createLearningService(repository, options = {}) {
             }
             let pointers;
             switch (input.action) {
+                case "cancel_iteration":
+                case "retry_iteration_dispatch":
+                    pointers = await commandLearningIterationDispatch(transaction, input, now());
+                    break;
+                case "cancel_iteration_reservation":
+                    pointers = await cancelLearningIterationReservation(transaction, input, now());
+                    break;
+                case "reserve_iteration":
+                    pointers = await reserveLearningIteration(transaction, input, context.actor.id, now());
+                    break;
                 case "queue_reward_check":
                     pointers = [await queueRewardCheck(transaction, input, operationId, now())];
                     break;
@@ -72,7 +86,7 @@ export function createLearningService(repository, options = {}) {
                     pointers = [await review(transaction, input, context.actor.id)];
                     break;
                 case "seal_batch":
-                    pointers = await seal(transaction, input, context.actor.id);
+                    pointers = await sealLearningBatch(transaction, input, context.actor.id, now());
                     break;
             }
             if (input.action === "publish" || input.action === "publish_resources") {
@@ -143,7 +157,7 @@ export function createLearningService(repository, options = {}) {
                 break;
             }
         }
-        await transaction.put(input.kind, resource, input.expectedRevision);
+        await transaction.put(input.kind, resource, input.expectedRevision, input.kind === "policy" ? { parentId: input.content.modelProjectId } : undefined);
         return pointer(input.kind, resource);
     }
     async function submit(transaction, input) {
@@ -308,37 +322,6 @@ export function createLearningService(repository, options = {}) {
         await transaction.put("decision", decision, input.expectedRevision, { parentId: evidence.id, status: decision.taskAdmissibility });
         return pointer("decision", decision);
     }
-    async function seal(transaction, input, actorId) {
-        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)));
-        resolveBoundRewards(binding, rewards);
-        const evidence = await Promise.all(input.evidence.map((ref) => currentEvidence(transaction, ref)));
-        const decisions = await Promise.all(input.decisions.map(async (ref) => {
-            const decision = await requireLearningRelease(transaction, "decision", ref);
-            const current = await requireLearningResource(transaction, "decision", ref.id);
-            if (!sameLearningRef(learningRef(current), ref))
-                throw new LearningDomainError("task_admission_revision_stale", 409);
-            return decision;
-        }));
-        const priorSplits = [];
-        for (const item of evidence) {
-            for (const reservation of taskFamilyReservations(item, definition)) {
-                const split = await transaction.familySplit(reservation.namespace, reservation.kind, reservation.key);
-                if (split !== null)
-                    priorSplits.push({ ...reservation, split: split });
-            }
-        }
-        const batch = sealTaskBatch({ id: input.batchId, definition, binding, rewards, purpose: input.purpose, evidence, decisions, priorSplits, actorId, now: now() });
-        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 {
         command,
         async inspectEvidence(context, reference) {
@@ -361,13 +344,6 @@ export function createLearningService(repository, options = {}) {
         },
     };
 }
-async function currentEvidence(transaction, ref) {
-    const evidence = await requireLearningRelease(transaction, "evidence", ref);
-    const current = await requireLearningResource(transaction, "evidence", ref.id);
-    if (!sameLearningRef(learningRef(current), ref))
-        throw new LearningDomainError("task_evidence_revision_stale", 409);
-    return evidence;
-}
 async function gradeResult(transaction, id, evidence, target) {
     if (id === null)
         return null;
@@ -391,6 +367,6 @@ function authorize(context, input) {
         if (!sourceId || sourceId !== context.actor.sourceId)
             throw new LearningDomainError("learning_source_not_authorized", 403);
     }
-    if (["review", "apply_correction", "resolve_feedback", "seal_batch"].includes(input.action) && context.actor.role !== "reviewer")
+    if (["review", "apply_correction", "resolve_feedback", "seal_batch", "reserve_iteration", "cancel_iteration_reservation", "cancel_iteration", "retry_iteration_dispatch"].includes(input.action) && context.actor.role !== "reviewer")
         throw new LearningDomainError("learning_review_not_authorized", 403);
 }

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

@@ -0,0 +1,8 @@
+import { type LearningRevisionRef, type TaskEvidence } from "./contracts.js";
+import type { LearningCommand } from "./operations.js";
+import { type LearningResourcePointer, type LearningTransaction } from "./repository.js";
+export declare function sealLearningBatch(transaction: LearningTransaction, input: Extract<LearningCommand, {
+    action: "seal_batch";
+}>, actorId: string, timestamp: string): Promise<LearningResourcePointer[]>;
+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

@@ -0,0 +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"}

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

@@ -1183,10 +1183,12 @@ export declare const LearningIterationStatusSchema: z.ZodEnum<{
     waiting_for_data: "waiting_for_data";
     waiting_for_review: "waiting_for_review";
     ready: "ready";
+    dispatching: "dispatching";
     evaluating: "evaluating";
     candidate_ready: "candidate_ready";
     paused: "paused";
     cancelling: "cancelling";
+    completed_without_candidate: "completed_without_candidate";
 }>;
 export declare const LearningIterationSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
@@ -1206,10 +1208,12 @@ export declare const LearningIterationSchema: z.ZodObject<{
         waiting_for_data: "waiting_for_data";
         waiting_for_review: "waiting_for_review";
         ready: "ready";
+        dispatching: "dispatching";
         evaluating: "evaluating";
         candidate_ready: "candidate_ready";
         paused: "paused";
         cancelling: "cancelling";
+        completed_without_candidate: "completed_without_candidate";
     }>;
     triggerIdentity: z.ZodString;
     batch: z.ZodNullable<z.ZodObject<{
@@ -1242,6 +1246,11 @@ export declare const LearningIterationSchema: z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict>>;
+    candidateDecision: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>>;
     dispatchId: z.ZodString;
     retryCount: z.ZodNumber;
     spendUsd: z.ZodNumber;
@@ -2078,10 +2087,12 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
         waiting_for_data: "waiting_for_data";
         waiting_for_review: "waiting_for_review";
         ready: "ready";
+        dispatching: "dispatching";
         evaluating: "evaluating";
         candidate_ready: "candidate_ready";
         paused: "paused";
         cancelling: "cancelling";
+        completed_without_candidate: "completed_without_candidate";
     }>;
     triggerIdentity: z.ZodString;
     batch: z.ZodNullable<z.ZodObject<{
@@ -2114,6 +2125,11 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
         id: z.ZodString;
         contentHash: z.ZodString;
     }, z.core.$strict>>;
+    candidateDecision: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>>;
     dispatchId: z.ZodString;
     retryCount: z.ZodNumber;
     spendUsd: z.ZodNumber;

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

@@ -1 +1 @@
-{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/learning/contracts.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,wBAAwB,2CAAiC,CAAC;AACvE,eAAO,MAAM,yBAAyB;;;;kBAAyB,CAAC;AAChE,eAAO,MAAM,yBAAyB,aAAiJ,CAAC;AAExL,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsBtC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsF,CAAC;AAExH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;kBAWzB,CAAC;AACZ;0EAC0E;AAC1E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;kBAM5B,CAAC;AACZ,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgBtC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsF,CAAC;AAExH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgB7B,CAAC;AAEZ,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAS3B,CAAC;AACZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAgF,CAAC;AAEhH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;kBAW9B,CAAC;AACZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBASpB,CAAC;AAEZ,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqB7C,CAAC;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA6F,CAAC;AAEtI,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBjC,CAAC;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAiF,CAAC;AAE9G,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA8BtC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAsF,CAAC;AACxH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;EAAkL,CAAC;AAC7N,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBzB,CAAC;AAEZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBpB,CAAC;AAEZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2P,CAAC;AAE/R,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,mBAAmB,CAEhH;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAE9F;AACD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAG9G;AACD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIjF"}
+{"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

@@ -12,4 +12,8 @@ export * from "./reward-authoring.js";
 export * from "./reward-checks.js";
 export * from "./reward-check-worker.js";
 export * from "./reward-fixture-executor.js";
+export * from "./iteration-reservation-contracts.js";
+export * from "./iteration-dispatch-contracts.js";
+export * from "./iteration-dispatch-worker.js";
+export * from "./iteration-candidate-decision.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/learning/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC"}

package/dist/types/learning/iteration-candidate-decision.d.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+import { type LearningRepository } from "./repository.js";
+export declare const LearningCandidateDecisionObservationSchema: z.ZodObject<{
+    scope: z.ZodString;
+    iterationId: z.ZodString;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    outcome: z.ZodEnum<{
+        rejected: "rejected";
+        accepted: "accepted";
+    }>;
+    execution: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    evaluation: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+    receipt: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LearningCandidateDecisionObservation = z.infer<typeof LearningCandidateDecisionObservationSchema>;
+/** Trusted host boundary: verify the provider's immutable decision and ownership
+ * before calling. This reconciles retained evidence; it does not authorize a
+ * review, accept a model automatically, or activate serving. */
+export declare function reconcileLearningCandidateDecision(repository: LearningRepository, value: LearningCandidateDecisionObservation, options?: {
+    now?: () => string;
+}): Promise<{
+    schemaVersion: "openpond.learningIteration.v1";
+    id: string;
+    revision: number;
+    policy: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    status: "failed" | "cancelled" | "rejected" | "accepted" | "training" | "waiting_for_data" | "waiting_for_review" | "ready" | "dispatching" | "evaluating" | "candidate_ready" | "paused" | "cancelling" | "completed_without_candidate";
+    triggerIdentity: string;
+    batch: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    } | null;
+    sourceWatermarks: Record<string, number>;
+    trainingParent: {
+        id: string;
+        contentHash: string;
+    };
+    teacher: {
+        id: string;
+        contentHash: string;
+    } | null;
+    upstreamEvent: {
+        id: string;
+        contentHash: string;
+    } | null;
+    trainingJob: {
+        id: string;
+        contentHash: string;
+    } | null;
+    evaluationJob: {
+        id: string;
+        contentHash: string;
+    } | null;
+    candidateVersion: {
+        id: string;
+        contentHash: string;
+    } | null;
+    candidateDecision: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    } | null;
+    dispatchId: string;
+    retryCount: number;
+    spendUsd: number;
+    failure: {
+        code: string;
+        message: string;
+    } | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+//# sourceMappingURL=iteration-candidate-decision.d.ts.map

package/dist/types/learning/iteration-candidate-decision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-candidate-decision.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-candidate-decision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,eAAO,MAAM,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAS5C,CAAC;AACZ,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0CAA0C,CAAC,CAAC;AAE9G;;gEAEgE;AAChE,wBAAsB,kCAAkC,CAAC,UAAU,EAAE,kBAAkB,EAAE,KAAK,EAAE,oCAAoC,EAClI,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BrC"}

package/dist/types/learning/iteration-dispatch-commands.d.ts

@@ -0,0 +1,8 @@
+import type { LearningCommand } from "./operations.js";
+import { type LearningResourcePointer, type LearningTransaction } from "./repository.js";
+type DispatchCommand = Extract<LearningCommand, {
+    action: "cancel_iteration" | "retry_iteration_dispatch";
+}>;
+export declare function commandLearningIterationDispatch(tx: LearningTransaction, input: DispatchCommand, now: string): Promise<LearningResourcePointer[]>;
+export {};
+//# sourceMappingURL=iteration-dispatch-commands.d.ts.map

package/dist/types/learning/iteration-dispatch-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-dispatch-commands.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-dispatch-commands.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAkD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEzI,KAAK,eAAe,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,kBAAkB,GAAG,0BAA0B,CAAA;CAAE,CAAC,CAAC;AAE7G,wBAAsB,gCAAgC,CAAC,EAAE,EAAE,mBAAmB,EAAE,KAAK,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAoBvJ"}

package/dist/types/learning/iteration-dispatch-contracts.d.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+/** The executor validates its protocol payload before returning this snapshot.
+ * Credentials and expiring transport URLs belong to the executor, not payload. */
+export declare const LearningIterationSubmissionSchema: z.ZodObject<{
+    provider: z.ZodString;
+    protocol: z.ZodString;
+    payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+export declare const LearningIterationDispatchSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningIterationDispatch.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    iterationId: z.ZodString;
+    chainId: z.ZodString;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    batch: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+        blocked: "blocked";
+        preparing: "preparing";
+        prepared: "prepared";
+        submitted: "submitted";
+        settled: "settled";
+    }>;
+    submission: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        protocol: z.ZodString;
+        payload: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    submissionHash: z.ZodNullable<z.ZodString>;
+    submissionStartedAt: z.ZodNullable<z.ZodString>;
+    execution: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    terminalReceipt: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    cancelRequestedAt: z.ZodNullable<z.ZodString>;
+    leaseOwner: z.ZodNullable<z.ZodString>;
+    leaseGeneration: z.ZodNumber;
+    leaseExpiresAt: z.ZodNullable<z.ZodString>;
+    consecutiveFailures: z.ZodNumber;
+    nextAttemptAt: z.ZodNullable<z.ZodString>;
+    lastError: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+/** Terminal cleanup includes fencing future submission under this dispatch ID.
+ * The execution adapter verifies its authoritative provider receipt. */
+export declare const LearningIterationObservationSchema: z.ZodObject<{
+    scope: z.ZodString;
+    dispatchId: z.ZodString;
+    submissionHash: z.ZodString;
+    execution: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        failed: "failed";
+        cancelled: "cancelled";
+        running: "running";
+        evaluating: "evaluating";
+        succeeded: "succeeded";
+    }>;
+    spendUsd: z.ZodNumber;
+    cleanupComplete: z.ZodBoolean;
+    receipt: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    evaluation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    candidate: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>>;
+    failure: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type LearningIterationSubmission = z.infer<typeof LearningIterationSubmissionSchema>;
+export type LearningIterationDispatch = z.infer<typeof LearningIterationDispatchSchema>;
+export type LearningIterationObservation = z.infer<typeof LearningIterationObservationSchema>;
+//# sourceMappingURL=iteration-dispatch-contracts.d.ts.map

package/dist/types/learning/iteration-dispatch-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-dispatch-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-dispatch-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;kFACkF;AAClF,eAAO,MAAM,iCAAiC;;;;kBAInC,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC1C,CAAC;AAEH;wEACwE;AACxE,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkB7C,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAC5F,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AACxF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC"}