@inetafrica/open-claudia 2.0.2 → 2.0.4

package/bin/agent.js

@@ -0,0 +1,60 @@
+// open-claudia agent "<prompt>" [--role "<role>"] [--json] [--cwd <dir>]
+// Spawn a fresh, throwaway Claude sub-agent for focused research.
+// No session resume; the parent agent captures stdout and decides what
+// to do with the result.
+
+const path = require("path");
+
+const HELP = `
+Spawn a fresh Claude sub-agent. Output goes to stdout.
+
+  open-claudia agent "<prompt>" [--role "<role>"] [--cwd <dir>] [--json] [--timeout <s>]
+
+The sub-agent has read-only research tools (Read, Glob, Grep, Bash for read-only
+commands) but no access to your chat session or the send-* CLIs.
+`;
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+function hasFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return false;
+  args.splice(idx, 1);
+  return true;
+}
+
+async function run(args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "help") {
+    console.log(HELP); process.exit(args[0] === "--help" || args[0] === "help" ? 0 : 2);
+  }
+  const rest = args.slice();
+  const role = takeFlag(rest, "role");
+  const cwd = takeFlag(rest, "cwd") || process.cwd();
+  const timeoutS = takeFlag(rest, "timeout");
+  const json = hasFlag(rest, "json");
+  const prompt = rest.join(" ").trim();
+  if (!prompt) { console.error("Missing prompt."); process.exit(2); }
+
+  const { spawnSubagent } = require(path.join(__dirname, "..", "core", "subagent"));
+  const channelId = process.env.OC_CHANNEL_ID || null;
+  try {
+    const res = await spawnSubagent(prompt, {
+      cwd,
+      role,
+      channelId,
+      json,
+      timeoutMs: timeoutS ? Number(timeoutS) * 1000 : undefined,
+    });
+    if (res.text) process.stdout.write(res.text + (res.text.endsWith("\n") ? "" : "\n"));
+    if (res.truncated) process.stderr.write("(output truncated to 64KB)\n");
+    process.exit(0);
+  } catch (e) { console.error(`agent failed: ${e.message}`); process.exit(1); }
+}
+
+module.exports = { run, HELP };

package/bin/cli.js

@@ -233,6 +233,40 @@ switch (command) {
     break;
   }
 
+  case "tw":
+  case "transcript-window": {
+    require("./transcript-window").run(args.slice(1));
+    break;
+  }
+
+  case "schedule-wakeup": {
+    require("./schedule").runScheduleWakeup(args.slice(1));
+    break;
+  }
+  case "cron-add": {
+    require("./schedule").runCronAdd(args.slice(1));
+    break;
+  }
+  case "cron-list":
+  case "job-list": {
+    require("./schedule").runCronList();
+    break;
+  }
+  case "cron-remove": {
+    require("./schedule").runCronRemove(args.slice(1));
+    break;
+  }
+
+  case "task": {
+    require("./task").run(args.slice(1));
+    break;
+  }
+
+  case "agent": {
+    require("./agent").run(args.slice(1));
+    break;
+  }
+
   default:
     console.log(`
 Open Claudia — AI Coding Assistant via Telegram
@@ -252,6 +286,18 @@ Send tools (only work inside an active bot-spawned task):
   open-claudia send-photo <path> [caption]
   open-claudia send-voice <path>
 
+Memory tools:
+  open-claudia transcript-window <pattern>   Search project transcript, show hits with context
+                                             (alias: tw; --help for options)
+
+Background work (only inside an active bot-spawned task):
+  open-claudia schedule-wakeup <when> "<prompt>"   One-shot future wake-up; resumes session
+  open-claudia cron-add "<sched>" "<prompt>"       Recurring cron job
+  open-claudia cron-list                           List all wakeups + crons on this channel
+  open-claudia cron-remove <id>                    Remove a scheduled job
+  open-claudia task add|list|start|done|remove     Per-channel todo (survives restarts)
+  open-claudia agent "<prompt>" [--role X]         Spawn a throwaway sub-agent for research
+
 Start options:
   --web           Also start the web UI
   --quick         Skip slow health checks (Claude auth, Telegram API)

package/bin/loopback-client.js

@@ -0,0 +1,99 @@
+// Shared loopback HTTP client used by every subprocess CLI that needs
+// to talk back to the running bot. Resolves the URL+token from env
+// (OC_SEND_URL / OC_SEND_TOKEN) with a fallback to scanning the
+// loopback info file directory written by the bot at startup.
+
+const fs = require("fs");
+const path = require("path");
+const http = require("http");
+const configDir = require(path.join(__dirname, "..", "config-dir"));
+
+function readLoopbackInfo() {
+  try {
+    const dir = path.join(configDir, "loopback");
+    if (!fs.existsSync(dir)) return null;
+    const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    let newest = null;
+    for (const f of entries) {
+      const full = path.join(dir, f);
+      const stat = fs.statSync(full);
+      if (!newest || stat.mtimeMs > newest.mtimeMs) newest = { full, mtimeMs: stat.mtimeMs };
+    }
+    if (!newest) return null;
+    return JSON.parse(fs.readFileSync(newest.full, "utf-8"));
+  } catch (e) { return null; }
+}
+
+function context() {
+  let sendUrl = process.env.OC_SEND_URL;
+  let sendToken = process.env.OC_SEND_TOKEN;
+  if (!sendUrl || !sendToken) {
+    const info = readLoopbackInfo();
+    if (info) { sendUrl = info.url; sendToken = info.token; }
+  }
+  return {
+    sendUrl,
+    sendToken,
+    channelId: process.env.OC_CHANNEL_ID,
+    adapterId: process.env.OC_CHANNEL_ADAPTER,
+    canonicalUserId: process.env.OC_CANONICAL_USER_ID || null,
+    sessionId: process.env.OC_LAST_SESSION_ID || null,
+    sessionKey: process.env.OC_LAST_SESSION_KEY || null,
+  };
+}
+
+function requireContext() {
+  const ctx = context();
+  if (!ctx.sendUrl || !ctx.sendToken || !ctx.channelId || !ctx.adapterId) {
+    console.error("No active chat context. This command only works from inside a bot-spawned task.");
+    process.exit(2);
+  }
+  return ctx;
+}
+
+function postJson(kind, body) {
+  const ctx = requireContext();
+  const u = new URL(ctx.sendUrl);
+  const payload = JSON.stringify({
+    channelId: ctx.channelId,
+    adapter: ctx.adapterId,
+    canonicalUserId: ctx.canonicalUserId,
+    sessionId: ctx.sessionId,
+    sessionKey: ctx.sessionKey,
+    ...body,
+  });
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      method: "POST",
+      hostname: u.hostname,
+      port: u.port,
+      path: `/${kind}`,
+      headers: {
+        Authorization: `Bearer ${ctx.sendToken}`,
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload),
+      },
+    }, (res) => {
+      let out = "";
+      res.on("data", (c) => { out += c; });
+      res.on("end", () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try { resolve(JSON.parse(out)); }
+          catch (e) { resolve({ ok: true }); }
+        } else {
+          let msg = `loopback ${res.statusCode}: ${out}`;
+          try {
+            const parsed = JSON.parse(out);
+            if (parsed && parsed.error) msg = `loopback ${res.statusCode}: ${parsed.error}`;
+          } catch (e) {}
+          reject(new Error(msg));
+        }
+      });
+    });
+    req.on("error", (e) => reject(new Error(`loopback request failed: ${e.message}`)));
+    req.write(payload);
+    req.end();
+  });
+}
+
+module.exports = { context, requireContext, postJson, readLoopbackInfo };

package/bin/schedule.js

@@ -0,0 +1,118 @@
+// open-claudia schedule-wakeup / cron-add / cron-list / cron-remove
+// CLI surface for the agent to manage its own background work.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Background scheduling — manage wakeups and crons.
+
+Wakeups (one-shot, resumes the same conversation):
+  open-claudia schedule-wakeup <when> "<prompt>" [--label "<label>"]
+    <when>: duration (e.g. 30s, 5m, 2h, 1d) OR an ISO datetime (e.g. 2026-05-16T15:00:00Z)
+
+Crons (recurring):
+  open-claudia cron-add "<5-field cron>" "<prompt>" [--label "<label>"] [--project <name>]
+  open-claudia cron-list                         # all wakeups + crons for this channel
+  open-claudia cron-remove <id>                  # remove by id from cron-list
+
+Each fire wakes the agent up in the same channel and resumes the Claude session
+that was active when the schedule was created (so context carries over).
+`;
+
+const DUR = /^(\d+)\s*(s|sec|secs|m|min|mins|h|hr|hrs|d|day|days)$/i;
+
+function parseWhen(s) {
+  if (!s) return null;
+  const m = String(s).trim().match(DUR);
+  if (m) {
+    const n = parseInt(m[1], 10);
+    const unit = m[2].toLowerCase();
+    const ms = unit.startsWith("s") ? n * 1000
+      : unit.startsWith("m") ? n * 60 * 1000
+      : unit.startsWith("h") ? n * 60 * 60 * 1000
+      : n * 24 * 60 * 60 * 1000;
+    return Date.now() + ms;
+  }
+  const ts = Date.parse(String(s));
+  if (Number.isFinite(ts)) return ts;
+  return null;
+}
+
+function takeFlag(args, name) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx < 0) return null;
+  const v = args[idx + 1];
+  args.splice(idx, 2);
+  return v;
+}
+
+function fmtJob(j) {
+  const when = j.kind === "wakeup"
+    ? `fires ${new Date(j.fireAt).toISOString()}`
+    : `schedule "${j.schedule}"`;
+  const proj = j.project ? ` [${j.project}]` : "";
+  const src = j.source ? ` (${j.source})` : "";
+  return `${j.id}  ${j.kind}  ${j.label || "(no label)"}${proj}${src}  ${when}`;
+}
+
+async function runScheduleWakeup(args) {
+  if (args.length < 2 || args[0] === "--help") { console.log(HELP); process.exit(args[0] === "--help" ? 0 : 2); }
+  const rest = args.slice();
+  const label = takeFlag(rest, "label");
+  const project = takeFlag(rest, "project");
+  const when = parseWhen(rest[0]);
+  if (!when) {
+    console.error(`Could not parse <when>: "${rest[0]}". Use a duration (5m, 2h, 1d) or ISO datetime.`);
+    process.exit(2);
+  }
+  const prompt = rest.slice(1).join(" ");
+  if (!prompt) { console.error("Missing prompt."); process.exit(2); }
+  try {
+    const res = await postJson("schedule-wakeup", { fireAt: when, prompt, label: label || prompt.slice(0, 60), project });
+    console.log(`Scheduled wakeup ${res.job.id} for ${new Date(when).toISOString()}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runCronAdd(args) {
+  if (args.length < 2 || args[0] === "--help") { console.log(HELP); process.exit(args[0] === "--help" ? 0 : 2); }
+  const rest = args.slice();
+  const label = takeFlag(rest, "label");
+  const project = takeFlag(rest, "project");
+  const schedule = rest[0];
+  const prompt = rest.slice(1).join(" ");
+  if (!schedule || !prompt) { console.error("Usage: cron-add \"<schedule>\" \"<prompt>\""); process.exit(2); }
+  try {
+    const res = await postJson("cron-add", { schedule, prompt, label: label || prompt.slice(0, 60), project });
+    console.log(`Added cron ${res.job.id} (${schedule}).`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runCronList() {
+  try {
+    const res = await postJson("job-list", {});
+    const list = res.jobs || [];
+    if (list.length === 0) { console.log("No jobs."); process.exit(0); }
+    for (const j of list) console.log(fmtJob(j));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runCronRemove(args) {
+  const id = args[0];
+  if (!id) { console.error("Usage: cron-remove <id>"); process.exit(2); }
+  try {
+    const res = await postJson("cron-remove", { id });
+    console.log(res.ok ? `Removed ${id}.` : `Not found: ${id}.`);
+    process.exit(res.ok ? 0 : 1);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+module.exports = {
+  HELP,
+  runScheduleWakeup,
+  runCronAdd,
+  runCronList,
+  runCronRemove,
+};

package/bin/task.js

@@ -0,0 +1,93 @@
+// open-claudia task <subcommand>
+// Per-channel todo list. Use this for multi-step work so progress
+// survives compactions and restarts.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Per-channel todo list.
+
+  open-claudia task add "<content>"
+  open-claudia task list [--status pending|in_progress|completed]
+  open-claudia task start <id>
+  open-claudia task done <id>
+  open-claudia task remove <id>
+  open-claudia task clear-completed
+`;
+
+function fmt(t, idx) {
+  const mark = t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+  return `${idx + 1}. ${mark} ${t.content}    (${t.id})`;
+}
+
+async function runAdd(args) {
+  const content = args.join(" ").trim();
+  if (!content) { console.error("Usage: task add \"<content>\""); process.exit(2); }
+  try {
+    const res = await postJson("task-add", { content });
+    console.log(`Added task ${res.task.id}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runList(args) {
+  const status = args[args.indexOf("--status") + 1] && args.includes("--status") ? args[args.indexOf("--status") + 1] : null;
+  try {
+    const res = await postJson("task-list", status ? { status } : {});
+    const list = res.tasks || [];
+    if (list.length === 0) { console.log("No tasks."); process.exit(0); }
+    list.forEach((t, i) => console.log(fmt(t, i)));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runUpdate(args, status) {
+  const id = args[0];
+  if (!id) { console.error(`Usage: task ${status === "in_progress" ? "start" : "done"} <id>`); process.exit(2); }
+  try {
+    const res = await postJson("task-update", { id, status });
+    if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
+    console.log(`Task ${id} → ${status}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runRemove(args) {
+  const id = args[0];
+  if (!id) { console.error("Usage: task remove <id>"); process.exit(2); }
+  try {
+    const res = await postJson("task-remove", { id });
+    if (!res.ok) { console.error(`Not found: ${id}`); process.exit(1); }
+    console.log(`Removed ${id}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runClearCompleted() {
+  try {
+    await postJson("task-clear-completed", {});
+    console.log("Cleared completed tasks.");
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function run(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  if (!sub || sub === "--help" || sub === "help") { console.log(HELP); process.exit(sub ? 0 : 2); }
+  switch (sub) {
+    case "add": return runAdd(rest);
+    case "list": case "ls": return runList(rest);
+    case "start": return runUpdate(rest, "in_progress");
+    case "done": case "complete": return runUpdate(rest, "completed");
+    case "pending": return runUpdate(rest, "pending");
+    case "remove": case "rm": return runRemove(rest);
+    case "clear-completed": case "clear": return runClearCompleted();
+    default:
+      console.error(`Unknown task subcommand: ${sub}`);
+      console.log(HELP);
+      process.exit(2);
+  }
+}
+
+module.exports = { run, HELP };

package/bin/transcript-window.js

@@ -0,0 +1,202 @@
+// Search the project transcript JSONL for a pattern and print each hit
+// with surrounding turns of context, capped to keep the output bounded.
+//
+// One JSONL line = one user or assistant turn. Output is plain text:
+// match header, separator-delimited context blocks (before, HIT, after).
+//
+// Path resolution:
+//   1. --path <file> flag
+//   2. OC_TRANSCRIPT_PATH env (injected by core/runner.js for bot-spawned tasks)
+//   3. error out — we don't try to guess
+
+const fs = require("fs");
+
+const DEFAULTS = {
+  before: 2,
+  after: 2,
+  maxTurns: 10,
+  maxChars: 1200,
+};
+
+function parseArgs(argv) {
+  const out = {
+    pattern: null,
+    before: DEFAULTS.before,
+    after: DEFAULTS.after,
+    maxTurns: DEFAULTS.maxTurns,
+    maxChars: DEFAULTS.maxChars,
+    regex: false,
+    path: null,
+    json: false,
+    help: false,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") { out.help = true; continue; }
+    if (a === "--regex") { out.regex = true; continue; }
+    if (a === "--json") { out.json = true; continue; }
+    if (a === "--before") { out.before = parseInt(argv[++i], 10); continue; }
+    if (a === "--after") { out.after = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-turns") { out.maxTurns = parseInt(argv[++i], 10); continue; }
+    if (a === "--max-chars") { out.maxChars = parseInt(argv[++i], 10); continue; }
+    if (a === "--path") { out.path = argv[++i]; continue; }
+    if (a.startsWith("--")) {
+      console.error(`Unknown flag: ${a}`);
+      process.exit(2);
+    }
+    if (out.pattern === null) { out.pattern = a; continue; }
+    console.error(`Unexpected argument: ${a}`);
+    process.exit(2);
+  }
+  if (!Number.isFinite(out.before) || out.before < 0) out.before = DEFAULTS.before;
+  if (!Number.isFinite(out.after) || out.after < 0) out.after = DEFAULTS.after;
+  if (!Number.isFinite(out.maxTurns) || out.maxTurns < 1) out.maxTurns = DEFAULTS.maxTurns;
+  if (!Number.isFinite(out.maxChars) || out.maxChars < 100) out.maxChars = DEFAULTS.maxChars;
+  return out;
+}
+
+function printHelp() {
+  console.log(`Usage: open-claudia transcript-window <pattern> [options]
+
+Search the active project transcript and print each hit with surrounding turns.
+
+Options:
+  --before N        Turns of context before each hit (default ${DEFAULTS.before})
+  --after N         Turns of context after each hit (default ${DEFAULTS.after})
+  --max-turns K     Stop after K hits (default ${DEFAULTS.maxTurns})
+  --max-chars C     Cap per-turn text length (default ${DEFAULTS.maxChars})
+  --regex           Treat pattern as a regex (default: literal, case-insensitive)
+  --path <file>     Transcript path (default: OC_TRANSCRIPT_PATH env)
+  --json            Emit JSONL of matched windows instead of pretty text
+
+Exit codes: 0 hits found, 1 no hits, 2 usage error, 3 transcript unreadable.`);
+}
+
+function resolveTranscriptPath(flagPath) {
+  if (flagPath) return flagPath;
+  if (process.env.OC_TRANSCRIPT_PATH) return process.env.OC_TRANSCRIPT_PATH;
+  return null;
+}
+
+function loadTurns(transcriptPath) {
+  const raw = fs.readFileSync(transcriptPath, "utf-8");
+  const turns = [];
+  let lineNo = 0;
+  for (const line of raw.split("\n")) {
+    lineNo++;
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line);
+      turns.push({
+        lineNo,
+        timestamp: obj.timestamp || "",
+        role: obj.role || "",
+        text: typeof obj.text === "string" ? obj.text : "",
+        sessionId: obj.sessionId || "",
+      });
+    } catch (e) {
+      // skip malformed line
+    }
+  }
+  return turns;
+}
+
+function buildMatcher(pattern, regex) {
+  if (regex) {
+    try { return new RegExp(pattern); }
+    catch (e) {
+      console.error(`Invalid regex: ${e.message}`);
+      process.exit(2);
+    }
+  }
+  const lc = pattern.toLowerCase();
+  return { test: (s) => s.toLowerCase().includes(lc) };
+}
+
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars) + `\n[...truncated, ${text.length - maxChars} more chars]`;
+}
+
+function formatTurn(turn, label, maxChars) {
+  return [
+    `--- ${label}  line ${turn.lineNo}  ${turn.timestamp}  ${turn.role} ---`,
+    truncate(turn.text, maxChars),
+  ].join("\n");
+}
+
+function run(argv) {
+  const opts = parseArgs(argv);
+  if (opts.help || !opts.pattern) {
+    printHelp();
+    process.exit(opts.help ? 0 : 2);
+  }
+  const transcriptPath = resolveTranscriptPath(opts.path);
+  if (!transcriptPath) {
+    console.error("No transcript path. Pass --path <file>, or run inside an active bot-spawned task (OC_TRANSCRIPT_PATH).");
+    process.exit(2);
+  }
+  if (!fs.existsSync(transcriptPath)) {
+    console.error(`Transcript not found: ${transcriptPath}`);
+    process.exit(3);
+  }
+
+  let turns;
+  try { turns = loadTurns(transcriptPath); }
+  catch (e) {
+    console.error(`Failed to read transcript: ${e.message}`);
+    process.exit(3);
+  }
+
+  const matcher = buildMatcher(opts.pattern, opts.regex);
+  const hits = [];
+  for (let i = 0; i < turns.length; i++) {
+    if (matcher.test(turns[i].text)) {
+      hits.push(i);
+      if (hits.length >= opts.maxTurns) break;
+    }
+  }
+
+  if (hits.length === 0) {
+    console.error(`No matches for ${JSON.stringify(opts.pattern)} in ${transcriptPath}`);
+    process.exit(1);
+  }
+
+  if (opts.json) {
+    for (let h = 0; h < hits.length; h++) {
+      const idx = hits[h];
+      const window = [];
+      for (let j = Math.max(0, idx - opts.before); j <= Math.min(turns.length - 1, idx + opts.after); j++) {
+        window.push({ ...turns[j], offset: j - idx });
+      }
+      process.stdout.write(JSON.stringify({ matchIndex: h + 1, matchLine: turns[idx].lineNo, window }) + "\n");
+    }
+    process.exit(0);
+  }
+
+  console.log(`Transcript: ${transcriptPath}`);
+  console.log(`Pattern: ${JSON.stringify(opts.pattern)}${opts.regex ? " (regex)" : ""}`);
+  console.log(`Hits: ${hits.length}  Window: -${opts.before}/+${opts.after} turns  Per-turn cap: ${opts.maxChars} chars`);
+  console.log("");
+
+  for (let h = 0; h < hits.length; h++) {
+    const idx = hits[h];
+    const start = Math.max(0, idx - opts.before);
+    const end = Math.min(turns.length - 1, idx + opts.after);
+    console.log(`===== match ${h + 1}/${hits.length}  line ${turns[idx].lineNo} =====`);
+    for (let j = start; j <= end; j++) {
+      const offset = j - idx;
+      const label = offset === 0 ? "HIT" : (offset < 0 ? `ctx ${offset}` : `ctx +${offset}`);
+      console.log(formatTurn(turns[j], label, opts.maxChars));
+    }
+    console.log("");
+  }
+
+  process.exit(0);
+}
+
+module.exports = { run, parseArgs, loadTurns };
+
+if (require.main === module) {
+  run(process.argv.slice(2));
+}

package/bot.js

@@ -13,7 +13,7 @@ const { execSync } = require("child_process");
 const { config, BOT_DIR, CONFIG_DIR, SOUL_FILE, VAULT_FILE, CHAT_ID } = require("./core/config");
 const { vault } = require("./core/vault-store");
 const { isOnboarded } = require("./core/onboarding");
-const { initCrons } = require("./core/cron");
+const { initScheduler, stopAll: stopScheduler } = require("./core/scheduler");
 const { onMessage, onAction } = require("./core/router");
 const { publicCommands } = require("./core/commands");
 const registry = require("./core/adapter-registry");
@@ -43,6 +43,7 @@ async function gracefulShutdown(signal) {
     }
   }
   for (const a of adapters) { try { await a.stop(); } catch (e) {} }
+  try { stopScheduler(); } catch (e) {}
   try { loopback.stop(); } catch (e) {}
   try {
     const mediaDir = path.join(CONFIG_DIR, "media");
@@ -159,7 +160,7 @@ setInterval(checkForUpdates, 5 * 60 * 1000);
     }
   } catch (e) {}
 
-  initCrons();
+  initScheduler(adapters);
 
   try {
     const lb = await loopback.start(registry);