Function tick

packages/agent-core/src/tools/cron/scheduler.ts:278–423

()

  }

  function tick(): void {
    if (isKilled?.() === true) return;
    if (!isIdle()) return;

    const tasks = source();
    if (tasks.length === 0) return;

    const now = clocks.wallNow();

    // We clear inFlight at the end of the tick; entry-time defence
    // against re-entry handled by the `inFlight.has(id)` skip below.
    try {
      for (const task of tasks) {
        try {
          if (inFlight.has(task.id)) continue;

          const parsed = getParsed(task.cron);

          // First time we see this task in this scheduler instance,
          // seed `lastSeenAt` from the persisted `task.lastFiredAt`
          // (when present and sane). This is the one-line fix for
          // "resume replays yesterday's already-fired 09:00 cron":
          // without seeding, the baseline below would fall back to
          // `task.createdAt` and `countCoalesced` would treat every
          // ideal fire since creation as still due. A `lastFiredAt`
          // strictly greater than `now` is treated as corrupt (clock
          // skew, mis-set bench env) and ignored — never trust a
          // stored cursor enough to *skip* a legitimately-due fire.
          if (
            !seededFromDisk.has(task.id) &&
            task.lastFiredAt !== undefined &&
            Number.isFinite(task.lastFiredAt) &&
            task.lastFiredAt <= now &&
            !lastSeenAt.has(task.id)
          ) {
            lastSeenAt.set(task.id, task.lastFiredAt);
          }
          seededFromDisk.add(task.id);

          // Base from which to compute the next ideal fire. For a
          // freshly-added task this is its createdAt; once we've fired
          // (or seen it pass), bump to the wall clock at that moment
          // so we don't double-count the same fire on the next tick.
          const seen = lastSeenAt.get(task.id);
          const baseFromMs =
            seen !== undefined && seen > task.createdAt ? seen : task.createdAt;

          const nextFireAt = computeJitteredNext(task, parsed, baseFromMs);
          if (nextFireAt === null) continue;

          if (now < nextFireAt) continue;

          // Due — compute coalescedCount starting from the first
          // ideal fire (not the jittered one — jitter only shifts the
          // delivery point, not the underlying schedule). One-shot
          // tasks are removed after a single delivery and must always
          // report `coalescedCount: 1`; multi-occurrence semantics
          // make no sense for "remind me at X" reminders that were