fix(schedule-engine): seed lastScheduleTime on recovery via cron-prev

Recovery (Redis job missing for an instance) was re-registering with
no lastScheduleTime, so the post-recovery first fire fell through the
fallback chain to instance.lastScheduledTimestamp — which is frozen at
the value last written before this PR stopped writing the column. For
schedules that fired heavily after deploy then suffered a Redis loss,
that meant payload.lastTimestamp would report a stale pre-deploy
timestamp on the first fire post-recovery.

Compute lastScheduleTime as the cron expression's previous slot (pure
cron math, no DB read — recovery fan-outs must not add load to hot
tables). Guarded against the cron-prev predating the instance's
createdAt and against cron-parser throwing on malformed expressions.
For continuously-running schedules this equals the actual last fire
time; for long-paused or recently-edited schedules it's the same
approximation the dashboard "Last run" cell accepts.

Per Devin and CodeRabbit review on PR #3476.

Author: ericallam

internal-packages/schedule-engine/src/engine/index.ts

@@ -11,7 +11,11 @@ import { Logger } from "@trigger.dev/core/logger";
 import { PrismaClient } from "@trigger.dev/database";
 import { Worker, type JobHandlerParams } from "@trigger.dev/redis-worker";
 import { calculateDistributedExecutionTime } from "./distributedScheduling.js";
-import { calculateNextScheduledTimestamp, nextScheduledTimestamps } from "./scheduleCalculation.js";
+import {
+  calculateNextScheduledTimestamp,
+  nextScheduledTimestamps,
+  previousScheduledTimestamp,
+} from "./scheduleCalculation.js";
 import {
   RegisterScheduleInstanceParams,
   ScheduleEngineOptions,
@@ -699,10 +703,12 @@ export class ScheduleEngine {
         select: {
           id: true,
           generatorExpression: true,
+          timezone: true,
           instances: {
             select: {
               id: true,
               environmentId: true,
+              createdAt: true,
             },
           },
         },
@@ -777,8 +783,9 @@ export class ScheduleEngine {
     instance: {
       id: string;
       environmentId: string;
+      createdAt: Date;
     };
-    schedule: { id: string; generatorExpression: string };
+    schedule: { id: string; generatorExpression: string; timezone: string | null };
   }) {
     // inspect the schedule worker to see if there is a job for this instance
     const job = await this.worker.getJob(`scheduled-task-instance:${instance.id}`);
@@ -793,13 +800,39 @@ export class ScheduleEngine {
       return "skipped";
     }
 
+    // Approximate the previous fire from the cron expression itself rather
+    // than reading state from the DB. For a continuously-running schedule
+    // this equals the actual last fire time. For paused-then-resumed
+    // schedules or recently-edited cron expressions the value will be
+    // approximate — same trade-off the dashboard "Last run" cell accepts.
+    // Guarded against the schedule not having existed long enough to have
+    // fired (cron's previous slot before instance creation), and against
+    // cron-parser throwing on malformed expressions. Pure cron math, no DB
+    // read — recovery fan-outs (Redis crash, restart storms) must not add
+    // load to hot tables.
+    let lastScheduleTime: Date | undefined;
+    try {
+      const cronPrev = previousScheduledTimestamp(
+        schedule.generatorExpression,
+        schedule.timezone
+      );
+      if (cronPrev.getTime() > instance.createdAt.getTime()) {
+        lastScheduleTime = cronPrev;
+      }
+    } catch {
+      lastScheduleTime = undefined;
+    }
+
     this.logger.info("No job found for instance, registering next run", {
       instanceId: instance.id,
       schedule,
+      lastScheduleTime: lastScheduleTime?.toISOString(),
     });
 
-    // If the job does not exist, register the next run
-    await this.registerNextTaskScheduleInstance({ instanceId: instance.id });
+    await this.registerNextTaskScheduleInstance({
+      instanceId: instance.id,
+      lastScheduleTime,
+    });
 
     return "recovered";
   }

internal-packages/schedule-engine/src/engine/scheduleCalculation.ts

@@ -29,6 +29,26 @@ function calculateNextStep(schedule: string, timezone: string | null, currentDat
     .toDate();
 }
 
+/**
+ * Cron's previous slot relative to `fromTimestamp`. For a continuously-
+ * running schedule this equals the actual last fire time; for paused or
+ * DST-edge cases it's an approximation. Used only on the recovery path
+ * where the actual last fire isn't recoverable from in-flight worker state.
+ */
+export function previousScheduledTimestamp(
+  cron: string,
+  timezone: string | null,
+  fromTimestamp: Date = new Date()
+) {
+  return parseExpression(cron, {
+    currentDate: fromTimestamp,
+    utc: timezone === null,
+    tz: timezone ?? undefined,
+  })
+    .prev()
+    .toDate();
+}
+
 export function nextScheduledTimestamps(
   cron: string,
   timezone: string | null,