@elizaos/plugin-cron 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/index.js

@@ -17,13 +17,9 @@ import {
   resolveHeartbeatConfig,
   startHeartbeat,
   wakeHeartbeatNow
-} from "./chunk-IZYSN6UN.js";
+} from "./chunk-ZY3PG5VX.js";
 import "./chunk-MLKGABMK.js";
 
-// src/services/cron-service.ts
-import { Service, logger } from "@elizaos/core";
-import { v4 as uuidv43 } from "uuid";
-
 // src/constants.ts
 var CRON_SERVICE_TYPE = "CRON";
 var CRON_JOB_COMPONENT_PREFIX = "cron_job";
@@ -43,233 +39,6 @@ var CronActions = {
   RUN_CRON: "RUN_CRON"
 };
 
-// src/storage/cron-storage.ts
-import { v4 as uuidv4 } 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 || uuidv4(),
-    entityId: runtime.agentId,
-    agentId: runtime.agentId,
-    roomId: runtime.agentId,
-    // Use agentId as room for agent-scoped data
-    worldId: existing?.worldId || uuidv4(),
-    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 || uuidv4(),
-        entityId: runtime.agentId,
-        agentId: runtime.agentId,
-        roomId: runtime.agentId,
-        worldId: existing?.worldId || uuidv4(),
-        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/scheduler/timer-manager.ts
-import { Cron as Cron2 } from "croner";
-
 // src/scheduler/schedule-utils.ts
 import { Cron } from "croner";
 function parseTimestamp(timestamp) {
@@ -482,1007 +251,693 @@ function parseScheduleDescription(description, nowMs = Date.now()) {
   return void 0;
 }
 
-// src/scheduler/timer-manager.ts
-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();
+// 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]}`);
   }
-  /**
-   * 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();
+  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);
       }
-      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());
+      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} * * *`
+        };
       }
     }
   }
-  /**
-   * 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;
+  const inMatch = /in\s+(\d+\s*(?:second|minute|hour|day)s?)/i.exec(text);
+  if (inMatch && !result.schedule) {
+    result.schedule = parseScheduleDescription(`in ${inMatch[1]}`);
   }
-  /**
-   * Forces an immediate check for due jobs
-   */
-  checkNow() {
-    if (this.running) {
-      this.performCheck();
-    }
+  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();
   }
-  /**
-   * 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();
-    }
+  const nameMatch = /(?:called|named)\s+["']?([^"']+)["']?/i.exec(text);
+  if (nameMatch) {
+    result.name = nameMatch[1].trim();
   }
-  /**
-   * Stops the periodic check interval
-   */
-  stopCheckInterval() {
-    if (this.checkInterval) {
-      clearInterval(this.checkInterval);
-      this.checkInterval = null;
-    }
+  if (!result.name && result.schedule) {
+    const scheduleDesc = formatSchedule(result.schedule);
+    result.name = `Cron job (${scheduleDesc})`;
   }
-  /**
-   * 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);
-      }
+  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" };
     }
-    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);
+    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 } };
     }
-  }
-  /**
-   * Clears all tracked jobs
-   */
-  clearAllJobs() {
-    for (const [, tracked] of this.trackedJobs) {
-      if (tracked.cronInstance) {
-        tracked.cronInstance.stop();
-      }
+    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" };
     }
-    this.trackedJobs.clear();
-  }
-};
-
-// src/executor/job-executor.ts
-import { v4 as uuidv42 } 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"));
+    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 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}
+    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'
+        }
+      }
+    ]
+  ]
+};
 
-${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()
+// 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 (!action) {
-    throw new Error(`Action not found: ${payload.actionName}`);
-  }
-  const roomId = payload.roomId || runtime.agentId;
-  const memory = {
-    id: uuidv42(),
-    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}`);
+  if (idMatch) {
+    return { id: idMatch[1] };
   }
-  const handlerResult = await action.handler(runtime, memory, void 0, void 0, callback);
-  const outputParts = [];
-  if (callbackResponses.length > 0) {
-    outputParts.push(...callbackResponses);
+  const quotedMatch = /["']([^"']+)["']/i.exec(text);
+  if (quotedMatch) {
+    return { name: quotedMatch[1] };
   }
-  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));
-      }
-    }
+  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
+  if (namedMatch) {
+    return { name: namedMatch[1] };
   }
-  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`;
+  return {};
 }
-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");
+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 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}`);
+    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;
       }
-    };
-    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";
+    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" };
     }
-    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";
+    if (!jobName) {
+      const job = await cronService.getJob(jobId);
+      if (job) {
+        jobName = job.name;
       }
-      return null;
     }
-    case "event": {
-      const eventName = payload.eventName?.trim();
-      if (!eventName) {
-        return "Event payload must have non-empty eventName";
+    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
       }
-      if (typeof runtime.emitEvent !== "function") {
-        return "Runtime does not support emitEvent for event execution";
+    };
+  },
+  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.'
+        }
       }
-      return null;
-    }
-    case "action": {
-      const actionName = payload.actionName?.trim();
-      if (!actionName) {
-        return "Action payload must have non-empty actionName";
+    ],
+    [
+      {
+        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.'
+        }
       }
-      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/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}
 
-// 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 };
+`;
+  details += `ID: ${job.id}
+`;
+  if (job.description) {
+    details += `Description: ${job.description}
+`;
   }
-  /**
-   * Starts the cron service
-   */
-  static async start(runtime) {
-    const service = new _CronService(runtime);
-    await service.initialize();
-    return service;
+  details += `
+Schedule: ${scheduleStr}
+`;
+  details += `Status: ${statusStr}
+`;
+  if (job.deleteAfterRun) {
+    details += `Type: one-shot (will be deleted after successful run)
+`;
   }
-  /**
-   * 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`
-    );
+  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}
+`;
   }
-  /**
-   * Stops the cron service
-   */
-  async stop() {
-    if (this.timerManager) {
-      this.timerManager.stop();
-    }
-    this.initialized = false;
-    logger.info(`[CronService] Stopped for agent ${this.runtime.agentId}`);
+  if (job.state.lastError) {
+    details += `  Last error: ${job.state.lastError}
+`;
   }
-  /**
-   * Gets the service configuration
-   */
-  getConfig() {
-    return { ...this.cronConfig };
+  if (job.state.lastDurationMs !== void 0) {
+    details += `  Last duration: ${job.state.lastDurationMs}ms
+`;
   }
-  // ============================================================================
-  // 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;
+  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}
+`;
   }
-  /**
-   * 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 (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" };
     }
-    if (patch.schedule) {
-      const scheduleError = validateSchedule(patch.schedule, this.cronConfig);
-      if (scheduleError) {
-        throw new Error(`Invalid schedule: ${scheduleError}`);
+    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 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
+    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" };
       }
-    };
-    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;
+      await callback?.({
+        text: formatJobDetails(job)
+      });
+      return { success: true, data: { job } };
     }
-    if (patch.payload) {
-      const execError = validateJobExecutability(this.runtime, updated);
-      if (execError) {
-        throw new Error(`Job cannot be executed: ${execError}`);
-      }
+    const filter = {};
+    if (text.includes("all")) {
+      filter.includeDisabled = true;
     }
-    await this.storage.saveJob(updated);
-    if (updated.enabled) {
-      this.timerManager.trackJob(updated);
-    } else {
-      this.timerManager.untrackJob(jobId);
+    if (text.includes("enabled") || text.includes("active")) {
+      filter.enabled = true;
+      filter.includeDisabled = false;
     }
-    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;
+    if (text.includes("disabled") || text.includes("inactive")) {
+      filter.enabled = false;
+      filter.includeDisabled = true;
     }
-    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})`);
+    if (options?.filter && typeof options.filter === "object") {
+      Object.assign(filter, options.filter);
     }
-    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);
+    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] };
   }
-  /**
-   * Lists all jobs, optionally filtered
-   * @param filter Optional filter criteria
-   * @returns Array of matching jobs
-   */
-  async listJobs(filter) {
-    return this.storage.listJobs(filter);
+  const quotedMatch = /["']([^"']+)["']/i.exec(text);
+  if (quotedMatch) {
+    return { name: quotedMatch[1] };
   }
-  /**
-   * Gets the count of jobs
-   */
-  async getJobCount() {
-    return this.storage.getJobCount();
+  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
+  if (namedMatch) {
+    return { name: namedMatch[1] };
   }
-  // ============================================================================
-  // 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}`);
+  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" };
     }
-    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"
-        };
+    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 (!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;
+    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" };
     }
-    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;
+    if (!jobName) {
+      const job = await cronService.getJob(jobId);
+      if (job) {
+        jobName = job.name;
+      }
     }
-    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 result = await cronService.runJob(jobId, "force");
+    if (!result.ran) {
+      await callback?.({
+        text: `Could not run job: ${result.error}`
+      });
+      return { success: false, error: result.error };
     }
-    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);
-      }
+    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}`;
     }
-  }
-  /**
-   * 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
-      };
+    if (result.error) {
+      responseText += `
+Error: ${result.error}`;
     }
-    await this.runtime.emitEvent(eventName, {
-      runtime: this.runtime,
-      source: `cron:${job.id}`,
-      ...eventData
+    await callback?.({
+      text: responseText
     });
-  }
-  // ============================================================================
-  // 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
+      success: result.status === "ok",
+      data: {
+        jobId,
+        jobName,
+        result
+      }
     };
-  }
-  /**
-   * 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/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/update-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] };
+  },
+  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) {
@@ -1502,7 +957,9 @@ function parseUpdateIntent(text) {
   } else if (normalized.includes("disable")) {
     patch.enabled = false;
   }
-  const everyMatch = /every\s+(\d+\s*(?:second|minute|hour|day|week)s?)/i.exec(text);
+  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) {
@@ -1545,13 +1002,13 @@ var updateCronAction = {
     let jobId = options?.jobId;
     let patch = options?.patch || {};
     if (!jobId) {
-      const identifier = extractJobIdentifier(text);
+      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()
+          (j) => j.name.toLowerCase() === identifier.name?.toLowerCase()
         );
         if (!job) {
           await callback?.({
@@ -1631,682 +1088,1289 @@ Next run: ${nextRun}`
   ]
 };
 
-// src/actions/delete-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] };
+// 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}`;
   }
-  const quotedMatch = /["']([^"']+)["']/i.exec(text);
-  if (quotedMatch) {
-    return { name: quotedMatch[1] };
+  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,
+  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((job) => job.enabled);
+    const disabledJobs = jobs.filter((job) => !job.enabled);
+    const nowMs = Date.now();
+    const oneHourFromNow = nowMs + 36e5;
+    const upcomingJobs = enabledJobs.filter(
+      (job) => job.state.nextRunAtMs && job.state.nextRunAtMs <= oneHourFromNow
+    );
+    const recentJobs = jobs.filter(
+      (job) => job.state.lastRunAtMs && job.state.lastRunAtMs >= nowMs - 36e5
+    );
+    const failedJobs = jobs.filter((job) => job.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((job) => ({
+          id: job.id,
+          name: job.name,
+          enabled: job.enabled,
+          schedule: job.schedule,
+          nextRunAtMs: job.state.nextRunAtMs,
+          lastStatus: job.state.lastStatus
+        })),
+        upcoming: upcomingJobs.map((job) => job.id),
+        failed: failedJobs.map((job) => job.id),
+        recent: recentJobs.map((job) => job.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;
   }
-  const namedMatch = /(?:job|cron)\s+(?:called|named)\s+(\S+)/i.exec(text);
-  if (namedMatch) {
-    return { name: namedMatch[1] };
+  if (filter.tags?.length) {
+    if (!job.tags?.some((tag) => filter.tags?.includes(tag))) return false;
   }
-  return {};
+  return true;
 }
-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 = 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;
+function getCronStorage(runtime) {
+  return {
+    async getJob(jobId) {
+      const componentType = getJobComponentType(jobId);
+      const component = await runtime.getComponent(
+        runtime.agentId,
+        componentType
+      );
+      if (!component) {
+        return null;
       }
-    }
-    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 validatedJob = validateJobData(component.data);
+      if (!validatedJob) {
+        console.warn(`[cron-storage] Invalid job data for ${jobId}, skipping`);
+        return null;
       }
-    }
-    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
+      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);
       }
-    };
-  },
-  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.'
-        }
+    },
+    async deleteJob(jobId) {
+      const componentType = getJobComponentType(jobId);
+      const existing = await runtime.getComponent(
+        runtime.agentId,
+        componentType
+      );
+      if (!existing) {
+        return false;
       }
-    ],
-    [
-      {
-        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.'
+      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);
         }
       }
-    ]
-  ]
-};
-
-// 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");
+      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);
+    }
+  };
 }
-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}
-`;
+// 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 };
   }
-  if (job.tags && job.tags.length > 0) {
-    details += `
-Tags: ${job.tags.join(", ")}
-`;
+  /**
+   * Starts the cron service
+   */
+  static async start(runtime) {
+    const service = new _CronService(runtime);
+    await service.initialize();
+    return service;
   }
-  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" };
+  /**
+   * Initializes the service, loading existing jobs and starting timers
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
     }
-    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" };
+    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);
       }
-      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" };
+      if (job.enabled) {
+        this.timerManager.trackJob(job);
       }
-      await callback?.({
-        text: formatJobDetails(job)
-      });
-      return { success: true, data: { job } };
     }
-    const filter = {};
-    if (text.includes("all")) {
-      filter.includeDisabled = true;
+    if (this.cronConfig.catchUpMissedJobs) {
+      await this.handleMissedJobs(jobs);
     }
-    if (text.includes("enabled") || text.includes("active")) {
-      filter.enabled = true;
-      filter.includeDisabled = false;
+    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();
     }
-    if (text.includes("disabled") || text.includes("inactive")) {
-      filter.enabled = false;
-      filter.includeDisabled = true;
+    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}`);
     }
-    if (options?.filter && typeof options.filter === "object") {
-      Object.assign(filter, options.filter);
+    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 jobs = await cronService.listJobs(filter);
-    await callback?.({
-      text: formatJobList(jobs, filter.includeDisabled ?? false)
-    });
-    return {
-      success: true,
-      data: {
-        jobs,
-        count: jobs.length
+    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
       }
     };
-  },
-  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 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] };
+    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;
   }
-  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" };
+  /**
+   * 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}`);
     }
-    const text = message.content?.text ?? "";
-    let jobId = options?.jobId;
-    let jobName;
-    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;
-        jobName = job.name;
+    if (patch.schedule) {
+      const scheduleError = validateSchedule(patch.schedule, this.cronConfig);
+      if (scheduleError) {
+        throw new Error(`Invalid schedule: ${scheduleError}`);
       }
     }
-    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" };
+    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 (!jobName) {
-      const job = await cronService.getJob(jobId);
-      if (job) {
-        jobName = job.name;
+    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}`);
       }
     }
-    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 };
+    await this.storage.saveJob(updated);
+    if (updated.enabled) {
+      this.timerManager.trackJob(updated);
+    } else {
+      this.timerManager.untrackJob(jobId);
     }
-    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}`;
+    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;
     }
-    if (result.error) {
-      responseText += `
-Error: ${result.error}`;
+    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})`
+      );
     }
-    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/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}`;
+    return deleted;
   }
-  if (job.state.lastStatus === "error") {
-    line += " [last run failed]";
+  /**
+   * 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);
   }
-  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
-        }
-      };
+  /**
+   * 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}`);
     }
-    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.`);
+    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 {
-      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)
-      }
+      ran: true,
+      ...result
     };
   }
-};
-
-// 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;
+  // ============================================================================
+  // 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);
   }
-  const patch = normalizeCronJobPatch(body.patch ?? body);
-  if (!patch) {
-    res.status(400).json({ error: "Invalid patch" });
-    return;
+  /**
+   * 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;
   }
-  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;
+  /**
+   * 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);
+      }
+    }
   }
-  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;
+  /**
+   * 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
+    });
   }
-  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;
+  // ============================================================================
+  // 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
+    };
   }
-  const storePath = resolveCronStorePath();
-  if (!storePath) {
-    res.json({ entries: [] });
-    return;
+  /**
+   * 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
+    };
   }
-  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/cli/index.ts
-import { registerCliCommand, defineCliCommand } from "@elizaos/plugin-cli";
+import { defineCliCommand, registerCliCommand } from "@elizaos/plugin-cli";
 
 // src/cli/register.ts
 var defaultLogger = {
@@ -2378,13 +2442,26 @@ function registerCronCli(ctx) {
       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) => {
+  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 isOttoStyle = Boolean(
+      opts.session || opts.systemEvent || opts.message
+    );
     const schedule = parseScheduleOpts(opts);
     if (!schedule) {
       logger2.error("Choose exactly one schedule: --at, --every, or --cron");
@@ -2403,14 +2480,22 @@ function registerCronCli(ctx) {
       } 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"}`);
+        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");
+        logger2.error(
+          "Choose exactly one payload: --prompt, --action, --event, --system-event, or --message"
+        );
         process.exitCode = 1;
         return;
       }
@@ -2429,7 +2514,9 @@ function registerCronCli(ctx) {
         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"}`);
+        logger2.info(
+          `  Next run: ${job.state.nextRunAtMs ? new Date(job.state.nextRunAtMs).toISOString() : "N/A"}`
+        );
       }
     }
   });
@@ -2525,7 +2612,9 @@ 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;
+  const chosen = [Boolean(at), Boolean(every), Boolean(cronExpr)].filter(
+    Boolean
+  ).length;
   if (chosen === 0) return null;
   if (chosen > 1) return null;
   if (at) {
@@ -2548,7 +2637,9 @@ 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;
+  const chosen = [Boolean(prompt), Boolean(action), Boolean(event)].filter(
+    Boolean
+  ).length;
   if (chosen === 0) return null;
   if (chosen > 1) return null;
   if (prompt) {
@@ -2655,8 +2746,12 @@ function printCronList(jobs, log) {
     log("No cron jobs.");
     return;
   }
-  log("ID                                   | Name                     | Status   | Schedule                         | Next Run");
-  log("-------------------------------------|--------------------------|----------|----------------------------------|--------------------");
+  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);