@openpond/evals 0.10.1 → 0.10.2

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<{
@@ -2078,10 +2082,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<{

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

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

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

@@ -12,4 +12,7 @@ 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";
 //# 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"}

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"}

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

@@ -0,0 +1,35 @@
+import { type LearningIteration, type LearningPolicy, type TaskBatch } from "./contracts.js";
+import { type LearningIterationDispatch, type LearningIterationObservation, type LearningIterationSubmission } from "./iteration-dispatch-contracts.js";
+import { type LearningRepository } from "./repository.js";
+export type LearningIterationExecutionContext = {
+    scope: string;
+    dispatch: LearningIterationDispatch;
+    iteration: LearningIteration;
+    policy: LearningPolicy;
+    batch: TaskBatch;
+    signal: AbortSignal;
+};
+export interface LearningIterationExecutor {
+    /** Resolve immutable inputs and validate compatibility. Must not launch compute. */
+    prepare(input: LearningIterationExecutionContext): Promise<LearningIterationSubmission>;
+    /** Return the existing execution under dispatch.id; null means not found.
+     * An unavailable owner must throw, never report absence. */
+    reconcile(input: LearningIterationExecutionContext): Promise<LearningIterationObservation | null>;
+    /** Idempotently submit exactly dispatch.submission under dispatch.id, across
+     * crashes, lease owners and retries. Never create a different Job on retry. */
+    submit(input: LearningIterationExecutionContext): Promise<LearningIterationObservation>;
+    /** Cancel by dispatch identity, including an ambiguous initial submission.
+     * Terminal confirmation MUST fence late submits under that identity, including
+     * when no Job was created. A network abort alone is not cleanup confirmation. */
+    cancel(input: LearningIterationExecutionContext): Promise<LearningIterationObservation>;
+}
+export declare function createLearningIterationWorker(repository: LearningRepository, executor: LearningIterationExecutor, options: {
+    workerId: string;
+    executionOwner: LearningPolicy["executionOwner"];
+    now?: () => string;
+    leaseMs?: number;
+    requestTimeoutMs?: number;
+}): {
+    run: (scope: string, iterationId: string) => Promise<LearningIteration>;
+};
+//# sourceMappingURL=iteration-dispatch-worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-dispatch-worker.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-dispatch-worker.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAGtH,OAAO,EAEL,KAAK,yBAAyB,EAAE,KAAK,4BAA4B,EAAE,KAAK,2BAA2B,EACpG,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAmD,KAAK,kBAAkB,EAA4B,MAAM,iBAAiB,CAAC;AAErI,MAAM,MAAM,iCAAiC,GAAG;IAC9C,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,yBAAyB,CAAC;IACpC,SAAS,EAAE,iBAAiB,CAAC;IAC7B,MAAM,EAAE,cAAc,CAAC;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AACF,MAAM,WAAW,yBAAyB;IACxC,oFAAoF;IACpF,OAAO,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxF;gEAC4D;IAC5D,SAAS,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAAC;IAClG;mFAC+E;IAC/E,MAAM,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;IACxF;;qFAEiF;IACjF,MAAM,CAAC,KAAK,EAAE,iCAAiC,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;CACzF;AAID,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,kBAAkB,EAAE,QAAQ,EAAE,yBAAyB,EAAE,OAAO,EAAE;IAC1H,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,cAAc,CAAC,gBAAgB,CAAC,CAAC;IACjD,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;iBAsF2B,MAAM,eAAe,MAAM,KAAG,OAAO,CAAC,iBAAiB,CAAC;EA8DnF"}

package/dist/types/learning/iteration-eligibility.d.ts

@@ -0,0 +1,18 @@
+import { type LearningPolicy, type TaskAdmissionDecision, type TaskEvidence } from "./contracts.js";
+import { type LearningTransaction } from "./repository.js";
+export declare function learningChainId(modelProjectId: string): string;
+export declare function learningConsumptionId(chainId: string, evidence: TaskEvidence): string;
+export declare function inspectIterationEligibility(transaction: LearningTransaction, policy: LearningPolicy): Promise<{
+    counts: {
+        eligible: number;
+        awaitingReview: number;
+        excluded: number;
+        consumed: number;
+    };
+    selected: {
+        evidence: TaskEvidence;
+        decision: TaskAdmissionDecision;
+    }[];
+    purpose: "supervised_training" | "reward_training";
+}>;
+//# sourceMappingURL=iteration-eligibility.d.ts.map

package/dist/types/learning/iteration-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-eligibility.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-eligibility.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgC,KAAK,cAAc,EAAE,KAAK,qBAAqB,EAAkB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGlJ,OAAO,EAAmD,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE5G,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,CAErF;AAED,wBAAsB,2BAA2B,CAAC,WAAW,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc;;;;;;;;kBAY5E,YAAY;kBAAY,qBAAqB;;;GA2C1E"}

package/dist/types/learning/iteration-reservation-cancellation.d.ts

@@ -0,0 +1,8 @@
+import type { LearningCommand } from "./operations.js";
+import { type LearningResourcePointer, type LearningTransaction } from "./repository.js";
+/** Only a reservation that has never been dispatched can release spend locally.
+ * Submitted executions require authoritative cancellation and settlement. */
+export declare function cancelLearningIterationReservation(transaction: LearningTransaction, input: Extract<LearningCommand, {
+    action: "cancel_iteration_reservation";
+}>, now: string): Promise<LearningResourcePointer[]>;
+//# sourceMappingURL=iteration-reservation-cancellation.d.ts.map

package/dist/types/learning/iteration-reservation-cancellation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-reservation-cancellation.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-cancellation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAkD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEzI;6EAC6E;AAC7E,wBAAsB,kCAAkC,CACtD,WAAW,EAAE,mBAAmB,EAChC,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,8BAA8B,CAAA;CAAE,CAAC,EAC3E,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAsBpC"}

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

@@ -0,0 +1,90 @@
+import { z } from "zod";
+export declare const LearningIterationTriggerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"manual">;
+    identity: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"schedule">;
+    scheduledAt: z.ZodString;
+}, z.core.$strict>], "kind">;
+/** Stable across policy edits: a Model owns one learning chain in its scope. */
+export declare const LearningChainSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningChain.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    modelProjectId: z.ZodString;
+    activeIterationId: z.ZodNullable<z.ZodString>;
+    latestIterationId: z.ZodString;
+    lastReservedAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const LearningEligibilityCountsSchema: z.ZodObject<{
+    eligible: z.ZodNumber;
+    awaitingReview: z.ZodNumber;
+    excluded: z.ZodNumber;
+    consumed: z.ZodNumber;
+}, z.core.$strict>;
+/** Immutable evidence consumption survives rejection and policy revision changes.
+ * A corrected evidence revision is new data; reapproving the same revision isn't. */
+export declare const LearningConsumptionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningConsumption.v1">;
+    id: z.ZodString;
+    revision: z.ZodLiteral<1>;
+    chainId: z.ZodString;
+    iterationId: z.ZodString;
+    evidence: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    reservedAt: z.ZodString;
+}, z.core.$strict>;
+/** Dispatch must reconcile this reservation, never reserve a second batch on retry. */
+export declare const LearningIterationReservationSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningIterationReservation.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    chainId: z.ZodString;
+    iterationId: z.ZodString;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    trigger: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"manual">;
+        identity: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"schedule">;
+        scheduledAt: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    requestHash: z.ZodString;
+    outcome: z.ZodEnum<{
+        waiting_for_data: "waiting_for_data";
+        waiting_for_review: "waiting_for_review";
+        reserved: "reserved";
+    }>;
+    counts: z.ZodObject<{
+        eligible: z.ZodNumber;
+        awaitingReview: z.ZodNumber;
+        excluded: z.ZodNumber;
+        consumed: z.ZodNumber;
+    }, z.core.$strict>;
+    budget: z.ZodObject<{
+        maximumSpendUsd: z.ZodNumber;
+        reservedSpendUsd: z.ZodNumber;
+        settledSpendUsd: z.ZodNumber;
+        settledAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type LearningChain = z.infer<typeof LearningChainSchema>;
+export type LearningConsumption = z.infer<typeof LearningConsumptionSchema>;
+export type LearningIterationReservation = z.infer<typeof LearningIterationReservationSchema>;
+export type LearningIterationTrigger = z.infer<typeof LearningIterationTriggerSchema>;
+//# sourceMappingURL=iteration-reservation-contracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"iteration-reservation-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,8BAA8B;;;;;;4BAGzC,CAAC;AAEH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;kBASrB,CAAC;AAEZ,eAAO,MAAM,+BAA+B;;;;;kBAKjC,CAAC;AAEZ;qFACqF;AACrF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;kBAS3B,CAAC;AAEZ,uFAAuF;AACvF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmBpC,CAAC;AAEZ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAC9F,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC"}