@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/cron/service/jobs.js

@@ -1,7 +1,15 @@
 import crypto from "node:crypto";
+import { parseAbsoluteTimeMs } from "../parse.js";
 import { computeNextRunAtMs } from "../schedule.js";
 import { normalizeOptionalAgentId, normalizeOptionalText, normalizePayloadToSystemText, normalizeRequiredName, } from "./normalize.js";
 const STUCK_RUN_MS = 2 * 60 * 60 * 1000;
+function resolveEveryAnchorMs(params) {
+    const raw = params.schedule.anchorMs;
+    if (typeof raw === "number" && Number.isFinite(raw)) {
+        return Math.max(0, Math.floor(raw));
+    }
+    return Math.max(0, Math.floor(params.fallbackAnchorMs));
+}
 export function assertSupportedJobSpec(job) {
     if (job.sessionTarget === "main" && job.payload.kind !== "systemEvent") {
         throw new Error('main cron jobs require payload.kind="systemEvent"');
@@ -10,100 +18,189 @@ export function assertSupportedJobSpec(job) {
         throw new Error('isolated cron jobs require payload.kind="agentTurn"');
     }
 }
+function assertDeliverySupport(job) {
+    if (job.delivery && job.sessionTarget !== "isolated") {
+        throw new Error('cron delivery config is only supported for sessionTarget="isolated"');
+    }
+}
 export function findJobOrThrow(state, id) {
     const job = state.store?.jobs.find((j) => j.id === id);
-    if (!job)
+    if (!job) {
         throw new Error(`unknown cron job id: ${id}`);
+    }
     return job;
 }
 export function computeJobNextRunAtMs(job, nowMs) {
-    if (!job.enabled)
+    if (!job.enabled) {
         return undefined;
+    }
+    if (job.schedule.kind === "every") {
+        const anchorMs = resolveEveryAnchorMs({
+            schedule: job.schedule,
+            fallbackAnchorMs: job.createdAtMs,
+        });
+        return computeNextRunAtMs({ ...job.schedule, anchorMs }, nowMs);
+    }
     if (job.schedule.kind === "at") {
         // One-shot jobs stay due until they successfully finish.
-        if (job.state.lastStatus === "ok" && job.state.lastRunAtMs)
+        if (job.state.lastStatus === "ok" && job.state.lastRunAtMs) {
             return undefined;
-        return job.schedule.atMs;
+        }
+        // Handle both canonical `at` (string) and legacy `atMs` (number) fields.
+        // The store migration should convert atMs→at, but be defensive in case
+        // the migration hasn't run yet or was bypassed.
+        const schedule = job.schedule;
+        const atMs = typeof schedule.atMs === "number" && Number.isFinite(schedule.atMs) && schedule.atMs > 0
+            ? schedule.atMs
+            : typeof schedule.atMs === "string"
+                ? parseAbsoluteTimeMs(schedule.atMs)
+                : typeof schedule.at === "string"
+                    ? parseAbsoluteTimeMs(schedule.at)
+                    : null;
+        return atMs !== null ? atMs : undefined;
     }
     return computeNextRunAtMs(job.schedule, nowMs);
 }
 export function recomputeNextRuns(state) {
-    if (!state.store)
-        return;
+    if (!state.store) {
+        return false;
+    }
+    let changed = false;
     const now = state.deps.nowMs();
     for (const job of state.store.jobs) {
-        if (!job.state)
+        if (!job.state) {
             job.state = {};
+            changed = true;
+        }
         if (!job.enabled) {
-            job.state.nextRunAtMs = undefined;
-            job.state.runningAtMs = undefined;
+            if (job.state.nextRunAtMs !== undefined) {
+                job.state.nextRunAtMs = undefined;
+                changed = true;
+            }
+            if (job.state.runningAtMs !== undefined) {
+                job.state.runningAtMs = undefined;
+                changed = true;
+            }
             continue;
         }
         const runningAt = job.state.runningAtMs;
         if (typeof runningAt === "number" && now - runningAt > STUCK_RUN_MS) {
             state.deps.log.warn({ jobId: job.id, runningAtMs: runningAt }, "cron: clearing stuck running marker");
             job.state.runningAtMs = undefined;
+            changed = true;
+        }
+        // Only recompute if nextRunAtMs is missing or already past-due.
+        // Preserving a still-future nextRunAtMs avoids accidentally advancing
+        // a job that hasn't fired yet (e.g. during restart recovery).
+        const nextRun = job.state.nextRunAtMs;
+        const isDueOrMissing = nextRun === undefined || now >= nextRun;
+        if (isDueOrMissing) {
+            const newNext = computeJobNextRunAtMs(job, now);
+            if (job.state.nextRunAtMs !== newNext) {
+                job.state.nextRunAtMs = newNext;
+                changed = true;
+            }
         }
-        job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
     }
+    return changed;
 }
 export function nextWakeAtMs(state) {
     const jobs = state.store?.jobs ?? [];
     const enabled = jobs.filter((j) => j.enabled && typeof j.state.nextRunAtMs === "number");
-    if (enabled.length === 0)
+    if (enabled.length === 0) {
         return undefined;
+    }
     return enabled.reduce((min, j) => Math.min(min, j.state.nextRunAtMs), enabled[0].state.nextRunAtMs);
 }
 export function createJob(state, input) {
     const now = state.deps.nowMs();
     const id = crypto.randomUUID();
+    const schedule = input.schedule.kind === "every"
+        ? {
+            ...input.schedule,
+            anchorMs: resolveEveryAnchorMs({
+                schedule: input.schedule,
+                fallbackAnchorMs: now,
+            }),
+        }
+        : input.schedule;
+    const deleteAfterRun = typeof input.deleteAfterRun === "boolean"
+        ? input.deleteAfterRun
+        : schedule.kind === "at"
+            ? true
+            : undefined;
+    const enabled = typeof input.enabled === "boolean" ? input.enabled : true;
     const job = {
         id,
         agentId: normalizeOptionalAgentId(input.agentId),
         name: normalizeRequiredName(input.name),
         description: normalizeOptionalText(input.description),
-        enabled: input.enabled !== false,
-        deleteAfterRun: input.deleteAfterRun,
+        enabled,
+        deleteAfterRun,
         createdAtMs: now,
         updatedAtMs: now,
-        schedule: input.schedule,
+        schedule,
         sessionTarget: input.sessionTarget,
         wakeMode: input.wakeMode,
         payload: input.payload,
-        isolation: input.isolation,
+        delivery: input.delivery,
         state: {
             ...input.state,
         },
     };
     assertSupportedJobSpec(job);
+    assertDeliverySupport(job);
     job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
     return job;
 }
 export function applyJobPatch(job, patch) {
-    if ("name" in patch)
+    if ("name" in patch) {
         job.name = normalizeRequiredName(patch.name);
-    if ("description" in patch)
+    }
+    if ("description" in patch) {
         job.description = normalizeOptionalText(patch.description);
-    if (typeof patch.enabled === "boolean")
+    }
+    if (typeof patch.enabled === "boolean") {
         job.enabled = patch.enabled;
-    if (typeof patch.deleteAfterRun === "boolean")
+    }
+    if (typeof patch.deleteAfterRun === "boolean") {
         job.deleteAfterRun = patch.deleteAfterRun;
-    if (patch.schedule)
+    }
+    if (patch.schedule) {
         job.schedule = patch.schedule;
-    if (patch.sessionTarget)
+    }
+    if (patch.sessionTarget) {
         job.sessionTarget = patch.sessionTarget;
-    if (patch.wakeMode)
+    }
+    if (patch.wakeMode) {
         job.wakeMode = patch.wakeMode;
-    if (patch.payload)
+    }
+    if (patch.payload) {
         job.payload = mergeCronPayload(job.payload, patch.payload);
-    if (patch.isolation)
-        job.isolation = patch.isolation;
-    if (patch.state)
+    }
+    if (!patch.delivery && patch.payload?.kind === "agentTurn") {
+        // Back-compat: legacy clients still update delivery via payload fields.
+        const legacyDeliveryPatch = buildLegacyDeliveryPatch(patch.payload);
+        if (legacyDeliveryPatch &&
+            job.sessionTarget === "isolated" &&
+            job.payload.kind === "agentTurn") {
+            job.delivery = mergeCronDelivery(job.delivery, legacyDeliveryPatch);
+        }
+    }
+    if (patch.delivery) {
+        job.delivery = mergeCronDelivery(job.delivery, patch.delivery);
+    }
+    if (job.sessionTarget === "main" && job.delivery) {
+        job.delivery = undefined;
+    }
+    if (patch.state) {
         job.state = { ...job.state, ...patch.state };
+    }
     if ("agentId" in patch) {
         job.agentId = normalizeOptionalAgentId(patch.agentId);
     }
     assertSupportedJobSpec(job);
+    assertDeliverySupport(job);
 }
 function mergeCronPayload(existing, patch) {
     if (patch.kind !== existing.kind) {
@@ -120,25 +217,69 @@ function mergeCronPayload(existing, patch) {
         return buildPayloadFromPatch(patch);
     }
     const next = { ...existing };
-    if (typeof patch.message === "string")
+    if (typeof patch.message === "string") {
         next.message = patch.message;
-    if (typeof patch.model === "string")
+    }
+    if (typeof patch.model === "string") {
         next.model = patch.model;
-    if (typeof patch.thinking === "string")
+    }
+    if (typeof patch.thinking === "string") {
         next.thinking = patch.thinking;
-    if (typeof patch.timeoutSeconds === "number")
+    }
+    if (typeof patch.timeoutSeconds === "number") {
         next.timeoutSeconds = patch.timeoutSeconds;
-    if (typeof patch.deliver === "boolean")
+    }
+    if (typeof patch.allowUnsafeExternalContent === "boolean") {
+        next.allowUnsafeExternalContent = patch.allowUnsafeExternalContent;
+    }
+    if (typeof patch.deliver === "boolean") {
         next.deliver = patch.deliver;
-    if (typeof patch.channel === "string")
+    }
+    if (typeof patch.channel === "string") {
         next.channel = patch.channel;
-    if (typeof patch.to === "string")
+    }
+    if (typeof patch.to === "string") {
         next.to = patch.to;
+    }
     if (typeof patch.bestEffortDeliver === "boolean") {
         next.bestEffortDeliver = patch.bestEffortDeliver;
     }
     return next;
 }
+function buildLegacyDeliveryPatch(payload) {
+    const deliver = payload.deliver;
+    const toRaw = typeof payload.to === "string" ? payload.to.trim() : "";
+    const hasLegacyHints = typeof deliver === "boolean" ||
+        typeof payload.bestEffortDeliver === "boolean" ||
+        Boolean(toRaw);
+    if (!hasLegacyHints) {
+        return null;
+    }
+    const patch = {};
+    let hasPatch = false;
+    if (deliver === false) {
+        patch.mode = "none";
+        hasPatch = true;
+    }
+    else if (deliver === true || toRaw) {
+        patch.mode = "announce";
+        hasPatch = true;
+    }
+    if (typeof payload.channel === "string") {
+        const channel = payload.channel.trim().toLowerCase();
+        patch.channel = channel ? channel : undefined;
+        hasPatch = true;
+    }
+    if (typeof payload.to === "string") {
+        patch.to = payload.to.trim();
+        hasPatch = true;
+    }
+    if (typeof payload.bestEffortDeliver === "boolean") {
+        patch.bestEffort = payload.bestEffortDeliver;
+        hasPatch = true;
+    }
+    return hasPatch ? patch : null;
+}
 function buildPayloadFromPatch(patch) {
     if (patch.kind === "systemEvent") {
         if (typeof patch.text !== "string" || patch.text.length === 0) {
@@ -155,20 +296,52 @@ function buildPayloadFromPatch(patch) {
         model: patch.model,
         thinking: patch.thinking,
         timeoutSeconds: patch.timeoutSeconds,
+        allowUnsafeExternalContent: patch.allowUnsafeExternalContent,
         deliver: patch.deliver,
         channel: patch.channel,
         to: patch.to,
         bestEffortDeliver: patch.bestEffortDeliver,
     };
 }
+function mergeCronDelivery(existing, patch) {
+    const next = {
+        mode: existing?.mode ?? "none",
+        channel: existing?.channel,
+        to: existing?.to,
+        bestEffort: existing?.bestEffort,
+    };
+    if (typeof patch.mode === "string") {
+        next.mode = patch.mode === "deliver" ? "announce" : patch.mode;
+    }
+    if ("channel" in patch) {
+        const channel = typeof patch.channel === "string" ? patch.channel.trim() : "";
+        next.channel = channel ? channel : undefined;
+    }
+    if ("to" in patch) {
+        const to = typeof patch.to === "string" ? patch.to.trim() : "";
+        next.to = to ? to : undefined;
+    }
+    if (typeof patch.bestEffort === "boolean") {
+        next.bestEffort = patch.bestEffort;
+    }
+    return next;
+}
 export function isJobDue(job, nowMs, opts) {
-    if (opts.forced)
+    if (!job.state) {
+        job.state = {};
+    }
+    if (typeof job.state.runningAtMs === "number") {
+        return false;
+    }
+    if (opts.forced) {
         return true;
+    }
     return job.enabled && typeof job.state.nextRunAtMs === "number" && nowMs >= job.state.nextRunAtMs;
 }
 export function resolveJobPayloadTextForMain(job) {
-    if (job.payload.kind !== "systemEvent")
+    if (job.payload.kind !== "systemEvent") {
         return undefined;
+    }
     const text = normalizePayloadToSystemText(job.payload);
     return text.trim() ? text : undefined;
 }

package/dist/cron/service/ops.js

@@ -1,14 +1,22 @@
 import { applyJobPatch, computeJobNextRunAtMs, createJob, findJobOrThrow, isJobDue, nextWakeAtMs, recomputeNextRuns, } from "./jobs.js";
 import { locked } from "./locked.js";
 import { ensureLoaded, persist, warnIfDisabled } from "./store.js";
-import { armTimer, emit, executeJob, stopTimer, wake } from "./timer.js";
+import { armTimer, emit, executeJob, runMissedJobs, stopTimer, wake } from "./timer.js";
 export async function start(state) {
     await locked(state, async () => {
         if (!state.deps.cronEnabled) {
             state.deps.log.info({ enabled: false }, "cron: disabled");
             return;
         }
-        await ensureLoaded(state);
+        await ensureLoaded(state, { skipRecompute: true });
+        const jobs = state.store?.jobs ?? [];
+        for (const job of jobs) {
+            if (typeof job.state.runningAtMs === "number") {
+                state.deps.log.warn({ jobId: job.id, runningAtMs: job.state.runningAtMs }, "cron: clearing stale running marker on startup");
+                job.state.runningAtMs = undefined;
+            }
+        }
+        await runMissedJobs(state);
         recomputeNextRuns(state);
         await persist(state);
         armTimer(state);
@@ -24,21 +32,33 @@ export function stop(state) {
 }
 export async function status(state) {
     return await locked(state, async () => {
-        await ensureLoaded(state);
+        await ensureLoaded(state, { skipRecompute: true });
+        if (state.store) {
+            const changed = recomputeNextRuns(state);
+            if (changed) {
+                await persist(state);
+            }
+        }
         return {
             enabled: state.deps.cronEnabled,
             storePath: state.deps.storePath,
             jobs: state.store?.jobs.length ?? 0,
-            nextWakeAtMs: state.deps.cronEnabled === true ? (nextWakeAtMs(state) ?? null) : null,
+            nextWakeAtMs: state.deps.cronEnabled ? (nextWakeAtMs(state) ?? null) : null,
         };
     });
 }
 export async function list(state, opts) {
     return await locked(state, async () => {
-        await ensureLoaded(state);
+        await ensureLoaded(state, { skipRecompute: true });
+        if (state.store) {
+            const changed = recomputeNextRuns(state);
+            if (changed) {
+                await persist(state);
+            }
+        }
         const includeDisabled = opts?.includeDisabled === true;
         const jobs = (state.store?.jobs ?? []).filter((j) => includeDisabled || j.enabled);
-        return jobs.sort((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
+        return jobs.toSorted((a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0));
     });
 }
 export async function add(state, input) {
@@ -47,8 +67,18 @@ export async function add(state, input) {
         await ensureLoaded(state);
         const job = createJob(state, input);
         state.store?.jobs.push(job);
+        // Defensive: recompute all next-run times to ensure consistency
+        recomputeNextRuns(state);
         await persist(state);
         armTimer(state);
+        state.deps.log.info({
+            jobId: job.id,
+            jobName: job.name,
+            nextRunAtMs: job.state.nextRunAtMs,
+            schedulerNextWakeAtMs: nextWakeAtMs(state) ?? null,
+            timerArmed: state.timer !== null,
+            cronEnabled: state.deps.cronEnabled,
+        }, "cron: job added");
         emit(state, {
             jobId: job.id,
             action: "added",
@@ -64,13 +94,32 @@ export async function update(state, id, patch) {
         const job = findJobOrThrow(state, id);
         const now = state.deps.nowMs();
         applyJobPatch(job, patch);
-        job.updatedAtMs = now;
-        if (job.enabled) {
-            job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+        if (job.schedule.kind === "every") {
+            const anchor = job.schedule.anchorMs;
+            if (typeof anchor !== "number" || !Number.isFinite(anchor)) {
+                const patchSchedule = patch.schedule;
+                const fallbackAnchorMs = patchSchedule?.kind === "every"
+                    ? now
+                    : typeof job.createdAtMs === "number" && Number.isFinite(job.createdAtMs)
+                        ? job.createdAtMs
+                        : now;
+                job.schedule = {
+                    ...job.schedule,
+                    anchorMs: Math.max(0, Math.floor(fallbackAnchorMs)),
+                };
+            }
         }
-        else {
-            job.state.nextRunAtMs = undefined;
-            job.state.runningAtMs = undefined;
+        const scheduleChanged = patch.schedule !== undefined;
+        const enabledChanged = patch.enabled !== undefined;
+        job.updatedAtMs = now;
+        if (scheduleChanged || enabledChanged) {
+            if (job.enabled) {
+                job.state.nextRunAtMs = computeJobNextRunAtMs(job, now);
+            }
+            else {
+                job.state.nextRunAtMs = undefined;
+                job.state.runningAtMs = undefined;
+            }
         }
         await persist(state);
         armTimer(state);
@@ -87,27 +136,34 @@ export async function remove(state, id) {
         warnIfDisabled(state, "remove");
         await ensureLoaded(state);
         const before = state.store?.jobs.length ?? 0;
-        if (!state.store)
+        if (!state.store) {
             return { ok: false, removed: false };
+        }
         state.store.jobs = state.store.jobs.filter((j) => j.id !== id);
         const removed = (state.store.jobs.length ?? 0) !== before;
         await persist(state);
         armTimer(state);
-        if (removed)
+        if (removed) {
             emit(state, { jobId: id, action: "removed" });
+        }
         return { ok: true, removed };
     });
 }
 export async function run(state, id, mode) {
     return await locked(state, async () => {
         warnIfDisabled(state, "run");
-        await ensureLoaded(state);
+        await ensureLoaded(state, { skipRecompute: true });
         const job = findJobOrThrow(state, id);
+        if (typeof job.state.runningAtMs === "number") {
+            return { ok: true, ran: false, reason: "already-running" };
+        }
         const now = state.deps.nowMs();
         const due = isJobDue(job, now, { forced: mode === "force" });
-        if (!due)
+        if (!due) {
             return { ok: true, ran: false, reason: "not-due" };
+        }
         await executeJob(state, job, now, { forced: mode === "force" });
+        recomputeNextRuns(state);
         await persist(state);
         armTimer(state);
         return { ok: true, ran: true };

package/dist/cron/service/state.js

@@ -6,5 +6,7 @@ export function createCronServiceState(deps) {
         running: false,
         op: Promise.resolve(),
         warnedDisabled: false,
+        storeLoadedAtMs: null,
+        storeFileMtimeMs: null,
     };
 }