@openpond/evals 0.10.3 → 0.10.5

package/LEARNING.md

@@ -231,3 +231,46 @@ 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.
+
+### Policy readiness reads
+
+`client.inspectPolicy({ id, revision, contentHash })` sends the read payload
+`{ "action": "inspect_policy", "scope": "<profile-or-team>", "policy": { "id": "...", "revision": 1, "contentHash": "..." } }`.
+The authenticated owner reads a scope-serialized snapshot of the current policy's
+eligible, awaiting-review, excluded and consumed counts, chain identity, cooldown
+and daily budget. It uses the same eligibility, complete batch validation and
+budget accounting as manual or scheduled reservation. A stale policy reference is
+rejected; source-only credentials cannot read it.
+
+`canReserve` describes shared reservation readiness at `inspectedAt`. The actual
+command rechecks current state and execution-owner preparation still validates
+its training configuration. `blockers` explains unmet constraints. `counts: null`
+means inspection could not count valid sources or supported admission, not that
+the backlog is empty. Reads never write an iteration, timer fire, family
+reservation, batch, consumption or operation record and never launch training.
+
+### Durable learning schedules
+
+Policy publication atomically synchronizes a `schedule` resource. Enabling
+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/batch-service.js

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

package/dist/learning/index.js

@@ -16,3 +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";
+export * from "./policy-inspection.js";

package/dist/learning/iteration-budget.js

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

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

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

package/dist/learning/policy-inspection.js

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

package/dist/learning/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,8 @@
 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 { inspectLearningPolicy } from "./policy-inspection.js";
 import { requireCurrentLearningEvidence as currentEvidence, sealLearningBatch } from "./batch-service.js";
 import { saveAuthoringDraft, archiveAuthoringDraft, finalizeAuthoringDraft } from "./authoring-service.js";
 import { queueRewardCheck, cancelRewardCheck } from "./reward-check-service.js";
@@ -158,6 +160,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) {
@@ -324,6 +328,11 @@ export function createLearningService(repository, options = {}) {
     }
     return {
         command,
+        async inspectPolicy(context, reference) {
+            authorizeRead(context);
+            const ref = LearningRevisionRefSchema.parse(reference);
+            return repository.transaction(context.scope, transaction => inspectLearningPolicy(transaction, ref, context.actor.id, now()));
+        },
         async inspectEvidence(context, reference) {
             authorizeRead(context);
             const ref = LearningRevisionRefSchema.parse(reference);
@@ -362,6 +371,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/learning/transport.js

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