@hybrd/scheduler 2.0.0

package/dist/index.js

@@ -0,0 +1,1096 @@
+// src/index.ts
+import { randomUUID } from "crypto";
+import cronParser from "cron-parser";
+
+// src/store.ts
+import { readFileSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import initSqlJs from "sql.js";
+var SCHEMA = `
+CREATE TABLE IF NOT EXISTS cron_jobs (
+    id TEXT PRIMARY KEY,
+    agent_id TEXT,
+    session_key TEXT,
+    name TEXT NOT NULL,
+    description TEXT,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    delete_after_run INTEGER,
+    created_at_ms INTEGER NOT NULL,
+    updated_at_ms INTEGER NOT NULL,
+    schedule TEXT NOT NULL,
+    session_target TEXT NOT NULL DEFAULT 'isolated',
+    wake_mode TEXT NOT NULL DEFAULT 'now',
+    payload TEXT NOT NULL,
+    delivery TEXT,
+    state TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_cron_jobs_next_run ON cron_jobs(id);
+CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled ON cron_jobs(enabled);
+`;
+var SqliteSchedulerStore = class {
+  db = null;
+  dbPath;
+  onSave;
+  loadOnInit;
+  initPromise = null;
+  dirty = false;
+  saveTimer;
+  jobsCache = null;
+  constructor(options = {}) {
+    this.dbPath = options.dbPath ?? ":memory:";
+    this.onSave = options.onSave;
+    this.loadOnInit = options.loadOnInit ?? true;
+  }
+  async init() {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this._init();
+    return this.initPromise;
+  }
+  async _init() {
+    let SQL;
+    try {
+      const req = createRequire(process.cwd());
+      const sqlJsPath = dirname(req.resolve("sql.js"));
+      const wasmPath = join(sqlJsPath, "sql-wasm.wasm");
+      const wasmBinary = readFileSync(wasmPath);
+      SQL = await initSqlJs({ wasmBinary });
+    } catch {
+      SQL = await initSqlJs();
+    }
+    if (this.dbPath === ":memory:" || !this.loadOnInit) {
+      this.db = new SQL.Database();
+    } else {
+      try {
+        const buffer = readFileSync(this.dbPath);
+        this.db = new SQL.Database(new Uint8Array(buffer));
+      } catch {
+        this.db = new SQL.Database();
+      }
+    }
+    this.db.run(SCHEMA);
+    this.loadCache();
+    this.scheduleSave();
+  }
+  loadCache() {
+    if (!this.db) return;
+    const cache = /* @__PURE__ */ new Map();
+    const result = this.db.exec(
+      "SELECT id, agent_id, session_key, name, description, enabled, delete_after_run, created_at_ms, updated_at_ms, schedule, session_target, wake_mode, payload, delivery, state FROM cron_jobs"
+    );
+    const firstResult = result[0];
+    if (firstResult) {
+      for (const row of firstResult.values) {
+        const job = this.rowToJob(row);
+        if (job) {
+          cache.set(job.id, job);
+        }
+      }
+    }
+    this.jobsCache = cache;
+  }
+  scheduleSave() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+    this.saveTimer = setTimeout(() => {
+      void this.save();
+    }, 1e3);
+  }
+  async save() {
+    if (!this.db || !this.dirty) return;
+    const data = this.db.export();
+    this.dirty = false;
+    if (this.onSave) {
+      await this.onSave(data);
+    }
+  }
+  async close() {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+    }
+    await this.save();
+    this.db?.close();
+    this.db = null;
+    this.jobsCache = null;
+  }
+  rowToJob(row) {
+    try {
+      const schedule = JSON.parse(String(row[9]));
+      const payload = JSON.parse(String(row[12]));
+      const delivery = row[13] ? JSON.parse(String(row[13])) : void 0;
+      const state = JSON.parse(String(row[14]));
+      return {
+        id: String(row[0]),
+        agentId: row[1] ? String(row[1]) : void 0,
+        sessionKey: row[2] ? String(row[2]) : void 0,
+        name: String(row[3]),
+        description: row[4] ? String(row[4]) : void 0,
+        enabled: Boolean(row[5]),
+        deleteAfterRun: row[6] ? Boolean(row[6]) : void 0,
+        createdAtMs: Number(row[7]),
+        updatedAtMs: Number(row[8]),
+        schedule,
+        sessionTarget: row[10] ?? "isolated",
+        wakeMode: row[11] ?? "now",
+        payload,
+        delivery,
+        state
+      };
+    } catch {
+      return null;
+    }
+  }
+  jobToRow(job) {
+    return [
+      job.id,
+      job.agentId ?? null,
+      job.sessionKey ?? null,
+      job.name,
+      job.description ?? null,
+      job.enabled ? 1 : 0,
+      job.deleteAfterRun ? 1 : null,
+      job.createdAtMs,
+      job.updatedAtMs,
+      JSON.stringify(job.schedule),
+      job.sessionTarget,
+      job.wakeMode,
+      JSON.stringify(job.payload),
+      job.delivery ? JSON.stringify(job.delivery) : null,
+      JSON.stringify(job.state)
+    ];
+  }
+  ensureDb() {
+    if (!this.db) {
+      throw new Error("Store not initialized. Call init() first.");
+    }
+    return this.db;
+  }
+  ensureCache() {
+    if (!this.jobsCache) {
+      throw new Error("Cache not initialized. Call init() first.");
+    }
+    return this.jobsCache;
+  }
+  getJobSync(id) {
+    const cache = this.ensureCache();
+    return cache.get(id);
+  }
+  getAllJobsSync() {
+    const cache = this.ensureCache();
+    return Array.from(cache.values());
+  }
+  saveJobSync(job) {
+    const db = this.ensureDb();
+    const cache = this.ensureCache();
+    db.run(
+      `INSERT OR REPLACE INTO cron_jobs 
+            (id, agent_id, session_key, name, description, enabled, delete_after_run, created_at_ms, updated_at_ms, schedule, session_target, wake_mode, payload, delivery, state) 
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      this.jobToRow(job)
+    );
+    cache.set(job.id, job);
+    this.dirty = true;
+    this.scheduleSave();
+  }
+  saveAllJobsSync() {
+    const db = this.ensureDb();
+    const cache = this.ensureCache();
+    for (const job of cache.values()) {
+      db.run(
+        `INSERT OR REPLACE INTO cron_jobs 
+                (id, agent_id, session_key, name, description, enabled, delete_after_run, created_at_ms, updated_at_ms, schedule, session_target, wake_mode, payload, delivery, state) 
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        this.jobToRow(job)
+      );
+    }
+    this.dirty = true;
+    this.scheduleSave();
+  }
+  deleteJobSync(id) {
+    const db = this.ensureDb();
+    const cache = this.ensureCache();
+    db.run("DELETE FROM cron_jobs WHERE id = ?", [id]);
+    cache.delete(id);
+    this.dirty = true;
+    this.scheduleSave();
+  }
+  async getTask(id) {
+    return this.getJobSync(id);
+  }
+  async getAllTasks() {
+    return this.getAllJobsSync();
+  }
+  async saveTask(task) {
+    this.saveJobSync(task);
+  }
+  async deleteTask(id) {
+    this.deleteJobSync(id);
+  }
+};
+async function createSqliteStore(options) {
+  const resolvedOptions = { ...options };
+  if (resolvedOptions.dbPath && resolvedOptions.dbPath !== ":memory:" && !resolvedOptions.onSave) {
+    const { writeFileSync } = await import("fs");
+    const { dirname: dirname2 } = await import("path");
+    const { mkdirSync, existsSync } = await import("fs");
+    const dbPath = resolvedOptions.dbPath;
+    const dir = dirname2(dbPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    resolvedOptions.onSave = (data) => {
+      writeFileSync(dbPath, data);
+    };
+  }
+  const store = new SqliteSchedulerStore(resolvedOptions);
+  await store.init();
+  return store;
+}
+
+// src/tools.ts
+import { z } from "zod";
+var ScheduleSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("at"),
+    at: z.string()
+  }),
+  z.object({
+    kind: z.literal("every"),
+    everyMs: z.number().positive(),
+    anchorMs: z.number().optional()
+  }),
+  z.object({
+    kind: z.literal("cron"),
+    expr: z.string(),
+    tz: z.string().optional(),
+    staggerMs: z.number().optional()
+  })
+]);
+var PayloadSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("systemEvent"),
+    text: z.string()
+  }),
+  z.object({
+    kind: z.literal("agentTurn"),
+    message: z.string(),
+    model: z.string().optional(),
+    thinking: z.string().optional(),
+    timeoutSeconds: z.number().optional(),
+    allowUnsafeExternalContent: z.boolean().optional()
+  })
+]);
+var ScheduleTaskSchema = z.object({
+  id: z.string().optional(),
+  agentId: z.string().optional(),
+  sessionKey: z.string().optional(),
+  name: z.string(),
+  description: z.string().optional(),
+  enabled: z.boolean().optional(),
+  deleteAfterRun: z.boolean().optional(),
+  schedule: ScheduleSchema,
+  sessionTarget: z.enum(["main", "isolated"]).optional(),
+  wakeMode: z.enum(["now", "next-heartbeat"]).optional(),
+  payload: PayloadSchema,
+  delivery: z.object({
+    mode: z.enum(["none", "announce"]),
+    channel: z.string().optional(),
+    to: z.string().optional(),
+    accountId: z.string().optional(),
+    bestEffort: z.boolean().optional()
+  }).optional()
+});
+var ListTasksSchema = z.object({
+  includeDisabled: z.boolean().optional(),
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+  query: z.string().optional(),
+  enabled: z.enum(["all", "enabled", "disabled"]).optional(),
+  sortBy: z.enum(["nextRunAtMs", "updatedAtMs", "name"]).optional(),
+  sortDir: z.enum(["asc", "desc"]).optional()
+}).optional();
+var CancelTaskSchema = z.object({
+  taskId: z.string()
+});
+var GetTaskSchema = z.object({
+  taskId: z.string()
+});
+var RunTaskSchema = z.object({
+  taskId: z.string(),
+  mode: z.enum(["due", "force"]).optional()
+});
+function formatSchedule(schedule) {
+  switch (schedule.kind) {
+    case "at":
+      return `at ${schedule.at}`;
+    case "every":
+      return `every ${schedule.everyMs}ms`;
+    case "cron":
+      return `cron ${schedule.expr}${schedule.tz ? ` (${schedule.tz})` : ""}`;
+  }
+}
+function formatJob(job) {
+  return {
+    id: job.id,
+    name: job.name,
+    description: job.description,
+    enabled: job.enabled,
+    schedule: formatSchedule(job.schedule),
+    sessionTarget: job.sessionTarget,
+    wakeMode: job.wakeMode,
+    payload: job.payload,
+    delivery: job.delivery,
+    state: {
+      nextRunAtMs: job.state.nextRunAtMs,
+      lastRunAtMs: job.state.lastRunAtMs,
+      lastRunStatus: job.state.lastRunStatus,
+      lastError: job.state.lastError,
+      consecutiveErrors: job.state.consecutiveErrors
+    }
+  };
+}
+function createSchedulerTools(scheduler) {
+  return [
+    {
+      name: "schedule_task",
+      description: `Schedule a task to run at a specific time or interval.
+
+Examples:
+- One-time: { schedule: { kind: "at", at: "2026-03-01T09:00:00Z" }, payload: { kind: "agentTurn", message: "Check on the project" } }
+- Interval: { schedule: { kind: "every", everyMs: 300000 }, payload: { kind: "agentTurn", message: "Status check" } }
+- Cron: { schedule: { kind: "cron", expr: "0 9 * * 1-5" }, payload: { kind: "agentTurn", message: "Daily standup reminder" } }`,
+      inputSchema: ScheduleTaskSchema,
+      handler: async (args) => {
+        const parsed = ScheduleTaskSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: parsed.error.message
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const input = {
+            id: parsed.data.id,
+            agentId: parsed.data.agentId,
+            sessionKey: parsed.data.sessionKey,
+            name: parsed.data.name,
+            description: parsed.data.description,
+            enabled: parsed.data.enabled,
+            deleteAfterRun: parsed.data.deleteAfterRun,
+            schedule: parsed.data.schedule,
+            sessionTarget: parsed.data.sessionTarget,
+            wakeMode: parsed.data.wakeMode,
+            payload: parsed.data.payload,
+            delivery: parsed.data.delivery
+          };
+          const job = await scheduler.add(input);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  jobId: job.id,
+                  name: job.name,
+                  nextRunAtMs: job.state.nextRunAtMs
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: err instanceof Error ? err.message : "Failed to schedule task"
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    },
+    {
+      name: "list_scheduled_tasks",
+      description: "List all scheduled tasks with optional filtering and pagination",
+      inputSchema: ListTasksSchema,
+      handler: async (args) => {
+        const parsed = ListTasksSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: parsed.error.message })
+              }
+            ],
+            isError: true
+          };
+        }
+        const result = await scheduler.listPage(parsed.data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                items: result.items.map(formatJob),
+                total: result.total,
+                offset: result.offset,
+                limit: result.limit,
+                hasMore: result.hasMore
+              })
+            }
+          ]
+        };
+      }
+    },
+    {
+      name: "get_scheduled_task",
+      description: "Get details of a specific scheduled task",
+      inputSchema: GetTaskSchema,
+      handler: async (args) => {
+        const parsed = GetTaskSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: parsed.error.message })
+              }
+            ],
+            isError: true
+          };
+        }
+        const job = await scheduler.get(parsed.data.taskId);
+        if (!job) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({ error: "Task not found" })
+              }
+            ],
+            isError: true
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(formatJob(job), null, 2)
+            }
+          ]
+        };
+      }
+    },
+    {
+      name: "cancel_scheduled_task",
+      description: "Cancel and remove a scheduled task",
+      inputSchema: CancelTaskSchema,
+      handler: async (args) => {
+        const parsed = CancelTaskSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: parsed.error.message
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const result = await scheduler.remove(parsed.data.taskId);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  removed: result.removed
+                })
+              }
+            ]
+          };
+        } catch (err) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: err instanceof Error ? err.message : "Failed to cancel task"
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    },
+    {
+      name: "run_scheduled_task",
+      description: "Manually trigger a scheduled task to run now",
+      inputSchema: RunTaskSchema,
+      handler: async (args) => {
+        const parsed = RunTaskSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: parsed.error.message
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        try {
+          const result = await scheduler.run(
+            parsed.data.taskId,
+            parsed.data.mode
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result)
+              }
+            ]
+          };
+        } catch (err) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: err instanceof Error ? err.message : "Failed to run task"
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    }
+  ];
+}
+
+// src/index.ts
+var { parseExpression } = cronParser;
+var MAX_TIMER_DELAY_MS = 6e4;
+var MIN_REFIRE_GAP_MS = 2e3;
+var STUCK_RUN_MS = 2 * 60 * 60 * 1e3;
+var ERROR_BACKOFF_SCHEDULE_MS = [
+  3e4,
+  6e4,
+  5 * 6e4,
+  15 * 6e4,
+  60 * 6e4
+];
+function errorBackoffMs(consecutiveErrors) {
+  const idx = Math.min(
+    consecutiveErrors - 1,
+    ERROR_BACKOFF_SCHEDULE_MS.length - 1
+  );
+  return ERROR_BACKOFF_SCHEDULE_MS[Math.max(0, idx)] ?? 6e4;
+}
+var SchedulerService = class {
+  store;
+  dispatcher;
+  executor;
+  state;
+  timezone;
+  enabled;
+  eventCallback;
+  constructor(config) {
+    this.store = config.store;
+    this.dispatcher = config.dispatcher;
+    this.executor = config.executor;
+    this.timezone = config.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    this.enabled = config.enabled ?? true;
+    this.state = {
+      running: false,
+      timer: null,
+      op: Promise.resolve()
+    };
+  }
+  onEvent(callback) {
+    this.eventCallback = callback;
+  }
+  emit(event) {
+    this.eventCallback?.(event);
+  }
+  locked(fn) {
+    const next = this.state.op.then(fn, () => fn());
+    this.state.op = next.catch(() => {
+    });
+    return next;
+  }
+  computeNextRunAtMs(schedule, nowMs) {
+    try {
+      switch (schedule.kind) {
+        case "at": {
+          const atMs = new Date(schedule.at).getTime();
+          if (Number.isNaN(atMs)) return void 0;
+          return atMs > nowMs ? atMs : void 0;
+        }
+        case "every": {
+          const everyMs = Math.max(1, Math.floor(schedule.everyMs));
+          const anchorMs = schedule.anchorMs ?? nowMs;
+          const elapsed = Math.max(0, nowMs - anchorMs);
+          const steps = Math.max(
+            1,
+            Math.floor((elapsed + everyMs - 1) / everyMs)
+          );
+          return anchorMs + steps * everyMs;
+        }
+        case "cron": {
+          const interval = parseExpression(schedule.expr, {
+            tz: schedule.tz ?? this.timezone
+          });
+          const next = interval.next();
+          return next ? next.getTime() : void 0;
+        }
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  computeJobNextRunAtMs(job, nowMs) {
+    if (!job.enabled) return void 0;
+    if (job.schedule.kind === "every") {
+      const lastRunAtMs = job.state.lastRunAtMs;
+      if (typeof lastRunAtMs === "number" && Number.isFinite(lastRunAtMs)) {
+        const nextFromLastRun = Math.floor(lastRunAtMs) + job.schedule.everyMs;
+        if (nextFromLastRun > nowMs) {
+          return nextFromLastRun;
+        }
+      }
+    }
+    if (job.schedule.kind === "at") {
+      if (job.state.lastRunStatus === "ok") {
+        return void 0;
+      }
+    }
+    return this.computeNextRunAtMs(job.schedule, nowMs);
+  }
+  isRunnableJob(job, nowMs) {
+    if (!job.enabled) return false;
+    if (typeof job.state.runningAtMs === "number") {
+      if (nowMs - job.state.runningAtMs > STUCK_RUN_MS) {
+        return true;
+      }
+      return false;
+    }
+    const next = job.state.nextRunAtMs;
+    return typeof next === "number" && nowMs >= next;
+  }
+  findDueJobs(nowMs) {
+    const jobs = this.store.getAllJobsSync();
+    return jobs.filter((job) => this.isRunnableJob(job, nowMs));
+  }
+  nextWakeAtMs() {
+    const jobs = this.store.getAllJobsSync();
+    let min;
+    for (const job of jobs) {
+      if (!job.enabled) continue;
+      if (job.state.runningAtMs !== void 0) continue;
+      const next = job.state.nextRunAtMs;
+      if (typeof next !== "number") continue;
+      if (min === void 0 || next < min) {
+        min = next;
+      }
+    }
+    return min;
+  }
+  armTimer() {
+    this.stopTimer();
+    if (!this.enabled) return;
+    const nextAt = this.nextWakeAtMs();
+    if (!nextAt) return;
+    const now = Date.now();
+    const delay = Math.max(0, nextAt - now);
+    const clampedDelay = Math.min(delay, MAX_TIMER_DELAY_MS);
+    this.state.timer = setTimeout(() => {
+      void this.onTimer();
+    }, clampedDelay);
+  }
+  stopTimer() {
+    if (this.state.timer) {
+      clearTimeout(this.state.timer);
+      this.state.timer = null;
+    }
+  }
+  async onTimer() {
+    if (this.state.running) {
+      return;
+    }
+    this.state.running = true;
+    this.stopTimer();
+    try {
+      const dueJobs = await this.locked(async () => {
+        const now = Date.now();
+        const due = this.findDueJobs(now);
+        if (due.length === 0) {
+          this.recomputeNextRunsForMaintenance();
+          return [];
+        }
+        for (const job of due) {
+          job.state.runningAtMs = now;
+          job.state.lastError = void 0;
+        }
+        this.store.saveAllJobsSync();
+        return due;
+      });
+      for (const job of dueJobs) {
+        await this.executeJob(job);
+      }
+    } finally {
+      this.state.running = false;
+      this.armTimer();
+    }
+  }
+  recomputeNextRunsForMaintenance() {
+    const jobs = this.store.getAllJobsSync();
+    const now = Date.now();
+    let changed = false;
+    for (const job of jobs) {
+      if (!job.enabled) {
+        if (job.state.nextRunAtMs !== void 0) {
+          job.state.nextRunAtMs = void 0;
+          changed = true;
+        }
+        if (job.state.runningAtMs !== void 0) {
+          job.state.runningAtMs = void 0;
+          changed = true;
+        }
+        continue;
+      }
+      const runningAt = job.state.runningAtMs;
+      if (typeof runningAt === "number" && now - runningAt > STUCK_RUN_MS) {
+        job.state.runningAtMs = void 0;
+        changed = true;
+      }
+      if (job.state.nextRunAtMs === void 0) {
+        job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, now);
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.store.saveAllJobsSync();
+    }
+    return changed;
+  }
+  applyJobResult(job, result) {
+    job.state.runningAtMs = void 0;
+    job.state.lastRunAtMs = result.startedAt;
+    job.state.lastRunStatus = result.status;
+    job.state.lastDurationMs = result.endedAt - result.startedAt;
+    job.state.lastError = result.error;
+    if (result.status === "error") {
+      job.state.consecutiveErrors = (job.state.consecutiveErrors ?? 0) + 1;
+    } else {
+      job.state.consecutiveErrors = 0;
+    }
+    const shouldDelete = job.schedule.kind === "at" && job.deleteAfterRun === true && result.status === "ok";
+    if (!shouldDelete) {
+      if (job.schedule.kind === "at") {
+        job.enabled = false;
+        job.state.nextRunAtMs = void 0;
+      } else if (result.status === "error" && job.enabled) {
+        const backoff = errorBackoffMs(job.state.consecutiveErrors ?? 1);
+        const normalNext = this.computeJobNextRunAtMs(job, result.endedAt);
+        const backoffNext = result.endedAt + backoff;
+        job.state.nextRunAtMs = normalNext ? Math.max(normalNext, backoffNext) : backoffNext;
+      } else if (job.enabled) {
+        const naturalNext = this.computeJobNextRunAtMs(job, result.endedAt);
+        if (job.schedule.kind === "cron") {
+          const minNext = result.endedAt + MIN_REFIRE_GAP_MS;
+          job.state.nextRunAtMs = naturalNext ? Math.max(naturalNext, minNext) : minNext;
+        } else {
+          job.state.nextRunAtMs = naturalNext;
+        }
+      }
+    }
+    return shouldDelete;
+  }
+  async executeJob(job) {
+    const startedAt = Date.now();
+    this.emit({ jobId: job.id, action: "started", runAtMs: startedAt });
+    let result;
+    try {
+      if (job.sessionTarget === "main") {
+        result = await this.executor.runSystemEvent(job);
+      } else {
+        result = await this.executor.runAgentTurn(job);
+      }
+    } catch (err) {
+      result = {
+        status: "error",
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    const endedAt = Date.now();
+    if (job.delivery?.mode === "announce" && result.summary && job.delivery.channel && job.delivery.to) {
+      const deliveryResult = await this.dispatcher.dispatch({
+        channel: job.delivery.channel,
+        to: job.delivery.to,
+        message: result.summary
+      });
+      result.delivered = deliveryResult.delivered;
+    }
+    await this.locked(async () => {
+      const currentJob = this.store.getJobSync(job.id);
+      if (!currentJob) return;
+      const shouldDelete = this.applyJobResult(currentJob, {
+        status: result.status,
+        error: result.error,
+        delivered: result.delivered,
+        startedAt,
+        endedAt
+      });
+      this.emit({
+        jobId: currentJob.id,
+        action: "finished",
+        status: result.status,
+        error: result.error,
+        delivered: result.delivered,
+        runAtMs: startedAt,
+        durationMs: currentJob.state.lastDurationMs,
+        nextRunAtMs: currentJob.state.nextRunAtMs
+      });
+      if (shouldDelete) {
+        this.store.deleteJobSync(currentJob.id);
+        this.emit({ jobId: currentJob.id, action: "removed" });
+      } else {
+        this.store.saveJobSync(currentJob);
+      }
+    });
+  }
+  async start() {
+    if (!this.enabled) {
+      console.log("[scheduler] disabled");
+      return;
+    }
+    await this.locked(async () => {
+      const jobs = this.store.getAllJobsSync();
+      for (const job of jobs) {
+        if (typeof job.state.runningAtMs === "number") {
+          job.state.runningAtMs = void 0;
+        }
+      }
+      this.store.saveAllJobsSync();
+      this.recomputeNextRunsForMaintenance();
+    });
+    this.armTimer();
+    console.log("[scheduler] started");
+  }
+  async stop() {
+    this.stopTimer();
+    this.state.running = false;
+    await this.store.close();
+  }
+  async status() {
+    return this.locked(async () => {
+      const jobs = this.store.getAllJobsSync();
+      return {
+        enabled: this.enabled,
+        jobs: jobs.length,
+        nextWakeAtMs: this.nextWakeAtMs() ?? null
+      };
+    });
+  }
+  async add(input) {
+    return this.locked(async () => {
+      const now = Date.now();
+      const id = input.id ?? randomUUID();
+      const job = {
+        id,
+        agentId: input.agentId,
+        sessionKey: input.sessionKey,
+        name: input.name,
+        description: input.description,
+        enabled: input.enabled ?? true,
+        deleteAfterRun: input.deleteAfterRun,
+        createdAtMs: now,
+        updatedAtMs: now,
+        schedule: input.schedule,
+        sessionTarget: input.sessionTarget ?? "isolated",
+        wakeMode: input.wakeMode ?? "now",
+        payload: input.payload,
+        delivery: input.delivery,
+        state: {
+          ...input.state,
+          nextRunAtMs: void 0
+        }
+      };
+      job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, now);
+      this.store.saveJobSync(job);
+      this.armTimer();
+      this.emit({
+        jobId: job.id,
+        action: "added",
+        nextRunAtMs: job.state.nextRunAtMs
+      });
+      return job;
+    });
+  }
+  async get(id) {
+    return this.store.getJobSync(id);
+  }
+  async list(opts) {
+    const jobs = this.store.getAllJobsSync();
+    const includeDisabled = opts?.includeDisabled === true;
+    const filtered = jobs.filter((j) => includeDisabled || j.enabled);
+    return filtered.sort(
+      (a, b) => (a.state.nextRunAtMs ?? 0) - (b.state.nextRunAtMs ?? 0)
+    );
+  }
+  async listPage(opts) {
+    const jobs = this.store.getAllJobsSync();
+    const includeDisabled = opts?.enabled === "all" || opts?.enabled === "disabled";
+    const includeEnabled = opts?.enabled !== "disabled";
+    const query = opts?.query?.trim().toLowerCase() ?? "";
+    const filtered = jobs.filter((job) => {
+      if (!includeDisabled && !job.enabled) return false;
+      if (!includeEnabled && job.enabled) return false;
+      if (query) {
+        const haystack = [job.name, job.description ?? ""].join(" ").toLowerCase();
+        return haystack.includes(query);
+      }
+      return true;
+    });
+    const sortBy = opts?.sortBy ?? "nextRunAtMs";
+    const sortDir = opts?.sortDir ?? "asc";
+    const dir = sortDir === "desc" ? -1 : 1;
+    filtered.sort((a, b) => {
+      let cmp = 0;
+      if (sortBy === "name") {
+        cmp = a.name.localeCompare(b.name);
+      } else if (sortBy === "updatedAtMs") {
+        cmp = a.updatedAtMs - b.updatedAtMs;
+      } else {
+        const aNext = a.state.nextRunAtMs;
+        const bNext = b.state.nextRunAtMs;
+        if (typeof aNext === "number" && typeof bNext === "number") {
+          cmp = aNext - bNext;
+        } else if (typeof aNext === "number") {
+          cmp = -1;
+        } else if (typeof bNext === "number") {
+          cmp = 1;
+        }
+      }
+      return cmp * dir;
+    });
+    const total = filtered.length;
+    const offset = Math.max(0, Math.min(total, opts?.offset ?? 0));
+    const limit = Math.max(1, Math.min(200, opts?.limit ?? 50));
+    const items = filtered.slice(offset, offset + limit);
+    const nextOffset = offset + items.length;
+    return {
+      items,
+      total,
+      offset,
+      limit,
+      hasMore: nextOffset < total,
+      nextOffset: nextOffset < total ? nextOffset : null
+    };
+  }
+  async update(id, patch) {
+    return this.locked(async () => {
+      const job = this.store.getJobSync(id);
+      if (!job) {
+        throw new Error(`Job not found: ${id}`);
+      }
+      if (patch.name !== void 0) job.name = patch.name;
+      if (patch.description !== void 0) job.description = patch.description;
+      if (patch.enabled !== void 0) job.enabled = patch.enabled;
+      if (patch.deleteAfterRun !== void 0)
+        job.deleteAfterRun = patch.deleteAfterRun;
+      if (patch.schedule !== void 0) job.schedule = patch.schedule;
+      if (patch.sessionTarget !== void 0)
+        job.sessionTarget = patch.sessionTarget;
+      if (patch.wakeMode !== void 0) job.wakeMode = patch.wakeMode;
+      if (patch.payload !== void 0) job.payload = patch.payload;
+      if (patch.delivery !== void 0) job.delivery = patch.delivery;
+      job.updatedAtMs = Date.now();
+      if (job.enabled) {
+        job.state.nextRunAtMs = this.computeJobNextRunAtMs(job, job.updatedAtMs);
+      } else {
+        job.state.nextRunAtMs = void 0;
+        job.state.runningAtMs = void 0;
+      }
+      this.store.saveJobSync(job);
+      this.armTimer();
+      this.emit({
+        jobId: job.id,
+        action: "updated",
+        nextRunAtMs: job.state.nextRunAtMs
+      });
+      return job;
+    });
+  }
+  async remove(id) {
+    return this.locked(async () => {
+      const existed = this.store.getJobSync(id) !== void 0;
+      if (existed) {
+        this.store.deleteJobSync(id);
+        this.armTimer();
+        this.emit({ jobId: id, action: "removed" });
+      }
+      return { ok: true, removed: existed };
+    });
+  }
+  async run(id, mode) {
+    const job = this.store.getJobSync(id);
+    if (!job) {
+      return { ok: false, ran: false };
+    }
+    if (typeof job.state.runningAtMs === "number") {
+      return { ok: true, ran: false, reason: "already-running" };
+    }
+    const now = Date.now();
+    const due = mode === "force" || job.enabled && typeof job.state.nextRunAtMs === "number" && now >= job.state.nextRunAtMs;
+    if (!due) {
+      return { ok: true, ran: false, reason: "not-due" };
+    }
+    await this.executeJob(job);
+    return { ok: true, ran: true };
+  }
+};
+async function createSchedulerService(config) {
+  await config.store.init();
+  return new SchedulerService(config);
+}
+export {
+  SchedulerService,
+  SqliteSchedulerStore,
+  createSchedulerService,
+  createSchedulerTools,
+  createSqliteStore
+};
+//# sourceMappingURL=index.js.map