@openpond/evals 0.10.10 → 0.11.0

package/LEARNING.md

@@ -339,3 +339,23 @@ Taskset output paths, media types, schema references and size bounds. Evidence
 conversion copies them into every task before grading or sealing a batch, so a
 changed output contract requires a new definition and new matching evidence and
 review receipts. Definitions without this field retain their existing hashes.
+
+## Nightly and task-count triggers
+
+Policies may use `trigger: { kind: "nightly", localTime: "20:00", timeZone:
+"America/New_York" }`. The durable timer computes the next local date in that
+IANA timezone. DST repeats use the earlier occurrence once; missing local times
+advance by the DST gap. Calendar edits recompute the due time; unchanged calendars
+retain it. Existing `schedule` policies retain elapsed-interval semantics.
+
+`trigger: { kind: "approved_count" }` uses `admission.minimumApprovedExamples`
+as its threshold and checks once per minute. Below-threshold checks advance the
+timer without creating iterations or fire records. Once ready, the same atomic
+reservation, consumption, budget, cooldown and execution-owner checks apply.
+Both new automatic triggers require reviewer authorization to enable.
+
+`service.inspectTaskQueue(context, modelProjectId?)` is a read-only snapshot of
+unique eligible, unconsumed training attempts across current policies. It
+deduplicates shared sources and excludes held-out family reservations. Paused
+policies retain pending tasks. An invalid policy yields a null count and explicit
+issues rather than a misleading zero. Source credentials cannot read the queue.

package/dist/learning/contracts.js

@@ -5,6 +5,7 @@ import { RewardBindingSchema, RewardCompositionSchema, RewardReleaseRefSchema, R
 import { TaskRecordSchema, TaskSplitSchema, TasksetReleaseContentSchema } from "../tasksets.js";
 import { assertBoundedTaskJson, validateTaskSchema } from "../task-schema.js";
 import { JudgeCallReservationSchema } from "./judge-budget.js";
+import { NightlyScheduleSchema } from "./nightly-schedule.js";
 export const LearningJsonObjectSchema = z.record(z.string(), z.json());
 export const LearningRevisionRefSchema = RewardReleaseRefSchema;
 export const LearningJsonPointerSchema = z.string().max(2_000).refine((value) => value === "" || (value.startsWith("/") && !/~(?![01])/u.test(value)), "Use an RFC 6901 JSON pointer.");
@@ -222,6 +223,7 @@ export const LearningPolicyContentSchema = z.object({
         z.object({ kind: z.literal("manual") }).strict(),
         z.object({ kind: z.literal("approved_count") }).strict(),
         z.object({ kind: z.literal("schedule"), intervalSeconds: z.number().int().min(60).max(31_536_000) }).strict(),
+        NightlyScheduleSchema.extend({ kind: z.literal("nightly") }).strict(),
         z.object({ kind: z.literal("upstream_accepted"), modelProjectId: ReleaseIdSchema }).strict(),
     ]),
     trainingParent: ImmutableReleaseRefSchema,

package/dist/learning/index.js

@@ -29,4 +29,6 @@ export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./nightly-schedule.js";
 export * from "./policy-inspection.js";
+export * from "./task-queue-inspection.js";

package/dist/learning/iteration-eligibility.js

@@ -9,7 +9,7 @@ export function learningChainId(modelProjectId) {
 export function learningConsumptionId(chainId, evidence) {
     return `consumption-${contentHash([chainId, evidence.id, evidence.revision])}`;
 }
-export async function inspectIterationEligibility(transaction, policy) {
+export async function inspectIterationEligibility(transaction, policy, options = {}) {
     // These are the methods supported by the approved-batch materializer.
     const purpose = policy.training.method === "sft" ? "supervised_training" : "reward_training";
     if (!["sft", "grpo", "ppo"].includes(policy.training.method)) {
@@ -24,6 +24,7 @@ export async function inspectIterationEligibility(transaction, policy) {
         throw new LearningDomainError("learning_policy_binding_mismatch", 422);
     const counts = { eligible: 0, awaitingReview: 0, excluded: 0, consumed: 0 };
     const selected = [];
+    const eligibleEvidence = [];
     const chainId = learningChainId(policy.modelProjectId);
     const seen = new Set();
     let backlog = 0;
@@ -66,11 +67,13 @@ export async function inspectIterationEligibility(transaction, policy) {
                     continue;
                 }
                 counts.eligible += 1;
+                if (options.collectEligible)
+                    eligibleEvidence.push(learningRef(evidence));
                 if (selected.length < policy.limits.maxBatchExamples)
                     selected.push({ evidence, decision });
             }
             afterId = page.nextCursor ?? undefined;
         } while (afterId);
     }
-    return { counts, selected, purpose };
+    return { counts, selected, purpose, eligibleEvidence };
 }

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

@@ -4,6 +4,7 @@ import { LearningAcceptedParentSchema, LearningRevisionRefSchema } from "./contr
 export const LearningIterationTriggerSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("manual"), identity: ReleaseIdSchema }).strict(),
     z.object({ kind: z.literal("schedule"), scheduledAt: ReleaseTimestampSchema }).strict(),
+    z.object({ kind: z.literal("approved_count"), checkedAt: ReleaseTimestampSchema }).strict(),
 ]);
 /** Stable across policy edits: a Model owns one learning chain in its scope. */
 export const LearningChainSchema = z.object({

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

@@ -11,7 +11,8 @@ import { latestAcceptedLearningParent, resolveLearningTrainingParent } from "./i
 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 trigger = input.trigger.kind === "schedule" ? { ...input.trigger, scheduledAt: new Date(input.trigger.scheduledAt).toISOString() }
+        : input.trigger.kind === "approved_count" ? { ...input.trigger, checkedAt: new Date(input.trigger.checkedAt).toISOString() } : input.trigger;
     const triggerIdentity = contentHash([input.policy.id, trigger]);
     const id = `iteration-${contentHash([chainId, triggerIdentity])}`;
     const requestHash = contentHash({ policy: input.policy, trigger });
@@ -30,11 +31,17 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     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)
+        if (!["schedule", "nightly"].includes(policy.trigger.kind) || !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);
     }
+    if (input.trigger.kind === "approved_count") {
+        if (policy.trigger.kind !== "approved_count" || !policy.automation.train)
+            throw new LearningDomainError("learning_count_trigger_not_enabled", 409);
+        if (Date.parse(input.trigger.checkedAt) > Date.parse(now))
+            throw new LearningDomainError("learning_count_trigger_not_due", 409);
+    }
     const chain = await transaction.get("chain", chainId);
     if (chain?.activeIterationId)
         throw new LearningDomainError("learning_iteration_active", 409, chain.activeIterationId);
@@ -43,6 +50,8 @@ export async function reserveLearningIteration(transaction, input, actorId, now)
     }
     const eligibility = await inspectIterationEligibility(transaction, policy);
     const ready = eligibility.counts.eligible >= policy.admission.minimumApprovedExamples;
+    if (input.trigger.kind === "approved_count" && !ready)
+        throw new LearningDomainError("learning_count_threshold_not_met", 409);
     const status = ready ? "ready" : eligibility.counts.awaitingReview > 0 ? "waiting_for_review" : "waiting_for_data";
     const pointers = [];
     const acceptedParent = await latestAcceptedLearningParent(transaction, chainId, true);

package/dist/learning/nightly-schedule.js

@@ -0,0 +1,69 @@
+import { z } from "zod";
+export const NightlyScheduleSchema = z.object({
+    localTime: z.string().regex(/^(?:[01]\d|2[0-3]):[0-5]\d$/),
+    timeZone: z.string().min(1).max(200).refine(value => {
+        try {
+            new Intl.DateTimeFormat("en", { timeZone: value });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "Choose a valid IANA timezone."),
+}).strict();
+const DAY = 86_400_000;
+function formatter(calendar) {
+    return new Intl.DateTimeFormat("en-US", { timeZone: calendar.timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hourCycle: "h23" });
+}
+function wallTime(format, instant) {
+    const parts = Object.fromEntries(format.formatToParts(instant).filter(part => part.type !== "literal").map(part => [part.type, Number(part.value)]));
+    return Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute);
+}
+function localDay(format, instant) { return Math.floor(wallTime(format, instant) / DAY) * DAY; }
+/** One occurrence per local date. A repeated time uses its first occurrence;
+ * a missing time advances by the DST gap. Entirely skipped dates have no fire. */
+function occurrence(format, calendar, date) {
+    const [hour, minute] = calendar.localTime.split(":").map(Number);
+    const requested = date + hour * 3_600_000 + minute * 60_000;
+    const offsets = new Set();
+    for (let hours = -36; hours <= 36; hours += 6) {
+        const probe = requested + hours * 3_600_000;
+        offsets.add(wallTime(format, probe) - probe);
+    }
+    const candidates = [...offsets].map(offset => requested - offset).sort((a, b) => a - b);
+    const exact = candidates.find(instant => wallTime(format, instant) === requested);
+    if (exact !== undefined)
+        return exact;
+    const shifted = candidates.filter(instant => localDay(format, instant) === date && wallTime(format, instant) > requested);
+    return shifted.sort((a, b) => wallTime(format, a) - wallTime(format, b))[0] ?? null;
+}
+export function nextNightlyOccurrence(calendar, after) {
+    const parsed = NightlyScheduleSchema.parse(calendar);
+    const time = Date.parse(after);
+    if (!Number.isFinite(time))
+        throw new Error("A nightly schedule requires a valid timestamp.");
+    const format = formatter(parsed);
+    const date = localDay(format, time);
+    for (let days = 0; days < 4; days++) {
+        const candidate = occurrence(format, parsed, date + days * DAY);
+        if (candidate !== null && candidate > time)
+            return new Date(candidate).toISOString();
+    }
+    throw new Error("Unable to resolve the next nightly occurrence.");
+}
+export function coalesceNightlyOccurrences(calendar, due, now) {
+    const parsed = NightlyScheduleSchema.parse(calendar);
+    const format = formatter(parsed);
+    const time = Date.parse(now);
+    const date = localDay(format, time);
+    for (let days = 0; days < 4; days++) {
+        const candidate = occurrence(format, parsed, date - days * DAY);
+        if (candidate !== null && candidate <= time)
+            return {
+                coalescedThroughAt: new Date(candidate).toISOString(),
+                coalescedCount: Math.max(0, Math.round((localDay(format, candidate) - localDay(format, Date.parse(due))) / DAY)),
+                nextRunAt: nextNightlyOccurrence(parsed, now),
+            };
+    }
+    throw new Error("Unable to resolve the due nightly occurrence.");
+}

package/dist/learning/schedule-contracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { ReleaseHashSchema, ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
 import { LearningRevisionRefSchema } from "./contracts.js";
+import { NightlyScheduleSchema } from "./nightly-schedule.js";
 /** The durable timer is operational state; every fire retains its own policy. */
 export const LearningScheduleSchema = z.object({
     schemaVersion: z.literal("openpond.learningSchedule.v1"),
@@ -11,6 +12,7 @@ export const LearningScheduleSchema = z.object({
     executionOwner: z.enum(["local", "hosted"]),
     state: z.enum(["scheduled", "disabled", "blocked"]),
     intervalSeconds: z.number().int().min(60).max(31_536_000).nullable(),
+    calendar: NightlyScheduleSchema.nullable().default(null),
     nextRunAt: ReleaseTimestampSchema.nullable(),
     lastFire: LearningRevisionRefSchema.nullable(),
     consecutiveFailures: z.number().int().nonnegative(),
@@ -19,10 +21,12 @@ export const LearningScheduleSchema = z.object({
     createdAt: ReleaseTimestampSchema,
     updatedAt: ReleaseTimestampSchema,
 }).strict().superRefine((value, context) => {
-    if (value.state !== "disabled" && (!value.intervalSeconds || !value.nextRunAt))
+    if (value.state !== "disabled" && ((!value.intervalSeconds && !value.calendar) || !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." });
+    if (value.intervalSeconds && value.calendar)
+        context.addIssue({ code: "custom", path: ["calendar"], message: "A timer uses either an interval or a nightly calendar." });
 });
 /** Immutable occurrence evidence survives timer edits and coalesced downtime. */
 export const LearningScheduleFireSchema = z.object({

package/dist/learning/schedule-service.js

@@ -2,7 +2,8 @@ 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";
+import { requireLearningRelease, requireLearningResource } from "./repository.js";
+import { nextNightlyOccurrence } from "./nightly-schedule.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) {
@@ -14,15 +15,18 @@ export async function synchronizeLearningSchedule(tx, policy, now) {
     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 intervalSeconds = policy.trigger.kind === "schedule" ? policy.trigger.intervalSeconds : policy.trigger.kind === "approved_count" ? 60 : null;
+    const calendar = policy.trigger.kind === "nightly" ? { localTime: policy.trigger.localTime, timeZone: policy.trigger.timeZone } : null;
+    const enabled = policy.enabled && policy.automation.train && (intervalSeconds !== null || calendar !== null);
+    const previousPolicy = previous ? await requireLearningRelease(tx, "policy", previous.policy) : null;
     const preserveDue = previous?.nextRunAt && previous.intervalSeconds === intervalSeconds
+        && JSON.stringify(previous.calendar) === JSON.stringify(calendar) && previousPolicy?.trigger.kind === policy.trigger.kind
         && 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,
+        state: enabled ? "scheduled" : "disabled", intervalSeconds, calendar,
+        nextRunAt: enabled ? preserveDue ? previous.nextRunAt : calendar ? nextNightlyOccurrence(calendar, now) : 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,
     });

package/dist/learning/schedule-worker.js

@@ -4,6 +4,8 @@ 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";
+import { inspectIterationEligibility } from "./iteration-eligibility.js";
+import { coalesceNightlyOccurrences } from "./nightly-schedule.js";
 const skipReasons = new Map([
     ["learning_iteration_active", "active_iteration"], ["learning_iteration_cooldown", "cooldown"],
     ["learning_daily_budget_exhausted", "daily_budget"],
@@ -28,20 +30,33 @@ export function createLearningScheduleWorker(repository, options) {
                 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)
+                const matches = policy.trigger.kind === "nightly" ? schedule.intervalSeconds === null && schedule.calendar?.localTime === policy.trigger.localTime && schedule.calendar.timeZone === policy.trigger.timeZone
+                    : policy.trigger.kind === "schedule" ? schedule.calendar === null && policy.trigger.intervalSeconds === schedule.intervalSeconds
+                        : policy.trigger.kind === "approved_count" && schedule.calendar === null && schedule.intervalSeconds === 60;
+                if (policy.executionOwner !== schedule.executionOwner || !matches)
                     throw new LearningDomainError("learning_schedule_policy_mismatch", 409);
                 const scheduledAt = schedule.nextRunAt;
-                const interval = schedule.intervalSeconds * 1_000;
+                const interval = (schedule.intervalSeconds ?? 86_400) * 1_000;
                 const due = Date.parse(scheduledAt);
                 const coalescedCount = Math.floor((time - due) / interval);
+                const occurrence = schedule.calendar ? coalesceNightlyOccurrences(schedule.calendar, scheduledAt, timestamp) : {
+                    coalescedCount, coalescedThroughAt: new Date(due + coalescedCount * interval).toISOString(), nextRunAt: new Date(due + (coalescedCount + 1) * interval).toISOString(),
+                };
+                // Below-threshold count checks advance their timer without filling the
+                // Model's history with empty iterations or consuming any evidence.
+                if (policy.trigger.kind === "approved_count" && (await inspectIterationEligibility(tx, policy)).counts.eligible < policy.admission.minimumApprovedExamples) {
+                    const updated = LearningScheduleSchema.parse({ ...schedule, revision: schedule.revision + 1, nextRunAt: occurrence.nextRunAt,
+                        consecutiveFailures: 0, nextAttemptAt: null, lastError: null, updatedAt: timestamp });
+                    await tx.put("schedule", updated, schedule.revision, { parentId: schedule.modelProjectId, status: updated.state });
+                    return updated;
+                }
                 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);
+                        policy: schedule.policy, trigger: policy.trigger.kind === "approved_count" ? { kind: "approved_count", checkedAt: scheduledAt } : { kind: "schedule", scheduledAt } }, actorId, timestamp);
                     const pointer = pointers.find(value => value.kind === "iteration");
                     if (!pointer)
                         throw new LearningDomainError("learning_schedule_reservation_missing", 409);
@@ -59,12 +74,12 @@ export function createLearningScheduleWorker(repository, options) {
                 }
                 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,
+                    policy: schedule.policy, scheduledAt, coalescedThroughAt: occurrence.coalescedThroughAt,
+                    coalescedCount: occurrence.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),
+                    nextRunAt: occurrence.nextRunAt, 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;

package/dist/learning/service.js

@@ -9,6 +9,8 @@ import { assertRewardCalibration, qualifyRewardCheck } from "./reward-calibratio
 import { queueRewardCheck, cancelRewardCheck } from "./reward-check-service.js";
 import { LearningDomainError } from "./errors.js";
 import { contentHash } from "@openpond/harness";
+import { inspectLearningTaskQueue } from "./task-queue-inspection.js";
+import { LearningReadRequestSchema } from "./transport.js";
 import { createRewardBinding, createRewardRelease } from "../rewards.js";
 import { assertBoundedTaskJson, validateTaskValue } from "../task-schema.js";
 import { assertAdmissionDecision, assertGradeIdentity, inspectTaskEvidence } from "./admission.js";
@@ -360,6 +362,13 @@ export function createLearningService(repository, options = {}) {
     }
     return {
         command,
+        async inspectTaskQueue(context, modelProjectId = null) {
+            authorizeRead(context);
+            const input = LearningReadRequestSchema.parse({ action: "inspect_task_queue", scope: context.scope, modelProjectId });
+            if (input.action !== "inspect_task_queue")
+                throw new LearningDomainError("learning_request_invalid", 400);
+            return repository.transaction(context.scope, transaction => inspectLearningTaskQueue(transaction, input.modelProjectId, now()));
+        },
         async inspectPolicy(context, reference) {
             authorizeRead(context);
             const ref = LearningRevisionRefSchema.parse(reference);
@@ -407,7 +416,7 @@ function authorize(context, input) {
         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"))
+        && value.content.automation.train && value.content.trigger.kind !== "manual"))
         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;

package/dist/learning/task-queue-inspection.js

@@ -0,0 +1,48 @@
+import { ReleaseIdSchema, ReleaseTimestampSchema } from "@openpond/harness";
+import { z } from "zod";
+import { LearningDomainError } from "./errors.js";
+import { inspectIterationEligibility } from "./iteration-eligibility.js";
+import { taskFamilyReservations } from "./admission.js";
+import { requireLearningRelease } from "./repository.js";
+export const LearningTaskQueueInspectionSchema = z.object({
+    modelProjectId: ReleaseIdSchema.nullable(),
+    inspectedAt: ReleaseTimestampSchema,
+    pendingTrainingCount: z.number().int().nonnegative().nullable(),
+    issues: z.array(z.object({ policyId: ReleaseIdSchema, code: z.string(), message: z.string() }).strict()),
+}).strict();
+/** Count exact eligible, unconsumed attempts once across selected policies.
+ * Paused policies still have pending work; review-only and held-out tasks do not. */
+export async function inspectLearningTaskQueue(transaction, modelProjectId, now) {
+    const eligible = new Set();
+    const issues = [];
+    let afterId;
+    do {
+        const page = await transaction.list("policy", { limit: 100, ...(modelProjectId ? { parentId: modelProjectId } : {}), ...(afterId ? { afterId } : {}) });
+        for (const policy of page.items) {
+            try {
+                const inspection = await inspectIterationEligibility(transaction, policy, { collectEligible: true });
+                const definition = await requireLearningRelease(transaction, "definition", policy.taskDefinition);
+                for (const reference of inspection.eligibleEvidence) {
+                    const evidence = await requireLearningRelease(transaction, "evidence", reference);
+                    let heldOut = false;
+                    for (const family of taskFamilyReservations(evidence, definition)) {
+                        const split = await transaction.familySplit(family.namespace, family.kind, family.key);
+                        if (split !== null && split !== "train") {
+                            heldOut = true;
+                            break;
+                        }
+                    }
+                    if (!heldOut)
+                        eligible.add(JSON.stringify([reference.id, reference.revision, reference.contentHash]));
+                }
+            }
+            catch (error) {
+                if (!(error instanceof LearningDomainError))
+                    throw error;
+                issues.push({ policyId: policy.id, code: error.code, message: error.message });
+            }
+        }
+        afterId = page.nextCursor ?? undefined;
+    } while (afterId);
+    return LearningTaskQueueInspectionSchema.parse({ modelProjectId, inspectedAt: now, pendingTrainingCount: issues.length ? null : eligible.size, issues });
+}

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_task_queue"), scope: ReleaseIdSchema, modelProjectId: ReleaseIdSchema.nullable() }).strict(),
     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(),

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

@@ -1198,6 +1198,10 @@ export declare const LearningPolicyContentSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"schedule">;
         intervalSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        localTime: z.ZodString;
+        timeZone: z.ZodString;
+        kind: z.ZodLiteral<"nightly">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"upstream_accepted">;
         modelProjectId: z.ZodString;
@@ -1301,6 +1305,10 @@ export declare const LearningPolicySchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"schedule">;
         intervalSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        localTime: z.ZodString;
+        timeZone: z.ZodString;
+        kind: z.ZodLiteral<"nightly">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"upstream_accepted">;
         modelProjectId: z.ZodString;
@@ -2375,6 +2383,10 @@ export declare const LearningResourceSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"schedule">;
         intervalSeconds: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        localTime: z.ZodString;
+        timeZone: z.ZodString;
+        kind: z.ZodLiteral<"nightly">;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"upstream_accepted">;
         modelProjectId: z.ZodString;

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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AAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBpB,CAAC;AAEZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2P,CAAC;AAE/R,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,mBAAmB,CAEhH;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAE9F;AACD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAG9G;AACD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIjF"}
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/learning/contracts.ts"],"names":[],"mappings":"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C;AAEZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBpB,CAAC;AAEZ,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA2P,CAAC;AAE/R,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,wBAAgB,WAAW,CAAC,QAAQ,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,mBAAmB,CAEhH;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,mBAAmB,EAAE,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAE9F;AACD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAG9G;AACD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIjF"}

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

@@ -29,5 +29,7 @@ export { resolveLearningTrainingParent } from "./iteration-training-parent.js";
 export * from "./schedule-contracts.js";
 export * from "./schedule-service.js";
 export * from "./schedule-worker.js";
+export * from "./nightly-schedule.js";
 export * from "./policy-inspection.js";
+export * from "./task-queue-inspection.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,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,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,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,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,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,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,OAAO,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAC/E,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC"}

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

@@ -2,7 +2,9 @@ import { type LearningPolicy, type TaskAdmissionDecision, type TaskEvidence } fr
 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<{
+export declare function inspectIterationEligibility(transaction: LearningTransaction, policy: LearningPolicy, options?: {
+    collectEligible?: boolean;
+}): Promise<{
     counts: {
         eligible: number;
         awaitingReview: number;
@@ -14,5 +16,10 @@ export declare function inspectIterationEligibility(transaction: LearningTransac
         decision: TaskAdmissionDecision;
     }[];
     purpose: "supervised_training" | "reward_training";
+    eligibleEvidence: {
+        id: string;
+        contentHash: string;
+        revision: number;
+    }[];
 }>;
 //# sourceMappingURL=iteration-eligibility.d.ts.map

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

@@ -1 +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"}
+{"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,EAAE,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO;;;;;;;;kBAYzH,YAAY;kBAAY,qBAAqB;;;;;;;;GA6C1E"}

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

@@ -5,6 +5,9 @@ export declare const LearningIterationTriggerSchema: z.ZodDiscriminatedUnion<[z.
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"schedule">;
     scheduledAt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"approved_count">;
+    checkedAt: 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<{
@@ -75,6 +78,9 @@ export declare const LearningIterationReservationSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"schedule">;
         scheduledAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"approved_count">;
+        checkedAt: z.ZodString;
     }, z.core.$strict>], "kind">;
     requestHash: z.ZodString;
     outcome: z.ZodEnum<{

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

@@ -1 +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;;;;;;;;;;;;;;;;;;;;;;;kBAUrB,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"}
+{"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;;;;;;;;;4BAIzC,CAAC;AAEH,gFAAgF;AAChF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;kBAUrB,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"iteration-reservation-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-service.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG1I,KAAK,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAAC;AAEhF,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CA6ExK"}
+{"version":3,"file":"iteration-reservation-service.d.ts","sourceRoot":"","sources":["../../../../../src/learning/iteration-reservation-service.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmD,KAAK,uBAAuB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG1I,KAAK,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC,CAAC;AAEhF,kFAAkF;AAClF,wBAAsB,wBAAwB,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAmFxK"}

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

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const NightlyScheduleSchema: z.ZodObject<{
+    localTime: z.ZodString;
+    timeZone: z.ZodString;
+}, z.core.$strict>;
+export type NightlySchedule = z.infer<typeof NightlyScheduleSchema>;
+export declare function nextNightlyOccurrence(calendar: NightlySchedule, after: string): string;
+export declare function coalesceNightlyOccurrences(calendar: NightlySchedule, due: string, now: string): {
+    coalescedThroughAt: string;
+    coalescedCount: number;
+    nextRunAt: string;
+};
+//# sourceMappingURL=nightly-schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nightly-schedule.d.ts","sourceRoot":"","sources":["../../../../../src/learning/nightly-schedule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;kBAKvB,CAAC;AACZ,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AA6BpE,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAWtF;AAED,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;;EAc7F"}