clay-server 4.1.0-beta.4 → 4.1.0-beta.6

package/lib/scheduler.js

@@ -1,137 +1,46 @@
-/**
- * Loop Registry — unified storage for all Ralph Loops (one-off + scheduled).
- *
- * Stores loop records in ~/.clay/loops/{encodedCwd}.jsonl
- * Each record represents a job defined via clay-ralph (PROMPT.md + JUDGE.md).
- * Records with a `cron` field are checked every 30s and auto-triggered.
- * Records without cron are one-off (standard Ralph Loop behavior).
- */
-
 var fs = require("fs");
 var path = require("path");
+var crypto = require("crypto");
 var { CONFIG_DIR } = require("./config");
 var { encodeCwd } = require("./utils");
-
-// --- Cron parser (5-field: minute hour day-of-month month day-of-week) ---
-
-function parseCronField(field, min, max) {
-  var values = [];
-  var parts = field.split(",");
-  for (var i = 0; i < parts.length; i++) {
-    var part = parts[i].trim();
-
-    // wildcard with step: */N
-    if (part.indexOf("/") !== -1) {
-      var slashParts = part.split("/");
-      var step = parseInt(slashParts[1], 10);
-      var rangeStr = slashParts[0];
-      var rangeMin = min;
-      var rangeMax = max;
-      if (rangeStr !== "*") {
-        var rp = rangeStr.split("-");
-        rangeMin = parseInt(rp[0], 10);
-        rangeMax = rp.length > 1 ? parseInt(rp[1], 10) : rangeMin;
-      }
-      for (var v = rangeMin; v <= rangeMax; v += step) {
-        values.push(v);
-      }
-      continue;
-    }
-
-    // wildcard
-    if (part === "*") {
-      for (var v = min; v <= max; v++) {
-        values.push(v);
-      }
-      continue;
-    }
-
-    // range: N-M
-    if (part.indexOf("-") !== -1) {
-      var rangeParts = part.split("-");
-      var from = parseInt(rangeParts[0], 10);
-      var to = parseInt(rangeParts[1], 10);
-      for (var v = from; v <= to; v++) {
-        values.push(v);
-      }
-      continue;
-    }
-
-    // single value
-    values.push(parseInt(part, 10));
-  }
-  return values;
-}
-
-function parseCron(expr) {
-  var fields = expr.trim().split(/\s+/);
-  if (fields.length !== 5) return null;
-  return {
-    minutes: parseCronField(fields[0], 0, 59),
-    hours: parseCronField(fields[1], 0, 23),
-    daysOfMonth: parseCronField(fields[2], 1, 31),
-    months: parseCronField(fields[3], 1, 12),
-    daysOfWeek: parseCronField(fields[4], 0, 6),
-  };
-}
-
-function cronMatches(parsed, date) {
-  var minute = date.getMinutes();
-  var hour = date.getHours();
-  var dayOfMonth = date.getDate();
-  var month = date.getMonth() + 1;
-  var dayOfWeek = date.getDay();
-
-  return (
-    parsed.minutes.indexOf(minute) !== -1 &&
-    parsed.hours.indexOf(hour) !== -1 &&
-    parsed.daysOfMonth.indexOf(dayOfMonth) !== -1 &&
-    parsed.months.indexOf(month) !== -1 &&
-    parsed.daysOfWeek.indexOf(dayOfWeek) !== -1
-  );
+var scheduleRule = require("./schedule-rule");
+var recordRevision = require("./record-revision");
+var createScheduledRunState = require("./scheduled-run-state").createScheduledRunState;
+var attachLoopRegistryOccurrence = require("./loop-registry-occurrence").attachLoopRegistryOccurrence;
+var nextRunTime = require("./loop-cron").nextRunTime;
+
+function nextRecordRunTime(record, after) {
+  return record.scheduleRule ? scheduleRule.nextScheduleRuleTime(record.scheduleRule, after, record.runs, { startCount: record.scheduleStartCount, dateStartCounts: record.scheduleDateStartCounts }) : (record.cron ? nextRunTime(record.cron, after) : null);
 }
 
-/**
- * Calculate next run time from a cron expression after a given date.
- * Brute-force: check each minute for up to 366 days.
- */
-function nextRunTime(cronExpr, after) {
-  var parsed = parseCron(cronExpr);
-  if (!parsed) return null;
-
-  var d = new Date(after || Date.now());
-  d.setSeconds(0, 0);
-  d.setMinutes(d.getMinutes() + 1);
-
-  var limit = 366 * 24 * 60;
-  for (var i = 0; i < limit; i++) {
-    if (cronMatches(parsed, d)) {
-      return d.getTime();
-    }
-    d.setMinutes(d.getMinutes() + 1);
-  }
-  return null;
+function oneOffRunTime(record) {
+  var date = record.date.split("-");
+  var time = record.time.split(":");
+  return new Date(Number(date[0]), Number(date[1]) - 1, Number(date[2]), Number(time[0]), Number(time[1]), 0).getTime();
 }
 
-// --- Loop Registry factory ---
-
 function createLoopRegistry(opts) {
   var cwd = opts.cwd;
-  var onTrigger = opts.onTrigger;
-  var onChange = opts.onChange;
+  var onTrigger = opts.onTrigger, onChange = opts.onChange;
+  var canTrigger = opts.canTrigger, prepareTrigger = opts.prepareTrigger;
 
   var encoded = encodeCwd(cwd);
-  var registryDir = path.join(CONFIG_DIR, "loops");
-  var registryPath = path.join(registryDir, encoded + ".jsonl");
+  var registryPath = opts.registryPath || path.join(CONFIG_DIR, "loops", encoded + ".jsonl");
+  var registryDir = path.dirname(registryPath);
 
   var records = [];
   var timerId = null;
   var CHECK_INTERVAL = 30 * 1000;
   var lastTriggeredMinute = {};
-
-  // --- Persistence (JSONL) ---
+  var lastSaveError = null;
+  var scheduledRuns = createScheduledRunState({
+    getRecord: getById, save: save,
+    onChange: function () { if (onChange) onChange(records); },
+  });
+  var durableOccurrence;
 
   function load() {
+    var recoveredRun = false;
     try {
       var raw = fs.readFileSync(registryPath, "utf8");
       var lines = raw.trim().split("\n");
@@ -140,21 +49,24 @@ function createLoopRegistry(opts) {
         if (!lines[i].trim()) continue;
         try {
           var rec = JSON.parse(lines[i]);
-          // Recalculate nextRunAt for scheduled records
-          if (rec.cron && rec.enabled) {
-            rec.nextRunAt = nextRunTime(rec.cron);
-          } else if (!rec.cron && rec.enabled && rec.date && rec.time && rec.source === "schedule") {
-            // One-off: recalculate from date+time
-            var dtP = rec.date.split("-");
-            var tmP = rec.time.split(":");
-            var runD = new Date(parseInt(dtP[0], 10), parseInt(dtP[1], 10) - 1, parseInt(dtP[2], 10), parseInt(tmP[0], 10), parseInt(tmP[1], 10), 0);
-            rec.nextRunAt = runD.getTime();
+          if (scheduledRuns.recover(rec)) recoveredRun = true;
+          if ((rec.cron || rec.scheduleRule || (rec.source === "schedule" && rec.date && rec.time)) && !rec.scheduleIdentity) {
+            rec.scheduleIdentity = crypto.randomUUID(); rec.scheduleEpoch = 1; recoveredRun = true;
+          } else if (rec.scheduleIdentity && (!Number.isInteger(rec.scheduleEpoch) || rec.scheduleEpoch < 1)) {
+            rec.scheduleEpoch = 1; recoveredRun = true;
+          }
+          if ((rec.cron || rec.scheduleRule) && rec.enabled) {
+            if (!Number.isFinite(rec.nextRunAt)) rec.nextRunAt = nextRecordRunTime(rec);
+            if (rec.scheduleRule && !rec.nextRunAt) rec.enabled = false;
+          } else if (!rec.cron && !rec.scheduleRule && rec.enabled && rec.date && rec.time && rec.source === "schedule") {
+            rec.nextRunAt = oneOffRunTime(rec);
           }
           records.push(rec);
         } catch (e) {
           // skip malformed line
         }
       }
+      if (recoveredRun) save();
     } catch (e) {
       records = [];
     }
@@ -170,12 +82,28 @@ function createLoopRegistry(opts) {
       var tmpPath = registryPath + ".tmp";
       fs.writeFileSync(tmpPath, lines.join("\n") + "\n");
       fs.renameSync(tmpPath, registryPath);
+      lastSaveError = null;
+      return true;
     } catch (e) {
+      lastSaveError = e.message || String(e);
       console.error("[loop-registry] Failed to save:", e.message);
+      return false;
     }
   }
 
-  // --- Timer (scheduled loops only) ---
+  function notifyOrRollback(rollback) {
+    if (!onChange) return true;
+    try { onChange(records); return true; }
+    catch (error) {
+      rollback();
+      var syncMessage = error && (error.message || String(error)) || "unknown durable scheduler error";
+      var rollbackSaved = save();
+      var rollbackMessage = rollbackSaved ? "" : " Registry rollback could not be stored: " + (lastSaveError || "unknown storage error") + ".";
+      lastSaveError = "Schedule metadata was rolled back because durable synchronization failed: " + syncMessage + "." + rollbackMessage;
+      console.error("[loop-registry] " + lastSaveError);
+      return false;
+    }
+  }
 
   function startTimer() {
     if (timerId) return;
@@ -201,13 +129,24 @@ function createLoopRegistry(opts) {
       if (!rec.enabled) continue;
       if (!rec.nextRunAt) continue;
       if (rec.nextRunAt > now) continue;
+      if (canTrigger && canTrigger(rec) === false) continue;
+
+      if (rec.scheduleRule) {
+        var duePrevious = JSON.parse(JSON.stringify(rec));
+        var currentDue = nextRecordRunTime(rec, now - 60000);
+        if (currentDue !== rec.nextRunAt) {
+          rec.nextRunAt = currentDue;
+          if (!currentDue) rec.enabled = false;
+          if (!save()) recordRevision.restoreRecord(rec, duePrevious);
+          if (onChange) onChange(records);
+          continue;
+        }
+      }
 
-      // Avoid double-trigger within same minute
       var triggerKey = rec.id + "_" + nowMinuteKey;
       if (lastTriggeredMinute[triggerKey]) continue;
       lastTriggeredMinute[triggerKey] = true;
 
-      // Clean old trigger keys
       var keys = Object.keys(lastTriggeredMinute);
       for (var k = 0; k < keys.length; k++) {
         var keyParts = keys[k].split("_");
@@ -217,8 +156,7 @@ function createLoopRegistry(opts) {
         }
       }
 
-      // Check recurrenceEnd conditions before triggering
-      if (rec.recurrenceEnd) {
+      if (!rec.scheduleRule && rec.recurrenceEnd) {
         var shouldDisable = false;
         if (rec.recurrenceEnd.type === "until" && rec.recurrenceEnd.date) {
           var reParts = rec.recurrenceEnd.date.split("-");
@@ -240,11 +178,9 @@ function createLoopRegistry(opts) {
         }
       }
 
-      // Check intervalEnd conditions before triggering
-      if (rec.intervalEnd) {
+      if (!rec.scheduleRule && rec.intervalEnd) {
         var skipTrigger = false;
         if (rec.intervalEnd.type === "until" && rec.intervalEnd.time) {
-          // Stop at a specific time of day
           var nowDate = new Date(now);
           var ieParts = rec.intervalEnd.time.split(":");
           var stopH = parseInt(ieParts[0], 10);
@@ -254,7 +190,6 @@ function createLoopRegistry(opts) {
             skipTrigger = true;
           }
         } else if (rec.intervalEnd.type === "after" && rec.intervalEnd.count > 0) {
-          // Stop after N runs today
           var todayStart = new Date(now);
           todayStart.setHours(0, 0, 0, 0);
           var todayStartMs = todayStart.getTime();
@@ -264,7 +199,6 @@ function createLoopRegistry(opts) {
           }
         }
         if (skipTrigger) {
-          // Advance nextRunAt without triggering
           if (rec.cron) {
             rec.nextRunAt = nextRunTime(rec.cron, now);
           }
@@ -273,36 +207,42 @@ function createLoopRegistry(opts) {
         }
       }
 
-      // Update nextRunAt
+      var previous = JSON.parse(JSON.stringify(rec));
+      var prepared = prepareTrigger ? prepareTrigger(rec) : null;
+      if (prepared && prepared.ok === false) { delete lastTriggeredMinute[triggerKey]; continue; }
+      scheduledRuns.prepareRecord(rec, prepared);
       rec.lastRunAt = now;
-      if (rec.cron) {
-        rec.nextRunAt = nextRunTime(rec.cron, now);
+      if (rec.scheduleRule) scheduleRule.recordScheduleStartState(rec, now);
+      if (rec.cron || rec.scheduleRule) {
+        rec.nextRunAt = nextRecordRunTime(rec, now);
+        if (rec.scheduleRule && !rec.nextRunAt) rec.enabled = false;
       } else {
-        // One-off schedule: disable after firing
         rec.nextRunAt = null;
         rec.enabled = false;
       }
-      save();
+      if (!save()) {
+        recordRevision.restoreRecord(rec, previous);
+        delete lastTriggeredMinute[triggerKey];
+        continue;
+      }
       if (onChange) onChange(records);
 
       console.log("[loop-registry] Triggering scheduled loop: " + rec.name + " (" + rec.id + ")");
       if (onTrigger) {
-        try { onTrigger(rec); } catch (e) {
+        try { onTrigger(rec, prepared); } catch (e) {
           console.error("[loop-registry] Trigger error:", e.message);
         }
       }
     }
   }
 
-  // --- CRUD ---
-
   function register(data) {
     var rec = {
       id: data.id || ("loop_" + Date.now() + "_" + require("crypto").randomBytes(3).toString("hex")),
       name: data.name || "Untitled",
       task: data.task || "",
       cron: data.cron || null,
-      enabled: data.cron ? (data.enabled !== false) : false,
+      enabled: (data.cron || data.scheduleRule) ? (data.enabled !== false) : false,
       maxIterations: (data.maxIterations >= 1) ? data.maxIterations : 20,
       createdAt: Date.now(),
       updatedAt: Date.now(),
@@ -320,29 +260,41 @@ function createLoopRegistry(opts) {
       recurrenceEnd: data.recurrenceEnd || null,
       mode: data.mode || "loop",
       prompt: data.prompt || null,
+      ownerId: data.ownerId || null,
+      ownerName: data.ownerName || null,
+      sessionId: data.sessionId || null,
+      createdViaScheduledTasks: data.createdViaScheduledTasks === true,
       skipIfRunning: data.skipIfRunning !== undefined ? data.skipIfRunning : true,
       intervalEnd: data.intervalEnd || null,
+      scheduleRule: data.scheduleRule || null,
+      scheduleStartCount: Number(data.scheduleStartCount || 0),
+      scheduleDateStartCounts: data.scheduleDateStartCounts && typeof data.scheduleDateStartCounts === "object" ? Object.assign({}, data.scheduleDateStartCounts) : {},
+      scheduleIdentity: data.scheduleIdentity || crypto.randomUUID(),
+      scheduleEpoch: Number.isInteger(data.scheduleEpoch) && data.scheduleEpoch > 0 ? data.scheduleEpoch : 1,
+      execution: data.execution || null,
+      activeRun: data.activeRun || null,
       runs: [],
     };
-    if (rec.cron && rec.enabled) {
-      rec.nextRunAt = nextRunTime(rec.cron);
-    } else if (!rec.cron && rec.date && rec.time && rec.source === "schedule") {
-      // One-off schedule: compute nextRunAt from date + time
-      var dtParts = rec.date.split("-");
-      var tmParts = rec.time.split(":");
-      var runDate = new Date(parseInt(dtParts[0], 10), parseInt(dtParts[1], 10) - 1, parseInt(dtParts[2], 10), parseInt(tmParts[0], 10), parseInt(tmParts[1], 10), 0);
-      rec.nextRunAt = runDate.getTime();
+    if (rec.createdViaScheduledTasks && data.maxIterations === undefined) delete rec.maxIterations;
+    if ((rec.cron || rec.scheduleRule) && rec.enabled) {
+      rec.nextRunAt = nextRecordRunTime(rec);
+    } else if (!rec.cron && !rec.scheduleRule && rec.date && rec.time && rec.source === "schedule") {
+      rec.nextRunAt = oneOffRunTime(rec);
       rec.enabled = true;
     }
     records.push(rec);
-    save();
-    if (onChange) onChange(records);
+    if (!save()) {
+      records.pop();
+      return null;
+    }
+    if (!notifyOrRollback(function () { records.pop(); })) return null;
     return rec;
   }
 
   function update(id, data) {
     var rec = getById(id);
     if (!rec) return null;
+    var previous = Object.assign({}, rec);
 
     if (data.name !== undefined) rec.name = data.name;
     if (data.cron !== undefined) rec.cron = data.cron;
@@ -353,39 +305,54 @@ function createLoopRegistry(opts) {
     if (data.recurrenceEnd !== undefined) rec.recurrenceEnd = data.recurrenceEnd;
     if (data.mode !== undefined) rec.mode = data.mode;
     if (data.prompt !== undefined) rec.prompt = data.prompt;
+    if (data.task !== undefined) rec.task = data.task;
+    if (data.ownerId !== undefined) rec.ownerId = data.ownerId;
+    if (data.ownerName !== undefined) rec.ownerName = data.ownerName;
+    if (data.sessionId !== undefined) rec.sessionId = data.sessionId;
     if (data.description !== undefined) rec.description = data.description;
     if (data.color !== undefined) rec.color = data.color;
     if (data.allDay !== undefined) rec.allDay = data.allDay;
     if (data.linkedTaskId !== undefined) rec.linkedTaskId = data.linkedTaskId;
+    if (data.source !== undefined) rec.source = data.source;
     if (data.skipIfRunning !== undefined) rec.skipIfRunning = data.skipIfRunning;
     if (data.intervalEnd !== undefined) rec.intervalEnd = data.intervalEnd;
-    rec.updatedAt = Date.now();
-    if (rec.cron && rec.enabled) {
-      rec.nextRunAt = nextRunTime(rec.cron);
-    } else if (!rec.cron && rec.date && rec.time && rec.source === "schedule") {
-      var dtP2 = rec.date.split("-");
-      var tmP2 = rec.time.split(":");
-      var runD2 = new Date(parseInt(dtP2[0], 10), parseInt(dtP2[1], 10) - 1, parseInt(dtP2[2], 10), parseInt(tmP2[0], 10), parseInt(tmP2[1], 10), 0);
-      rec.nextRunAt = runD2.getTime();
-      rec.enabled = true;
+    if (data.scheduleRule !== undefined) rec.scheduleRule = data.scheduleRule;
+    if (data.execution !== undefined) rec.execution = data.execution;
+    rec.updatedAt = recordRevision.nextRevision(rec);
+    if ((rec.cron || rec.scheduleRule) && rec.enabled) {
+      rec.nextRunAt = nextRecordRunTime(rec);
+    } else if (!rec.cron && !rec.scheduleRule && rec.enabled && rec.date && rec.time && rec.source === "schedule") {
+      rec.nextRunAt = oneOffRunTime(rec);
     } else {
       rec.nextRunAt = null;
     }
-
-    save();
-    if (onChange) onChange(records);
+    var sameTiming = previous.cron === rec.cron && previous.date === rec.date && previous.time === rec.time && JSON.stringify(previous.scheduleRule || null) === JSON.stringify(rec.scheduleRule || null);
+    if (!sameTiming || previous.enabled !== rec.enabled) rec.scheduleEpoch = Math.max(1, Number(previous.scheduleEpoch) || 1) + 1;
+    if (previous.enabled && rec.enabled && previous.nextRunAt && sameTiming) rec.nextRunAt = previous.nextRunAt;
+    if (data.ownerId) { delete rec.needsOwner; delete rec.setupRequired; }
+
+    if (!save()) {
+      recordRevision.restoreRecord(rec, previous);
+      return null;
+    }
+    if (!notifyOrRollback(function () { recordRevision.restoreRecord(rec, previous); })) return null;
     return rec;
   }
 
   function updateRecord(id, data) {
     var rec = getById(id);
     if (!rec) return null;
+    var previous = Object.assign({}, rec);
     var keys = Object.keys(data);
     for (var i = 0; i < keys.length; i++) {
       rec[keys[i]] = data[keys[i]];
     }
-    save();
-    if (onChange) onChange(records);
+    rec.updatedAt = recordRevision.nextRevision(previous);
+    if (!save()) {
+      recordRevision.restoreRecord(rec, previous);
+      return null;
+    }
+    if (!notifyOrRollback(function () { recordRevision.restoreRecord(rec, previous); })) return null;
     return rec;
   }
 
@@ -395,40 +362,33 @@ function createLoopRegistry(opts) {
       if (records[i].id === id) { idx = i; break; }
     }
     if (idx === -1) return false;
-    records.splice(idx, 1);
-    save();
-    if (onChange) onChange(records);
+    var removed = records.splice(idx, 1)[0];
+    if (!save()) { records.splice(idx, 0, removed); return false; }
+    if (!notifyOrRollback(function () { records.splice(idx, 0, removed); })) return false;
     return true;
   }
 
   function toggleEnabled(id) {
     var rec = getById(id);
-    if (!rec || !rec.cron) return null; // only toggle scheduled loops
+    var oneOffSchedule = rec && !rec.cron && !rec.scheduleRule && rec.date && rec.time && rec.source === "schedule";
+    if (!rec || (!rec.cron && !rec.scheduleRule && !oneOffSchedule)) return null;
+    var previous = Object.assign({}, rec);
     rec.enabled = !rec.enabled;
-    rec.updatedAt = Date.now();
-    rec.nextRunAt = rec.enabled ? nextRunTime(rec.cron) : null;
-    save();
-    if (onChange) onChange(records);
-    return rec;
-  }
-
-  function recordRun(id, result) {
-    var rec = getById(id);
-    if (!rec) return;
-    rec.lastRunAt = result.startedAt || Date.now();
-    rec.lastRunResult = result.reason || null;
-    rec.runs.push({
-      startedAt: result.startedAt || rec.lastRunAt,
-      finishedAt: Date.now(),
-      result: result.reason || "unknown",
-      iterations: result.iterations || 0,
-    });
-    // Keep only last 20 run entries
-    if (rec.runs.length > 20) {
-      rec.runs = rec.runs.slice(-20);
+    rec.scheduleEpoch = Math.max(1, Number(rec.scheduleEpoch) || 1) + 1;
+    rec.updatedAt = recordRevision.nextRevision(rec);
+    if (!rec.enabled) {
+      rec.nextRunAt = null;
+    } else if (rec.cron || rec.scheduleRule) {
+      rec.nextRunAt = nextRecordRunTime(rec);
+    } else {
+      rec.nextRunAt = oneOffRunTime(rec);
+    }
+    if (!save()) {
+      recordRevision.restoreRecord(rec, previous);
+      return null;
     }
-    save();
-    if (onChange) onChange(records);
+    if (!notifyOrRollback(function () { recordRevision.restoreRecord(rec, previous); })) return null;
+    return rec;
   }
 
   function getAll() {
@@ -445,25 +405,48 @@ function createLoopRegistry(opts) {
   function getScheduled() {
     var result = [];
     for (var i = 0; i < records.length; i++) {
-      if (records[i].cron) result.push(records[i]);
+      if (records[i].cron || records[i].scheduleRule) result.push(records[i]);
     }
     return result;
   }
 
+  durableOccurrence = attachLoopRegistryOccurrence({
+    getById: getById,
+    save: save,
+    changed: function () { if (onChange) onChange(records); },
+    lastSaveError: function () { return lastSaveError; },
+    prepareTrigger: prepareTrigger,
+    onTrigger: onTrigger,
+    scheduledRuns: scheduledRuns,
+    scheduleRule: scheduleRule,
+    nextRecordRunTime: nextRecordRunTime,
+  });
+
   return {
     load: load,
     save: save,
     startTimer: startTimer,
     stopTimer: stopTimer,
+    tick: tick,
     register: register,
     update: update,
     updateRecord: updateRecord,
     remove: remove,
     toggleEnabled: toggleEnabled,
-    recordRun: recordRun,
+    normalizeDurableOccurrence: durableOccurrence.normalize,
+    markNeedsOwner: durableOccurrence.markNeedsOwner,
+    prepareDurableOccurrence: durableOccurrence.prepare,
+    triggerDurableOccurrence: durableOccurrence.trigger,
+    completeDurableOccurrence: durableOccurrence.complete,
+    reconcileDurableOccurrence: durableOccurrence.reconcile,
+    recordRun: scheduledRuns.recordLegacy,
+    beginRun: scheduledRuns.begin,
+    updateRun: scheduledRuns.update,
+    completeRun: scheduledRuns.complete,
     getAll: getAll,
     getById: getById,
     getScheduled: getScheduled,
+    getLastSaveError: function () { return lastSaveError; },
     nextRunTime: nextRunTime,
   };
 }