@elizaos/plugin-cron 2.0.0-alpha.3

package/dist/index.js

@@ -0,0 +1,2753 @@
+import {
+  DEFAULT_CRON_CONFIG,
+  HEARTBEAT_WORKER_NAME,
+  drainSystemEvents,
+  executeOttoJob,
+  heartbeatWorker,
+  isOttoPayload,
+  isWithinActiveHours,
+  normalizeCronJobCreate,
+  normalizeCronJobPatch,
+  otto_exports,
+  pendingEventCount,
+  pushSystemEvent,
+  readCronRunLogEntries,
+  resolveCronRunLogPath,
+  resolveCronStorePath,
+  resolveHeartbeatConfig,
+  startHeartbeat,
+  wakeHeartbeatNow
+} from "./chunk-QQWDOGXP.js";
+import "./chunk-MLKGABMK.js";
+
+// src/constants.ts
+var CRON_SERVICE_TYPE = "CRON";
+var CRON_JOB_COMPONENT_PREFIX = "cron_job";
+var CRON_JOB_INDEX_COMPONENT = "cron_job_index";
+var CronEvents = {
+  CRON_FIRED: "CRON_FIRED",
+  CRON_CREATED: "CRON_CREATED",
+  CRON_UPDATED: "CRON_UPDATED",
+  CRON_DELETED: "CRON_DELETED",
+  CRON_FAILED: "CRON_FAILED"
+};
+var CronActions = {
+  CREATE_CRON: "CREATE_CRON",
+  UPDATE_CRON: "UPDATE_CRON",
+  DELETE_CRON: "DELETE_CRON",
+  LIST_CRONS: "LIST_CRONS",
+  RUN_CRON: "RUN_CRON"
+};
+
+// src/scheduler/schedule-utils.ts
+import { Cron } from "croner";
+function parseTimestamp(timestamp) {
+  const parsed = Date.parse(timestamp);
+  if (Number.isNaN(parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function validateAtSchedule(at) {
+  const ms = parseTimestamp(at);
+  if (ms === null) {
+    return `Invalid timestamp: "${at}". Expected ISO 8601 format (e.g., "2024-12-31T23:59:59Z")`;
+  }
+  return null;
+}
+function validateEverySchedule(everyMs, config) {
+  if (!Number.isFinite(everyMs) || everyMs <= 0) {
+    return `Invalid interval: ${everyMs}. Must be a positive number`;
+  }
+  const minInterval = config.minIntervalMs ?? DEFAULT_CRON_CONFIG.minIntervalMs;
+  if (everyMs < minInterval) {
+    return `Interval too short: ${everyMs}ms. Minimum allowed is ${minInterval}ms`;
+  }
+  return null;
+}
+function validateCronExpression(expr, tz) {
+  const trimmed = expr.trim();
+  if (!trimmed) {
+    return "Cron expression cannot be empty";
+  }
+  const trimmedTz = tz?.trim() || void 0;
+  if (trimmedTz) {
+    try {
+      Intl.DateTimeFormat("en-US", { timeZone: trimmedTz });
+    } catch {
+      return `Invalid timezone: "${trimmedTz}"`;
+    }
+  }
+  let cron;
+  try {
+    cron = new Cron(trimmed, { timezone: trimmedTz, catch: false });
+  } catch (err) {
+    return `Invalid cron expression: ${err instanceof Error ? err.message : String(err)}`;
+  }
+  const next = cron.nextRun();
+  cron.stop();
+  if (!next) {
+    return `Cron expression "${trimmed}" will never run`;
+  }
+  return null;
+}
+function validateSchedule(schedule, config) {
+  switch (schedule.kind) {
+    case "at":
+      return validateAtSchedule(schedule.at);
+    case "every":
+      return validateEverySchedule(schedule.everyMs, config);
+    case "cron":
+      return validateCronExpression(schedule.expr, schedule.tz);
+    default: {
+      const _exhaustive = schedule;
+      return `Unknown schedule kind: ${_exhaustive.kind}`;
+    }
+  }
+}
+function computeNextRunAtMs(schedule, nowMs) {
+  switch (schedule.kind) {
+    case "at": {
+      const atMs = parseTimestamp(schedule.at);
+      if (atMs === null) {
+        return void 0;
+      }
+      return atMs > nowMs ? atMs : void 0;
+    }
+    case "every": {
+      const everyMs = Math.max(1, Math.floor(schedule.everyMs));
+      const anchor = Math.max(0, Math.floor(schedule.anchorMs ?? nowMs));
+      if (nowMs < anchor) {
+        return anchor;
+      }
+      const elapsed = nowMs - anchor;
+      const steps = Math.max(1, Math.floor((elapsed + everyMs - 1) / everyMs));
+      return anchor + steps * everyMs;
+    }
+    case "cron": {
+      const expr = schedule.expr.trim();
+      if (!expr) {
+        return void 0;
+      }
+      const cron = new Cron(expr, {
+        timezone: schedule.tz?.trim() || void 0,
+        catch: false
+      });
+      const next = cron.nextRun(new Date(nowMs));
+      cron.stop();
+      return next ? next.getTime() : void 0;
+    }
+    default: {
+      const _exhaustive = schedule;
+      return void 0;
+    }
+  }
+}
+function isJobDue(nextRunAtMs, nowMs, toleranceMs = 1e3) {
+  if (nextRunAtMs === void 0) {
+    return false;
+  }
+  return nowMs >= nextRunAtMs - toleranceMs;
+}
+function formatSchedule(schedule) {
+  switch (schedule.kind) {
+    case "at": {
+      const date = new Date(schedule.at);
+      return `once at ${date.toLocaleString()}`;
+    }
+    case "every": {
+      const ms = schedule.everyMs;
+      if (ms >= 864e5) {
+        const days = Math.round(ms / 864e5);
+        return `every ${days} day${days === 1 ? "" : "s"}`;
+      }
+      if (ms >= 36e5) {
+        const hours = Math.round(ms / 36e5);
+        return `every ${hours} hour${hours === 1 ? "" : "s"}`;
+      }
+      if (ms >= 6e4) {
+        const minutes = Math.round(ms / 6e4);
+        return `every ${minutes} minute${minutes === 1 ? "" : "s"}`;
+      }
+      const seconds = Math.round(ms / 1e3);
+      return `every ${seconds} second${seconds === 1 ? "" : "s"}`;
+    }
+    case "cron": {
+      const tz = schedule.tz ? ` (${schedule.tz})` : "";
+      return `cron: ${schedule.expr}${tz}`;
+    }
+    default: {
+      const _exhaustive = schedule;
+      return "unknown schedule";
+    }
+  }
+}
+function parseDuration(duration) {
+  const match = /^(\d+(?:\.\d+)?)\s*(s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|days?)$/i.exec(
+    duration.trim()
+  );
+  if (!match) {
+    return null;
+  }
+  const value = parseFloat(match[1]);
+  if (value <= 0 || !Number.isFinite(value)) {
+    return null;
+  }
+  const unit = match[2].toLowerCase();
+  let ms;
+  if (unit.startsWith("s")) {
+    ms = Math.round(value * 1e3);
+  } else if (unit.startsWith("m")) {
+    ms = Math.round(value * 6e4);
+  } else if (unit.startsWith("h")) {
+    ms = Math.round(value * 36e5);
+  } else if (unit.startsWith("d")) {
+    ms = Math.round(value * 864e5);
+  } else {
+    return null;
+  }
+  return ms > 0 ? ms : null;
+}
+function parseScheduleDescription(description, nowMs = Date.now()) {
+  const normalized = description.trim().toLowerCase();
+  const inMatch = /^in\s+(.+)$/i.exec(normalized);
+  if (inMatch) {
+    const durationMs = parseDuration(inMatch[1]);
+    if (durationMs !== null) {
+      return {
+        kind: "at",
+        at: new Date(nowMs + durationMs).toISOString()
+      };
+    }
+  }
+  const everyMatch = /^every\s+(.+)$/i.exec(normalized);
+  if (everyMatch) {
+    const durationMs = parseDuration(everyMatch[1]);
+    if (durationMs !== null) {
+      return {
+        kind: "every",
+        everyMs: durationMs,
+        anchorMs: nowMs
+      };
+    }
+  }
+  const fields = normalized.split(/\s+/);
+  if (fields.length >= 5 && fields.length <= 6) {
+    const validation = validateCronExpression(normalized);
+    if (validation === null) {
+      return {
+        kind: "cron",
+        expr: normalized
+      };
+    }
+  }
+  const timestamp = parseTimestamp(description);
+  if (timestamp !== null) {
+    return {
+      kind: "at",
+      at: description
+    };
+  }
+  return void 0;
+}
+
+// src/actions/create-cron.ts
+function parseNaturalLanguageRequest(text) {
+  const result = {};
+  const normalized = text.toLowerCase();
+  const everyMatch = /every\s+(\d+\s*(?:second|minute|hour|day|week)s?)/i.exec(text);
+  if (everyMatch) {
+    result.schedule = parseScheduleDescription(`every ${everyMatch[1]}`);
+  }
+  const atMatch = /at\s+(\d{1,2}(?::\d{2})?\s*(?:am|pm)?)/i.exec(text);
+  if (atMatch && !result.schedule) {
+    const timeStr = atMatch[1].toLowerCase();
+    let hours;
+    let minutes = 0;
+    const timeParts = /(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/i.exec(timeStr);
+    if (timeParts) {
+      hours = parseInt(timeParts[1], 10);
+      if (timeParts[2]) {
+        minutes = parseInt(timeParts[2], 10);
+      }
+      if (timeParts[3]) {
+        if (timeParts[3].toLowerCase() === "pm" && hours !== 12) {
+          hours += 12;
+        } else if (timeParts[3].toLowerCase() === "am" && hours === 12) {
+          hours = 0;
+        }
+      }
+      if (normalized.includes("daily") || normalized.includes("every day")) {
+        result.schedule = {
+          kind: "cron",
+          expr: `${minutes} ${hours} * * *`
+        };
+      } else if (normalized.includes("weekday") || normalized.includes("monday to friday")) {
+        result.schedule = {
+          kind: "cron",
+          expr: `${minutes} ${hours} * * 1-5`
+        };
+      } else if (normalized.includes("weekend")) {
+        result.schedule = {
+          kind: "cron",
+          expr: `${minutes} ${hours} * * 0,6`
+        };
+      } else {
+        result.schedule = {
+          kind: "cron",
+          expr: `${minutes} ${hours} * * *`
+        };
+      }
+    }
+  }
+  const inMatch = /in\s+(\d+\s*(?:second|minute|hour|day)s?)/i.exec(text);
+  if (inMatch && !result.schedule) {
+    result.schedule = parseScheduleDescription(`in ${inMatch[1]}`);
+  }
+  const toMatch = /(?:to|that)\s+(.+?)(?:\s+every|\s+at|\s+in\s+\d|$)/i.exec(text);
+  if (toMatch) {
+    result.prompt = toMatch[1].trim();
+    result.name = toMatch[1].slice(0, 50).trim();
+  }
+  const nameMatch = /(?:called|named)\s+["']?([^"']+)["']?/i.exec(text);
+  if (nameMatch) {
+    result.name = nameMatch[1].trim();
+  }
+  if (!result.name && result.schedule) {
+    const scheduleDesc = formatSchedule(result.schedule);
+    result.name = `Cron job (${scheduleDesc})`;
+  }
+  return result;
+}
+function formatJobResponse(job) {
+  const scheduleStr = formatSchedule(job.schedule);
+  const nextRun = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toLocaleString() : "not scheduled";
+  return `Created cron job "${job.name}"
+- ID: ${job.id}
+- Schedule: ${scheduleStr}
+- Status: ${job.enabled ? "enabled" : "disabled"}
+- Next run: ${nextRun}`;
+}
+var createCronAction = {
+  name: CronActions.CREATE_CRON,
+  similes: [
+    "SCHEDULE_CRON",
+    "ADD_CRON",
+    "NEW_CRON",
+    "CREATE_SCHEDULED_JOB",
+    "SET_UP_CRON",
+    "SCHEDULE_JOB",
+    "CREATE_RECURRING_JOB"
+  ],
+  description: "Creates a new cron job that runs on a schedule. Supports interval-based schedules (every X minutes), cron expressions, and one-time schedules.",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasScheduleKeyword = text.includes("cron") || text.includes("schedule") || text.includes("every ") || text.includes("recurring") || text.includes("repeat") || text.includes("daily") || text.includes("hourly") || text.includes("weekly");
+    const hasCreateIntent = text.includes("create") || text.includes("add") || text.includes("set up") || text.includes("schedule") || text.includes("make");
+    return hasScheduleKeyword && hasCreateIntent;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      await callback?.({
+        text: "Cron service is not available. Please ensure the plugin is loaded."
+      });
+      return { success: false, error: "Cron service not available" };
+    }
+    const text = message.content?.text ?? "";
+    if (options?.jobInput && typeof options.jobInput === "object") {
+      const input = options.jobInput;
+      const scheduleError = validateSchedule(input.schedule, DEFAULT_CRON_CONFIG);
+      if (scheduleError) {
+        await callback?.({
+          text: `Invalid schedule: ${scheduleError}`
+        });
+        return { success: false, error: scheduleError };
+      }
+      const job2 = await cronService.createJob(input);
+      await callback?.({
+        text: formatJobResponse(job2)
+      });
+      return { success: true, data: { jobId: job2.id, job: job2 } };
+    }
+    const parsed = parseNaturalLanguageRequest(text);
+    if (!parsed.schedule) {
+      await callback?.({
+        text: `I couldn't understand the schedule. Please specify when the job should run, for example:
+- "every 5 minutes"
+- "every hour"
+- "daily at 9am"
+- "every weekday at 8:30am"`
+      });
+      return { success: false, error: "Could not parse schedule" };
+    }
+    const jobInput = {
+      name: parsed.name || "Unnamed cron job",
+      description: parsed.description,
+      enabled: true,
+      schedule: parsed.schedule,
+      payload: {
+        kind: "prompt",
+        text: parsed.prompt || "Run scheduled task"
+      }
+    };
+    if (parsed.schedule.kind === "at") {
+      jobInput.deleteAfterRun = true;
+    }
+    const job = await cronService.createJob(jobInput);
+    await callback?.({
+      text: formatJobResponse(job)
+    });
+    return {
+      success: true,
+      data: {
+        jobId: job.id,
+        job
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Create a cron job to check the news every hour" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Created cron job "check the news"\n- ID: abc-123\n- Schedule: every 1 hour\n- Status: enabled\n- Next run: in 1 hour'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Schedule a daily reminder at 9am to review my goals" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Created cron job "review my goals"\n- ID: def-456\n- Schedule: cron: 0 9 * * *\n- Status: enabled\n- Next run: tomorrow at 9:00 AM'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Set up a recurring job every 5 minutes to check server status" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Created cron job "check server status"\n- ID: ghi-789\n- Schedule: every 5 minutes\n- Status: enabled\n- Next run: in 5 minutes'
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/delete-cron.ts
+function extractJobIdentifier(text) {
+  const idMatch = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i.exec(text);
+  if (idMatch) {
+    return { id: idMatch[1] };
+  }
+  const quotedMatch = /["']([^"']+)["']/i.exec(text);
+  if (quotedMatch) {
+    return { name: quotedMatch[1] };
+  }
+  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
+  if (namedMatch) {
+    return { name: namedMatch[1] };
+  }
+  return {};
+}
+var deleteCronAction = {
+  name: CronActions.DELETE_CRON,
+  similes: [
+    "REMOVE_CRON",
+    "CANCEL_CRON",
+    "STOP_CRON",
+    "DELETE_SCHEDULED_JOB",
+    "REMOVE_SCHEDULED_JOB"
+  ],
+  description: "Deletes a cron job by ID or name, removing it from the schedule permanently.",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasDeleteKeyword = text.includes("delete") || text.includes("remove") || text.includes("cancel") || text.includes("stop") && !text.includes("stop running");
+    const hasCronKeyword = text.includes("cron") || text.includes("job") || text.includes("schedule");
+    return hasDeleteKeyword && hasCronKeyword;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      await callback?.({
+        text: "Cron service is not available. Please ensure the plugin is loaded."
+      });
+      return { success: false, error: "Cron service not available" };
+    }
+    const text = message.content?.text ?? "";
+    let jobId = options?.jobId;
+    let jobName;
+    if (!jobId) {
+      const identifier = extractJobIdentifier(text);
+      if (identifier.id) {
+        jobId = identifier.id;
+      } else if (identifier.name) {
+        const jobs = await cronService.listJobs({ includeDisabled: true });
+        const job = jobs.find((j) => j.name.toLowerCase() === identifier.name?.toLowerCase());
+        if (!job) {
+          await callback?.({
+            text: `No cron job found with name: ${identifier.name}`
+          });
+          return { success: false, error: "Job not found" };
+        }
+        jobId = job.id;
+        jobName = job.name;
+      }
+    }
+    if (!jobId) {
+      await callback?.({
+        text: 'Please specify which cron job to delete. You can use the job ID or name.\nExample: "delete cron job abc-123" or "remove cron called daily-check"'
+      });
+      return { success: false, error: "No job identifier provided" };
+    }
+    if (!jobName) {
+      const job = await cronService.getJob(jobId);
+      if (job) {
+        jobName = job.name;
+      }
+    }
+    const deleted = await cronService.deleteJob(jobId);
+    if (!deleted) {
+      await callback?.({
+        text: `No cron job found with ID: ${jobId}`
+      });
+      return { success: false, error: "Job not found" };
+    }
+    await callback?.({
+      text: `Deleted cron job "${jobName || "unknown"}" (${jobId}).
+The job has been permanently removed and will no longer run.`
+    });
+    return {
+      success: true,
+      data: {
+        jobId,
+        jobName,
+        deleted: true
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Delete the cron job called daily-check" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Deleted cron job "daily-check" (abc-123).\nThe job has been permanently removed and will no longer run.'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Remove cron abc-123-def-456" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Deleted cron job "hourly-status" (abc-123-def-456).\nThe job has been permanently removed and will no longer run.'
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/list-crons.ts
+function formatJobList(jobs, includeDisabled) {
+  if (jobs.length === 0) {
+    return includeDisabled ? "No cron jobs found." : 'No active cron jobs found. Use "list all crons" to include disabled jobs.';
+  }
+  const lines = [`Found ${jobs.length} cron job${jobs.length === 1 ? "" : "s"}:
+`];
+  for (const job of jobs) {
+    const scheduleStr = formatSchedule(job.schedule);
+    const statusStr = job.enabled ? "enabled" : "disabled";
+    const nextRun = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toLocaleString() : "not scheduled";
+    const lastStatus = job.state.lastStatus ? ` (last: ${job.state.lastStatus})` : "";
+    lines.push(
+      `\u2022 ${job.name}${lastStatus}
+  ID: ${job.id}
+  Schedule: ${scheduleStr}
+  Status: ${statusStr}
+  Next run: ${nextRun}
+  Runs: ${job.state.runCount} | Errors: ${job.state.errorCount}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatJobDetails(job) {
+  const scheduleStr = formatSchedule(job.schedule);
+  const statusStr = job.enabled ? "enabled" : "disabled";
+  const nextRun = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toLocaleString() : "not scheduled";
+  const lastRun = job.state.lastRunAtMs ? new Date(job.state.lastRunAtMs).toLocaleString() : "never";
+  let details = `Cron Job: ${job.name}
+
+`;
+  details += `ID: ${job.id}
+`;
+  if (job.description) {
+    details += `Description: ${job.description}
+`;
+  }
+  details += `
+Schedule: ${scheduleStr}
+`;
+  details += `Status: ${statusStr}
+`;
+  if (job.deleteAfterRun) {
+    details += `Type: one-shot (will be deleted after successful run)
+`;
+  }
+  details += `
+Execution Stats:
+`;
+  details += `  Next run: ${nextRun}
+`;
+  details += `  Last run: ${lastRun}
+`;
+  details += `  Total runs: ${job.state.runCount}
+`;
+  details += `  Total errors: ${job.state.errorCount}
+`;
+  if (job.state.lastStatus) {
+    details += `  Last status: ${job.state.lastStatus}
+`;
+  }
+  if (job.state.lastError) {
+    details += `  Last error: ${job.state.lastError}
+`;
+  }
+  if (job.state.lastDurationMs !== void 0) {
+    details += `  Last duration: ${job.state.lastDurationMs}ms
+`;
+  }
+  details += `
+Payload Type: ${job.payload.kind}
+`;
+  if (job.payload.kind === "prompt") {
+    details += `Prompt: ${job.payload.text.slice(0, 200)}${job.payload.text.length > 200 ? "..." : ""}
+`;
+  } else if (job.payload.kind === "action") {
+    details += `Action: ${job.payload.actionName}
+`;
+  } else if (job.payload.kind === "event") {
+    details += `Event: ${job.payload.eventName}
+`;
+  }
+  if (job.tags && job.tags.length > 0) {
+    details += `
+Tags: ${job.tags.join(", ")}
+`;
+  }
+  details += `
+Created: ${new Date(job.createdAtMs).toLocaleString()}
+`;
+  details += `Updated: ${new Date(job.updatedAtMs).toLocaleString()}
+`;
+  return details;
+}
+var listCronsAction = {
+  name: CronActions.LIST_CRONS,
+  similes: [
+    "SHOW_CRONS",
+    "GET_CRONS",
+    "VIEW_CRONS",
+    "LIST_SCHEDULED_JOBS",
+    "SHOW_SCHEDULED_JOBS",
+    "MY_CRONS",
+    "CRON_STATUS"
+  ],
+  description: "Lists all cron jobs. Can filter by enabled status or show details of a specific job.",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasListKeyword = text.includes("list") || text.includes("show") || text.includes("view") || text.includes("get") || text.includes("what");
+    const hasCronKeyword = text.includes("cron") || text.includes("scheduled") || text.includes("job") || text.includes("schedule");
+    return hasListKeyword && hasCronKeyword;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      await callback?.({
+        text: "Cron service is not available. Please ensure the plugin is loaded."
+      });
+      return { success: false, error: "Cron service not available" };
+    }
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const idMatch = /(?:job|cron)\s+([a-f0-9-]{36})/i.exec(text);
+    if (idMatch) {
+      const jobId = idMatch[1];
+      const job = await cronService.getJob(jobId);
+      if (!job) {
+        await callback?.({
+          text: `No cron job found with ID: ${jobId}`
+        });
+        return { success: false, error: "Job not found" };
+      }
+      await callback?.({
+        text: formatJobDetails(job)
+      });
+      return { success: true, data: { job } };
+    }
+    const nameMatch = /(?:called|named)\s+["']?([^"']+)["']?/i.exec(text);
+    if (nameMatch) {
+      const jobName = nameMatch[1].toLowerCase();
+      const jobs2 = await cronService.listJobs({ includeDisabled: true });
+      const job = jobs2.find((j) => j.name.toLowerCase().includes(jobName));
+      if (!job) {
+        await callback?.({
+          text: `No cron job found with name containing: ${jobName}`
+        });
+        return { success: false, error: "Job not found" };
+      }
+      await callback?.({
+        text: formatJobDetails(job)
+      });
+      return { success: true, data: { job } };
+    }
+    const filter = {};
+    if (text.includes("all")) {
+      filter.includeDisabled = true;
+    }
+    if (text.includes("enabled") || text.includes("active")) {
+      filter.enabled = true;
+      filter.includeDisabled = false;
+    }
+    if (text.includes("disabled") || text.includes("inactive")) {
+      filter.enabled = false;
+      filter.includeDisabled = true;
+    }
+    if (options?.filter && typeof options.filter === "object") {
+      Object.assign(filter, options.filter);
+    }
+    const jobs = await cronService.listJobs(filter);
+    await callback?.({
+      text: formatJobList(jobs, filter.includeDisabled ?? false)
+    });
+    return {
+      success: true,
+      data: {
+        jobs,
+        count: jobs.length
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "List my cron jobs" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Found 2 cron jobs:\n\n\u2022 Daily news check\n  ID: abc-123\n  Schedule: cron: 0 9 * * *\n  Status: enabled\n  Next run: tomorrow at 9:00 AM\n  Runs: 5 | Errors: 0\n\n\u2022 Hourly status check\n  ID: def-456\n  Schedule: every 1 hour\n  Status: enabled\n  Next run: in 45 minutes\n  Runs: 120 | Errors: 2"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Show all crons including disabled" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Found 3 cron jobs:\n\n\u2022 Daily news check\n  ID: abc-123\n  Schedule: cron: 0 9 * * *\n  Status: enabled\n  ...\n\n\u2022 Old backup job\n  ID: xyz-789\n  Schedule: every 1 day\n  Status: disabled\n  ..."
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/run-cron.ts
+function extractJobIdentifier2(text) {
+  const idMatch = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i.exec(text);
+  if (idMatch) {
+    return { id: idMatch[1] };
+  }
+  const quotedMatch = /["']([^"']+)["']/i.exec(text);
+  if (quotedMatch) {
+    return { name: quotedMatch[1] };
+  }
+  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
+  if (namedMatch) {
+    return { name: namedMatch[1] };
+  }
+  return {};
+}
+var runCronAction = {
+  name: CronActions.RUN_CRON,
+  similes: [
+    "EXECUTE_CRON",
+    "TRIGGER_CRON",
+    "FIRE_CRON",
+    "RUN_SCHEDULED_JOB",
+    "EXECUTE_JOB",
+    "TRIGGER_JOB"
+  ],
+  description: "Manually runs a cron job immediately, regardless of its schedule. Useful for testing or one-off execution.",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasRunKeyword = text.includes("run") || text.includes("execute") || text.includes("trigger") || text.includes("fire");
+    const hasCronKeyword = text.includes("cron") || text.includes("job") || text.includes("schedule");
+    const isCreateIntent = text.includes("run every") || text.includes("runs every");
+    return hasRunKeyword && hasCronKeyword && !isCreateIntent;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      await callback?.({
+        text: "Cron service is not available. Please ensure the plugin is loaded."
+      });
+      return { success: false, error: "Cron service not available" };
+    }
+    const text = message.content?.text ?? "";
+    let jobId = options?.jobId;
+    let jobName;
+    if (!jobId) {
+      const identifier = extractJobIdentifier2(text);
+      if (identifier.id) {
+        jobId = identifier.id;
+      } else if (identifier.name) {
+        const jobs = await cronService.listJobs({ includeDisabled: true });
+        const job = jobs.find((j) => j.name.toLowerCase() === identifier.name?.toLowerCase());
+        if (!job) {
+          await callback?.({
+            text: `No cron job found with name: ${identifier.name}`
+          });
+          return { success: false, error: "Job not found" };
+        }
+        jobId = job.id;
+        jobName = job.name;
+      }
+    }
+    if (!jobId) {
+      await callback?.({
+        text: 'Please specify which cron job to run. You can use the job ID or name.\nExample: "run cron job abc-123" or "execute cron called daily-check"'
+      });
+      return { success: false, error: "No job identifier provided" };
+    }
+    if (!jobName) {
+      const job = await cronService.getJob(jobId);
+      if (job) {
+        jobName = job.name;
+      }
+    }
+    const result = await cronService.runJob(jobId, "force");
+    if (!result.ran) {
+      await callback?.({
+        text: `Could not run job: ${result.error}`
+      });
+      return { success: false, error: result.error };
+    }
+    let responseText = `Ran cron job "${jobName || "unknown"}" (${jobId})
+`;
+    responseText += `Status: ${result.status}
+`;
+    responseText += `Duration: ${result.durationMs}ms
+`;
+    if (result.status === "ok" && result.output) {
+      const outputPreview = result.output.length > 500 ? `${result.output.slice(0, 500)}... (truncated)` : result.output;
+      responseText += `
+Output:
+${outputPreview}`;
+    }
+    if (result.error) {
+      responseText += `
+Error: ${result.error}`;
+    }
+    await callback?.({
+      text: responseText
+    });
+    return {
+      success: result.status === "ok",
+      data: {
+        jobId,
+        jobName,
+        result
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Run the cron job called daily-check now" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Ran cron job "daily-check" (abc-123)\nStatus: ok\nDuration: 1250ms\n\nOutput:\nDaily check completed successfully. All systems operational.'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Execute cron abc-123-def-456" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Ran cron job "status-checker" (abc-123-def-456)\nStatus: ok\nDuration: 850ms'
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/update-cron.ts
+function extractJobIdentifier3(text) {
+  const idMatch = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i.exec(text);
+  if (idMatch) {
+    return { id: idMatch[1] };
+  }
+  const quotedMatch = /["']([^"']+)["']/i.exec(text);
+  if (quotedMatch) {
+    return { name: quotedMatch[1] };
+  }
+  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
+  if (namedMatch) {
+    return { name: namedMatch[1] };
+  }
+  return {};
+}
+function parseUpdateIntent(text) {
+  const patch = {};
+  const normalized = text.toLowerCase();
+  if (normalized.includes("enable") && !normalized.includes("disable")) {
+    patch.enabled = true;
+  } else if (normalized.includes("disable")) {
+    patch.enabled = false;
+  }
+  const everyMatch = /every\s+(\d+\s*(?:second|minute|hour|day|week)s?)/i.exec(text);
+  if (everyMatch) {
+    const schedule = parseScheduleDescription(`every ${everyMatch[1]}`);
+    if (schedule) {
+      patch.schedule = schedule;
+    }
+  }
+  const renameMatch = /rename\s+(?:to|as)\s+["']?([^"']+)["']?/i.exec(text);
+  if (renameMatch) {
+    patch.name = renameMatch[1].trim();
+  }
+  return patch;
+}
+var updateCronAction = {
+  name: CronActions.UPDATE_CRON,
+  similes: [
+    "MODIFY_CRON",
+    "EDIT_CRON",
+    "CHANGE_CRON",
+    "ENABLE_CRON",
+    "DISABLE_CRON",
+    "PAUSE_CRON",
+    "RESUME_CRON"
+  ],
+  description: "Updates an existing cron job. Can enable/disable jobs, change schedules, or modify other properties.",
+  validate: async (_runtime, message) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasUpdateKeyword = text.includes("update") || text.includes("modify") || text.includes("edit") || text.includes("change") || text.includes("enable") || text.includes("disable") || text.includes("pause") || text.includes("resume");
+    const hasCronKeyword = text.includes("cron") || text.includes("job") || text.includes("schedule");
+    return hasUpdateKeyword && hasCronKeyword;
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      await callback?.({
+        text: "Cron service is not available. Please ensure the plugin is loaded."
+      });
+      return { success: false, error: "Cron service not available" };
+    }
+    const text = message.content?.text ?? "";
+    let jobId = options?.jobId;
+    let patch = options?.patch || {};
+    if (!jobId) {
+      const identifier = extractJobIdentifier3(text);
+      if (identifier.id) {
+        jobId = identifier.id;
+      } else if (identifier.name) {
+        const jobs = await cronService.listJobs({ includeDisabled: true });
+        const job = jobs.find((j) => j.name.toLowerCase() === identifier.name?.toLowerCase());
+        if (!job) {
+          await callback?.({
+            text: `No cron job found with name: ${identifier.name}`
+          });
+          return { success: false, error: "Job not found" };
+        }
+        jobId = job.id;
+      }
+    }
+    if (!jobId) {
+      await callback?.({
+        text: 'Please specify which cron job to update. You can use the job ID or name.\nExample: "disable cron job abc-123" or "enable cron called daily-check"'
+      });
+      return { success: false, error: "No job identifier provided" };
+    }
+    if (Object.keys(patch).length === 0) {
+      patch = parseUpdateIntent(text);
+    }
+    if (Object.keys(patch).length === 0) {
+      await callback?.({
+        text: 'Please specify what to update. Examples:\n- "enable cron job abc-123"\n- "disable cron called daily-check"\n- "change cron abc-123 to run every 2 hours"'
+      });
+      return { success: false, error: "No updates specified" };
+    }
+    const updatedJob = await cronService.updateJob(jobId, patch);
+    const changes = [];
+    if (patch.enabled !== void 0) {
+      changes.push(`status: ${patch.enabled ? "enabled" : "disabled"}`);
+    }
+    if (patch.schedule) {
+      changes.push(`schedule: ${formatSchedule(patch.schedule)}`);
+    }
+    if (patch.name) {
+      changes.push(`name: ${patch.name}`);
+    }
+    const nextRun = updatedJob.state.nextRunAtMs ? new Date(updatedJob.state.nextRunAtMs).toLocaleString() : "not scheduled";
+    await callback?.({
+      text: `Updated cron job "${updatedJob.name}" (${updatedJob.id})
+Changes: ${changes.join(", ")}
+Next run: ${nextRun}`
+    });
+    return {
+      success: true,
+      data: {
+        jobId: updatedJob.id,
+        job: updatedJob,
+        changes
+      }
+    };
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Disable the cron job called daily-check" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Updated cron job "daily-check" (abc-123)\nChanges: status: disabled\nNext run: not scheduled'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: { text: "Enable cron abc-123-def-456" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Updated cron job "status checker" (abc-123-def-456)\nChanges: status: enabled\nNext run: in 5 minutes'
+        }
+      }
+    ]
+  ]
+};
+
+// src/providers/cron-context.ts
+function formatJobForContext(job) {
+  const scheduleStr = formatSchedule(job.schedule);
+  const nextRun = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : "not scheduled";
+  let line = `- ${job.name} (${scheduleStr})`;
+  if (!job.enabled) {
+    line += " [disabled]";
+  } else {
+    line += ` - next: ${nextRun}`;
+  }
+  if (job.state.lastStatus === "error") {
+    line += " [last run failed]";
+  }
+  return line;
+}
+var cronContextProvider = {
+  name: "cronContext",
+  description: "Provides information about scheduled cron jobs",
+  dynamic: true,
+  position: 50,
+  // Middle priority
+  get: async (runtime, _message, _state) => {
+    const cronService = runtime.getService(CRON_SERVICE_TYPE);
+    if (!cronService) {
+      return {
+        text: "",
+        values: {
+          hasCronService: false,
+          cronJobCount: 0
+        },
+        data: {
+          available: false
+        }
+      };
+    }
+    const jobs = await cronService.listJobs({ includeDisabled: true });
+    const enabledJobs = jobs.filter((j) => j.enabled);
+    const disabledJobs = jobs.filter((j) => !j.enabled);
+    const nowMs = Date.now();
+    const oneHourFromNow = nowMs + 36e5;
+    const upcomingJobs = enabledJobs.filter(
+      (j) => j.state.nextRunAtMs && j.state.nextRunAtMs <= oneHourFromNow
+    );
+    const recentJobs = jobs.filter(
+      (j) => j.state.lastRunAtMs && j.state.lastRunAtMs >= nowMs - 36e5
+    );
+    const failedJobs = jobs.filter((j) => j.state.lastStatus === "error");
+    const lines = [];
+    if (jobs.length === 0) {
+      lines.push("No cron jobs are scheduled.");
+    } else {
+      lines.push(`Scheduled Jobs (${enabledJobs.length} active, ${disabledJobs.length} disabled):`);
+      if (upcomingJobs.length > 0) {
+        lines.push("\nUpcoming (next hour):");
+        for (const job of upcomingJobs.slice(0, 5)) {
+          lines.push(formatJobForContext(job));
+        }
+        if (upcomingJobs.length > 5) {
+          lines.push(`  ... and ${upcomingJobs.length - 5} more`);
+        }
+      }
+      if (failedJobs.length > 0) {
+        lines.push("\nRecently failed:");
+        for (const job of failedJobs.slice(0, 3)) {
+          lines.push(`- ${job.name}: ${job.state.lastError || "unknown error"}`);
+        }
+      }
+      if (enabledJobs.length <= 10 && enabledJobs.length > 0) {
+        lines.push("\nAll active jobs:");
+        for (const job of enabledJobs) {
+          lines.push(formatJobForContext(job));
+        }
+      } else if (enabledJobs.length > 10) {
+        lines.push(`
+${enabledJobs.length} active jobs total. Use "list crons" to see all.`);
+      }
+    }
+    return {
+      text: lines.join("\n"),
+      values: {
+        hasCronService: true,
+        cronJobCount: jobs.length,
+        enabledJobCount: enabledJobs.length,
+        disabledJobCount: disabledJobs.length,
+        upcomingJobCount: upcomingJobs.length,
+        failedJobCount: failedJobs.length
+      },
+      data: {
+        available: true,
+        jobs: jobs.map((j) => ({
+          id: j.id,
+          name: j.name,
+          enabled: j.enabled,
+          schedule: j.schedule,
+          nextRunAtMs: j.state.nextRunAtMs,
+          lastStatus: j.state.lastStatus
+        })),
+        upcoming: upcomingJobs.map((j) => j.id),
+        failed: failedJobs.map((j) => j.id),
+        recent: recentJobs.map((j) => j.id)
+      }
+    };
+  }
+};
+
+// src/routes/index.ts
+function getCronService(runtime) {
+  const svc = runtime.getService(CRON_SERVICE_TYPE);
+  if (!svc) {
+    throw new Error("CronService not available");
+  }
+  return svc;
+}
+async function handleCronStatus(_req, res, runtime) {
+  const svc = getCronService(runtime);
+  const status = await svc.getStatus();
+  res.json({
+    enabled: status.initialized,
+    jobs: status.jobCount,
+    tracked: status.trackedJobCount,
+    config: status.config
+  });
+}
+async function handleCronList(req, res, runtime) {
+  const includeDisabled = req.body?.includeDisabled === true;
+  const svc = getCronService(runtime);
+  const jobs = await svc.listJobs({ includeDisabled });
+  res.json({ jobs });
+}
+async function handleCronAdd(req, res, runtime) {
+  const body = req.body ?? {};
+  const normalized = normalizeCronJobCreate(body);
+  if (!normalized) {
+    res.status(400).json({ error: "Invalid job input" });
+    return;
+  }
+  const svc = getCronService(runtime);
+  const job = await svc.createJob(normalized);
+  res.json({ job });
+}
+async function handleCronUpdate(req, res, runtime) {
+  const body = req.body ?? {};
+  const jobId = typeof body.jobId === "string" ? body.jobId : typeof body.id === "string" ? body.id : "";
+  if (!jobId) {
+    res.status(400).json({ error: "Missing jobId" });
+    return;
+  }
+  const patch = normalizeCronJobPatch(body.patch ?? body);
+  if (!patch) {
+    res.status(400).json({ error: "Invalid patch" });
+    return;
+  }
+  const svc = getCronService(runtime);
+  const job = await svc.updateJob(jobId, patch);
+  res.json({ job });
+}
+async function handleCronRemove(req, res, runtime) {
+  const body = req.body ?? {};
+  const jobId = typeof body.jobId === "string" ? body.jobId : typeof body.id === "string" ? body.id : "";
+  if (!jobId) {
+    res.status(400).json({ error: "Missing jobId" });
+    return;
+  }
+  const svc = getCronService(runtime);
+  const deleted = await svc.deleteJob(jobId);
+  res.json({ deleted });
+}
+async function handleCronRun(req, res, runtime) {
+  const body = req.body ?? {};
+  const jobId = typeof body.jobId === "string" ? body.jobId : typeof body.id === "string" ? body.id : "";
+  if (!jobId) {
+    res.status(400).json({ error: "Missing jobId" });
+    return;
+  }
+  const mode = body.mode === "due" ? "due" : "force";
+  const svc = getCronService(runtime);
+  const result = await svc.runJob(jobId, mode);
+  res.json(result);
+}
+async function handleCronRuns(req, res, _runtime) {
+  const body = req.body ?? {};
+  const jobId = typeof body.id === "string" ? body.id : "";
+  const limit = typeof body.limit === "number" ? body.limit : 50;
+  if (!jobId) {
+    res.status(400).json({ error: "Missing id" });
+    return;
+  }
+  const storePath = resolveCronStorePath();
+  if (!storePath) {
+    res.json({ entries: [] });
+    return;
+  }
+  const logPath = resolveCronRunLogPath({ storePath, jobId });
+  const entries = await readCronRunLogEntries(logPath, { limit, jobId });
+  res.json({ entries });
+}
+var cronRoutes = [
+  { type: "POST", path: "/api/cron/status", handler: handleCronStatus },
+  { type: "POST", path: "/api/cron/list", handler: handleCronList },
+  { type: "POST", path: "/api/cron/add", handler: handleCronAdd },
+  { type: "POST", path: "/api/cron/update", handler: handleCronUpdate },
+  { type: "POST", path: "/api/cron/remove", handler: handleCronRemove },
+  { type: "POST", path: "/api/cron/run", handler: handleCronRun },
+  { type: "POST", path: "/api/cron/runs", handler: handleCronRuns }
+];
+
+// src/services/cron-service.ts
+import { logger, Service } from "@elizaos/core";
+import { v4 as uuidv43 } from "uuid";
+
+// src/executor/job-executor.ts
+import { v4 as uuidv4 } from "uuid";
+function createTimeoutController(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort(new Error("Job execution timeout"));
+  }, timeoutMs);
+  return {
+    controller,
+    cleanup: () => clearTimeout(timer)
+  };
+}
+async function withEnforcedTimeout(operation, timeoutMs, signal) {
+  if (signal.aborted) {
+    throw new Error("Job execution timeout");
+  }
+  const timeoutPromise = new Promise((_, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error("Job execution timeout"));
+    }, timeoutMs);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timeoutId);
+      reject(new Error("Job execution timeout"));
+    });
+  });
+  return Promise.race([operation(), timeoutPromise]);
+}
+async function executePromptPayload(runtime, payload, context) {
+  const cronContext = `[Cron Job: ${context.job.name}]${context.job.description ? ` - ${context.job.description}` : ""}`;
+  const fullPrompt = `${cronContext}
+
+${payload.text}`;
+  const result = await runtime.useModel("TEXT_LARGE", {
+    prompt: fullPrompt
+  });
+  return result;
+}
+async function executeActionPayload(runtime, payload, context) {
+  const actions = runtime.actions ?? [];
+  const action = actions.find((a) => a.name.toLowerCase() === payload.actionName.toLowerCase());
+  if (!action) {
+    throw new Error(`Action not found: ${payload.actionName}`);
+  }
+  const roomId = payload.roomId || runtime.agentId;
+  const memory = {
+    id: uuidv4(),
+    entityId: runtime.agentId,
+    roomId,
+    agentId: runtime.agentId,
+    content: {
+      text: `[Cron Job: ${context.job.name}] Executing action: ${payload.actionName}`,
+      // Spread params into content for actions to access
+      ...payload.params
+    },
+    createdAt: Date.now()
+  };
+  const callbackResponses = [];
+  const callback = async (response) => {
+    if (response.text) {
+      callbackResponses.push(response.text);
+    }
+    return [];
+  };
+  const isValid = await action.validate(runtime, memory, void 0);
+  if (!isValid) {
+    throw new Error(`Action validation failed: ${payload.actionName}`);
+  }
+  const handlerResult = await action.handler(runtime, memory, void 0, void 0, callback);
+  const outputParts = [];
+  if (callbackResponses.length > 0) {
+    outputParts.push(...callbackResponses);
+  }
+  if (handlerResult !== void 0 && handlerResult !== null) {
+    if (typeof handlerResult === "string") {
+      outputParts.push(handlerResult);
+    } else if (typeof handlerResult === "object") {
+      const result = handlerResult;
+      if (result.text && typeof result.text === "string") {
+        outputParts.push(result.text);
+      } else if (result.success !== void 0 || result.data !== void 0) {
+        outputParts.push(JSON.stringify(handlerResult));
+      }
+    }
+  }
+  return outputParts.join("\n") || `Action ${payload.actionName} completed`;
+}
+async function executeEventPayload(runtime, payload, context) {
+  const eventPayload = {
+    runtime,
+    source: `cron:${context.job.id}`,
+    cronJob: {
+      id: context.job.id,
+      name: context.job.name
+    },
+    ...payload.payload || {}
+  };
+  await runtime.emitEvent(payload.eventName, eventPayload);
+  return `Event ${payload.eventName} emitted`;
+}
+async function executeJob(runtime, job, config) {
+  const payloadRecord = job.payload;
+  if (isOttoPayload(payloadRecord)) {
+    return executeOttoJob(runtime, job, config);
+  }
+  const startedAtMs = Date.now();
+  let timeoutMs = config.defaultTimeoutMs ?? DEFAULT_CRON_CONFIG.defaultTimeoutMs;
+  if (job.payload.kind === "prompt" && job.payload.timeoutSeconds) {
+    timeoutMs = job.payload.timeoutSeconds * 1e3;
+  }
+  const { controller, cleanup } = createTimeoutController(timeoutMs);
+  const context = {
+    job,
+    startedAtMs,
+    signal: controller.signal
+  };
+  let status = "ok";
+  let output;
+  let error;
+  try {
+    if (controller.signal.aborted) {
+      throw new Error("Job execution timeout");
+    }
+    const executeOperation = async () => {
+      switch (job.payload.kind) {
+        case "prompt":
+          return executePromptPayload(runtime, job.payload, context);
+        case "action":
+          return executeActionPayload(runtime, job.payload, context);
+        case "event":
+          return executeEventPayload(runtime, job.payload, context);
+        default: {
+          const _exhaustive = job.payload;
+          throw new Error(`Unknown payload kind: ${job.payload.kind}`);
+        }
+      }
+    };
+    output = await withEnforcedTimeout(executeOperation, timeoutMs, controller.signal);
+  } catch (err) {
+    if (err instanceof Error) {
+      if (err.message === "Job execution timeout" || controller.signal.aborted) {
+        status = "timeout";
+        error = "Execution timed out";
+      } else {
+        status = "error";
+        error = err.message;
+      }
+    } else {
+      status = "error";
+      error = String(err);
+    }
+  } finally {
+    cleanup();
+  }
+  const durationMs = Date.now() - startedAtMs;
+  return {
+    status,
+    durationMs,
+    output,
+    error
+  };
+}
+function validateJobExecutability(runtime, job) {
+  const { payload } = job;
+  const payloadRecord = payload;
+  if (isOttoPayload(payloadRecord)) {
+    if (payloadRecord.kind === "systemEvent") {
+      const text = typeof payloadRecord.text === "string" ? payloadRecord.text.trim() : "";
+      return text ? null : "systemEvent payload must have non-empty text";
+    }
+    if (payloadRecord.kind === "agentTurn") {
+      const message = typeof payloadRecord.message === "string" ? payloadRecord.message.trim() : "";
+      return message ? null : "agentTurn payload must have non-empty message";
+    }
+    return null;
+  }
+  switch (payload.kind) {
+    case "prompt": {
+      const text = payload.text?.trim();
+      if (!text) {
+        return "Prompt payload must have non-empty text";
+      }
+      if (typeof runtime.useModel !== "function") {
+        return "Runtime does not support useModel for prompt execution";
+      }
+      return null;
+    }
+    case "event": {
+      const eventName = payload.eventName?.trim();
+      if (!eventName) {
+        return "Event payload must have non-empty eventName";
+      }
+      if (typeof runtime.emitEvent !== "function") {
+        return "Runtime does not support emitEvent for event execution";
+      }
+      return null;
+    }
+    case "action": {
+      const actionName = payload.actionName?.trim();
+      if (!actionName) {
+        return "Action payload must have non-empty actionName";
+      }
+      const actions = runtime.actions ?? [];
+      const action = actions.find((a) => a.name.toLowerCase() === actionName.toLowerCase());
+      return action ? null : `Action not found: ${payload.actionName}`;
+    }
+    default: {
+      return `Unknown payload kind: ${payload.kind}`;
+    }
+  }
+}
+
+// src/scheduler/timer-manager.ts
+import { Cron as Cron2 } from "croner";
+var TimerManager = class {
+  config;
+  onJobDue;
+  trackedJobs = /* @__PURE__ */ new Map();
+  checkInterval = null;
+  running = false;
+  constructor(config, onJobDue) {
+    this.config = config;
+    this.onJobDue = onJobDue;
+  }
+  /**
+   * Starts the timer manager
+   */
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.startCheckInterval();
+  }
+  /**
+   * Stops the timer manager and cleans up all timers
+   */
+  stop() {
+    this.running = false;
+    this.stopCheckInterval();
+    this.clearAllJobs();
+  }
+  /**
+   * Adds or updates a job in the timer manager
+   * @param job The job to track
+   */
+  trackJob(job) {
+    this.untrackJob(job.id);
+    if (!job.enabled) {
+      return;
+    }
+    const tracked = {
+      job,
+      executing: false
+    };
+    if (job.schedule.kind === "cron") {
+      const cronInstance = new Cron2(job.schedule.expr, {
+        timezone: job.schedule.tz?.trim() || void 0,
+        catch: true,
+        paused: true
+        // We manage firing manually via the check interval
+      });
+      tracked.cronInstance = cronInstance;
+    }
+    tracked.nextRunAtMs = job.state.nextRunAtMs ?? computeNextRunAtMs(job.schedule, Date.now());
+    this.trackedJobs.set(job.id, tracked);
+  }
+  /**
+   * Removes a job from tracking
+   * @param jobId The job ID to remove
+   */
+  untrackJob(jobId) {
+    const tracked = this.trackedJobs.get(jobId);
+    if (tracked) {
+      if (tracked.cronInstance) {
+        tracked.cronInstance.stop();
+      }
+      this.trackedJobs.delete(jobId);
+    }
+  }
+  /**
+   * Marks a job as currently executing (to prevent overlapping executions)
+   * @param jobId The job ID
+   */
+  markExecuting(jobId) {
+    const tracked = this.trackedJobs.get(jobId);
+    if (tracked) {
+      tracked.executing = true;
+    }
+  }
+  /**
+   * Marks a job as finished executing and recalculates next run
+   * @param jobId The job ID
+   * @param updatedJob The job with updated state (optional)
+   */
+  markFinished(jobId, updatedJob) {
+    const tracked = this.trackedJobs.get(jobId);
+    if (tracked) {
+      tracked.executing = false;
+      if (updatedJob) {
+        tracked.job = updatedJob;
+        tracked.nextRunAtMs = computeNextRunAtMs(updatedJob.schedule, Date.now());
+      }
+    }
+  }
+  /**
+   * Gets the next scheduled run time for a job
+   * @param jobId The job ID
+   * @returns Next run time in ms, or undefined
+   */
+  getNextRunAtMs(jobId) {
+    return this.trackedJobs.get(jobId)?.nextRunAtMs;
+  }
+  /**
+   * Gets all tracked job IDs
+   */
+  getTrackedJobIds() {
+    return Array.from(this.trackedJobs.keys());
+  }
+  /**
+   * Gets the count of tracked jobs
+   */
+  getTrackedJobCount() {
+    return this.trackedJobs.size;
+  }
+  /**
+   * Checks if a specific job is currently executing
+   */
+  isJobExecuting(jobId) {
+    return this.trackedJobs.get(jobId)?.executing ?? false;
+  }
+  /**
+   * Forces an immediate check for due jobs
+   */
+  checkNow() {
+    if (this.running) {
+      this.performCheck();
+    }
+  }
+  /**
+   * Starts the periodic check interval
+   */
+  startCheckInterval() {
+    if (this.checkInterval) {
+      return;
+    }
+    const intervalMs = this.config.timerCheckIntervalMs ?? DEFAULT_CRON_CONFIG.timerCheckIntervalMs;
+    this.checkInterval = setInterval(() => {
+      this.performCheck();
+    }, intervalMs);
+    if (this.checkInterval.unref) {
+      this.checkInterval.unref();
+    }
+  }
+  /**
+   * Stops the periodic check interval
+   */
+  stopCheckInterval() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+  /**
+   * Performs a check for all due jobs
+   */
+  performCheck() {
+    const nowMs = Date.now();
+    const dueJobs = [];
+    for (const [jobId, tracked] of this.trackedJobs) {
+      if (tracked.executing) {
+        continue;
+      }
+      if (!tracked.job.enabled) {
+        continue;
+      }
+      if (isJobDue(tracked.nextRunAtMs, nowMs)) {
+        dueJobs.push(jobId);
+      }
+    }
+    for (const jobId of dueJobs) {
+      const tracked = this.trackedJobs.get(jobId);
+      if (tracked && !tracked.executing) {
+        tracked.executing = true;
+        this.onJobDue(jobId).catch((error) => {
+          console.error(`[CronTimerManager] Error executing job ${jobId}:`, error);
+        });
+      }
+    }
+  }
+  /**
+   * Clears all tracked jobs
+   */
+  clearAllJobs() {
+    for (const [, tracked] of this.trackedJobs) {
+      if (tracked.cronInstance) {
+        tracked.cronInstance.stop();
+      }
+    }
+    this.trackedJobs.clear();
+  }
+};
+
+// src/storage/cron-storage.ts
+import { v4 as uuidv42 } from "uuid";
+var AsyncMutex = class {
+  queue = [];
+  locked = false;
+  async acquire() {
+    return new Promise((resolve) => {
+      const tryAcquire = () => {
+        if (!this.locked) {
+          this.locked = true;
+          resolve(() => this.release());
+        } else {
+          this.queue.push(tryAcquire);
+        }
+      };
+      tryAcquire();
+    });
+  }
+  release() {
+    this.locked = false;
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    }
+  }
+};
+var indexMutexes = /* @__PURE__ */ new Map();
+function getIndexMutex(agentId) {
+  let mutex = indexMutexes.get(agentId);
+  if (!mutex) {
+    mutex = new AsyncMutex();
+    indexMutexes.set(agentId, mutex);
+  }
+  return mutex;
+}
+function getJobComponentType(jobId) {
+  return `${CRON_JOB_COMPONENT_PREFIX}:${jobId}`;
+}
+async function getJobIndex(runtime) {
+  const component = await runtime.getComponent(runtime.agentId, CRON_JOB_INDEX_COMPONENT);
+  if (!component) {
+    return { jobIds: [] };
+  }
+  return component.data;
+}
+async function saveJobIndex(runtime, index) {
+  const existing = await runtime.getComponent(runtime.agentId, CRON_JOB_INDEX_COMPONENT);
+  const component = {
+    id: existing?.id || uuidv42(),
+    entityId: runtime.agentId,
+    agentId: runtime.agentId,
+    roomId: runtime.agentId,
+    // Use agentId as room for agent-scoped data
+    worldId: existing?.worldId || uuidv42(),
+    sourceEntityId: runtime.agentId,
+    type: CRON_JOB_INDEX_COMPONENT,
+    createdAt: existing?.createdAt || Date.now(),
+    data: index
+  };
+  if (existing) {
+    await runtime.updateComponent(component);
+  } else {
+    await runtime.createComponent(component);
+  }
+}
+async function addToIndex(runtime, jobId) {
+  const mutex = getIndexMutex(runtime.agentId);
+  const release = await mutex.acquire();
+  try {
+    const index = await getJobIndex(runtime);
+    if (!index.jobIds.includes(jobId)) {
+      index.jobIds.push(jobId);
+      await saveJobIndex(runtime, index);
+    }
+  } finally {
+    release();
+  }
+}
+async function removeFromIndex(runtime, jobId) {
+  const mutex = getIndexMutex(runtime.agentId);
+  const release = await mutex.acquire();
+  try {
+    const index = await getJobIndex(runtime);
+    const filtered = index.jobIds.filter((id) => id !== jobId);
+    if (filtered.length !== index.jobIds.length) {
+      index.jobIds = filtered;
+      await saveJobIndex(runtime, index);
+    }
+  } finally {
+    release();
+  }
+}
+function validateJobData(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const obj = data;
+  if (typeof obj.id !== "string" || !obj.id) {
+    return null;
+  }
+  if (typeof obj.name !== "string" || !obj.name) {
+    return null;
+  }
+  if (typeof obj.createdAtMs !== "number") {
+    return null;
+  }
+  if (typeof obj.updatedAtMs !== "number") {
+    return null;
+  }
+  if (!obj.schedule || typeof obj.schedule !== "object") {
+    return null;
+  }
+  const schedule = obj.schedule;
+  const validScheduleKinds = ["at", "every", "cron"];
+  if (!validScheduleKinds.includes(schedule.kind)) {
+    return null;
+  }
+  if (!obj.payload || typeof obj.payload !== "object") {
+    return null;
+  }
+  const payload = obj.payload;
+  const validPayloadKinds = ["prompt", "action", "event"];
+  if (!validPayloadKinds.includes(payload.kind)) {
+    return null;
+  }
+  if (!obj.state || typeof obj.state !== "object") {
+    return null;
+  }
+  const state = obj.state;
+  if (typeof state.runCount !== "number" || typeof state.errorCount !== "number") {
+    return null;
+  }
+  const job = {
+    ...data,
+    enabled: typeof obj.enabled === "boolean" ? obj.enabled : true,
+    deleteAfterRun: typeof obj.deleteAfterRun === "boolean" ? obj.deleteAfterRun : false
+  };
+  return job;
+}
+function matchesFilter(job, filter) {
+  if (!filter) return true;
+  if (filter.enabled !== void 0) {
+    if (job.enabled !== filter.enabled) return false;
+  } else if (!filter.includeDisabled && !job.enabled) {
+    return false;
+  }
+  if (filter.tags?.length) {
+    if (!job.tags?.some((tag) => filter.tags?.includes(tag))) return false;
+  }
+  return true;
+}
+function getCronStorage(runtime) {
+  return {
+    async getJob(jobId) {
+      const componentType = getJobComponentType(jobId);
+      const component = await runtime.getComponent(runtime.agentId, componentType);
+      if (!component) {
+        return null;
+      }
+      const validatedJob = validateJobData(component.data);
+      if (!validatedJob) {
+        console.warn(`[cron-storage] Invalid job data for ${jobId}, skipping`);
+        return null;
+      }
+      return validatedJob;
+    },
+    async saveJob(job) {
+      const componentType = getJobComponentType(job.id);
+      const existing = await runtime.getComponent(runtime.agentId, componentType);
+      const component = {
+        id: existing?.id || uuidv42(),
+        entityId: runtime.agentId,
+        agentId: runtime.agentId,
+        roomId: runtime.agentId,
+        worldId: existing?.worldId || uuidv42(),
+        sourceEntityId: runtime.agentId,
+        type: componentType,
+        createdAt: existing?.createdAt || job.createdAtMs,
+        data: job
+      };
+      if (existing) {
+        await runtime.updateComponent(component);
+      } else {
+        await runtime.createComponent(component);
+        await addToIndex(runtime, job.id);
+      }
+    },
+    async deleteJob(jobId) {
+      const componentType = getJobComponentType(jobId);
+      const existing = await runtime.getComponent(runtime.agentId, componentType);
+      if (!existing) {
+        return false;
+      }
+      await runtime.deleteComponent(existing.id);
+      await removeFromIndex(runtime, jobId);
+      return true;
+    },
+    async listJobs(filter) {
+      const index = await getJobIndex(runtime);
+      const jobs = [];
+      for (const jobId of index.jobIds) {
+        const job = await this.getJob(jobId);
+        if (job && matchesFilter(job, filter)) {
+          jobs.push(job);
+        }
+      }
+      jobs.sort((a, b) => {
+        const aNext = a.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER;
+        const bNext = b.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER;
+        return aNext - bNext;
+      });
+      return jobs;
+    },
+    async getJobCount() {
+      const index = await getJobIndex(runtime);
+      return index.jobIds.length;
+    },
+    async hasJob(jobId) {
+      const index = await getJobIndex(runtime);
+      return index.jobIds.includes(jobId);
+    }
+  };
+}
+
+// src/services/cron-service.ts
+var CronService = class _CronService extends Service {
+  static serviceType = CRON_SERVICE_TYPE;
+  capabilityDescription = "Schedules and executes recurring or one-time cron jobs";
+  cronConfig;
+  storage;
+  timerManager;
+  initialized = false;
+  constructor(runtime, config) {
+    super(runtime);
+    this.cronConfig = { ...DEFAULT_CRON_CONFIG, ...config };
+  }
+  /**
+   * Starts the cron service
+   */
+  static async start(runtime) {
+    const service = new _CronService(runtime);
+    await service.initialize();
+    return service;
+  }
+  /**
+   * Initializes the service, loading existing jobs and starting timers
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    this.storage = getCronStorage(this.runtime);
+    this.timerManager = new TimerManager(this.cronConfig, async (jobId) => {
+      await this.handleJobDue(jobId);
+    });
+    const jobs = await this.storage.listJobs({ includeDisabled: true });
+    for (const job of jobs) {
+      const nowMs = Date.now();
+      const nextRunAtMs = computeNextRunAtMs(job.schedule, nowMs);
+      if (job.state.nextRunAtMs !== nextRunAtMs) {
+        job.state.nextRunAtMs = nextRunAtMs;
+        await this.storage.saveJob(job);
+      }
+      if (job.enabled) {
+        this.timerManager.trackJob(job);
+      }
+    }
+    if (this.cronConfig.catchUpMissedJobs) {
+      await this.handleMissedJobs(jobs);
+    }
+    this.timerManager.start();
+    await startHeartbeat(this.runtime);
+    this.initialized = true;
+    logger.info(`[CronService] Started for agent ${this.runtime.agentId} with ${jobs.length} jobs`);
+  }
+  /**
+   * Stops the cron service
+   */
+  async stop() {
+    if (this.timerManager) {
+      this.timerManager.stop();
+    }
+    this.initialized = false;
+    logger.info(`[CronService] Stopped for agent ${this.runtime.agentId}`);
+  }
+  /**
+   * Gets the service configuration
+   */
+  getConfig() {
+    return { ...this.cronConfig };
+  }
+  // ============================================================================
+  // CRUD OPERATIONS
+  // ============================================================================
+  /**
+   * Creates a new cron job
+   * @param input Job creation input
+   * @returns The created job
+   * @throws Error if validation fails or max jobs exceeded
+   */
+  async createJob(input) {
+    const scheduleError = validateSchedule(input.schedule, this.cronConfig);
+    if (scheduleError) {
+      throw new Error(`Invalid schedule: ${scheduleError}`);
+    }
+    const currentCount = await this.storage.getJobCount();
+    if (currentCount >= this.cronConfig.maxJobsPerAgent) {
+      throw new Error(
+        `Maximum jobs limit reached (${this.cronConfig.maxJobsPerAgent}). Delete some jobs before creating new ones.`
+      );
+    }
+    const nowMs = Date.now();
+    const job = {
+      id: uuidv43(),
+      name: input.name,
+      description: input.description,
+      // Explicitly default to true if not provided - jobs are enabled by default
+      enabled: input.enabled ?? true,
+      // Explicitly default to false - jobs persist after run by default
+      deleteAfterRun: input.deleteAfterRun ?? false,
+      createdAtMs: nowMs,
+      updatedAtMs: nowMs,
+      schedule: input.schedule,
+      payload: input.payload,
+      tags: input.tags,
+      metadata: input.metadata,
+      state: {
+        nextRunAtMs: computeNextRunAtMs(input.schedule, nowMs),
+        runCount: input.state?.runCount ?? 0,
+        errorCount: input.state?.errorCount ?? 0,
+        ...input.state
+      }
+    };
+    const execError = validateJobExecutability(this.runtime, job);
+    if (execError) {
+      throw new Error(`Job cannot be executed: ${execError}`);
+    }
+    await this.storage.saveJob(job);
+    if (job.enabled) {
+      this.timerManager.trackJob(job);
+    }
+    await this.emitCronEvent(CronEvents.CRON_CREATED, job);
+    logger.info(
+      `[CronService] Created job "${job.name}" (${job.id}) - ${formatSchedule(job.schedule)}`
+    );
+    return job;
+  }
+  /**
+   * Updates an existing cron job
+   * @param jobId The job ID to update
+   * @param patch The fields to update
+   * @returns The updated job
+   * @throws Error if job not found or validation fails
+   */
+  async updateJob(jobId, patch) {
+    const existing = await this.storage.getJob(jobId);
+    if (!existing) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    if (patch.schedule) {
+      const scheduleError = validateSchedule(patch.schedule, this.cronConfig);
+      if (scheduleError) {
+        throw new Error(`Invalid schedule: ${scheduleError}`);
+      }
+    }
+    const nowMs = Date.now();
+    const updated = {
+      ...existing,
+      ...patch,
+      id: existing.id,
+      // Ensure ID is immutable
+      createdAtMs: existing.createdAtMs,
+      // Ensure createdAt is immutable
+      updatedAtMs: nowMs,
+      state: {
+        ...existing.state,
+        ...patch.state
+      }
+    };
+    if (patch.schedule || patch.enabled === true && !existing.enabled) {
+      updated.state.nextRunAtMs = computeNextRunAtMs(updated.schedule, nowMs);
+    }
+    if (patch.enabled === false) {
+      updated.state.nextRunAtMs = void 0;
+      updated.state.runningAtMs = void 0;
+    }
+    if (patch.payload) {
+      const execError = validateJobExecutability(this.runtime, updated);
+      if (execError) {
+        throw new Error(`Job cannot be executed: ${execError}`);
+      }
+    }
+    await this.storage.saveJob(updated);
+    if (updated.enabled) {
+      this.timerManager.trackJob(updated);
+    } else {
+      this.timerManager.untrackJob(jobId);
+    }
+    await this.emitCronEvent(CronEvents.CRON_UPDATED, updated);
+    logger.info(`[CronService] Updated job "${updated.name}" (${updated.id})`);
+    return updated;
+  }
+  /**
+   * Deletes a cron job
+   * @param jobId The job ID to delete
+   * @returns true if deleted, false if not found
+   */
+  async deleteJob(jobId) {
+    const existing = await this.storage.getJob(jobId);
+    if (!existing) {
+      return false;
+    }
+    this.timerManager.untrackJob(jobId);
+    const deleted = await this.storage.deleteJob(jobId);
+    if (deleted) {
+      await this.emitCronEvent(CronEvents.CRON_DELETED, existing);
+      logger.info(`[CronService] Deleted job "${existing.name}" (${existing.id})`);
+    }
+    return deleted;
+  }
+  /**
+   * Gets a job by ID
+   * @param jobId The job ID
+   * @returns The job or null if not found
+   */
+  async getJob(jobId) {
+    return this.storage.getJob(jobId);
+  }
+  /**
+   * Lists all jobs, optionally filtered
+   * @param filter Optional filter criteria
+   * @returns Array of matching jobs
+   */
+  async listJobs(filter) {
+    return this.storage.listJobs(filter);
+  }
+  /**
+   * Gets the count of jobs
+   */
+  async getJobCount() {
+    return this.storage.getJobCount();
+  }
+  // ============================================================================
+  // EXECUTION
+  // ============================================================================
+  /**
+   * Manually runs a job immediately
+   * @param jobId The job ID to run
+   * @param mode 'force' to run even if disabled, 'due' to only run if due
+   * @returns Execution result
+   */
+  async runJob(jobId, mode = "force") {
+    const job = await this.storage.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    if (mode === "due") {
+      const nowMs = Date.now();
+      const nextRunAtMs = job.state.nextRunAtMs;
+      if (!nextRunAtMs || nowMs < nextRunAtMs) {
+        return {
+          ran: false,
+          status: "skipped",
+          durationMs: 0,
+          error: "Job is not due yet"
+        };
+      }
+    }
+    if (!job.enabled && mode !== "force") {
+      return {
+        ran: false,
+        status: "skipped",
+        durationMs: 0,
+        error: "Job is disabled"
+      };
+    }
+    const result = await this.executeJobInternal(job);
+    return {
+      ran: true,
+      ...result
+    };
+  }
+  // ============================================================================
+  // INTERNAL METHODS
+  // ============================================================================
+  /**
+   * Handles a job becoming due (called by timer manager)
+   */
+  async handleJobDue(jobId) {
+    const job = await this.storage.getJob(jobId);
+    if (!job) {
+      this.timerManager.untrackJob(jobId);
+      return;
+    }
+    if (!job.enabled) {
+      this.timerManager.untrackJob(jobId);
+      return;
+    }
+    await this.executeJobInternal(job);
+  }
+  /**
+   * Internal job execution with state management
+   */
+  async executeJobInternal(job) {
+    const nowMs = Date.now();
+    job.state.runningAtMs = nowMs;
+    await this.storage.saveJob(job);
+    logger.debug(`[CronService] Executing job "${job.name}" (${job.id})`);
+    const result = await executeJob(this.runtime, job, this.cronConfig);
+    job.state.runningAtMs = void 0;
+    job.state.lastRunAtMs = nowMs;
+    job.state.lastStatus = result.status;
+    job.state.lastDurationMs = result.durationMs;
+    if (result.status === "ok") {
+      job.state.runCount += 1;
+      job.state.lastError = void 0;
+    } else {
+      job.state.errorCount += 1;
+      job.state.lastError = result.error;
+    }
+    const nextNowMs = Date.now();
+    job.state.nextRunAtMs = computeNextRunAtMs(job.schedule, nextNowMs);
+    job.updatedAtMs = nextNowMs;
+    if (job.deleteAfterRun && result.status === "ok") {
+      await this.storage.deleteJob(job.id);
+      this.timerManager.untrackJob(job.id);
+      logger.info(
+        `[CronService] Deleted one-shot job "${job.name}" (${job.id}) after successful execution`
+      );
+    } else {
+      await this.storage.saveJob(job);
+      this.timerManager.markFinished(job.id, job);
+    }
+    const eventName = result.status === "ok" ? CronEvents.CRON_FIRED : CronEvents.CRON_FAILED;
+    await this.emitCronEvent(eventName, job, result);
+    logger.info(
+      `[CronService] Job "${job.name}" (${job.id}) completed with status: ${result.status}` + (result.error ? ` - ${result.error}` : "")
+    );
+    return result;
+  }
+  /**
+   * Handles catch-up for jobs that may have been missed while the service was stopped
+   */
+  async handleMissedJobs(jobs) {
+    const nowMs = Date.now();
+    const windowStart = nowMs - this.cronConfig.catchUpWindowMs;
+    for (const job of jobs) {
+      if (!job.enabled) {
+        continue;
+      }
+      const lastRunAtMs = job.state.lastRunAtMs ?? 0;
+      const nextRunAtMs = job.state.nextRunAtMs;
+      if (nextRunAtMs && nextRunAtMs >= windowStart && nextRunAtMs < nowMs && lastRunAtMs < nextRunAtMs) {
+        logger.info(
+          `[CronService] Catching up missed job "${job.name}" (${job.id}) that was due at ${new Date(nextRunAtMs).toISOString()}`
+        );
+        await this.executeJobInternal(job);
+      }
+    }
+  }
+  /**
+   * Emits a cron event
+   */
+  async emitCronEvent(eventName, job, result) {
+    const eventData = {
+      jobId: job.id,
+      jobName: job.name,
+      schedule: job.schedule
+    };
+    if (result) {
+      eventData.result = {
+        status: result.status,
+        durationMs: result.durationMs,
+        output: result.output,
+        error: result.error
+      };
+    }
+    await this.runtime.emitEvent(eventName, {
+      runtime: this.runtime,
+      source: `cron:${job.id}`,
+      ...eventData
+    });
+  }
+  // ============================================================================
+  // STATUS AND DIAGNOSTICS
+  // ============================================================================
+  /**
+   * Gets the service status
+   */
+  async getStatus() {
+    return {
+      initialized: this.initialized,
+      jobCount: await this.storage.getJobCount(),
+      trackedJobCount: this.timerManager?.getTrackedJobCount() ?? 0,
+      config: this.cronConfig
+    };
+  }
+  /**
+   * Performs a health check
+   */
+  async healthCheck() {
+    const issues = [];
+    if (!this.initialized) {
+      issues.push("Service not initialized");
+    }
+    if (!this.storage) {
+      issues.push("Storage not available");
+    }
+    if (!this.timerManager) {
+      issues.push("Timer manager not available");
+    }
+    return {
+      healthy: issues.length === 0,
+      issues
+    };
+  }
+};
+
+// src/cli/index.ts
+import { defineCliCommand, registerCliCommand } from "@elizaos/plugin-cli";
+
+// src/cli/register.ts
+var defaultLogger = {
+  info: (msg) => console.log(msg),
+  warn: (msg) => console.warn(msg),
+  error: (msg) => console.error(msg),
+  debug: (msg) => {
+    if (process.env.DEBUG) console.debug(msg);
+  }
+};
+function getLogger(ctx) {
+  return ctx.logger ?? defaultLogger;
+}
+function getCronService2(ctx) {
+  const logger2 = getLogger(ctx);
+  const runtime = ctx.getRuntime?.();
+  if (!runtime) {
+    logger2.error("No runtime available");
+    return null;
+  }
+  const service = runtime.getService(CRON_SERVICE_TYPE);
+  if (!service) {
+    logger2.error("CronService not available. Is the cron plugin enabled?");
+    return null;
+  }
+  return service;
+}
+function registerCronCli(ctx) {
+  const logger2 = getLogger(ctx);
+  const cron = ctx.program.command("cron").description("Manage cron jobs");
+  cron.command("status").description("Show cron scheduler status").option("--json", "Output JSON", false).action(async (opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const status = await service.getStatus();
+      if (opts.json) {
+        logger2.info(JSON.stringify(status, null, 2));
+      } else {
+        logger2.info(`Cron Service Status:`);
+        logger2.info(`  Initialized: ${status.initialized}`);
+        logger2.info(`  Jobs: ${status.jobCount}`);
+        logger2.info(`  Tracked: ${status.trackedJobCount}`);
+      }
+    } catch (err) {
+      logger2.error(`Failed to get status: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("list").description("List cron jobs").option("--all", "Include disabled jobs", false).option("--json", "Output JSON", false).action(async (opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const jobs = await service.listJobs({
+        includeDisabled: opts.all
+      });
+      if (opts.json) {
+        logger2.info(JSON.stringify({ jobs }, null, 2));
+      } else {
+        printCronList(jobs, logger2.info);
+      }
+    } catch (err) {
+      logger2.error(`Failed to list jobs: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("add").alias("create").description("Add a cron job").requiredOption("--name <name>", "Job name").option("--description <text>", "Optional description").option("--disabled", "Create job disabled", false).option("--delete-after-run", "Delete one-shot job after it succeeds", false).option("--at <when>", "Run once at time (ISO) or +duration (e.g. 20m)").option("--every <duration>", "Run every duration (e.g. 10m, 1h)").option("--cron <expr>", "Cron expression (5-field)").option("--tz <iana>", "Timezone for cron expressions (IANA)").option("--prompt <text>", "Prompt to execute").option("--action <name>", "Action to execute").option("--event <name>", "Event to emit").option("--session <target>", "Session target: main or isolated").option("--system-event <text>", "System event text (main session)").option("--message <text>", "Agent message (isolated session)").option("--wake <mode>", "Wake mode: now or next-heartbeat", "next-heartbeat").option("--announce", "Enable announce delivery for isolated jobs", false).option("--channel <name>", "Delivery channel (e.g. whatsapp, telegram, discord, last)").option("--to <target>", "Delivery target (e.g. phone number, channel ID)").option("--agent <id>", "Agent ID to bind this job to").option("--json", "Output JSON", false).action(async (opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    const isOttoStyle = Boolean(opts.session || opts.systemEvent || opts.message);
+    const schedule = parseScheduleOpts(opts);
+    if (!schedule) {
+      logger2.error("Choose exactly one schedule: --at, --every, or --cron");
+      process.exitCode = 1;
+      return;
+    }
+    if (isOttoStyle) {
+      const ottoInput = buildOttoJobInput(opts, schedule, logger2);
+      if (!ottoInput) {
+        process.exitCode = 1;
+        return;
+      }
+      const job = await service.createJob(ottoInput);
+      if (opts.json) {
+        logger2.info(JSON.stringify(job, null, 2));
+      } else {
+        logger2.info(`Created job: ${job.id}`);
+        logger2.info(`  Name: ${ottoInput.name}`);
+        logger2.info(
+          `  Session: ${ottoInput.sessionTarget ?? "n/a"}`
+        );
+        logger2.info(
+          `  Wake: ${ottoInput.wakeMode ?? "next-heartbeat"}`
+        );
+        logger2.info(
+          `  Next run: ${job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : "N/A"}`
+        );
+      }
+    } else {
+      const payload = parsePayloadOpts(opts);
+      if (!payload) {
+        logger2.error(
+          "Choose exactly one payload: --prompt, --action, --event, --system-event, or --message"
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const input = {
+        name: opts.name,
+        description: opts.description,
+        enabled: !opts.disabled,
+        deleteAfterRun: opts.deleteAfterRun || void 0,
+        schedule,
+        payload
+      };
+      const job = await service.createJob(input);
+      if (opts.json) {
+        logger2.info(JSON.stringify(job, null, 2));
+      } else {
+        logger2.info(`Created job: ${job.id}`);
+        logger2.info(`  Name: ${job.name}`);
+        logger2.info(`  Enabled: ${job.enabled}`);
+        logger2.info(
+          `  Next run: ${job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : "N/A"}`
+        );
+      }
+    }
+  });
+  cron.command("edit").description("Edit a cron job").argument("<id>", "Job ID").option("--name <name>", "Set name").option("--description <text>", "Set description").option("--enable", "Enable job").option("--disable", "Disable job").option("--at <when>", "Set one-shot time").option("--every <duration>", "Set interval").option("--cron <expr>", "Set cron expression").option("--tz <iana>", "Set timezone").option("--json", "Output JSON", false).action(async (id, opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const patch = {};
+      if (opts.name) patch.name = opts.name;
+      if (opts.description) patch.description = opts.description;
+      if (opts.enable) patch.enabled = true;
+      if (opts.disable) patch.enabled = false;
+      const schedule = parseScheduleOpts(opts);
+      if (schedule) {
+        patch.schedule = schedule;
+      }
+      const job = await service.updateJob(id, patch);
+      if (opts.json) {
+        logger2.info(JSON.stringify(job, null, 2));
+      } else {
+        logger2.info(`Updated job: ${job.id}`);
+      }
+    } catch (err) {
+      logger2.error(`Failed to update job: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("rm").alias("remove").alias("delete").description("Remove a cron job").argument("<id>", "Job ID").option("--json", "Output JSON", false).action(async (id, opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const deleted = await service.deleteJob(id);
+      if (opts.json) {
+        logger2.info(JSON.stringify({ deleted }, null, 2));
+      } else {
+        logger2.info(deleted ? `Deleted job: ${id}` : `Job not found: ${id}`);
+      }
+    } catch (err) {
+      logger2.error(`Failed to delete job: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("enable").description("Enable a cron job").argument("<id>", "Job ID").action(async (id) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await service.updateJob(id, { enabled: true });
+      logger2.info(`Enabled job: ${id}`);
+    } catch (err) {
+      logger2.error(`Failed to enable job: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("disable").description("Disable a cron job").argument("<id>", "Job ID").action(async (id) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      await service.updateJob(id, { enabled: false });
+      logger2.info(`Disabled job: ${id}`);
+    } catch (err) {
+      logger2.error(`Failed to disable job: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+  cron.command("run").description("Run a cron job now").argument("<id>", "Job ID").option("--force", "Run even if not due", false).action(async (id, opts) => {
+    const service = getCronService2(ctx);
+    if (!service) {
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      const result = await service.runJob(id, opts.force ? "force" : "due");
+      logger2.info(JSON.stringify(result, null, 2));
+    } catch (err) {
+      logger2.error(`Failed to run job: ${err}`);
+      process.exitCode = 1;
+    }
+  });
+}
+function parseScheduleOpts(opts) {
+  const at = typeof opts.at === "string" ? opts.at : "";
+  const every = typeof opts.every === "string" ? opts.every : "";
+  const cronExpr = typeof opts.cron === "string" ? opts.cron : "";
+  const chosen = [Boolean(at), Boolean(every), Boolean(cronExpr)].filter(Boolean).length;
+  if (chosen === 0) return null;
+  if (chosen > 1) return null;
+  if (at) {
+    const atIso = parseAt(at);
+    if (!atIso) return null;
+    return { kind: "at", at: atIso };
+  }
+  if (every) {
+    const everyMs = parseDurationMs(every);
+    if (!everyMs) return null;
+    return { kind: "every", everyMs };
+  }
+  if (cronExpr) {
+    const tz = typeof opts.tz === "string" && opts.tz.trim() ? opts.tz.trim() : void 0;
+    return { kind: "cron", expr: cronExpr, tz };
+  }
+  return null;
+}
+function parsePayloadOpts(opts) {
+  const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
+  const action = typeof opts.action === "string" ? opts.action : "";
+  const event = typeof opts.event === "string" ? opts.event : "";
+  const chosen = [Boolean(prompt), Boolean(action), Boolean(event)].filter(Boolean).length;
+  if (chosen === 0) return null;
+  if (chosen > 1) return null;
+  if (prompt) {
+    return { kind: "prompt", text: prompt };
+  }
+  if (action) {
+    return { kind: "action", actionName: action };
+  }
+  if (event) {
+    return { kind: "event", eventName: event };
+  }
+  return null;
+}
+function buildOttoJobInput(opts, schedule, cliLogger) {
+  const systemEvent = typeof opts.systemEvent === "string" ? opts.systemEvent.trim() : "";
+  const message = typeof opts.message === "string" ? opts.message.trim() : "";
+  let sessionTarget;
+  if (typeof opts.session === "string") {
+    sessionTarget = opts.session.trim().toLowerCase();
+  } else if (systemEvent) {
+    sessionTarget = "main";
+  } else if (message) {
+    sessionTarget = "isolated";
+  } else {
+    cliLogger.error("Provide --system-event (main) or --message (isolated)");
+    return null;
+  }
+  if (sessionTarget !== "main" && sessionTarget !== "isolated") {
+    cliLogger.error('--session must be "main" or "isolated"');
+    return null;
+  }
+  let payload;
+  if (sessionTarget === "main") {
+    if (!systemEvent) {
+      cliLogger.error("Main session jobs require --system-event <text>");
+      return null;
+    }
+    payload = { kind: "systemEvent", text: systemEvent };
+  } else {
+    if (!message) {
+      cliLogger.error("Isolated session jobs require --message <text>");
+      return null;
+    }
+    payload = { kind: "agentTurn", message };
+  }
+  let delivery;
+  if (sessionTarget === "isolated" && (opts.announce || opts.channel || opts.to)) {
+    delivery = {
+      mode: opts.announce ? "announce" : "none",
+      channel: typeof opts.channel === "string" ? opts.channel.trim() : "last",
+      to: typeof opts.to === "string" ? opts.to.trim() : void 0
+    };
+  }
+  const wakeMode = typeof opts.wake === "string" && opts.wake.trim() === "now" ? "now" : "next-heartbeat";
+  return {
+    name: typeof opts.name === "string" ? opts.name : "",
+    description: typeof opts.description === "string" ? opts.description : void 0,
+    enabled: !opts.disabled,
+    deleteAfterRun: Boolean(opts.deleteAfterRun) || (schedule.kind === "at" ? true : void 0),
+    schedule,
+    sessionTarget,
+    wakeMode,
+    payload,
+    delivery,
+    agentId: typeof opts.agent === "string" && opts.agent.trim() ? opts.agent.trim() : void 0
+  };
+}
+
+// src/cli/index.ts
+registerCliCommand(
+  defineCliCommand("cron", "Cron job scheduling commands", (ctx) => registerCronCli(ctx), {
+    priority: 50
+  })
+);
+function parseDurationMs(input) {
+  const raw = input.trim();
+  if (!raw) return null;
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i);
+  if (!match) return null;
+  const n = Number.parseFloat(match[1] ?? "");
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = (match[2] ?? "").toLowerCase();
+  const factor = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return Math.floor(n * factor);
+}
+function parseAt(input) {
+  const raw = input.trim();
+  if (!raw) return null;
+  const date = new Date(raw);
+  if (!Number.isNaN(date.getTime())) {
+    return date.toISOString();
+  }
+  const dur = parseDurationMs(raw);
+  if (dur !== null) {
+    return new Date(Date.now() + dur).toISOString();
+  }
+  return null;
+}
+function printCronList(jobs, log) {
+  if (jobs.length === 0) {
+    log("No cron jobs.");
+    return;
+  }
+  log(
+    "ID                                   | Name                     | Status   | Schedule                         | Next Run"
+  );
+  log(
+    "-------------------------------------|--------------------------|----------|----------------------------------|--------------------"
+  );
+  for (const job of jobs) {
+    const id = job.id.padEnd(36);
+    const name = (job.name || "(unnamed)").slice(0, 24).padEnd(24);
+    const status = (job.enabled ? "enabled" : "disabled").padEnd(8);
+    const schedule = formatSchedule(job.schedule).slice(0, 32).padEnd(32);
+    const next = job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString().slice(0, 19) : "N/A";
+    log(`${id} | ${name} | ${status} | ${schedule} | ${next}`);
+  }
+}
+
+// src/index.ts
+var CronPluginEvents = {
+  /** Request an immediate heartbeat tick. Payload: { text?: string } */
+  HEARTBEAT_WAKE: "HEARTBEAT_WAKE",
+  /** Enqueue a system event for the next heartbeat. Payload: { text: string } */
+  HEARTBEAT_SYSTEM_EVENT: "HEARTBEAT_SYSTEM_EVENT"
+};
+var cronPlugin = {
+  name: "cron",
+  description: "Cron job scheduling for recurring and one-time task automation",
+  // Register the cron service
+  services: [CronService],
+  // Actions for cron operations
+  actions: [createCronAction, updateCronAction, deleteCronAction, listCronsAction, runCronAction],
+  // Provider for cron context
+  providers: [cronContextProvider],
+  // HTTP routes for UI
+  routes: cronRoutes,
+  // Event handlers for cross-plugin coordination
+  events: {
+    [CronPluginEvents.HEARTBEAT_WAKE]: [
+      async (payload) => {
+        const runtime = payload.runtime;
+        if (!runtime) {
+          return;
+        }
+        const text = typeof payload.text === "string" ? payload.text : void 0;
+        if (text) {
+          pushSystemEvent(
+            runtime.agentId,
+            text,
+            typeof payload.source === "string" ? payload.source : "external"
+          );
+        }
+        await wakeHeartbeatNow(runtime);
+      }
+    ],
+    [CronPluginEvents.HEARTBEAT_SYSTEM_EVENT]: [
+      async (payload) => {
+        const runtime = payload.runtime;
+        if (!runtime) {
+          return;
+        }
+        const text = typeof payload.text === "string" ? payload.text : "";
+        if (text) {
+          pushSystemEvent(
+            runtime.agentId,
+            text,
+            typeof payload.source === "string" ? payload.source : "external"
+          );
+        }
+      }
+    ]
+  }
+};
+var index_default = cronPlugin;
+export {
+  CRON_JOB_COMPONENT_PREFIX,
+  CRON_JOB_INDEX_COMPONENT,
+  CRON_SERVICE_TYPE,
+  CronActions,
+  CronEvents,
+  CronPluginEvents,
+  CronService,
+  DEFAULT_CRON_CONFIG,
+  HEARTBEAT_WORKER_NAME,
+  TimerManager,
+  computeNextRunAtMs,
+  cronPlugin,
+  index_default as default,
+  drainSystemEvents,
+  executeJob,
+  formatSchedule,
+  getCronStorage,
+  heartbeatWorker,
+  isWithinActiveHours,
+  otto_exports as otto,
+  parseDuration,
+  parseScheduleDescription,
+  pendingEventCount,
+  pushSystemEvent,
+  resolveHeartbeatConfig,
+  startHeartbeat,
+  validateJobExecutability,
+  validateSchedule,
+  wakeHeartbeatNow
+};