@inetafrica/open-claudia 2.0.3 → 2.0.5

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

@@ -239,6 +239,34 @@ switch (command) {
     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
@@ -262,6 +290,14 @@ 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,154 @@
+// open-claudia task <subcommand>
+// Per-channel todo list. Use this for multi-step work so progress
+// survives compactions and restarts. Supports one level of hierarchy:
+// a parent "plan" task can have child subtasks via --parent.
+
+const { postJson } = require("./loopback-client");
+
+const HELP = `
+Per-channel todo list with optional plan/subtask hierarchy.
+
+  open-claudia task add "<content>" [--parent <id>] [--description "<...>"]
+  open-claudia task plan "<title>" "<sub1>" "<sub2>" ... [--description "<...>"]
+  open-claudia task list [--status pending|in_progress|completed]
+  open-claudia task start <id>
+  open-claudia task done <id>
+  open-claudia task remove <id>          # removing a plan removes its subtasks
+  open-claudia task clear-completed      # only clears plans whose subtasks are all done
+
+Use plans for any work with 3+ distinct steps. Mark subtasks in_progress
+as you start them and done as you finish, so a resumed turn or a new
+turn after compaction can pick up where you left off.
+`;
+
+function statusMark(t) {
+  return t.status === "completed" ? "[x]" : t.status === "in_progress" ? "[~]" : "[ ]";
+}
+
+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 renderTree(list) {
+  const byParent = new Map();
+  const roots = [];
+  for (const t of list) {
+    if (t.parentId) {
+      if (!byParent.has(t.parentId)) byParent.set(t.parentId, []);
+      byParent.get(t.parentId).push(t);
+    } else {
+      roots.push(t);
+    }
+  }
+  const lines = [];
+  roots.forEach((root, i) => {
+    lines.push(`${i + 1}. ${statusMark(root)} ${root.content}    (${root.id})`);
+    if (root.description) lines.push(`      ${root.description}`);
+    (byParent.get(root.id) || []).forEach((c) => {
+      lines.push(`    ${statusMark(c)} ${c.content}    (${c.id})`);
+    });
+  });
+  for (const orphan of list) {
+    if (orphan.parentId && !roots.find((r) => r.id === orphan.parentId)) {
+      lines.push(`    ${statusMark(orphan)} ${orphan.content}    (${orphan.id}) [orphan]`);
+    }
+  }
+  return lines.join("\n");
+}
+
+async function runAdd(args) {
+  const parentId = takeFlag(args, "parent");
+  const description = takeFlag(args, "description");
+  const content = args.join(" ").trim();
+  if (!content) { console.error("Usage: task add \"<content>\" [--parent <id>] [--description \"<...>\"]"); process.exit(2); }
+  try {
+    const res = await postJson("task-add", { content, parentId, description });
+    console.log(`Added task ${res.task.id}.`);
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runPlan(args) {
+  const description = takeFlag(args, "description");
+  if (args.length < 2) {
+    console.error("Usage: task plan \"<title>\" \"<sub1>\" \"<sub2>\" ... [--description \"<...>\"]");
+    process.exit(2);
+  }
+  const [title, ...subtasks] = args;
+  try {
+    const res = await postJson("task-plan", { title, subtasks, description });
+    const parent = res.plan.parent;
+    const kids = res.plan.children || [];
+    console.log(`Plan ${parent.id}: ${parent.content}`);
+    kids.forEach((c) => console.log(`  - ${c.content}  (${c.id})`));
+    process.exit(0);
+  } catch (e) { console.error(e.message); process.exit(1); }
+}
+
+async function runList(args) {
+  const status = 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); }
+    console.log(renderTree(list));
+    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); }
+    const extra = (res.removed && res.removed.alsoRemoved) ? ` (and ${res.removed.alsoRemoved} subtask${res.removed.alsoRemoved === 1 ? "" : "s"})` : "";
+    console.log(`Removed ${id}${extra}.`);
+    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 "plan": return runPlan(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/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);

package/core/actions.js

@@ -12,7 +12,8 @@ const { listProjects, projectKeyboard, workspacePath } = require("./projects");
 const { isChatOwner, approveAuthRequest, denyAuthRequest, authRequestLabel } = require("./access");
 const { finishOnboarding } = require("./onboarding");
 const { startSession } = require("./handlers");
-const { activeCrons, loadCrons, saveCrons, scheduleCron } = require("./cron");
+const jobs = require("./jobs");
+const scheduler = require("./scheduler");
 
 async function handleAction(envelope) {
   const adapter = envelope.adapter;
@@ -134,15 +135,25 @@ async function handleAction(envelope) {
     };
     const p = presets[d.slice(3)];
     if (!p) return;
-    const c = { id: `cron_${Date.now()}`, ...p, project: state.currentSession.name };
-    const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
-    await send(`Added: ${c.label} for ${state.currentSession.name}`);
+    scheduler.addJob({
+      kind: "cron",
+      adapter: envelope.adapter.id,
+      adapterType: envelope.adapter.type,
+      channelId: String(envelope.channelId),
+      canonicalUserId: envelope.canonicalUserId,
+      project: state.currentSession.name,
+      prompt: p.prompt,
+      label: p.label,
+      source: "user",
+      schedule: p.schedule,
+    });
+    await send(`Added: ${p.label} for ${state.currentSession.name}`);
     return;
   }
   if (d === "cp:clear") {
-    for (const [, v] of activeCrons) v.task.stop();
-    activeCrons.clear();
-    saveCrons([]);
+    for (const j of jobs.listForChannel(envelope.adapter.id, envelope.channelId)) {
+      if (j.kind === "cron" && j.source === "user") scheduler.removeJob(j.id);
+    }
     await send("All crons cleared.");
     return;
   }

package/core/adapter-registry.js

@@ -8,7 +8,7 @@
 // remember to re-wire everything.
 
 const { loadChannels } = require("./config");
-const { setAdapters } = require("./cron");
+const { setAdapters } = require("./scheduler");
 
 const { TelegramAdapter } = require("../channels/telegram/adapter");
 const { KazeeAdapter } = require("../channels/kazee/adapter");

package/core/config.js

@@ -57,6 +57,8 @@ const WHISPER_MODEL = config.WHISPER_MODEL || "";
 const FFMPEG = config.FFMPEG || "";
 const SOUL_FILE = config.SOUL_FILE || path.join(CONFIG_DIR, "soul.md");
 const CRONS_FILE = config.CRONS_FILE || path.join(CONFIG_DIR, "crons.json");
+const JOBS_FILE = config.JOBS_FILE || path.join(CONFIG_DIR, "jobs.json");
+const TASKS_DIR = config.TASKS_DIR || path.join(CONFIG_DIR, "tasks");
 const VAULT_FILE = config.VAULT_FILE || path.join(CONFIG_DIR, "vault.enc");
 const AUTH_FILE = config.AUTH_FILE || path.join(CONFIG_DIR, "auth.json");
 const IDENTITIES_FILE = config.IDENTITIES_FILE || path.join(CONFIG_DIR, "identities.json");
@@ -76,7 +78,7 @@ if (!CLAUDE_PATH) { console.error("CLAUDE_PATH not set"); process.exit(1); }
 if (!fs.existsSync(WORKSPACE)) {
   try {
     fs.mkdirSync(WORKSPACE, { recursive: true });
-    console.log(`Created workspace: ${WORKSPACE}`);
+    console.error(`Created workspace: ${WORKSPACE}`);
   } catch (e) {
     console.error(`Failed to create workspace: ${e.message}`);
     process.exit(1);
@@ -97,14 +99,14 @@ if (!resolvedCursorPath) {
   try { resolvedCursorPath = execSync("which agent 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
   catch (e) { resolvedCursorPath = null; }
 }
-if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
+if (resolvedCursorPath) console.error(`Cursor Agent CLI: ${resolvedCursorPath}`);
 
 let resolvedCodexPath = CODEX_PATH;
 if (!resolvedCodexPath) {
   try { resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null; }
   catch (e) { resolvedCodexPath = null; }
 }
-if (resolvedCodexPath) console.log(`Codex CLI: ${resolvedCodexPath}`);
+if (resolvedCodexPath) console.error(`Codex CLI: ${resolvedCodexPath}`);
 
 if (!fs.existsSync(TEMP_DIR)) fs.mkdirSync(TEMP_DIR, { recursive: true });
 if (!fs.existsSync(FILES_DIR)) fs.mkdirSync(FILES_DIR, { recursive: true });
@@ -191,7 +193,7 @@ module.exports = {
   TRANSCRIPT_MAX_ENTRY_CHARS,
   TRANSCRIPTS_DIR,
   WHISPER_CLI, WHISPER_MODEL, FFMPEG,
-  SOUL_FILE, CRONS_FILE, VAULT_FILE, AUTH_FILE, IDENTITIES_FILE,
+  SOUL_FILE, CRONS_FILE, JOBS_FILE, TASKS_DIR, VAULT_FILE, AUTH_FILE, IDENTITIES_FILE,
   STATE_FILE, SESSIONS_FILE,
   TEMP_DIR, FILES_DIR,
   MAX_FILE_SIZE, MAX_VOICE_SIZE, MAX_PROCESS_TIMEOUT,

package/core/handlers.js

@@ -14,16 +14,15 @@ const {
 const { register } = require("./commands");
 const { send, deleteMessage } = require("./io");
 const { currentState, resetSettings, resetSessionUsage, saveState, getProjectSessions, getLastProjectSession, recordSession, linkIdentity } = require("./state");
-const { canonicalForChannel, normalizeCanonicalUserId, channelKey, identities } = require("./identity");
+const { canonicalForChannel, canonicalForTelegram, normalizeCanonicalUserId, channelKey, identities } = require("./identity");
 const { isChatAuthorized, isChatOwner, recordPendingAuthRequest, authRequestLabel, hasOwner, bootstrapOwner } = require("./access");
 const { isOnboarded, startOnboarding } = require("./onboarding");
 const { listProjects, findProject, projectKeyboard, workspacePath } = require("./projects");
 const { vault } = require("./vault-store");
 const { redactSensitive } = require("./redact");
 const { runDoctorChecks, formatDoctorReport } = require("./doctor");
-const {
-  loadCrons, saveCrons, scheduleCron, activeCrons,
-} = require("./cron");
+const jobs = require("./jobs");
+const scheduler = require("./scheduler");
 const {
   runClaude, compactActiveSession, getActiveSessionId,
 } = require("./runner");
@@ -897,8 +896,9 @@ register({
   name: "cron", description: "Manage scheduled tasks", args: "[add|remove ...]",
   handler: async (env, { tail }) => {
     if (!authorized(env)) return;
+    const channelJobs = () => jobs.listForChannel(env.adapter.id, env.channelId).filter((j) => j.kind === "cron");
     if (!tail) {
-      const list = loadCrons();
+      const list = channelJobs();
       if (list.length === 0) {
         return send("No crons.\n\nAdd: /cron add \"<schedule>\" <project> \"<prompt>\"\n\nOr pick a preset:", {
           keyboard: { inline_keyboard: [
@@ -907,7 +907,7 @@ register({
           ] },
         });
       }
-      return send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project}`).join("\n") + "\n\nRemove: /cron remove <#>");
+      return send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project || ""}`).join("\n") + "\n\nRemove: /cron remove <#>");
     }
 
     const addMatch = tail.match(/^add\s+"(.+)"\s+(\S+)\s+"(.+)"$/);
@@ -915,19 +915,28 @@ register({
       if (!cronLib.validate(addMatch[1])) return send("Invalid cron schedule.");
       const proj = findProject(addMatch[2]);
       if (!proj || Array.isArray(proj)) return send("Project not found.");
-      const c = { id: `cron_${Date.now()}`, schedule: addMatch[1], project: proj, prompt: addMatch[3], label: addMatch[3].slice(0, 50) };
-      const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
-      return send(`Added: ${c.label} (${c.schedule}) for ${proj}`);
+      scheduler.addJob({
+        kind: "cron",
+        adapter: env.adapter.id,
+        adapterType: env.adapter.type,
+        channelId: String(env.channelId),
+        canonicalUserId: env.canonicalUserId,
+        project: proj,
+        prompt: addMatch[3],
+        label: addMatch[3].slice(0, 50),
+        source: "user",
+        schedule: addMatch[1],
+      });
+      return send(`Added: ${addMatch[3].slice(0, 50)} (${addMatch[1]}) for ${proj}`);
     }
 
     const removeMatch = tail.match(/^remove\s+(\d+)$/);
     if (removeMatch) {
-      const list = loadCrons();
+      const list = channelJobs();
       const idx = parseInt(removeMatch[1], 10) - 1;
       if (idx < 0 || idx >= list.length) return send("Invalid number.");
-      const removed = list.splice(idx, 1)[0]; saveCrons(list);
-      if (activeCrons.has(removed.id)) { activeCrons.get(removed.id).task.stop(); activeCrons.delete(removed.id); }
-      return send(`Removed: ${removed.label}`);
+      const removed = scheduler.removeJob(list[idx].id);
+      return send(`Removed: ${removed ? removed.label : "(unknown)"}`);
     }
 
     send('Usage: /cron | /cron add "<schedule>" <project> "<prompt>" | /cron remove <#>');