@openpond/evals 0.10.3 → 0.10.4

package/LEARNING.md

@@ -231,3 +231,29 @@ cleanup receipt, retains the decision reference on the iteration, and records
 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.
+
+### Durable learning schedules
+
+Policy publication atomically synchronizes a `schedule` resource. Enabling
+scheduled training requires reviewer authority, including batched publication,
+because it authorizes the same reservation as manual Train. The timer preserves
+its pending occurrence through ordinary policy edits. Pause removes its pending
+due time; resume, cadence changes and execution-owner changes start a future
+occurrence. `synchronizeLearningSchedule` can initialize an existing current
+policy, but refuses stale policies and does not reset an unchanged timer.
+
+`createLearningScheduleWorker` runs a typed learning reservation in the same
+repository transaction as an immutable `schedule_fire` and timer advance.
+Duplicate replicas and restarts therefore cannot consume a second batch for an
+occurrence. Downtime retains the original due time and coalesces subsequent
+missed occurrences into one fire, recording the covered time and count.
+Insufficient approved evidence records waiting without reserved spend. An active
+chain, cooldown or daily budget limit records an explicit skip. Review approval
+does not move the next due time or independently start training.
+
+Other errors roll back reservation mutations and keep the original occurrence
+for bounded retries. Exhausting the policy retry limit blocks the timer with a
+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.

package/dist/learning/index.js

@@ -16,3 +16,6 @@ export * from "./iteration-reservation-contracts.js";
 export * from "./iteration-dispatch-contracts.js";
 export * from "./iteration-dispatch-worker.js";
 export * from "./iteration-candidate-decision.js";
+export * from "./schedule-contracts.js";
+export * from "./schedule-service.js";
+export * from "./schedule-worker.js";

package/dist/learning/repository.js

@@ -1,5 +1,6 @@
 import { LearningChainSchema, LearningConsumptionSchema, LearningIterationReservationSchema } from "./iteration-reservation-contracts.js";
 import { LearningIterationDispatchSchema } from "./iteration-dispatch-contracts.js";
+import { LearningScheduleSchema, LearningScheduleFireSchema } from "./schedule-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";
@@ -18,6 +19,7 @@ export const learningResourceSchemas = {
     decision: TaskAdmissionDecisionSchema, batch: TaskBatchSchema, policy: LearningPolicySchema,
     chain: LearningChainSchema, consumption: LearningConsumptionSchema, reservation: LearningIterationReservationSchema,
     dispatch: LearningIterationDispatchSchema,
+    schedule: LearningScheduleSchema, schedule_fire: LearningScheduleFireSchema,
     iteration: LearningIterationSchema, grade: TaskGradeRunSchema, package: TasksetReleaseSchema,
 };
 export const LearningResourceKindSchema = z.enum(Object.keys(learningResourceSchemas));

package/dist/learning/schedule-contracts.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { LearningRevisionRefSchema } from "./contracts.js";
+/** The durable timer is operational state; every fire retains its own policy. */
+export const LearningScheduleSchema = z.object({
+    schemaVersion: z.literal("openpond.learningSchedule.v1"),
+    id: ReleaseIdSchema,
+    revision: z.number().int().positive(),
+    policy: LearningRevisionRefSchema,
+    modelProjectId: ReleaseIdSchema,
+    executionOwner: z.enum(["local", "hosted"]),
+    state: z.enum(["scheduled", "disabled", "blocked"]),
+    intervalSeconds: z.number().int().min(60).max(31_536_000).nullable(),
+    nextRunAt: ReleaseTimestampSchema.nullable(),
+    lastFire: LearningRevisionRefSchema.nullable(),
+    consecutiveFailures: z.number().int().nonnegative(),
+    nextAttemptAt: ReleaseTimestampSchema.nullable(),
+    lastError: z.string().max(20_000).nullable(),
+    createdAt: ReleaseTimestampSchema,
+    updatedAt: ReleaseTimestampSchema,
+}).strict().superRefine((value, context) => {
+    if (value.state !== "disabled" && (!value.intervalSeconds || !value.nextRunAt))
+        context.addIssue({ code: "custom", path: ["nextRunAt"], message: "An active timer must retain its cadence and due time." });
+    if (value.state === "disabled" && value.nextRunAt)
+        context.addIssue({ code: "custom", path: ["nextRunAt"], message: "A disabled timer cannot have a pending occurrence." });
+});
+/** Immutable occurrence evidence survives timer edits and coalesced downtime. */
+export const LearningScheduleFireSchema = z.object({
+    schemaVersion: z.literal("openpond.learningScheduleFire.v1"),
+    id: ReleaseIdSchema,
+    revision: z.literal(1),
+    scheduleId: ReleaseIdSchema,
+    policy: LearningRevisionRefSchema,
+    scheduledAt: ReleaseTimestampSchema,
+    coalescedThroughAt: ReleaseTimestampSchema,
+    coalescedCount: z.number().int().nonnegative(),
+    outcome: z.enum(["reserved", "waiting_for_data", "waiting_for_review", "skipped"]),
+    reason: z.enum(["active_iteration", "cooldown", "daily_budget"]).nullable(),
+    iteration: z.object({ id: ReleaseIdSchema, revision: z.number().int().positive() }).strict().nullable(),
+    createdAt: ReleaseTimestampSchema,
+    contentHash: ReleaseHashSchema,
+}).strict().superRefine((value, context) => {
+    if ((value.outcome === "skipped") !== Boolean(value.reason) || (value.outcome !== "skipped") !== Boolean(value.iteration))
+        context.addIssue({ code: "custom", path: ["outcome"], message: "A fire retains either its reservation or its explicit skip reason." });
+});

package/dist/learning/schedule-service.js

@@ -0,0 +1,31 @@
+import { contentHash } from "@openpond/harness";
+import { assertLearningContentHash, learningRef, sameLearningRef } from "./contracts.js";
+import { LearningScheduleSchema } from "./schedule-contracts.js";
+import { LearningDomainError } from "./errors.js";
+import { requireLearningResource } from "./repository.js";
+export function learningScheduleId(policyId) { return `schedule-${contentHash(policyId)}`; }
+/** Called atomically with policy publication. No external timer or Work is made. */
+export async function synchronizeLearningSchedule(tx, policy, now) {
+    assertLearningContentHash(policy);
+    const current = await requireLearningResource(tx, "policy", policy.id);
+    if (!sameLearningRef(learningRef(current), learningRef(policy)))
+        throw new LearningDomainError("learning_policy_revision_stale", 409);
+    const id = learningScheduleId(policy.id);
+    const previous = await tx.get("schedule", id);
+    if (previous && sameLearningRef(previous.policy, learningRef(policy)))
+        return previous;
+    const intervalSeconds = policy.trigger.kind === "schedule" ? policy.trigger.intervalSeconds : null;
+    const enabled = policy.enabled && policy.automation.train && intervalSeconds !== null;
+    const preserveDue = previous?.nextRunAt && previous.intervalSeconds === intervalSeconds
+        && previous.executionOwner === policy.executionOwner;
+    const schedule = LearningScheduleSchema.parse({
+        schemaVersion: "openpond.learningSchedule.v1", id, revision: (previous?.revision ?? 0) + 1,
+        policy: learningRef(policy), modelProjectId: policy.modelProjectId, executionOwner: policy.executionOwner,
+        state: enabled ? "scheduled" : "disabled", intervalSeconds,
+        nextRunAt: enabled ? preserveDue ? previous.nextRunAt : new Date(Date.parse(now) + intervalSeconds * 1_000).toISOString() : null,
+        lastFire: previous?.lastFire ?? null, consecutiveFailures: 0, nextAttemptAt: null, lastError: null,
+        createdAt: previous?.createdAt ?? now, updatedAt: now,
+    });
+    await tx.put("schedule", schedule, previous?.revision ?? 0, { parentId: policy.modelProjectId, status: schedule.state });
+    return schedule;
+}

package/dist/learning/schedule-worker.js

@@ -0,0 +1,96 @@
+import { contentHash } from "@openpond/harness";
+import { learningRef, sealLearningContent } from "./contracts.js";
+import { LearningDomainError } from "./errors.js";
+import { reserveLearningIteration } from "./iteration-reservation-service.js";
+import { LearningScheduleFireSchema, LearningScheduleSchema } from "./schedule-contracts.js";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
+const skipReasons = new Map([
+    ["learning_iteration_active", "active_iteration"], ["learning_iteration_cooldown", "cooldown"],
+    ["learning_daily_budget_exhausted", "daily_budget"],
+]);
+/** Like a durable scheduled Work fire, the occurrence and timer advance commit
+ * together. Here the typed target is a learning reservation, never a prompt or
+ * provider submission. All work inside the transaction is repository-only. */
+export function createLearningScheduleWorker(repository, options) {
+    const now = options.now ?? (() => new Date().toISOString());
+    async function run(scope, scheduleId, actorId) {
+        let attempt = null;
+        try {
+            return await repository.transaction(scope, async (tx) => {
+                const schedule = await requireLearningResource(tx, "schedule", scheduleId);
+                if (schedule.executionOwner !== options.executionOwner)
+                    throw new LearningDomainError("learning_execution_owner_mismatch", 409);
+                const timestamp = now();
+                const time = Date.parse(timestamp);
+                if (schedule.state !== "scheduled" || !schedule.nextRunAt || Date.parse(schedule.nextRunAt) > time
+                    || (schedule.nextAttemptAt && Date.parse(schedule.nextAttemptAt) > time))
+                    return schedule;
+                attempt = { schedule, maxRetries: 0 };
+                const policy = await requireLearningRelease(tx, "policy", schedule.policy);
+                attempt.maxRetries = policy.limits.maxRetries;
+                if (policy.executionOwner !== schedule.executionOwner || policy.trigger.kind !== "schedule"
+                    || policy.trigger.intervalSeconds !== schedule.intervalSeconds)
+                    throw new LearningDomainError("learning_schedule_policy_mismatch", 409);
+                const scheduledAt = schedule.nextRunAt;
+                const interval = schedule.intervalSeconds * 1_000;
+                const due = Date.parse(scheduledAt);
+                const coalescedCount = Math.floor((time - due) / interval);
+                const id = `schedule-fire-${contentHash([schedule.id, scheduledAt])}`;
+                let outcome = "skipped";
+                let reason = null;
+                let iteration = null;
+                try {
+                    const pointers = await reserveLearningIteration(tx, { action: "reserve_iteration", operationId: id,
+                        policy: schedule.policy, trigger: { kind: "schedule", scheduledAt } }, actorId, timestamp);
+                    const pointer = pointers.find(value => value.kind === "iteration");
+                    if (!pointer)
+                        throw new LearningDomainError("learning_schedule_reservation_missing", 409);
+                    const reservation = await requireLearningResource(tx, "reservation", pointer.id);
+                    outcome = reservation.outcome;
+                    iteration = { id: pointer.id, revision: pointer.revision };
+                }
+                catch (error) {
+                    // These admission checks run before reservation mutations. Every other
+                    // error must roll back the whole fire, including any partial batch.
+                    const skip = error instanceof LearningDomainError ? skipReasons.get(error.code) : undefined;
+                    if (!skip)
+                        throw error;
+                    reason = skip;
+                }
+                const fire = LearningScheduleFireSchema.parse(sealLearningContent({
+                    schemaVersion: "openpond.learningScheduleFire.v1", id, revision: 1, scheduleId,
+                    policy: schedule.policy, scheduledAt, coalescedThroughAt: new Date(due + coalescedCount * interval).toISOString(),
+                    coalescedCount, outcome, reason, iteration, createdAt: timestamp,
+                }));
+                await tx.put("schedule_fire", fire, 0, { parentId: schedule.id, status: outcome });
+                const updated = LearningScheduleSchema.parse({ ...schedule, revision: schedule.revision + 1,
+                    nextRunAt: new Date(due + (coalescedCount + 1) * interval).toISOString(), lastFire: learningRef(fire),
+                    consecutiveFailures: 0, nextAttemptAt: null, lastError: null, updatedAt: timestamp });
+                await tx.put("schedule", updated, schedule.revision, { parentId: schedule.modelProjectId, status: updated.state });
+                return updated;
+            });
+        }
+        catch (error) {
+            // Failed transactions keep the original due time and exact fire identity.
+            // A concurrent policy edit owns its new timer; never overwrite that state.
+            const failed = attempt;
+            if (!failed)
+                throw error;
+            return repository.transaction(scope, async (tx) => {
+                const current = await requireLearningResource(tx, "schedule", scheduleId);
+                if (current.revision !== failed.schedule.revision)
+                    return current;
+                const timestamp = now();
+                const consecutiveFailures = current.consecutiveFailures + 1;
+                const blocked = consecutiveFailures > failed.maxRetries;
+                const updated = LearningScheduleSchema.parse({ ...current, revision: current.revision + 1,
+                    state: blocked ? "blocked" : "scheduled", consecutiveFailures,
+                    nextAttemptAt: blocked ? null : new Date(Date.parse(timestamp) + Math.min(60_000, 1_000 * 2 ** Math.min(consecutiveFailures - 1, 10))).toISOString(),
+                    lastError: (error instanceof Error ? error.message : String(error)).slice(0, 20_000), updatedAt: timestamp });
+                await tx.put("schedule", updated, current.revision, { parentId: current.modelProjectId, status: updated.state });
+                return updated;
+            });
+        }
+    }
+    return { run };
+}

package/dist/learning/service.js

@@ -1,6 +1,7 @@
 import { cancelLearningIterationReservation } from "./iteration-reservation-cancellation.js";
 import { commandLearningIterationDispatch } from "./iteration-dispatch-commands.js";
 import { reserveLearningIteration } from "./iteration-reservation-service.js";
+import { synchronizeLearningSchedule } from "./schedule-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";
@@ -158,6 +159,8 @@ export function createLearningService(repository, options = {}) {
             }
         }
         await transaction.put(input.kind, resource, input.expectedRevision, input.kind === "policy" ? { parentId: input.content.modelProjectId } : undefined);
+        if (input.kind === "policy")
+            await synchronizeLearningSchedule(transaction, LearningPolicySchema.parse(resource), now());
         return pointer(input.kind, resource);
     }
     async function submit(transaction, input) {
@@ -362,6 +365,10 @@ function authorizeRead(context) {
 function authorize(context, input) {
     if (!context.scope.trim() || !context.actor.id.trim())
         throw new LearningDomainError("learning_scope_required", 400);
+    const publications = input.action === "publish" ? [input] : input.action === "publish_resources" ? input.resources : [];
+    if (context.actor.role !== "reviewer" && publications.some(value => value.kind === "policy" && value.content.enabled
+        && value.content.automation.train && value.content.trigger.kind === "schedule"))
+        throw new LearningDomainError("learning_review_not_authorized", 403);
     if (context.actor.role === "source") {
         const sourceId = input.action === "submit_example" ? input.example.sourceId : input.action === "submit_feedback" ? input.feedback.sourceId : null;
         if (!sourceId || sourceId !== context.actor.sourceId)

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

@@ -16,4 +16,7 @@ export * from "./iteration-reservation-contracts.js";
 export * from "./iteration-dispatch-contracts.js";
 export * from "./iteration-dispatch-worker.js";
 export * from "./iteration-candidate-decision.js";
+export * from "./schedule-contracts.js";
+export * from "./schedule-service.js";
+export * from "./schedule-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;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,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;AAClD,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC"}

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

@@ -1152,6 +1152,69 @@ export declare const learningResourceSchemas: {
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
     }, z.core.$strict>;
+    readonly schedule: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningSchedule.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        modelProjectId: z.ZodString;
+        executionOwner: z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+        }>;
+        state: z.ZodEnum<{
+            blocked: "blocked";
+            scheduled: "scheduled";
+            disabled: "disabled";
+        }>;
+        intervalSeconds: z.ZodNullable<z.ZodNumber>;
+        nextRunAt: z.ZodNullable<z.ZodString>;
+        lastFire: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        consecutiveFailures: z.ZodNumber;
+        nextAttemptAt: z.ZodNullable<z.ZodString>;
+        lastError: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>;
+    readonly schedule_fire: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningScheduleFire.v1">;
+        id: z.ZodString;
+        revision: z.ZodLiteral<1>;
+        scheduleId: z.ZodString;
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        scheduledAt: z.ZodString;
+        coalescedThroughAt: z.ZodString;
+        coalescedCount: z.ZodNumber;
+        outcome: z.ZodEnum<{
+            skipped: "skipped";
+            waiting_for_data: "waiting_for_data";
+            waiting_for_review: "waiting_for_review";
+            reserved: "reserved";
+        }>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            active_iteration: "active_iteration";
+            cooldown: "cooldown";
+            daily_budget: "daily_budget";
+        }>>;
+        iteration: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
+    }, z.core.$strict>;
     readonly iteration: z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.learningIteration.v1">;
         id: z.ZodString;
@@ -1550,14 +1613,16 @@ export declare const LearningResourceKindSchema: z.ZodEnum<{
     binding: "binding";
     batch: "batch";
     grade: "grade";
+    schedule: "schedule";
     definition: "definition";
     draft: "draft";
+    iteration: "iteration";
     reward_check: "reward_check";
     chain: "chain";
     consumption: "consumption";
     reservation: "reservation";
     dispatch: "dispatch";
-    iteration: "iteration";
+    schedule_fire: "schedule_fire";
     package: "package";
 }>;
 export type LearningResourceFor<K extends LearningResourceKind> = z.infer<(typeof learningResourceSchemas)[K]>;

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

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

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+/** The durable timer is operational state; every fire retains its own policy. */
+export declare const LearningScheduleSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningSchedule.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    modelProjectId: z.ZodString;
+    executionOwner: z.ZodEnum<{
+        local: "local";
+        hosted: "hosted";
+    }>;
+    state: z.ZodEnum<{
+        blocked: "blocked";
+        scheduled: "scheduled";
+        disabled: "disabled";
+    }>;
+    intervalSeconds: z.ZodNullable<z.ZodNumber>;
+    nextRunAt: z.ZodNullable<z.ZodString>;
+    lastFire: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    consecutiveFailures: z.ZodNumber;
+    nextAttemptAt: z.ZodNullable<z.ZodString>;
+    lastError: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+/** Immutable occurrence evidence survives timer edits and coalesced downtime. */
+export declare const LearningScheduleFireSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"openpond.learningScheduleFire.v1">;
+    id: z.ZodString;
+    revision: z.ZodLiteral<1>;
+    scheduleId: z.ZodString;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        contentHash: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    scheduledAt: z.ZodString;
+    coalescedThroughAt: z.ZodString;
+    coalescedCount: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        skipped: "skipped";
+        waiting_for_data: "waiting_for_data";
+        waiting_for_review: "waiting_for_review";
+        reserved: "reserved";
+    }>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        active_iteration: "active_iteration";
+        cooldown: "cooldown";
+        daily_budget: "daily_budget";
+    }>>;
+    iteration: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>>;
+    createdAt: z.ZodString;
+    contentHash: z.ZodString;
+}, z.core.$strict>;
+export type LearningSchedule = z.infer<typeof LearningScheduleSchema>;
+export type LearningScheduleFire = z.infer<typeof LearningScheduleFireSchema>;
+//# sourceMappingURL=schedule-contracts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-contracts.d.ts","sourceRoot":"","sources":["../../../../../src/learning/schedule-contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,iFAAiF;AACjF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBjC,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiBrC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

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

@@ -0,0 +1,30 @@
+import { type LearningPolicy } from "./contracts.js";
+import { type LearningTransaction } from "./repository.js";
+export declare function learningScheduleId(policyId: string): string;
+/** Called atomically with policy publication. No external timer or Work is made. */
+export declare function synchronizeLearningSchedule(tx: LearningTransaction, policy: LearningPolicy, now: string): Promise<{
+    schemaVersion: "openpond.learningSchedule.v1";
+    id: string;
+    revision: number;
+    policy: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    };
+    modelProjectId: string;
+    executionOwner: "local" | "hosted";
+    state: "blocked" | "scheduled" | "disabled";
+    intervalSeconds: number | null;
+    nextRunAt: string | null;
+    lastFire: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    } | null;
+    consecutiveFailures: number;
+    nextAttemptAt: string | null;
+    lastError: string | null;
+    createdAt: string;
+    updatedAt: string;
+}>;
+//# sourceMappingURL=schedule-service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/schedule-service.ts"],"names":[],"mappings":"AACA,OAAO,EAA2D,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAG9G,OAAO,EAA2B,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEpF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,UAAiD;AAEpG,oFAAoF;AACpF,wBAAsB,2BAA2B,CAAC,EAAE,EAAE,mBAAmB,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;GAqB7G"}

package/dist/types/learning/schedule-worker.d.ts

@@ -0,0 +1,12 @@
+import { type LearningSchedule } from "./schedule-contracts.js";
+import { type LearningRepository } from "./repository.js";
+/** Like a durable scheduled Work fire, the occurrence and timer advance commit
+ * together. Here the typed target is a learning reservation, never a prompt or
+ * provider submission. All work inside the transaction is repository-only. */
+export declare function createLearningScheduleWorker(repository: LearningRepository, options: {
+    executionOwner: "local" | "hosted";
+    now?: () => string;
+}): {
+    run: (scope: string, scheduleId: string, actorId: string) => Promise<LearningSchedule>;
+};
+//# sourceMappingURL=schedule-worker.d.ts.map

package/dist/types/learning/schedule-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-worker.d.ts","sourceRoot":"","sources":["../../../../../src/learning/schedule-worker.ts"],"names":[],"mappings":"AAIA,OAAO,EAAsD,KAAK,gBAAgB,EAA6B,MAAM,yBAAyB,CAAC;AAC/I,OAAO,EAAmD,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAO3G;;8EAE8E;AAC9E,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,EAAE;IACpF,cAAc,EAAE,OAAO,GAAG,QAAQ,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACxD;iBAG2B,MAAM,cAAc,MAAM,WAAW,MAAM,KAAG,OAAO,CAAC,gBAAgB,CAAC;EAuElG"}

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/service.ts"],"names":[],"mappings":"AAYA,OAAO,EAA+Q,KAAK,mBAAmB,EAAwC,MAAM,gBAAgB,CAAC;AAE7W,OAAO,EAAmH,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAgC,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAA4B,MAAM,iBAAiB,CAAC;AAK5W,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtG,MAAM,MAAM,sBAAsB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,sBAAsB,EAAE,CAAA;CAAE,CAAC;AAEnG,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO;uBAGxE,sBAAsB,OAAO,OAAO,KAAG,OAAO,CAAC,uBAAuB,CAAC;6BAyPtE,sBAAsB,aAAa,mBAAmB;;;;;;;;;;;;;QAS3E,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,MAAM,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;SAIxI,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,UAAS,OAAO,CAAC,qBAAqB,CAAC,GAAQ,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;EAMrK"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/service.ts"],"names":[],"mappings":"AAaA,OAAO,EAA+Q,KAAK,mBAAmB,EAAwC,MAAM,gBAAgB,CAAC;AAE7W,OAAO,EAAmH,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAgC,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAA4B,MAAM,iBAAiB,CAAC;AAK5W,MAAM,MAAM,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtG,MAAM,MAAM,sBAAsB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAE,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,sBAAsB,EAAE,CAAA;CAAE,CAAC;AAEnG,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,kBAAkB,EAAE,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;CAAO;uBAGxE,sBAAsB,OAAO,OAAO,KAAG,OAAO,CAAC,uBAAuB,CAAC;6BA0PtE,sBAAsB,aAAa,mBAAmB;;;;;;;;;;;;;QAS3E,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,MAAM,MAAM,aAAa,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;SAIxI,CAAC,SAAS,oBAAoB,WAAW,sBAAsB,QAAQ,CAAC,UAAS,OAAO,CAAC,qBAAqB,CAAC,GAAQ,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;EAMrK"}

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

@@ -1459,14 +1459,16 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         binding: "binding";
         batch: "batch";
         grade: "grade";
+        schedule: "schedule";
         definition: "definition";
         draft: "draft";
+        iteration: "iteration";
         reward_check: "reward_check";
         chain: "chain";
         consumption: "consumption";
         reservation: "reservation";
         dispatch: "dispatch";
-        iteration: "iteration";
+        schedule_fire: "schedule_fire";
         package: "package";
     }>;
     id: z.ZodString;
@@ -1485,14 +1487,16 @@ export declare const LearningReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         binding: "binding";
         batch: "batch";
         grade: "grade";
+        schedule: "schedule";
         definition: "definition";
         draft: "draft";
+        iteration: "iteration";
         reward_check: "reward_check";
         chain: "chain";
         consumption: "consumption";
         reservation: "reservation";
         dispatch: "dispatch";
-        iteration: "iteration";
+        schedule_fire: "schedule_fire";
         package: "package";
     }>;
     parentId: z.ZodOptional<z.ZodString>;
@@ -2973,6 +2977,67 @@ export declare const LearningOperationResultSchema: z.ZodObject<{
         lastError: z.ZodNullable<z.ZodString>;
         createdAt: z.ZodString;
         updatedAt: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningSchedule.v1">;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        modelProjectId: z.ZodString;
+        executionOwner: z.ZodEnum<{
+            local: "local";
+            hosted: "hosted";
+        }>;
+        state: z.ZodEnum<{
+            blocked: "blocked";
+            scheduled: "scheduled";
+            disabled: "disabled";
+        }>;
+        intervalSeconds: z.ZodNullable<z.ZodNumber>;
+        nextRunAt: z.ZodNullable<z.ZodString>;
+        lastFire: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        consecutiveFailures: z.ZodNumber;
+        nextAttemptAt: z.ZodNullable<z.ZodString>;
+        lastError: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict> | z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"openpond.learningScheduleFire.v1">;
+        id: z.ZodString;
+        revision: z.ZodLiteral<1>;
+        scheduleId: z.ZodString;
+        policy: z.ZodObject<{
+            id: z.ZodString;
+            contentHash: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>;
+        scheduledAt: z.ZodString;
+        coalescedThroughAt: z.ZodString;
+        coalescedCount: z.ZodNumber;
+        outcome: z.ZodEnum<{
+            skipped: "skipped";
+            waiting_for_data: "waiting_for_data";
+            waiting_for_review: "waiting_for_review";
+            reserved: "reserved";
+        }>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            active_iteration: "active_iteration";
+            cooldown: "cooldown";
+            daily_budget: "daily_budget";
+        }>>;
+        iteration: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            revision: z.ZodNumber;
+        }, z.core.$strict>>;
+        createdAt: z.ZodString;
+        contentHash: z.ZodString;
     }, z.core.$strict> | z.ZodObject<{
         schemaVersion: z.ZodLiteral<"openpond.rewardCheckRun.v1">;
         id: z.ZodString;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpond/evals",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "Portable Tasksets, graders, evaluation runs, receipts, conformance fixtures, and Work evidence for OpenPond Harnesses",
   "license": "MIT",
   "type": "module",

package/schemas/learning/v1/read-request.schema.json

@@ -137,6 +137,8 @@
         "consumption",
         "reservation",
         "dispatch",
+        "schedule",
+        "schedule_fire",
         "iteration",
         "grade",
         "package"

package/schemas/learning/v1/schedule.schema.json

@@ -0,0 +1,188 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "schemaVersion": {
+      "$ref": "#/$defs/__schema0"
+    },
+    "id": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "revision": {
+      "$ref": "#/$defs/__schema2"
+    },
+    "policy": {
+      "$ref": "#/$defs/__schema3"
+    },
+    "modelProjectId": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "executionOwner": {
+      "$ref": "#/$defs/__schema4"
+    },
+    "state": {
+      "$ref": "#/$defs/__schema5"
+    },
+    "intervalSeconds": {
+      "$ref": "#/$defs/__schema6"
+    },
+    "nextRunAt": {
+      "$ref": "#/$defs/__schema7"
+    },
+    "lastFire": {
+      "$ref": "#/$defs/__schema9"
+    },
+    "consecutiveFailures": {
+      "$ref": "#/$defs/__schema10"
+    },
+    "nextAttemptAt": {
+      "$ref": "#/$defs/__schema11"
+    },
+    "lastError": {
+      "$ref": "#/$defs/__schema12"
+    },
+    "createdAt": {
+      "$ref": "#/$defs/__schema8"
+    },
+    "updatedAt": {
+      "$ref": "#/$defs/__schema8"
+    }
+  },
+  "required": [
+    "schemaVersion",
+    "id",
+    "revision",
+    "policy",
+    "modelProjectId",
+    "executionOwner",
+    "state",
+    "intervalSeconds",
+    "nextRunAt",
+    "lastFire",
+    "consecutiveFailures",
+    "nextAttemptAt",
+    "lastError",
+    "createdAt",
+    "updatedAt"
+  ],
+  "additionalProperties": false,
+  "$defs": {
+    "__schema0": {
+      "type": "string",
+      "const": "openpond.learningSchedule.v1"
+    },
+    "__schema1": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 240
+    },
+    "__schema2": {
+      "type": "integer",
+      "exclusiveMinimum": 0,
+      "maximum": 9007199254740991
+    },
+    "__schema3": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/__schema1"
+        },
+        "contentHash": {
+          "type": "string",
+          "pattern": "^[a-f0-9]{64}$"
+        },
+        "revision": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "required": [
+        "id",
+        "contentHash",
+        "revision"
+      ],
+      "additionalProperties": false
+    },
+    "__schema4": {
+      "type": "string",
+      "enum": [
+        "local",
+        "hosted"
+      ]
+    },
+    "__schema5": {
+      "type": "string",
+      "enum": [
+        "scheduled",
+        "disabled",
+        "blocked"
+      ]
+    },
+    "__schema6": {
+      "anyOf": [
+        {
+          "type": "integer",
+          "minimum": 60,
+          "maximum": 31536000
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "__schema7": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/__schema8"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "__schema8": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
+    },
+    "__schema9": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/__schema3"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "__schema10": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "__schema11": {
+      "anyOf": [
+        {
+          "$ref": "#/$defs/__schema8"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "__schema12": {
+      "anyOf": [
+        {
+          "type": "string",
+          "maxLength": 20000
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "$id": "urn:openpond:learning:v1:schedule",
+  "$comment": "Generated from @openpond/evals. Cross-resource identity, authorization, idempotency, admission, grading and split constraints are enforced by the shared domain service in addition to this structural schema."
+}

package/schemas/learning/v1/schedule_fire.schema.json

@@ -0,0 +1,163 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "schemaVersion": {
+      "$ref": "#/$defs/__schema0"
+    },
+    "id": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "revision": {
+      "$ref": "#/$defs/__schema2"
+    },
+    "scheduleId": {
+      "$ref": "#/$defs/__schema1"
+    },
+    "policy": {
+      "$ref": "#/$defs/__schema3"
+    },
+    "scheduledAt": {
+      "$ref": "#/$defs/__schema5"
+    },
+    "coalescedThroughAt": {
+      "$ref": "#/$defs/__schema5"
+    },
+    "coalescedCount": {
+      "$ref": "#/$defs/__schema6"
+    },
+    "outcome": {
+      "$ref": "#/$defs/__schema7"
+    },
+    "reason": {
+      "$ref": "#/$defs/__schema8"
+    },
+    "iteration": {
+      "$ref": "#/$defs/__schema9"
+    },
+    "createdAt": {
+      "$ref": "#/$defs/__schema5"
+    },
+    "contentHash": {
+      "$ref": "#/$defs/__schema4"
+    }
+  },
+  "required": [
+    "schemaVersion",
+    "id",
+    "revision",
+    "scheduleId",
+    "policy",
+    "scheduledAt",
+    "coalescedThroughAt",
+    "coalescedCount",
+    "outcome",
+    "reason",
+    "iteration",
+    "createdAt",
+    "contentHash"
+  ],
+  "additionalProperties": false,
+  "$defs": {
+    "__schema0": {
+      "type": "string",
+      "const": "openpond.learningScheduleFire.v1"
+    },
+    "__schema1": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 240
+    },
+    "__schema2": {
+      "type": "number",
+      "const": 1
+    },
+    "__schema3": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "$ref": "#/$defs/__schema1"
+        },
+        "contentHash": {
+          "$ref": "#/$defs/__schema4"
+        },
+        "revision": {
+          "type": "integer",
+          "exclusiveMinimum": 0,
+          "maximum": 9007199254740991
+        }
+      },
+      "required": [
+        "id",
+        "contentHash",
+        "revision"
+      ],
+      "additionalProperties": false
+    },
+    "__schema4": {
+      "type": "string",
+      "pattern": "^[a-f0-9]{64}$"
+    },
+    "__schema5": {
+      "type": "string",
+      "format": "date-time",
+      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
+    },
+    "__schema6": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 9007199254740991
+    },
+    "__schema7": {
+      "type": "string",
+      "enum": [
+        "reserved",
+        "waiting_for_data",
+        "waiting_for_review",
+        "skipped"
+      ]
+    },
+    "__schema8": {
+      "anyOf": [
+        {
+          "type": "string",
+          "enum": [
+            "active_iteration",
+            "cooldown",
+            "daily_budget"
+          ]
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "__schema9": {
+      "anyOf": [
+        {
+          "type": "object",
+          "properties": {
+            "id": {
+              "$ref": "#/$defs/__schema1"
+            },
+            "revision": {
+              "type": "integer",
+              "exclusiveMinimum": 0,
+              "maximum": 9007199254740991
+            }
+          },
+          "required": [
+            "id",
+            "revision"
+          ],
+          "additionalProperties": false
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "$id": "urn:openpond:learning:v1:schedule_fire",
+  "$comment": "Generated from @openpond/evals. Cross-resource identity, authorization, idempotency, admission, grading and split constraints are enforced by the shared domain service in addition to this structural schema."
+}