cc-claw 0.20.9 → 0.20.11

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.20.9" : (() => {
+    VERSION = true ? "0.20.11" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -2721,15 +2721,16 @@ function toggleShowThinkingUi(chatId) {
 function getSkillSuggestionsEnabled(chatId) {
   const row = getDb().prepare(
     "SELECT value FROM chat_skill_suggestions WHERE chat_id = ?"
-  ).get(chatId);
+  ).get(SKILL_SUGGESTIONS_GLOBAL_KEY);
   return (row?.value ?? 1) === 1;
 }
-function setSkillSuggestionsEnabled(chatId, enabled) {
+function setSkillSuggestionsEnabled(chatIdOrEnabled, enabled) {
+  const value = typeof chatIdOrEnabled === "boolean" ? chatIdOrEnabled : enabled;
   getDb().prepare(`
     INSERT INTO chat_skill_suggestions (chat_id, value)
     VALUES (?, ?)
     ON CONFLICT(chat_id) DO UPDATE SET value = ?
-  `).run(chatId, enabled ? 1 : 0, enabled ? 1 : 0);
+  `).run(SKILL_SUGGESTIONS_GLOBAL_KEY, value ? 1 : 0, value ? 1 : 0);
 }
 function getMode(chatId) {
   const row = getDb().prepare(
@@ -2933,12 +2934,13 @@ function clearChatPaidSlots(chatId) {
 function clearAllPaidSlots() {
   getDb().prepare("DELETE FROM chat_allow_paid_slots").run();
 }
-var pendingEscalations, ESCALATION_TTL_MS, ALL_TOOLS, GLOBAL_SUMMARIZER_SENTINEL, ChatSettingsSnapshot;
+var SKILL_SUGGESTIONS_GLOBAL_KEY, pendingEscalations, ESCALATION_TTL_MS, ALL_TOOLS, GLOBAL_SUMMARIZER_SENTINEL, ChatSettingsSnapshot;
 var init_chat_settings = __esm({
   "src/memory/chat-settings.ts"() {
     "use strict";
     init_store5();
     init_sessions();
+    SKILL_SUGGESTIONS_GLOBAL_KEY = "__global__";
     pendingEscalations = /* @__PURE__ */ new Map();
     ESCALATION_TTL_MS = 5 * 60 * 1e3;
     ALL_TOOLS = ["Read", "Glob", "Grep", "Bash", "Write", "Edit", "WebFetch", "WebSearch", "Agent", "AskUserQuestion"];
@@ -3293,6 +3295,24 @@ var init_summaries = __esm({
 });
 
 // src/memory/jobs.ts
+var jobs_exports = {};
+__export(jobs_exports, {
+  cancelJobById: () => cancelJobById,
+  completeJobRun: () => completeJobRun,
+  getActiveJobs: () => getActiveJobs,
+  getAllJobs: () => getAllJobs,
+  getJobById: () => getJobById,
+  getJobRuns: () => getJobRuns,
+  incrementJobFailures: () => incrementJobFailures,
+  insertJob: () => insertJob,
+  insertJobRun: () => insertJobRun,
+  pruneJobRuns: () => pruneJobRuns,
+  resetJobFailures: () => resetJobFailures,
+  updateJob: () => updateJob,
+  updateJobEnabled: () => updateJobEnabled,
+  updateJobLastRun: () => updateJobLastRun,
+  updateJobNextRun: () => updateJobNextRun
+});
 function insertJob(params) {
   const db3 = getDb();
   const result = db3.prepare(`
@@ -5892,6 +5912,10 @@ async function routeModelForTask(task, preferredModel) {
   if (!server) return void 0;
   return { model: best.model, server, reason: best.reason };
 }
+function getEligibleModelsForTask(task) {
+  const available = getAvailableModels();
+  return filterByTask(available, task).map((m) => m.name);
+}
 function routeModelForTaskSync(task, preferredModel) {
   if (preferredModel) {
     const model2 = getModelByName(preferredModel);
@@ -6128,6 +6152,7 @@ var service_exports = {};
 __export(service_exports, {
   addServer: () => addServer2,
   discoverModels: () => discoverModels,
+  getEligibleModelsForTask: () => getEligibleModelsForTask,
   getLoadedModels: () => getLoadedModels,
   getModelForTask: () => getModelForTask,
   getModelForTaskAsync: () => getModelForTaskAsync,
@@ -6199,8 +6224,8 @@ async function healthCheck(serverName) {
   }
   if (needsCatalogRefresh) {
     try {
-      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter5("ollama");
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter4("ollama");
       if ("refreshModelCatalog" in adapter) {
         adapter.refreshModelCatalog();
       }
@@ -9580,8 +9605,8 @@ async function spawnSubAgent(chatId, opts) {
   if (!runner) throw new Error(`Unknown runner: ${opts.runner}`);
   if (opts.model) {
     try {
-      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter5(opts.runner);
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter4(opts.runner);
       if (adapter.availableModels && !adapter.availableModels[opts.model]) {
         const validModels = Object.keys(adapter.availableModels).join(", ");
         throw new Error(`Unknown model "${opts.model}" for ${opts.runner}. Available: ${validModels}`);
@@ -9962,8 +9987,8 @@ async function handleAgentComplete(agentId, chatId, resultText, usage2, mcpsAdde
     const runner = getRunner(agent.runnerId);
     if (runner) {
       try {
-        const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-        const adapter = getAdapter5(agent.runnerId);
+        const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+        const adapter = getAdapter4(agent.runnerId);
         const model2 = agent.model ?? adapter.defaultModel;
         const pricing = adapter.pricing[model2];
         if (pricing) {
@@ -10712,7 +10737,7 @@ var init_chat = __esm({
         }
         const { askAgent: askAgent3 } = await Promise.resolve().then(() => (init_agent(), agent_exports));
         const { getMode: getMode3, getCwd: getCwd3, getModel: getModel3, addUsage: addUsage3, getBackend: getBackend3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-        const { getAdapterForChat: getAdapterForChat3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+        const { getAdapterForChat: getAdapterForChat2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
         const chatId = body.chatId;
         const backend2 = body.backend;
         const PERM_LEVEL = { plan: 0, safe: 1, yolo: 2 };
@@ -10722,7 +10747,7 @@ var init_chat = __esm({
         const cwd = body.cwd ?? getCwd3(chatId);
         const model2 = body.model ?? getModel3(chatId) ?? (() => {
           try {
-            return getAdapterForChat3(chatId).defaultModel;
+            return getAdapterForChat2(chatId).defaultModel;
           } catch {
             return void 0;
           }
@@ -11358,8 +11383,8 @@ var init_config = __esm({
     handleHeartbeatSet = async (req, res) => {
       try {
         const body = JSON.parse(await readBody(req));
-        const { setHeartbeatConfig: setHeartbeatConfig3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-        setHeartbeatConfig3(body.chatId, body);
+        const { setHeartbeatConfig: setHeartbeatConfig4 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+        setHeartbeatConfig4(body.chatId, body);
         jsonResponse(res, { success: true });
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
@@ -14561,9 +14586,637 @@ var init_propose = __esm({
   }
 });
 
-// src/bootstrap/profile.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync14 } from "fs";
+// src/channels/telegram-throttle.ts
+var telegram_throttle_exports = {};
+__export(telegram_throttle_exports, {
+  TelegramThrottle: () => TelegramThrottle,
+  getThrottleState: () => getThrottleState
+});
+import { GrammyError } from "grammy";
+function getThrottleState() {
+  if (!_activeThrottle) return null;
+  return _activeThrottle.getState();
+}
+function is429(err) {
+  return err instanceof GrammyError && err.error_code === 429;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var PER_CHAT_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, MAX_TOTAL_PAUSE_MS, _activeThrottle, TelegramThrottle;
+var init_telegram_throttle = __esm({
+  "src/channels/telegram-throttle.ts"() {
+    "use strict";
+    init_log();
+    PER_CHAT_INTERVAL_MS = 350;
+    GLOBAL_INTERVAL_MS = 50;
+    MAX_RETRIES2 = 2;
+    RETRY_DELAY_MS = 1e3;
+    MAX_QUEUE_SIZE = 100;
+    MAX_TOTAL_PAUSE_MS = 30 * 60 * 1e3;
+    _activeThrottle = null;
+    TelegramThrottle = class {
+      queue = [];
+      processing = false;
+      lastSendPerChat = /* @__PURE__ */ new Map();
+      lastGlobalSend = 0;
+      // Pause state
+      pausedUntil = 0;
+      pauseStartedAt = 0;
+      chatsPendingNotification = /* @__PURE__ */ new Set();
+      resumeNotifier;
+      constructor() {
+        _activeThrottle = this;
+      }
+      /**
+       * Register a callback that fires when the throttle resumes after a pause.
+       * The callback should send a message directly via bot.api (NOT through the throttle).
+       */
+      setResumeNotifier(fn) {
+        this.resumeNotifier = fn;
+      }
+      /** Enqueue a Telegram API call with automatic pacing and 429 handling. */
+      async send(chatId, label2, fn) {
+        return new Promise((resolve, reject) => {
+          if (this.queue.length >= MAX_QUEUE_SIZE) {
+            const dropped = this.queue.shift();
+            if (dropped) {
+              warn(`[throttle] Queue full (${MAX_QUEUE_SIZE}), dropping oldest: ${dropped.label}`);
+              dropped.reject(new Error("Dropped from send queue (overflow)"));
+            }
+          }
+          this.queue.push({ chatId, label: label2, fn, resolve, reject });
+          this.drain();
+        });
+      }
+      /** Check whether the throttle is currently paused (rate-limited). */
+      isPaused() {
+        return Date.now() < this.pausedUntil;
+      }
+      /** Get structured state for diagnostics / health checks. */
+      getState() {
+        const now = Date.now();
+        const paused = now < this.pausedUntil;
+        return {
+          isPaused: paused,
+          queueDepth: this.queue.length,
+          pausedUntilMs: this.pausedUntil,
+          pauseRemainingSec: paused ? Math.ceil((this.pausedUntil - now) / 1e3) : 0
+        };
+      }
+      // ── Queue processor ─────────────────────────────────────────────────
+      async drain() {
+        if (this.processing) return;
+        this.processing = true;
+        try {
+          while (this.queue.length > 0) {
+            while (this.isPaused()) {
+              if (this.pauseStartedAt > 0 && Date.now() - this.pauseStartedAt > MAX_TOTAL_PAUSE_MS) {
+                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items`);
+                this.flushQueueWithError("Telegram rate limit exceeded max wait time");
+                this.pausedUntil = 0;
+                this.pauseStartedAt = 0;
+                this.chatsPendingNotification.clear();
+                break;
+              }
+              const waitMs = Math.min(this.pausedUntil - Date.now(), 5e3);
+              if (waitMs > 0) await sleep(waitMs);
+            }
+            if (this.queue.length === 0) break;
+            if (this.chatsPendingNotification.size > 0) {
+              await this.sendResumeNotifications();
+            }
+            const item = this.queue[0];
+            const lastChat = this.lastSendPerChat.get(item.chatId) ?? 0;
+            const chatWait = PER_CHAT_INTERVAL_MS - (Date.now() - lastChat);
+            if (chatWait > 0) await sleep(chatWait);
+            const globalWait = GLOBAL_INTERVAL_MS - (Date.now() - this.lastGlobalSend);
+            if (globalWait > 0) await sleep(globalWait);
+            this.queue.shift();
+            try {
+              const result = await this.execWithRetry(item.label, item.fn);
+              this.recordSend(item.chatId);
+              item.resolve(result);
+            } catch (err) {
+              if (is429(err)) {
+                const retrySec = err.parameters?.retry_after ?? 10;
+                this.enterPause(retrySec, item);
+                continue;
+              }
+              item.reject(err);
+            }
+          }
+        } finally {
+          this.processing = false;
+        }
+      }
+      // ── Retry logic (non-429 errors only) ───────────────────────────────
+      async execWithRetry(label2, fn) {
+        for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+          try {
+            return await fn();
+          } catch (err) {
+            if (is429(err)) throw err;
+            if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
+              warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
+              await sleep(RETRY_DELAY_MS);
+              continue;
+            }
+            throw err;
+          }
+        }
+        throw new Error("unreachable");
+      }
+      // ── Pause management ────────────────────────────────────────────────
+      enterPause(retrySec, failedItem) {
+        this.queue.unshift(failedItem);
+        this.pausedUntil = Date.now() + retrySec * 1e3;
+        if (this.pauseStartedAt === 0) this.pauseStartedAt = Date.now();
+        for (const qi of this.queue) {
+          this.chatsPendingNotification.add(qi.chatId);
+        }
+        warn(`[throttle] 429 \u2014 pausing ALL sends for ${retrySec}s (${this.queue.length} items queued)`);
+      }
+      async sendResumeNotifications() {
+        const chats2 = new Set(this.chatsPendingNotification);
+        this.chatsPendingNotification.clear();
+        if (!this.resumeNotifier) return;
+        const pausedSec = this.pauseStartedAt > 0 ? Math.round((Date.now() - this.pauseStartedAt) / 1e3) : 0;
+        this.pauseStartedAt = 0;
+        for (const chatId of chats2) {
+          const queuedForChat = this.queue.filter((q) => q.chatId === chatId).length;
+          if (queuedForChat === 0) continue;
+          try {
+            await this.resumeNotifier(chatId, pausedSec, queuedForChat);
+            this.recordSend(chatId);
+          } catch (err) {
+            if (is429(err)) {
+              const retrySec = err.parameters?.retry_after ?? 10;
+              this.pausedUntil = Date.now() + retrySec * 1e3;
+              if (this.pauseStartedAt === 0) this.pauseStartedAt = Date.now();
+              for (const c of chats2) this.chatsPendingNotification.add(c);
+              warn(`[throttle] Resume notification hit 429, re-pausing for ${retrySec}s`);
+              return;
+            }
+            warn(`[throttle] Resume notification failed for chat ${chatId}: ${err}`);
+          }
+        }
+      }
+      // ── Helpers ─────────────────────────────────────────────────────────
+      recordSend(chatId) {
+        const now = Date.now();
+        this.lastSendPerChat.set(chatId, now);
+        this.lastGlobalSend = now;
+      }
+      flushQueueWithError(message) {
+        while (this.queue.length > 0) {
+          const item = this.queue.shift();
+          item.reject(new Error(message));
+        }
+      }
+    };
+  }
+});
+
+// src/health/checks.ts
+import { existsSync as existsSync14, statSync as statSync6, readFileSync as readFileSync8 } from "fs";
+import { execFileSync, execSync as execSync3 } from "child_process";
+function getRecentErrors() {
+  if (!existsSync14(ERROR_LOG_PATH)) return null;
+  const logContent = readFileSync8(ERROR_LOG_PATH, "utf-8");
+  const allLines = logContent.split("\n").filter(Boolean).slice(-500);
+  const last24h = Date.now() - 864e5;
+  const lines = allLines.filter((line) => {
+    const match = line.match(/^\[(\d{4}-\d{2}-\d{2})\s+([\d:+-]+)/);
+    if (match) return (/* @__PURE__ */ new Date(`${match[1]}T${match[2]}`)).getTime() > last24h;
+    return false;
+  });
+  if (lines.length === 0) return null;
+  const classified = { rate429: [], contentSilence: [], spawnTimeout: [], other: [], total: 0 };
+  for (const line of lines) {
+    if (/429|rate.?limit/i.test(line)) classified.rate429.push(line);
+    else if (/content silence/i.test(line)) classified.contentSilence.push(line);
+    else if (/spawn timeout|timeout after \d+s/i.test(line)) classified.spawnTimeout.push(line);
+    else classified.other.push(line);
+  }
+  classified.total = lines.length;
+  return classified;
+}
+function checkDatabase() {
+  const checks = [];
+  if (existsSync14(DB_PATH)) {
+    const size = statSync6(DB_PATH).size;
+    checks.push({ name: "Database", status: "ok", message: `${(size / 1024).toFixed(0)}KB` });
+  } else {
+    checks.push({ name: "Database", status: "error", message: "Not found", fix: "cc-claw setup" });
+  }
+  return checks;
+}
+function checkDiskSpace() {
+  try {
+    const dfOutput = execSync3("df -k " + DATA_PATH, { encoding: "utf-8" });
+    const lines = dfOutput.trim().split("\n");
+    if (lines.length >= 2) {
+      const parts = lines[1].split(/\s+/);
+      const availKB = parseInt(parts[3], 10);
+      if (availKB < 1e5) {
+        return { name: "Disk space", status: "warning", message: `${(availKB / 1024).toFixed(0)}MB available` };
+      }
+      return { name: "Disk space", status: "ok", message: `${(availKB / 1024 / 1024).toFixed(1)}GB available` };
+    }
+  } catch {
+  }
+  return null;
+}
+function checkErrorLog() {
+  const checks = [];
+  const errors = getRecentErrors();
+  if (!errors) {
+    checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
+    return checks;
+  }
+  if (errors.rate429.length > 10) {
+    checks.push({ name: "Rate limits", status: "error", message: `${errors.rate429.length} rate-limit (429) errors in last 24h` });
+  } else if (errors.rate429.length > 0) {
+    checks.push({ name: "Rate limits", status: "warning", message: `${errors.rate429.length} rate-limit errors in last 24h` });
+  }
+  if (errors.contentSilence.length > 0) {
+    checks.push({ name: "Content silence", status: "warning", message: `${errors.contentSilence.length} silence timeout(s) in last 24h` });
+  }
+  if (errors.spawnTimeout.length > 0) {
+    checks.push({ name: "Spawn timeouts", status: "warning", message: `${errors.spawnTimeout.length} backend timeout(s) in last 24h` });
+  }
+  if (errors.other.length > 0) {
+    checks.push({ name: "Other errors", status: "warning", message: `${errors.other.length} error(s) in last 24h` });
+  }
+  if (checks.length === 0) {
+    checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
+  }
+  return checks;
+}
+function checkBackendCLIs() {
+  const checks = [];
+  const CLI_BINARIES = { claude: "claude", gemini: "gemini", codex: "codex", cursor: "agent" };
+  let installed = 0;
+  for (const [label2, binary] of Object.entries(CLI_BINARIES)) {
+    try {
+      const path = execFileSync("which", [binary], { encoding: "utf-8", timeout: 5e3 }).trim();
+      if (path) {
+        checks.push({ name: `${label2} CLI`, status: "ok", message: path });
+        installed++;
+      }
+    } catch {
+    }
+  }
+  if (installed === 0) {
+    checks.push({ name: "Backend CLIs", status: "error", message: "No backend CLIs found" });
+  }
+  return checks;
+}
+function checkOllamaServers() {
+  try {
+    const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
+    const servers = OllamaStore.listServers();
+    if (servers.length > 0) {
+      const online = servers.filter((s) => s.status === "online");
+      const models = OllamaStore.getAvailableModels();
+      if (online.length === servers.length) {
+        return { name: "Ollama", status: "ok", message: `${online.length} server(s) online, ${models.length} model(s)` };
+      } else if (online.length > 0) {
+        return { name: "Ollama", status: "warning", message: `${online.length}/${servers.length} server(s) online` };
+      }
+      return { name: "Ollama", status: "warning", message: `${servers.length} server(s) configured, all offline`, fix: "ollama serve" };
+    }
+  } catch {
+  }
+  return null;
+}
+function checkBackendLimitsAll() {
+  const checks = [];
+  try {
+    const { getAllBackendIds: getAllBackendIds3 } = (init_backends(), __toCommonJS(backends_exports));
+    const { checkBackendLimits: checkBackendLimits2 } = (init_store5(), __toCommonJS(store_exports5));
+    for (const backend2 of getAllBackendIds3()) {
+      const limitMsg = checkBackendLimits2(backend2);
+      if (limitMsg) {
+        checks.push({ name: `${backend2} limits`, status: "warning", message: limitMsg });
+      }
+    }
+  } catch {
+  }
+  return checks;
+}
+function checkSchedulerHealth() {
+  const checks = [];
+  try {
+    const { getHealthReport: getHealthReport2 } = (init_health2(), __toCommonJS(health_exports2));
+    const report = getHealthReport2();
+    if (report.failingJobs.length > 0) {
+      for (const j of report.failingJobs) {
+        checks.push({
+          name: `Job #${j.id}`,
+          status: report.failingJobs.length > 2 ? "error" : "warning",
+          message: `"${j.description.slice(0, 40)}": ${j.failures} consecutive failures`
+        });
+      }
+    }
+    checks.push({
+      name: "Scheduler",
+      status: report.status === "healthy" ? "ok" : "warning",
+      message: `${report.activeJobs} jobs active, ${report.failingJobs.length} failing`
+    });
+  } catch {
+  }
+  return checks;
+}
+function checkTelegramThrottle() {
+  try {
+    const { getThrottleState: getThrottleState2 } = (init_telegram_throttle(), __toCommonJS(telegram_throttle_exports));
+    const state = getThrottleState2();
+    if (!state) return null;
+    if (state.isPaused) {
+      return {
+        name: "Telegram send queue",
+        status: "error",
+        message: `PAUSED \u2014 rate-limited, ${state.pauseRemainingSec}s remaining, ${state.queueDepth} message(s) queued`
+      };
+    }
+    if (state.queueDepth > 5) {
+      return {
+        name: "Telegram send queue",
+        status: "warning",
+        message: `${state.queueDepth} message(s) queued (pacing)`
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function runAllHealthChecks() {
+  const checks = [];
+  checks.push(...checkDatabase());
+  const disk = checkDiskSpace();
+  if (disk) checks.push(disk);
+  checks.push(...checkErrorLog());
+  const throttle = checkTelegramThrottle();
+  if (throttle) checks.push(throttle);
+  checks.push(...checkBackendLimitsAll());
+  checks.push(...checkSchedulerHealth());
+  const ollama2 = checkOllamaServers();
+  if (ollama2) checks.push(ollama2);
+  const errors = checks.filter((c) => c.status === "error").length;
+  const warnings = checks.filter((c) => c.status === "warning").length;
+  let statusLine;
+  if (errors === 0 && warnings === 0) {
+    statusLine = "\u2705 All systems OK";
+  } else {
+    const parts = [];
+    if (errors > 0) parts.push(`${errors} error(s)`);
+    if (warnings > 0) parts.push(`${warnings} warning(s)`);
+    statusLine = `\u26A0\uFE0F ${parts.join(", ")}`;
+  }
+  return { checks, errors, warnings, statusLine };
+}
+function formatHealthForPrompt(summary) {
+  const lines = [];
+  for (const check of summary.checks) {
+    const icon = check.status === "ok" ? "\u2705" : check.status === "warning" ? "\u26A0\uFE0F" : "\u274C";
+    lines.push(`${icon} ${check.name}: ${check.message}`);
+  }
+  return lines.join("\n");
+}
+var init_checks = __esm({
+  "src/health/checks.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/bootstrap/heartbeat.ts
+var heartbeat_exports = {};
+__export(heartbeat_exports, {
+  HEARTBEAT_JOB_TYPE: () => HEARTBEAT_JOB_TYPE,
+  HEARTBEAT_OK: () => HEARTBEAT_OK,
+  assembleHeartbeatPrompt: () => assembleHeartbeatPrompt,
+  disableHeartbeat: () => disableHeartbeat,
+  enableHeartbeat: () => enableHeartbeat,
+  findHeartbeatJob: () => findHeartbeatJob,
+  formatHeartbeatStatus: () => formatHeartbeatStatus,
+  initHeartbeat: () => initHeartbeat,
+  parseHeartbeatCommand: () => parseHeartbeatCommand,
+  runHeartbeatNow: () => runHeartbeatNow,
+  startAllHeartbeats: () => startAllHeartbeats,
+  startHeartbeatForChat: () => startHeartbeatForChat,
+  stopAllHeartbeats: () => stopAllHeartbeats,
+  stopHeartbeatForChat: () => stopHeartbeatForChat,
+  updateHeartbeatConfig: () => updateHeartbeatConfig
+});
+import { readFileSync as readFileSync9, existsSync as existsSync15 } from "fs";
 import { join as join14 } from "path";
+function findHeartbeatJob() {
+  try {
+    const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
+    const db3 = getDb2();
+    const row = db3.prepare(
+      "SELECT * FROM jobs WHERE job_type = 'heartbeat' AND active = 1 ORDER BY id LIMIT 1"
+    ).get();
+    if (!row) return null;
+    const { getJobById: getJobById3 } = (init_store5(), __toCommonJS(store_exports5));
+    return getJobById3(row.id) ?? null;
+  } catch {
+    return null;
+  }
+}
+function enableHeartbeat(chatId, opts) {
+  const existing = findHeartbeatJob();
+  if (existing) {
+    if (!existing.enabled) {
+      const { resumeJob: resumeJob2 } = (init_cron(), __toCommonJS(cron_exports));
+      resumeJob2(existing.id);
+      log(`[heartbeat] Resumed job #${existing.id}`);
+    }
+    return existing.id;
+  }
+  const { insertJob: insertJob2 } = (init_jobs(), __toCommonJS(jobs_exports));
+  const { startSingleJob: startSingleJob2 } = (init_cron(), __toCommonJS(cron_exports));
+  const intervalMs = opts?.intervalMs ?? DEFAULT_INTERVAL_MS;
+  const job = insertJob2({
+    scheduleType: "every",
+    everyMs: intervalMs,
+    description: DEFAULT_DESCRIPTION,
+    chatId,
+    backend: opts?.backend ?? null,
+    model: opts?.model ?? null,
+    sessionType: "isolated",
+    deliveryMode: "announce",
+    channel: opts?.channel ?? "telegram",
+    target: opts?.target ?? chatId,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+    jobType: HEARTBEAT_JOB_TYPE,
+    timeout: 120
+  });
+  startSingleJob2(job);
+  log(`[heartbeat] Created job #${job.id} (every ${intervalMs / 6e4}min)`);
+  return job.id;
+}
+function disableHeartbeat() {
+  const job = findHeartbeatJob();
+  if (!job) return false;
+  const { pauseJob: pauseJob2 } = (init_cron(), __toCommonJS(cron_exports));
+  pauseJob2(job.id);
+  log(`[heartbeat] Paused job #${job.id}`);
+  return true;
+}
+async function runHeartbeatNow() {
+  const job = findHeartbeatJob();
+  if (!job) return;
+  const { triggerJob: triggerJob2 } = (init_cron(), __toCommonJS(cron_exports));
+  await triggerJob2(job.id);
+}
+function updateHeartbeatConfig(updates) {
+  const job = findHeartbeatJob();
+  if (!job) return false;
+  const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
+  const db3 = getDb2();
+  const sets = [];
+  const values = [];
+  if (updates.intervalMs !== void 0) {
+    sets.push("every_ms = ?");
+    values.push(updates.intervalMs);
+  }
+  if (updates.backend !== void 0) {
+    sets.push("backend = ?");
+    values.push(updates.backend);
+  }
+  if (updates.model !== void 0) {
+    sets.push("model = ?");
+    values.push(updates.model);
+  }
+  if (updates.target !== void 0) {
+    sets.push("target = ?");
+    values.push(updates.target);
+  }
+  if (updates.channel !== void 0) {
+    sets.push("channel = ?");
+    values.push(updates.channel);
+  }
+  if (sets.length === 0) return false;
+  values.push(job.id);
+  db3.prepare(`UPDATE jobs SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  if (job.enabled) {
+    const { stopJobTimer: stopJobTimer2, startSingleJob: startSingleJob2, listJobs: listJobs3 } = (init_cron(), __toCommonJS(cron_exports));
+    const { getJobById: getJobById3 } = (init_store5(), __toCommonJS(store_exports5));
+    stopJobTimer2(job.id);
+    const refreshed = getJobById3(job.id);
+    if (refreshed) startSingleJob2(refreshed);
+  }
+  return true;
+}
+function initHeartbeat(_channelReg) {
+}
+function startAllHeartbeats() {
+}
+function stopAllHeartbeats() {
+}
+function startHeartbeatForChat(chatId) {
+  enableHeartbeat(chatId);
+}
+function stopHeartbeatForChat(_chatId) {
+  disableHeartbeat();
+}
+function assembleHeartbeatPrompt(chatId) {
+  cleanExpiredWatches();
+  const sections = [];
+  sections.push(
+    "You are running a periodic heartbeat check. Review the following system health data and active watches. If nothing needs the user's attention, respond with exactly HEARTBEAT_OK and nothing else. Only alert on genuine issues \u2014 do NOT report that everything is fine."
+  );
+  const healthSummary = runAllHealthChecks();
+  const healthText = formatHealthForPrompt(healthSummary);
+  sections.push(`[System Health Report]
+${healthText}`);
+  const watches = getActiveWatches(chatId);
+  if (watches.length > 0) {
+    const watchLines = watches.map((w, i) => {
+      const expiry = w.expiresAt ? ` (expires: ${w.expiresAt})` : "";
+      return `${i + 1}. ${w.description}${expiry}`;
+    });
+    sections.push(`[Active Watches \u2014 execute these checks using your tools]
+${watchLines.join("\n")}`);
+  }
+  if (existsSync15(HEARTBEAT_MD_PATH)) {
+    try {
+      const custom = readFileSync9(HEARTBEAT_MD_PATH, "utf-8").trim();
+      if (custom) {
+        sections.push(`[Custom checks from HEARTBEAT.md]
+${custom}`);
+      }
+    } catch {
+    }
+  }
+  return sections.join("\n\n");
+}
+function formatHeartbeatStatus(chatId) {
+  const job = findHeartbeatJob();
+  const watches = getActiveWatches(chatId);
+  if (!job) {
+    const lines2 = ["Heartbeat: not configured", "Use /heartbeat on to enable."];
+    if (watches.length > 0) {
+      lines2.push("", `Active watches (${watches.length}):`);
+      for (const w of watches) {
+        const expiry = w.expiresAt ? ` (until ${w.expiresAt})` : "";
+        lines2.push(`  - ${w.description}${expiry}`);
+      }
+    }
+    return lines2.join("\n");
+  }
+  const lines = [
+    `Heartbeat: ${job.enabled ? "ON" : "PAUSED"} (job #${job.id})`,
+    `Interval: ${(job.everyMs ?? DEFAULT_INTERVAL_MS) / 6e4} minutes`,
+    `Last run: ${job.lastRunAt ?? "never"}`,
+    `Next run: ${job.nextRunAt ?? "N/A"}`
+  ];
+  if (job.backend || job.model) {
+    lines.push(`Backend: ${job.backend ?? "default"} | Model: ${job.model ?? "default"}`);
+  }
+  if (job.target && job.target !== chatId) {
+    lines.push(`Delivery: ${job.target}`);
+  }
+  if (job.fallbacks?.length > 0) {
+    lines.push(`Fallbacks: ${job.fallbacks.map((f) => `${f.backend}${f.model ? `:${f.model}` : ""}`).join(", ")}`);
+  }
+  if (watches.length > 0) {
+    lines.push("", `Active watches (${watches.length}):`);
+    for (const w of watches) {
+      const expiry = w.expiresAt ? ` (until ${w.expiresAt})` : "";
+      lines.push(`  - ${w.description}${expiry}`);
+    }
+  }
+  return lines.join("\n");
+}
+function parseHeartbeatCommand(_chatId, args) {
+  const parts = args.trim().toLowerCase().split(/\s+/);
+  return { action: parts[0] ?? "status", value: parts.slice(1).join(" ") };
+}
+var HEARTBEAT_MD_PATH, HEARTBEAT_OK, HEARTBEAT_JOB_TYPE, DEFAULT_INTERVAL_MS, DEFAULT_DESCRIPTION;
+var init_heartbeat2 = __esm({
+  "src/bootstrap/heartbeat.ts"() {
+    "use strict";
+    init_paths();
+    init_store5();
+    init_checks();
+    init_log();
+    HEARTBEAT_MD_PATH = join14(WORKSPACE_PATH, "HEARTBEAT.md");
+    HEARTBEAT_OK = "HEARTBEAT_OK";
+    HEARTBEAT_JOB_TYPE = "heartbeat";
+    DEFAULT_INTERVAL_MS = 30 * 60 * 1e3;
+    DEFAULT_DESCRIPTION = "System heartbeat \u2014 health checks and watch tasks";
+  }
+});
+
+// src/bootstrap/profile.ts
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, existsSync as existsSync16 } from "fs";
+import { join as join15 } from "path";
 function hasActiveProfile(chatId) {
   return activeProfiles.has(chatId);
 }
@@ -14692,8 +15345,8 @@ function extractUserUpdates(text) {
   return { cleanText, updates };
 }
 function appendToUserProfile(key, value) {
-  if (!existsSync14(USER_PATH2)) return;
-  const content = readFileSync8(USER_PATH2, "utf-8");
+  if (!existsSync16(USER_PATH2)) return;
+  const content = readFileSync10(USER_PATH2, "utf-8");
   const line = `- **${key}**: ${value}`;
   if (content.includes(line)) return;
   const updated = content.trimEnd() + `
@@ -14708,7 +15361,7 @@ var init_profile = __esm({
     "use strict";
     init_paths();
     init_log();
-    USER_PATH2 = join14(IDENTITY_PATH, "USER.md");
+    USER_PATH2 = join15(IDENTITY_PATH, "USER.md");
     activeProfiles = /* @__PURE__ */ new Map();
   }
 });
@@ -15745,8 +16398,8 @@ async function handleAdd(chatId, channel, name, host, port) {
   }
   const models = await OllamaService.discoverModels(name);
   try {
-    const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-    const adapter = getAdapter5("ollama");
+    const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const adapter = getAdapter4("ollama");
     if ("refreshModelCatalog" in adapter) {
       adapter.refreshModelCatalog();
     }
@@ -15799,8 +16452,8 @@ async function sendDiscover(chatId, channel, serverName) {
     const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
     const models = await OllamaService.discoverModels(serverName);
     try {
-      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter5("ollama");
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter4("ollama");
       if ("refreshModelCatalog" in adapter) {
         adapter.refreshModelCatalog();
       }
@@ -16005,8 +16658,8 @@ __export(session_log_exports2, {
   startSessionLogCleanupTimer: () => startSessionLogCleanupTimer,
   tailSessionLog: () => tailSessionLog
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync6, createReadStream } from "fs";
-import { join as join15, basename } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync8, appendFileSync, readdirSync as readdirSync9, unlinkSync as unlinkSync6, statSync as statSync7, createReadStream } from "fs";
+import { join as join16, basename } from "path";
 import { createInterface as createInterface6 } from "readline";
 function getRetentionDays() {
   const env = process.env.SESSION_LOG_RETENTION_DAYS;
@@ -16018,15 +16671,15 @@ function getRetentionDays() {
 }
 function cleanupSessionLogs(retentionDays) {
   const days = retentionDays ?? getRetentionDays();
-  if (!existsSync15(SESSION_LOGS_PATH)) return 0;
+  if (!existsSync17(SESSION_LOGS_PATH)) return 0;
   const cutoff = Date.now() - days * 24 * 60 * 60 * 1e3;
   let cleaned = 0;
   try {
     for (const file of readdirSync9(SESSION_LOGS_PATH)) {
       if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
-      const filePath = join15(SESSION_LOGS_PATH, file);
+      const filePath = join16(SESSION_LOGS_PATH, file);
       try {
-        const { mtimeMs } = statSync6(filePath);
+        const { mtimeMs } = statSync7(filePath);
         if (mtimeMs < cutoff) {
           unlinkSync6(filePath);
           cleaned++;
@@ -16050,13 +16703,13 @@ function startSessionLogCleanupTimer() {
   return timer;
 }
 function listSessionLogs() {
-  if (!existsSync15(SESSION_LOGS_PATH)) return [];
+  if (!existsSync17(SESSION_LOGS_PATH)) return [];
   const logs = [];
   for (const file of readdirSync9(SESSION_LOGS_PATH)) {
     if (!file.startsWith("session-") || !file.endsWith(".log")) continue;
-    const filePath = join15(SESSION_LOGS_PATH, file);
+    const filePath = join16(SESSION_LOGS_PATH, file);
     try {
-      const stat3 = statSync6(filePath);
+      const stat3 = statSync7(filePath);
       const match = file.match(/^session-(.+?)-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})\.log$/);
       logs.push({
         filename: file,
@@ -16073,7 +16726,7 @@ function listSessionLogs() {
   return logs;
 }
 async function* tailSessionLog(filePath, lines = 50) {
-  if (!existsSync15(filePath)) {
+  if (!existsSync17(filePath)) {
     yield `File not found: ${filePath}`;
     return;
   }
@@ -16101,12 +16754,12 @@ var init_session_log2 = __esm({
       constructor(chatId, backend2, model2) {
         this.backend = backend2;
         this.model = model2;
-        if (!existsSync15(SESSION_LOGS_PATH)) {
+        if (!existsSync17(SESSION_LOGS_PATH)) {
           mkdirSync8(SESSION_LOGS_PATH, { recursive: true });
         }
         const ts2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
         const sanitizedChatId = chatId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        this.filePath = join15(SESSION_LOGS_PATH, `session-${sanitizedChatId}-${ts2}.log`);
+        this.filePath = join16(SESSION_LOGS_PATH, `session-${sanitizedChatId}-${ts2}.log`);
         const header2 = [
           "\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
           `CC-Claw Agent Session \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}`,
@@ -16508,14 +17161,14 @@ var init_gate = __esm({
 
 // src/voice/stt.ts
 import crypto from "crypto";
-import { execFile as execFile2, execFileSync } from "child_process";
+import { execFile as execFile2, execFileSync as execFileSync2 } from "child_process";
 import { readFile as readFile2, unlink } from "fs/promises";
 import { promisify as promisify2 } from "util";
 function ensureFfmpeg() {
   if (ffmpegAvailable === true) return;
   if (ffmpegAvailable === false) throw new Error("ffmpeg is required for voice replies. Install it: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)");
   try {
-    execFileSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    execFileSync2("ffmpeg", ["-version"], { stdio: "ignore" });
     ffmpegAvailable = true;
   } catch {
     ffmpegAvailable = false;
@@ -16714,9 +17367,9 @@ var init_stt = __esm({
 });
 
 // src/media/image-gen.ts
-import { mkdirSync as mkdirSync9, existsSync as existsSync16, unlink as unlink2, readdir, stat } from "fs";
+import { mkdirSync as mkdirSync9, existsSync as existsSync18, unlink as unlink2, readdir, stat } from "fs";
 import { writeFile } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function generateImage(prompt) {
   const apiKey = process.env.GEMINI_API_KEY;
   if (!apiKey) {
@@ -16763,12 +17416,12 @@ async function generateImage(prompt) {
   if (!imageData) {
     throw new Error(textResponse ?? "Gemini did not generate an image. The prompt may have been filtered.");
   }
-  if (!existsSync16(IMAGE_OUTPUT_DIR)) {
+  if (!existsSync18(IMAGE_OUTPUT_DIR)) {
     mkdirSync9(IMAGE_OUTPUT_DIR, { recursive: true });
   }
   const ext = mimeType.includes("jpeg") || mimeType.includes("jpg") ? "jpg" : "png";
   const filename = `img_${Date.now()}.${ext}`;
-  const filePath = join16(IMAGE_OUTPUT_DIR, filename);
+  const filePath = join17(IMAGE_OUTPUT_DIR, filename);
   const buffer = Buffer.from(imageData, "base64");
   await writeFile(filePath, buffer);
   log(`[image-gen] Saved ${buffer.length} bytes to ${filePath}`);
@@ -16786,7 +17439,7 @@ function cleanupGeneratedImage(filePath) {
 function pruneImageCache() {
   readdir(IMAGE_OUTPUT_DIR, (err, files) => {
     if (err || !files) return;
-    const imageFiles = files.filter((f) => /\.(png|jpg)$/.test(f)).map((f) => join16(IMAGE_OUTPUT_DIR, f));
+    const imageFiles = files.filter((f) => /\.(png|jpg)$/.test(f)).map((f) => join17(IMAGE_OUTPUT_DIR, f));
     if (imageFiles.length === 0) return;
     const now = Date.now();
     let statsPending = imageFiles.length;
@@ -16818,8 +17471,8 @@ var init_image_gen = __esm({
     MAX_GENERATED_IMAGES = 20;
     IMAGE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
     IMAGE_MODEL = "gemini-3.1-flash-image-preview";
-    IMAGE_OUTPUT_DIR = join16(
-      process.env.CC_CLAW_HOME ?? join16(process.env.HOME ?? "/tmp", ".cc-claw"),
+    IMAGE_OUTPUT_DIR = join17(
+      process.env.CC_CLAW_HOME ?? join17(process.env.HOME ?? "/tmp", ".cc-claw"),
       "data",
       "images"
     );
@@ -17276,7 +17929,7 @@ var init_video = __esm({
 });
 
 // src/router/media.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 import { mkdir, writeFile as writeFile2, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
 function getMediaRetentionMs() {
   const hours = parseInt(process.env.MEDIA_RETENTION_HOURS ?? "24", 10);
@@ -17285,7 +17938,7 @@ function getMediaRetentionMs() {
 async function saveMedia(buffer, prefix, ext) {
   await mkdir(MEDIA_INCOMING_PATH, { recursive: true });
   const filename = `${prefix}-${Date.now()}.${ext}`;
-  const fullPath = join17(MEDIA_INCOMING_PATH, filename);
+  const fullPath = join18(MEDIA_INCOMING_PATH, filename);
   await writeFile2(fullPath, buffer);
   return fullPath;
 }
@@ -17299,7 +17952,7 @@ async function cleanupOldMedia() {
     let removed = 0;
     for (const file of files) {
       try {
-        const filePath = join17(MEDIA_INCOMING_PATH, file);
+        const filePath = join18(MEDIA_INCOMING_PATH, file);
         const s = await stat2(filePath);
         if (now - s.mtimeMs > retentionMs) {
           await unlink3(filePath);
@@ -17535,7 +18188,7 @@ var init_media = __esm({
     init_helpers();
     init_response();
     init_live_status();
-    MEDIA_INCOMING_PATH = join17(MEDIA_PATH, "incoming");
+    MEDIA_INCOMING_PATH = join18(MEDIA_PATH, "incoming");
   }
 });
 
@@ -17848,9 +18501,9 @@ __export(install_exports, {
   installSkillFromGitHub: () => installSkillFromGitHub
 });
 import { mkdir as mkdir2, readdir as readdir3, readFile as readFile4, cp } from "fs/promises";
-import { existsSync as existsSync17 } from "fs";
-import { join as join18, basename as basename2 } from "path";
-import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync19 } from "fs";
+import { join as join19, basename as basename2 } from "path";
+import { execSync as execSync4 } from "child_process";
 async function installSkillFromGitHub(urlOrShorthand) {
   let repoUrl;
   let subPath;
@@ -17860,36 +18513,36 @@ async function installSkillFromGitHub(urlOrShorthand) {
   }
   repoUrl = parsed.cloneUrl;
   subPath = parsed.subPath;
-  const tmpDir = join18("/tmp", `cc-claw-skill-${Date.now()}`);
+  const tmpDir = join19("/tmp", `cc-claw-skill-${Date.now()}`);
   try {
     log(`[skill-install] Cloning ${repoUrl} to ${tmpDir}`);
-    execSync3(`git clone --depth 1 ${repoUrl} ${tmpDir}`, {
+    execSync4(`git clone --depth 1 ${repoUrl} ${tmpDir}`, {
       stdio: "pipe",
       timeout: 3e4
     });
-    if (!existsSync17(join18(tmpDir, ".git"))) {
+    if (!existsSync19(join19(tmpDir, ".git"))) {
       return { success: false, error: "Git clone failed: no .git directory produced" };
     }
-    const searchRoot = subPath ? join18(tmpDir, subPath) : tmpDir;
+    const searchRoot = subPath ? join19(tmpDir, subPath) : tmpDir;
     const skillDir = await findSkillDir(searchRoot);
     if (!skillDir) {
       return { success: false, error: "No SKILL.md found in the repository." };
     }
     const skillFolderName = basename2(skillDir);
-    const destDir = join18(SKILLS_PATH, skillFolderName);
-    if (existsSync17(destDir)) {
+    const destDir = join19(SKILLS_PATH, skillFolderName);
+    if (existsSync19(destDir)) {
       log(`[skill-install] Overwriting existing skill at ${destDir}`);
     }
     await mkdir2(destDir, { recursive: true });
     await cp(skillDir, destDir, { recursive: true });
     let skillName = skillFolderName;
     try {
-      const content = await readFile4(join18(destDir, "SKILL.md"), "utf-8");
+      const content = await readFile4(join19(destDir, "SKILL.md"), "utf-8");
       const nameMatch = content.match(/^name:\s*(.+)$/m);
       if (nameMatch) skillName = nameMatch[1].trim().replace(/^["']|["']$/g, "");
     } catch {
       try {
-        const content = await readFile4(join18(destDir, "skill.md"), "utf-8");
+        const content = await readFile4(join19(destDir, "skill.md"), "utf-8");
         const nameMatch = content.match(/^name:\s*(.+)$/m);
         if (nameMatch) skillName = nameMatch[1].trim().replace(/^["']|["']$/g, "");
       } catch {
@@ -17902,7 +18555,7 @@ async function installSkillFromGitHub(urlOrShorthand) {
     return { success: false, error: errorMessage(err) };
   } finally {
     try {
-      execSync3(`rm -rf ${tmpDir}`, { stdio: "pipe" });
+      execSync4(`rm -rf ${tmpDir}`, { stdio: "pipe" });
     } catch {
     }
   }
@@ -17924,15 +18577,15 @@ function parseGitHubUrl(input) {
 async function findSkillDir(root) {
   const candidates = ["SKILL.md", "skill.md"];
   for (const c of candidates) {
-    if (existsSync17(join18(root, c))) return root;
+    if (existsSync19(join19(root, c))) return root;
   }
   try {
     const entries = await readdir3(root, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       for (const c of candidates) {
-        if (existsSync17(join18(root, entry.name, c))) {
-          return join18(root, entry.name);
+        if (existsSync19(join19(root, entry.name, c))) {
+          return join19(root, entry.name);
         }
       }
     }
@@ -17944,15 +18597,15 @@ async function findSkillDir(root) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       let subEntries;
       try {
-        subEntries = await readdir3(join18(root, entry.name), { withFileTypes: true });
+        subEntries = await readdir3(join19(root, entry.name), { withFileTypes: true });
       } catch {
         continue;
       }
       for (const sub of subEntries) {
         if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
         for (const c of candidates) {
-          if (existsSync17(join18(root, entry.name, sub.name, c))) {
-            return join18(root, entry.name, sub.name);
+          if (existsSync19(join19(root, entry.name, sub.name, c))) {
+            return join19(root, entry.name, sub.name);
           }
         }
       }
@@ -17969,444 +18622,6 @@ var init_install = __esm({
   }
 });
 
-// src/health/checks.ts
-import { existsSync as existsSync18, statSync as statSync7, readFileSync as readFileSync9 } from "fs";
-import { execFileSync as execFileSync2, execSync as execSync4 } from "child_process";
-function getRecentErrors() {
-  if (!existsSync18(ERROR_LOG_PATH)) return null;
-  const logContent = readFileSync9(ERROR_LOG_PATH, "utf-8");
-  const allLines = logContent.split("\n").filter(Boolean).slice(-500);
-  const last24h = Date.now() - 864e5;
-  const lines = allLines.filter((line) => {
-    const match = line.match(/^\[(\d{4}-\d{2}-\d{2})\s+([\d:+-]+)/);
-    if (match) return (/* @__PURE__ */ new Date(`${match[1]}T${match[2]}`)).getTime() > last24h;
-    return false;
-  });
-  if (lines.length === 0) return null;
-  const classified = { rate429: [], contentSilence: [], spawnTimeout: [], other: [], total: 0 };
-  for (const line of lines) {
-    if (/429|rate.?limit/i.test(line)) classified.rate429.push(line);
-    else if (/content silence/i.test(line)) classified.contentSilence.push(line);
-    else if (/spawn timeout|timeout after \d+s/i.test(line)) classified.spawnTimeout.push(line);
-    else classified.other.push(line);
-  }
-  classified.total = lines.length;
-  return classified;
-}
-function checkDatabase() {
-  const checks = [];
-  if (existsSync18(DB_PATH)) {
-    const size = statSync7(DB_PATH).size;
-    checks.push({ name: "Database", status: "ok", message: `${(size / 1024).toFixed(0)}KB` });
-  } else {
-    checks.push({ name: "Database", status: "error", message: "Not found", fix: "cc-claw setup" });
-  }
-  return checks;
-}
-function checkDiskSpace() {
-  try {
-    const dfOutput = execSync4("df -k " + DATA_PATH, { encoding: "utf-8" });
-    const lines = dfOutput.trim().split("\n");
-    if (lines.length >= 2) {
-      const parts = lines[1].split(/\s+/);
-      const availKB = parseInt(parts[3], 10);
-      if (availKB < 1e5) {
-        return { name: "Disk space", status: "warning", message: `${(availKB / 1024).toFixed(0)}MB available` };
-      }
-      return { name: "Disk space", status: "ok", message: `${(availKB / 1024 / 1024).toFixed(1)}GB available` };
-    }
-  } catch {
-  }
-  return null;
-}
-function checkErrorLog() {
-  const checks = [];
-  const errors = getRecentErrors();
-  if (!errors) {
-    checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
-    return checks;
-  }
-  if (errors.rate429.length > 10) {
-    checks.push({ name: "Rate limits", status: "error", message: `${errors.rate429.length} rate-limit (429) errors in last 24h` });
-  } else if (errors.rate429.length > 0) {
-    checks.push({ name: "Rate limits", status: "warning", message: `${errors.rate429.length} rate-limit errors in last 24h` });
-  }
-  if (errors.contentSilence.length > 0) {
-    checks.push({ name: "Content silence", status: "warning", message: `${errors.contentSilence.length} silence timeout(s) in last 24h` });
-  }
-  if (errors.spawnTimeout.length > 0) {
-    checks.push({ name: "Spawn timeouts", status: "warning", message: `${errors.spawnTimeout.length} backend timeout(s) in last 24h` });
-  }
-  if (errors.other.length > 0) {
-    checks.push({ name: "Other errors", status: "warning", message: `${errors.other.length} error(s) in last 24h` });
-  }
-  if (checks.length === 0) {
-    checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
-  }
-  return checks;
-}
-function checkBackendCLIs() {
-  const checks = [];
-  const CLI_BINARIES = { claude: "claude", gemini: "gemini", codex: "codex", cursor: "agent" };
-  let installed = 0;
-  for (const [label2, binary] of Object.entries(CLI_BINARIES)) {
-    try {
-      const path = execFileSync2("which", [binary], { encoding: "utf-8", timeout: 5e3 }).trim();
-      if (path) {
-        checks.push({ name: `${label2} CLI`, status: "ok", message: path });
-        installed++;
-      }
-    } catch {
-    }
-  }
-  if (installed === 0) {
-    checks.push({ name: "Backend CLIs", status: "error", message: "No backend CLIs found" });
-  }
-  return checks;
-}
-function checkOllamaServers() {
-  try {
-    const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
-    const servers = OllamaStore.listServers();
-    if (servers.length > 0) {
-      const online = servers.filter((s) => s.status === "online");
-      const models = OllamaStore.getAvailableModels();
-      if (online.length === servers.length) {
-        return { name: "Ollama", status: "ok", message: `${online.length} server(s) online, ${models.length} model(s)` };
-      } else if (online.length > 0) {
-        return { name: "Ollama", status: "warning", message: `${online.length}/${servers.length} server(s) online` };
-      }
-      return { name: "Ollama", status: "warning", message: `${servers.length} server(s) configured, all offline`, fix: "ollama serve" };
-    }
-  } catch {
-  }
-  return null;
-}
-function checkBackendLimitsAll() {
-  const checks = [];
-  try {
-    const { getAllBackendIds: getAllBackendIds3 } = (init_backends(), __toCommonJS(backends_exports));
-    const { checkBackendLimits: checkBackendLimits2 } = (init_store5(), __toCommonJS(store_exports5));
-    for (const backend2 of getAllBackendIds3()) {
-      const limitMsg = checkBackendLimits2(backend2);
-      if (limitMsg) {
-        checks.push({ name: `${backend2} limits`, status: "warning", message: limitMsg });
-      }
-    }
-  } catch {
-  }
-  return checks;
-}
-function checkSchedulerHealth() {
-  const checks = [];
-  try {
-    const { getHealthReport: getHealthReport2 } = (init_health2(), __toCommonJS(health_exports2));
-    const report = getHealthReport2();
-    if (report.failingJobs.length > 0) {
-      for (const j of report.failingJobs) {
-        checks.push({
-          name: `Job #${j.id}`,
-          status: report.failingJobs.length > 2 ? "error" : "warning",
-          message: `"${j.description.slice(0, 40)}": ${j.failures} consecutive failures`
-        });
-      }
-    }
-    checks.push({
-      name: "Scheduler",
-      status: report.status === "healthy" ? "ok" : "warning",
-      message: `${report.activeJobs} jobs active, ${report.failingJobs.length} failing`
-    });
-  } catch {
-  }
-  return checks;
-}
-function runAllHealthChecks() {
-  const checks = [];
-  checks.push(...checkDatabase());
-  const disk = checkDiskSpace();
-  if (disk) checks.push(disk);
-  checks.push(...checkErrorLog());
-  checks.push(...checkBackendLimitsAll());
-  checks.push(...checkSchedulerHealth());
-  const ollama2 = checkOllamaServers();
-  if (ollama2) checks.push(ollama2);
-  const errors = checks.filter((c) => c.status === "error").length;
-  const warnings = checks.filter((c) => c.status === "warning").length;
-  let statusLine;
-  if (errors === 0 && warnings === 0) {
-    statusLine = "\u2705 All systems OK";
-  } else {
-    const parts = [];
-    if (errors > 0) parts.push(`${errors} error(s)`);
-    if (warnings > 0) parts.push(`${warnings} warning(s)`);
-    statusLine = `\u26A0\uFE0F ${parts.join(", ")}`;
-  }
-  return { checks, errors, warnings, statusLine };
-}
-function formatHealthForPrompt(summary) {
-  const lines = [];
-  for (const check of summary.checks) {
-    const icon = check.status === "ok" ? "\u2705" : check.status === "warning" ? "\u26A0\uFE0F" : "\u274C";
-    lines.push(`${icon} ${check.name}: ${check.message}`);
-  }
-  return lines.join("\n");
-}
-var init_checks = __esm({
-  "src/health/checks.ts"() {
-    "use strict";
-    init_paths();
-  }
-});
-
-// src/bootstrap/heartbeat.ts
-import { readFileSync as readFileSync10, existsSync as existsSync19 } from "fs";
-import { join as join19 } from "path";
-function initHeartbeat(channelReg) {
-  registry2 = channelReg;
-}
-function startHeartbeatForChat(chatId) {
-  stopHeartbeatForChat(chatId);
-  const config2 = getHeartbeatConfig(chatId);
-  if (!config2 || !config2.enabled) return;
-  let running = false;
-  const timer = setInterval(async () => {
-    if (running) {
-      log(`[heartbeat] Skipping tick for ${chatId}: previous heartbeat still running`);
-      return;
-    }
-    running = true;
-    try {
-      await runHeartbeat(chatId, config2);
-    } finally {
-      running = false;
-    }
-  }, config2.intervalMs);
-  activeTimers.set(chatId, timer);
-  const nextBeat = new Date(Date.now() + config2.intervalMs).toISOString();
-  updateHeartbeatTimestamps(chatId, config2.lastBeatAt ?? "", nextBeat);
-  log(`[heartbeat] Started for chat ${chatId} (every ${config2.intervalMs / 6e4}min)`);
-}
-function stopHeartbeatForChat(chatId) {
-  const timer = activeTimers.get(chatId);
-  if (timer) {
-    clearInterval(timer);
-    activeTimers.delete(chatId);
-  }
-}
-function stopAllHeartbeats() {
-  for (const [chatId] of activeTimers) {
-    stopHeartbeatForChat(chatId);
-  }
-}
-function startAllHeartbeats() {
-  try {
-    const db3 = getDb();
-    const allowedIds = (process.env.ALLOWED_CHAT_ID ?? "").split(",").map((s) => s.trim()).filter(Boolean);
-    for (const chatId of allowedIds) {
-      const existing = getHeartbeatConfig(chatId);
-      if (!existing) {
-        setHeartbeatConfig(chatId, { enabled: true });
-        log(`[heartbeat] Enabled by default for chat ${chatId}`);
-      }
-    }
-    const rows = db3.prepare(
-      "SELECT chat_id FROM chat_heartbeat WHERE enabled = 1"
-    ).all();
-    for (const row of rows) {
-      startHeartbeatForChat(row.chat_id);
-    }
-    if (rows.length > 0) {
-      log(`[heartbeat] Started ${rows.length} heartbeat(s)`);
-    }
-  } catch {
-  }
-}
-async function runHeartbeatNow(chatId) {
-  const config2 = getHeartbeatConfig(chatId);
-  if (!config2) return;
-  await runHeartbeat(chatId, config2);
-}
-async function runHeartbeat(chatId, config2) {
-  if (!isWithinActiveHours(config2.activeStart, config2.activeEnd)) {
-    log(`[heartbeat] Skipping for ${chatId}: outside active hours (${config2.activeStart}-${config2.activeEnd})`);
-    return;
-  }
-  cleanExpiredWatches();
-  const prompt = assembleHeartbeatPrompt(chatId);
-  const resolvedBackend = resolveBackendId(chatId, config2);
-  const resolvedModel = config2.model ?? void 0;
-  try {
-    const response = await askAgent(chatId, prompt, {
-      bootstrapTier: "heartbeat",
-      backend: resolvedBackend,
-      model: resolvedModel,
-      timeoutMs: 12e4
-    });
-    if (response.usage) {
-      const heartbeatModel = resolvedModel ?? getModel(chatId) ?? resolvedBackend;
-      addUsage(chatId, response.usage.input, response.usage.output, response.usage.cacheRead, heartbeatModel, void 0, response.usage.contextSize);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const next = new Date(Date.now() + config2.intervalMs).toISOString();
-    updateHeartbeatTimestamps(chatId, now, next);
-    const trimmed = response.text.trim();
-    if (trimmed === HEARTBEAT_OK || trimmed.startsWith(HEARTBEAT_OK)) {
-      log(`[heartbeat] ${chatId}: nothing to report`);
-      return;
-    }
-    await deliverHeartbeatMessage(chatId, config2, response.text);
-  } catch (err) {
-    error(`[heartbeat] Error for ${chatId}: ${errorMessage(err)}`);
-    const fallbacks = parseHeartbeatFallbacks(config2.fallbacks);
-    if (fallbacks.length > 0) {
-      for (const fb of fallbacks) {
-        try {
-          log(`[heartbeat] Trying fallback: ${fb.backend}${fb.model ? `:${fb.model}` : ""}`);
-          const fbResponse = await askAgent(chatId, prompt, {
-            bootstrapTier: "heartbeat",
-            backend: fb.backend,
-            model: fb.model,
-            timeoutMs: 12e4
-          });
-          const now = (/* @__PURE__ */ new Date()).toISOString();
-          const next = new Date(Date.now() + config2.intervalMs).toISOString();
-          updateHeartbeatTimestamps(chatId, now, next);
-          const trimmed = fbResponse.text.trim();
-          if (trimmed === HEARTBEAT_OK || trimmed.startsWith(HEARTBEAT_OK)) {
-            log(`[heartbeat] ${chatId}: nothing to report (via fallback ${fb.backend})`);
-            return;
-          }
-          await deliverHeartbeatMessage(chatId, config2, fbResponse.text);
-          return;
-        } catch (fbErr) {
-          error(`[heartbeat] Fallback ${fb.backend} failed: ${errorMessage(fbErr)}`);
-        }
-      }
-    }
-  }
-}
-async function deliverHeartbeatMessage(chatId, config2, text) {
-  const channelName = config2.channel ?? "telegram";
-  const channel = registry2?.get(channelName);
-  if (!channel) return;
-  const targetChatId = config2.target ?? chatId;
-  if (channelName === "telegram") {
-    const topicMatch = targetChatId.match(/^(.+):topic:(\d+)$/);
-    if (topicMatch) {
-      await channel.sendText(topicMatch[1], text, { threadId: parseInt(topicMatch[2], 10) });
-    } else {
-      await channel.sendText(targetChatId, text);
-    }
-  } else {
-    await channel.sendText(targetChatId, text);
-  }
-}
-function resolveBackendId(chatId, config2) {
-  if (config2.backend) {
-    const available = getAvailableBackendIds();
-    if (available.includes(config2.backend)) {
-      return config2.backend;
-    }
-  }
-  return void 0;
-}
-function isWithinActiveHours(start, end) {
-  try {
-    const now = /* @__PURE__ */ new Date();
-    const [startH, startM] = start.split(":").map(Number);
-    const [endH, endM] = end.split(":").map(Number);
-    const currentMinutes = now.getHours() * 60 + now.getMinutes();
-    const startMinutes = startH * 60 + (startM || 0);
-    const endMinutes = endH * 60 + (endM || 0);
-    if (startMinutes <= endMinutes) {
-      return currentMinutes >= startMinutes && currentMinutes <= endMinutes;
-    }
-    return currentMinutes >= startMinutes || currentMinutes <= endMinutes;
-  } catch {
-    return true;
-  }
-}
-function assembleHeartbeatPrompt(chatId) {
-  const sections = [];
-  sections.push("You are running a periodic heartbeat check. Review the following system health data and active watches. If nothing needs the user's attention, respond with exactly HEARTBEAT_OK and nothing else. Only alert on genuine issues \u2014 do NOT report that everything is fine.");
-  const healthSummary = runAllHealthChecks();
-  const healthText = formatHealthForPrompt(healthSummary);
-  sections.push(`[System Health Report]
-${healthText}`);
-  const watches = getActiveWatches(chatId);
-  if (watches.length > 0) {
-    const watchLines = watches.map((w, i) => {
-      const expiry = w.expiresAt ? ` (expires: ${w.expiresAt})` : "";
-      return `${i + 1}. ${w.description}${expiry}`;
-    });
-    sections.push(`[Active Watches \u2014 execute these checks using your tools]
-${watchLines.join("\n")}`);
-  }
-  if (existsSync19(HEARTBEAT_MD_PATH)) {
-    try {
-      const custom = readFileSync10(HEARTBEAT_MD_PATH, "utf-8").trim();
-      if (custom) {
-        sections.push(`[Custom checks from HEARTBEAT.md]
-${custom}`);
-      }
-    } catch {
-    }
-  }
-  return sections.join("\n\n");
-}
-function formatHeartbeatStatus(chatId) {
-  const config2 = getHeartbeatConfig(chatId);
-  if (!config2) {
-    return "Heartbeat: not configured\nUse /heartbeat on to enable.";
-  }
-  const watches = getActiveWatches(chatId);
-  const lines = [
-    `Heartbeat: ${config2.enabled ? "ON" : "OFF"}`,
-    `Interval: ${config2.intervalMs / 6e4} minutes`,
-    `Active hours: ${config2.activeStart} - ${config2.activeEnd}`,
-    `Last beat: ${config2.lastBeatAt ?? "never"}`,
-    `Next beat: ${config2.nextBeatAt ?? "N/A"}`
-  ];
-  if (config2.backend || config2.model) {
-    lines.push(`Backend: ${config2.backend ?? "default"} | Model: ${config2.model ?? "default"}`);
-  }
-  if (config2.target) {
-    lines.push(`Delivery: ${config2.target}`);
-  }
-  const fallbacks = parseHeartbeatFallbacks(config2.fallbacks);
-  if (fallbacks.length > 0) {
-    lines.push(`Fallbacks: ${fallbacks.map((f) => `${f.backend}${f.model ? `:${f.model}` : ""}`).join(", ")}`);
-  }
-  if (watches.length > 0) {
-    lines.push("", `Active watches (${watches.length}):`);
-    for (const w of watches) {
-      const expiry = w.expiresAt ? ` (until ${w.expiresAt})` : "";
-      lines.push(`  - ${w.description}${expiry}`);
-    }
-  }
-  return lines.join("\n");
-}
-function parseHeartbeatCommand(chatId, args) {
-  const parts = args.trim().toLowerCase().split(/\s+/);
-  return { action: parts[0] ?? "status", value: parts.slice(1).join(" ") };
-}
-var HEARTBEAT_MD_PATH, HEARTBEAT_OK, registry2, activeTimers;
-var init_heartbeat2 = __esm({
-  "src/bootstrap/heartbeat.ts"() {
-    "use strict";
-    init_paths();
-    init_agent();
-    init_store5();
-    init_backends();
-    init_checks();
-    init_log();
-    HEARTBEAT_MD_PATH = join19(WORKSPACE_PATH, "HEARTBEAT.md");
-    HEARTBEAT_OK = "HEARTBEAT_OK";
-    registry2 = null;
-    activeTimers = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/skills/discover.ts
 var discover_exports = {};
 __export(discover_exports, {
@@ -19134,7 +19349,10 @@ async function sendHeartbeatKeyboard(chatId, channel, messageId) {
   }
   if (fallbacks.length > 0) {
     buttons.push([
-      { label: fallbacks.map((f) => capitalize(f.backend)).join(" \u2192 "), data: "hb:noop" },
+      { label: fallbacks.map((f) => {
+        const name = capitalize(f.backend);
+        return f.model ? `${name} (${shortModelName(f.model)})` : name;
+      }).join(" \u2192 "), data: "hb:noop" },
       { label: "Clear All", data: "hb:fb:clear", style: "danger" }
     ]);
   }
@@ -22299,12 +22517,44 @@ async function handleSummarizerCommand(chatId, commandArgs, msg, channel) {
       [{ label: `Off (disable)${isOff ? " \u2713" : ""}`, data: "summarizer:off", ...isOff ? { style: "primary" } : {} }]
     ];
     for (const a of getAvailableAdapters()) {
-      const pinned = current.backend === a.id;
-      buttons.push([{
-        label: `${pinned ? "\u2713 " : ""}${a.displayName}: ${a.summarizerModel}`,
-        data: `summarizer:${a.id}:${a.summarizerModel}`,
-        ...pinned ? { style: "primary" } : {}
-      }]);
+      if (a.id === "ollama") {
+        try {
+          const { OllamaService } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+          const eligible = OllamaService.getEligibleModelsForTask("summarize");
+          for (const modelName of eligible) {
+            const pinned = current.backend === "ollama" && current.model === modelName;
+            buttons.push([{
+              label: `${pinned ? "\u2713 " : ""}Ollama: ${modelName}`,
+              data: `summarizer:ollama:${modelName}`,
+              ...pinned ? { style: "primary" } : {}
+            }]);
+          }
+          if (eligible.length === 0 && a.summarizerModel) {
+            const pinned = current.backend === a.id;
+            buttons.push([{
+              label: `${pinned ? "\u2713 " : ""}${a.displayName}: ${a.summarizerModel}`,
+              data: `summarizer:${a.id}:${a.summarizerModel}`,
+              ...pinned ? { style: "primary" } : {}
+            }]);
+          }
+        } catch {
+          if (a.summarizerModel) {
+            const pinned = current.backend === a.id;
+            buttons.push([{
+              label: `${pinned ? "\u2713 " : ""}${a.displayName}: ${a.summarizerModel}`,
+              data: `summarizer:${a.id}:${a.summarizerModel}`,
+              ...pinned ? { style: "primary" } : {}
+            }]);
+          }
+        }
+      } else {
+        const pinned = current.backend === a.id;
+        buttons.push([{
+          label: `${pinned ? "\u2713 " : ""}${a.displayName}: ${a.summarizerModel}`,
+          data: `summarizer:${a.id}:${a.summarizerModel}`,
+          ...pinned ? { style: "primary" } : {}
+        }]);
+      }
     }
     await channel.sendKeyboard(chatId, `Session summarizer (current: ${currentLabel}):`, buttons);
   } else {
@@ -23272,7 +23522,21 @@ function parseExtractedSkill(llmResponse) {
   let content = llmResponse;
   const fenceMatch = llmResponse.match(/```(?:markdown|md)?\s*\n([\s\S]*?)```/);
   if (fenceMatch) content = fenceMatch[1].trim();
-  const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  let fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    const greedyFence = llmResponse.match(/```(?:markdown|md)?\s*\n([\s\S]*)```/);
+    if (greedyFence) {
+      content = greedyFence[1].trim();
+      fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    }
+  }
+  if (!fmMatch) {
+    fmMatch = llmResponse.match(/---\s*\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+      const fmStart = llmResponse.indexOf(fmMatch[0]);
+      content = llmResponse.slice(fmStart).replace(/```\s*$/, "").trim();
+    }
+  }
   if (!fmMatch) {
     warn("[auto-skill] No frontmatter found in extracted skill");
     return null;
@@ -24024,8 +24288,8 @@ ${rotationNote}`, { parseMode: "html" });
     if (action === "toggle") {
       const backend2 = parts[2];
       const model2 = parts[3];
-      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const toggleAdapter = getAdapter5(backend2);
+      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const toggleAdapter = getAdapter4(backend2);
       const label2 = toggleAdapter.availableModels[model2]?.label ?? model2;
       const { toggleParticipant: toggleParticipant2, buildSelectKeyboard: buildSelectKeyboard2, hasPendingCouncil: hasPendingCouncil2 } = await Promise.resolve().then(() => (init_wizard2(), wizard_exports));
       if (!hasPendingCouncil2(chatId)) {
@@ -24271,54 +24535,38 @@ Salience: ${memory2.salience.toFixed(2)} | Created: ${memory2.created_at.slice(0
     }
     return;
   } else if (data.startsWith("hb:")) {
+    const { enableHeartbeat: enableHeartbeat2, disableHeartbeat: disableHeartbeat2, runHeartbeatNow: triggerHb, updateHeartbeatConfig: updateHeartbeatConfig2, findHeartbeatJob: findHeartbeatJob2 } = await Promise.resolve().then(() => (init_heartbeat2(), heartbeat_exports));
     const rest = data.slice(3);
     if (rest === "on") {
-      setHeartbeatConfig(chatId, { enabled: true });
-      startHeartbeatForChat(chatId);
+      enableHeartbeat2(chatId);
       await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest === "off") {
-      setHeartbeatConfig(chatId, { enabled: false });
-      stopHeartbeatForChat(chatId);
-      await channel.sendText(chatId, "\u26A0\uFE0F Heartbeat disabled. You won't receive proactive health alerts or watch notifications.\nRe-enable with /heartbeat on.", { parseMode: "plain" });
+      disableHeartbeat2();
+      await channel.sendText(chatId, "\u26A0\uFE0F Heartbeat paused. Re-enable with /heartbeat on.", { parseMode: "plain" });
       await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest.startsWith("interval:")) {
       const min = parseInt(rest.slice(9), 10);
       if (isNaN(min) || min < 1) return;
-      const ms = min * 6e4;
-      setHeartbeatConfig(chatId, { intervalMs: ms });
-      stopHeartbeatForChat(chatId);
-      const hbConf = getHeartbeatConfig(chatId);
-      if (hbConf?.enabled) startHeartbeatForChat(chatId);
+      updateHeartbeatConfig2({ intervalMs: min * 6e4 });
       await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest.startsWith("backend:")) {
       const bid = rest.slice(8);
       if (bid === "default") {
-        updateHeartbeatField(chatId, "backend", null);
-        updateHeartbeatField(chatId, "model", null);
+        updateHeartbeatConfig2({ backend: null, model: null });
       } else {
-        updateHeartbeatField(chatId, "backend", bid);
-        updateHeartbeatField(chatId, "model", null);
+        updateHeartbeatConfig2({ backend: bid, model: null });
       }
       await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest.startsWith("model:")) {
       const model2 = rest.slice(6);
-      if (model2 === "default") {
-        updateHeartbeatField(chatId, "model", null);
-      } else {
-        updateHeartbeatField(chatId, "model", model2);
-      }
+      updateHeartbeatConfig2({ model: model2 === "default" ? null : model2 });
       await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest === "thinking") {
-      const config2 = getHeartbeatConfig(chatId);
-      const current = config2?.thinking ?? "off";
-      const cycle = ["off", "low", "medium", "high"];
-      const next = cycle[(cycle.indexOf(current) + 1) % cycle.length];
-      updateHeartbeatField(chatId, "thinking", next === "off" ? null : next);
-      await sendHeartbeatKeyboard(chatId, channel, messageId);
+      await channel.sendText(chatId, "Thinking level for heartbeat: use /editjob to configure.", { parseMode: "plain" });
     } else if (rest === "run") {
       await channel.sendText(chatId, "\u23F3 Running heartbeat check...", { parseMode: "plain" });
       try {
-        await runHeartbeatNow(chatId);
+        await triggerHb();
         await channel.sendText(chatId, "\u2705 Heartbeat check complete.", { parseMode: "plain" });
       } catch (err) {
         await channel.sendText(chatId, `\u274C Heartbeat failed: ${err instanceof Error ? err.message : String(err)}`, { parseMode: "plain" });
@@ -24327,13 +24575,49 @@ Salience: ${memory2.salience.toFixed(2)} | Created: ${memory2.created_at.slice(0
       await channel.sendText(chatId, "Use /watch to manage awareness tasks.\n\nExamples:\n  /watch add Check my email for urgent messages\n  /watch add Check if Ollama is running\n  /watch list\n  /watch remove 1", { parseMode: "plain" });
     } else if (rest.startsWith("fb:add:")) {
       const bid = rest.slice(7);
+      try {
+        const adapter = getAdapter(bid);
+        const models = Object.entries(adapter.availableModels);
+        const rows = [
+          [{ label: `Select model for ${capitalize(bid)} fallback:`, data: "hb:noop" }],
+          [{ label: "Default", data: `hb:fb:pick:${bid}:default`, style: "primary" }]
+        ];
+        if (models.length > 0) {
+          rows.push(models.slice(0, 4).map(([key]) => ({
+            label: shortModelName(key),
+            data: `hb:fb:pick:${bid}:${key}`
+          })));
+        }
+        rows.push([{ label: "\u2190 Back", data: "hb:fb:back" }]);
+        await sendOrEditKeyboard(
+          chatId,
+          channel,
+          messageId,
+          `Pick a model for the ${capitalize(bid)} fallback:`,
+          rows
+        );
+      } catch {
+        const config2 = getHeartbeatConfig(chatId);
+        const current = parseHeartbeatFallbacks(config2?.fallbacks ?? null);
+        if (!current.some((f) => f.backend === bid)) {
+          current.push({ backend: bid });
+          updateHeartbeatField(chatId, "fallbacks", JSON.stringify(current));
+        }
+        await sendHeartbeatKeyboard(chatId, channel, messageId);
+      }
+    } else if (rest.startsWith("fb:pick:")) {
+      const parts = rest.slice(8).split(":");
+      const bid = parts[0];
+      const model2 = parts.slice(1).join(":");
       const config2 = getHeartbeatConfig(chatId);
       const current = parseHeartbeatFallbacks(config2?.fallbacks ?? null);
       if (!current.some((f) => f.backend === bid)) {
-        current.push({ backend: bid });
+        current.push(model2 === "default" ? { backend: bid } : { backend: bid, model: model2 });
         updateHeartbeatField(chatId, "fallbacks", JSON.stringify(current));
       }
       await sendHeartbeatKeyboard(chatId, channel, messageId);
+    } else if (rest === "fb:back") {
+      await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest === "fb:clear") {
       updateHeartbeatField(chatId, "fallbacks", null);
       await sendHeartbeatKeyboard(chatId, channel, messageId);
@@ -24532,7 +24816,6 @@ var init_callbacks = __esm({
     init_discover();
     init_profile();
     init_profile();
-    init_heartbeat2();
     init_store5();
     init_summarize();
     init_inject();
@@ -25709,7 +25992,7 @@ function startSingleJob(job) {
   }
 }
 function stopJobTimer(id) {
-  const timer = activeTimers2.get(id);
+  const timer = activeTimers.get(id);
   if (!timer) return;
   if (timer instanceof Cron) {
     timer.stop();
@@ -25717,7 +26000,7 @@ function stopJobTimer(id) {
     clearTimeout(timer);
     clearInterval(timer);
   }
-  activeTimers2.delete(id);
+  activeTimers.delete(id);
 }
 function cancelJob(id) {
   stopJobTimer(id);
@@ -25764,7 +26047,7 @@ function startCronJob(job) {
       await executeJob(fresh);
     }
   });
-  activeTimers2.set(job.id, cronInstance);
+  activeTimers.set(job.id, cronInstance);
   const nextRun = cronInstance.nextRun();
   if (nextRun) {
     updateJobNextRun(job.id, nextRun.toISOString());
@@ -25785,9 +26068,9 @@ function startOneShot(job) {
       await executeJob(fresh);
     }
     updateJobEnabled(jobId, false);
-    activeTimers2.delete(jobId);
+    activeTimers.delete(jobId);
   }, Math.max(0, delay));
-  activeTimers2.set(job.id, timer);
+  activeTimers.set(job.id, timer);
   updateJobNextRun(job.id, job.atTime);
 }
 function startInterval(job) {
@@ -25800,7 +26083,7 @@ function startInterval(job) {
       updateJobNextRun(jobId, new Date(Date.now() + everyMs).toISOString());
     }
   }, everyMs);
-  activeTimers2.set(job.id, interval);
+  activeTimers.set(job.id, interval);
   updateJobNextRun(job.id, new Date(Date.now() + everyMs).toISOString());
 }
 async function executeJob(job) {
@@ -25811,7 +26094,7 @@ async function executeJob(job) {
     return;
   }
   runningJobs.add(job.id);
-  const timer = activeTimers2.get(job.id);
+  const timer = activeTimers.get(job.id);
   if (timer instanceof Cron) {
     const nextRun = timer.nextRun();
     if (nextRun) updateJobNextRun(job.id, nextRun.toISOString());
@@ -25905,6 +26188,24 @@ async function runWithRetry(job, model2, runId, t0) {
     }
     return { text: formatNightlySummary2(allInsights, totalPending) };
   }
+  if (job.jobType === "heartbeat") {
+    const { assembleHeartbeatPrompt: assembleHeartbeatPrompt2, HEARTBEAT_OK: HEARTBEAT_OK2 } = await Promise.resolve().then(() => (init_heartbeat2(), heartbeat_exports));
+    const hbPrompt = assembleHeartbeatPrompt2(job.chatId);
+    const hbTimeoutMs = job.timeout ? job.timeout * 1e3 : 12e4;
+    const response = await askAgent(chatId, hbPrompt, {
+      bootstrapTier: "heartbeat",
+      backend: resolveJobBackendId(job),
+      model: model2,
+      timeoutMs: hbTimeoutMs
+    });
+    const trimmed = response.text.trim();
+    if (trimmed === HEARTBEAT_OK2 || trimmed.startsWith(HEARTBEAT_OK2)) {
+      log(`[heartbeat] Job #${job.id}: nothing to report`);
+      return { text: "", usage: response.usage };
+    }
+    const cleanText = response.text.replace(/\[REACT:[^\]]*\]/g, "").replace(/\[SEND_FILE:[^\]]*\]/g, "").replace(/\[GENERATE_IMAGE:[^\]]*\]/g, "").replace(/\[HISTORY_SEARCH:[^\]]*\]/g, "").replace(/\[UPDATE_USER:[^\]]*\]/g, "").trim();
+    return { text: cleanText, usage: response.usage };
+  }
   if (job.thinking && job.thinking !== "auto") {
     setThinkingLevel(chatId, job.thinking);
   }
@@ -25998,13 +26299,13 @@ function resolveJobModel(job) {
   }
 }
 function shutdownScheduler() {
-  for (const [id] of activeTimers2) {
+  for (const [id] of activeTimers) {
     stopJobTimer(id);
   }
   stopHealthMonitor2();
   log("[scheduler] Shutdown complete");
 }
-var activeTimers2, runningJobs;
+var activeTimers, runningJobs;
 var init_cron = __esm({
   "src/scheduler/cron.ts"() {
     "use strict";
@@ -26015,7 +26316,7 @@ var init_cron = __esm({
     init_delivery();
     init_retry();
     init_health2();
-    activeTimers2 = /* @__PURE__ */ new Map();
+    activeTimers = /* @__PURE__ */ new Map();
     runningJobs = /* @__PURE__ */ new Set();
   }
 });
@@ -26161,6 +26462,16 @@ var init_wrap_backend = __esm({
         maxConcurrentSessions: 4,
         specialties: ["multi-provider", "code-generation", "analysis", "planning", "debugging"],
         mcpInjection: "config-file"
+      },
+      ollama: {
+        supportsSessionResume: false,
+        supportsMcp: false,
+        // HTTP-based adapter — no CLI MCP injection
+        supportsNdjson: false,
+        supportsPermissionModes: false,
+        maxConcurrentSessions: 8,
+        specialties: ["local-inference", "summarization"],
+        mcpInjection: "add-remove"
       }
     };
   }
@@ -26690,52 +27001,7 @@ ${body.replace(/<[^>]*>/g, "").trim()}</code>
 });
 
 // src/channels/telegram.ts
-import { API_CONSTANTS, Bot, GrammyError, InlineKeyboard, InputFile } from "grammy";
-function tripCircuitBreaker(retrySec) {
-  const until = Date.now() + retrySec * 1e3;
-  if (until > circuitBreakerUntil) {
-    circuitBreakerUntil = until;
-    warn(`[telegram] Circuit breaker tripped \u2014 blocking ALL Telegram API calls for ${retrySec}s`);
-  }
-}
-function isCircuitBreakerActive() {
-  return Date.now() < circuitBreakerUntil;
-}
-function isRateLimitError(err) {
-  return err instanceof GrammyError && err.error_code === 429;
-}
-async function withRetry(label2, fn) {
-  for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
-    if (isCircuitBreakerActive()) {
-      throw new GrammyError(
-        `Circuit breaker active \u2014 skipping ${label2}`,
-        { ok: false, error_code: 429, description: "Rate limited (circuit breaker)" },
-        label2,
-        {}
-      );
-    }
-    try {
-      return await fn();
-    } catch (err) {
-      if (err instanceof GrammyError && err.error_code === 429) {
-        const retrySec = err.parameters?.retry_after ?? FALLBACK_RETRY_SEC;
-        tripCircuitBreaker(retrySec);
-        if (retrySec > GIVE_UP_THRESHOLD_SEC) {
-          warn(`[telegram] 429 on ${label2} \u2014 retry_after ${retrySec}s exceeds threshold, giving up`);
-          throw err;
-        }
-        if (attempt < MAX_RETRIES2) {
-          warn(`[telegram] 429 on ${label2} (attempt ${attempt + 1}/${MAX_RETRIES2}) \u2014 retrying in ${retrySec}s`);
-          await new Promise((r) => setTimeout(r, retrySec * 1e3));
-          continue;
-        }
-        warn(`[telegram] 429 on ${label2} \u2014 exhausted ${MAX_RETRIES2} retries, giving up`);
-      }
-      throw err;
-    }
-  }
-  throw new Error(`withRetry: unreachable`);
-}
+import { API_CONSTANTS, Bot, GrammyError as GrammyError2, InlineKeyboard, InputFile } from "grammy";
 function isFastPathMessage(msg) {
   if (msg.type === "command" && msg.command && FAST_PATH_COMMANDS.has(msg.command)) {
     return true;
@@ -26758,17 +27024,14 @@ function numericChatId(chatId) {
   const raw = chatId.includes(":") ? chatId.split(":").pop() : chatId;
   return parseInt(raw);
 }
-var MAX_RETRIES2, FALLBACK_RETRY_SEC, GIVE_UP_THRESHOLD_SEC, circuitBreakerUntil, FAST_PATH_COMMANDS, TelegramChannel;
+var FAST_PATH_COMMANDS, TelegramChannel;
 var init_telegram2 = __esm({
   "src/channels/telegram.ts"() {
     "use strict";
     init_telegram();
     init_log();
     init_store5();
-    MAX_RETRIES2 = 2;
-    FALLBACK_RETRY_SEC = 3;
-    GIVE_UP_THRESHOLD_SEC = 30;
-    circuitBreakerUntil = 0;
+    init_telegram_throttle();
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat"]);
     TelegramChannel = class {
       name = "telegram";
@@ -26779,6 +27042,7 @@ var init_telegram2 = __esm({
       agentMessageIds = /* @__PURE__ */ new Map();
       // messageId → chatId
       reactionHandlers = [];
+      throttle;
       constructor() {
         const token = process.env.TELEGRAM_BOT_TOKEN;
         if (!token) {
@@ -26794,6 +27058,17 @@ var init_telegram2 = __esm({
         this.primaryChatId = ids[0];
         this.allowedChatIds = new Set(ids);
         this.bot = new Bot(token);
+        this.throttle = new TelegramThrottle();
+        this.throttle.setResumeNotifier(async (chatId, pausedSec, queuedCount) => {
+          try {
+            await this.bot.api.sendMessage(
+              numericChatId(chatId),
+              `\u26A0\uFE0F Rate-limited by Telegram for ${pausedSec}s \u2014 delivering ${queuedCount} pending message(s) now.`
+            );
+          } catch (err) {
+            warn("[telegram] Resume notification failed:", err instanceof Error ? err.message : err);
+          }
+        });
       }
       /** The first ID in ALLOWED_CHAT_ID — used for heartbeat, notifications, etc. */
       getPrimaryChatId() {
@@ -26929,11 +27204,17 @@ var init_telegram2 = __esm({
           }
           const data = ctx.callbackQuery.data;
           const messageId = ctx.callbackQuery.message?.message_id?.toString();
+          const threadId = ctx.callbackQuery.message?.message_thread_id;
           ctx.answerCallbackQuery().catch(() => {
           });
           (async () => {
+            let ch = this;
+            if (threadId) {
+              const { withThread: withThread2 } = await Promise.resolve().then(() => (init_thread_wrapper(), thread_wrapper_exports));
+              ch = withThread2(this, threadId);
+            }
             for (const handler2 of this.callbackHandlers) {
-              await handler2(chatId, data, this, messageId);
+              await handler2(chatId, data, ch, messageId);
             }
           })().catch((err) => {
             error("[telegram] Callback handler error:", err);
@@ -26963,7 +27244,7 @@ var init_telegram2 = __esm({
         });
         this.bot.catch((botError) => {
           const err = botError.error;
-          if (err instanceof GrammyError) {
+          if (err instanceof GrammyError2) {
             error(`[telegram] Grammy error ${err.error_code}: ${err.description}`);
           } else {
             error("[telegram] Unhandled error:", err);
@@ -26983,6 +27264,7 @@ var init_telegram2 = __esm({
         await this.bot.stop();
       }
       async sendTyping(chatId, threadId) {
+        if (this.throttle.isPaused()) return;
         try {
           await this.bot.api.sendChatAction(numericChatId(chatId), "typing", {
             ...threadId ? { message_thread_id: threadId } : {}
@@ -26997,7 +27279,8 @@ var init_telegram2 = __esm({
         if (parseMode === "plain") {
           const plainChunks = splitMessage(sanitizeForTelegram(text));
           for (const chunk of plainChunks) {
-            const sent = await withRetry(
+            const sent = await this.throttle.send(
+              chatId,
               "sendText:plain",
               () => this.bot.api.sendMessage(numericChatId(chatId), chunk, { ...threadOpts, ...replyOpts })
             );
@@ -27009,7 +27292,8 @@ var init_telegram2 = __esm({
         const chunks = splitMessage(formatted);
         for (const chunk of chunks) {
           try {
-            const sent = await withRetry(
+            const sent = await this.throttle.send(
+              chatId,
               "sendText:html",
               () => this.bot.api.sendMessage(numericChatId(chatId), chunk, {
                 parse_mode: "HTML",
@@ -27019,9 +27303,9 @@ var init_telegram2 = __esm({
             );
             this.trackAgentMessage(sent.message_id, chatId);
           } catch (err) {
-            if (isRateLimitError(err)) throw err;
             warn("[telegram] sendText HTML failed, falling back to plain:", err instanceof Error ? err.message : err);
-            const sent = await withRetry(
+            const sent = await this.throttle.send(
+              chatId,
               "sendText:fallback",
               () => this.bot.api.sendMessage(
                 numericChatId(chatId),
@@ -27034,7 +27318,8 @@ var init_telegram2 = __esm({
         }
       }
       async sendVoice(chatId, audioBuffer, fileName, threadId) {
-        await withRetry(
+        await this.throttle.send(
+          chatId,
           "sendVoice",
           () => this.bot.api.sendVoice(
             numericChatId(chatId),
@@ -27044,7 +27329,8 @@ var init_telegram2 = __esm({
         );
       }
       async sendFile(chatId, buffer, fileName, _mimeType, threadId) {
-        await withRetry(
+        await this.throttle.send(
+          chatId,
           "sendFile",
           () => this.bot.api.sendDocument(
             numericChatId(chatId),
@@ -27064,7 +27350,8 @@ var init_telegram2 = __esm({
           const formatted = sanitizeForTelegram(parseMode === "html" ? text : parseMode === "plain" ? text : formatForTelegram(text));
           const threadOpts = threadId ? { message_thread_id: threadId } : {};
           const opts = parseMode === "plain" ? { ...threadOpts } : { parse_mode: "HTML", ...threadOpts };
-          const msg = await withRetry(
+          const msg = await this.throttle.send(
+            chatId,
             "sendTextReturningId",
             () => this.bot.api.sendMessage(numericChatId(chatId), formatted, opts)
           );
@@ -27077,7 +27364,8 @@ var init_telegram2 = __esm({
       async editText(chatId, messageId, text, parseMode) {
         const formatted = sanitizeForTelegram(parseMode === "html" ? text : formatForTelegram(text));
         try {
-          await withRetry(
+          await this.throttle.send(
+            chatId,
             "editText:html",
             () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
               parse_mode: "HTML"
@@ -27085,10 +27373,10 @@ var init_telegram2 = __esm({
           );
           return true;
         } catch (err) {
-          if (isRateLimitError(err)) return false;
           warn("[telegram] editText HTML failed, trying plain fallback:", err instanceof Error ? err.message : err);
           try {
-            await withRetry(
+            await this.throttle.send(
+              chatId,
               "editText:fallback",
               () => this.bot.api.editMessageText(
                 numericChatId(chatId),
@@ -27116,7 +27404,8 @@ var init_telegram2 = __esm({
         }
         const formatted = sanitizeForTelegram(formatForTelegram(text));
         try {
-          await withRetry(
+          await this.throttle.send(
+            chatId,
             "editKeyboard:html",
             () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
               parse_mode: "HTML",
@@ -27125,9 +27414,9 @@ var init_telegram2 = __esm({
           );
           return true;
         } catch (err) {
-          if (isRateLimitError(err)) return false;
           try {
-            await withRetry(
+            await this.throttle.send(
+              chatId,
               "editKeyboard:plain",
               () => this.bot.api.editMessageText(
                 numericChatId(chatId),
@@ -27167,7 +27456,8 @@ var init_telegram2 = __esm({
         const formatted = sanitizeForTelegram(formatForTelegram(safeText));
         const threadOpts = threadId ? { message_thread_id: threadId } : {};
         try {
-          const msg = await withRetry(
+          const msg = await this.throttle.send(
+            chatId,
             "sendKeyboard",
             () => this.bot.api.sendMessage(numericChatId(chatId), formatted, {
               parse_mode: "HTML",
@@ -27177,14 +27467,11 @@ var init_telegram2 = __esm({
           );
           return msg.message_id.toString();
         } catch (err) {
-          if (isRateLimitError(err)) {
-            warn(`[telegram] sendKeyboard rate-limited, skipping all fallbacks`);
-            return void 0;
-          }
           error(`[telegram] sendKeyboard failed (chat=${chatId}, textLen=${text.length}):`, err);
           try {
             const escaped = safeText.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-            const retryMsg = await withRetry(
+            const retryMsg = await this.throttle.send(
+              chatId,
               "sendKeyboard:plain",
               () => this.bot.api.sendMessage(numericChatId(chatId), escaped, {
                 reply_markup: keyboard,
@@ -27193,13 +27480,13 @@ var init_telegram2 = __esm({
             );
             return retryMsg.message_id.toString();
           } catch (plainErr) {
-            if (isRateLimitError(plainErr)) return void 0;
             error(`[telegram] sendKeyboard plain retry also failed:`, plainErr);
           }
           try {
             const plainText = safeText.replace(/<[^>]+>/g, "");
             if (plainText.trim()) {
-              await withRetry(
+              await this.throttle.send(
+                chatId,
                 "sendKeyboard:text-rescue",
                 () => this.bot.api.sendMessage(numericChatId(chatId), plainText, { ...threadOpts })
               );
@@ -27207,7 +27494,8 @@ var init_telegram2 = __esm({
           } catch {
           }
           try {
-            const fallbackMsg = await withRetry(
+            const fallbackMsg = await this.throttle.send(
+              chatId,
               "sendKeyboard:fallback",
               () => this.bot.api.sendMessage(numericChatId(chatId), "\u2B06\uFE0F (see above for details)", {
                 reply_markup: keyboard,
@@ -27541,7 +27829,7 @@ var init_bootstrap = __esm({
 });
 
 // src/memory/migrate-embeddings.ts
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function migrateEmbeddings() {
@@ -27568,7 +27856,7 @@ async function migrateEmbeddings() {
       }
     }
     log(`[migrate-embeddings] Embedded ${memoriesEmbedded} memories so far...`);
-    if (batch.length === BATCH_SIZE) await sleep(BATCH_DELAY_MS);
+    if (batch.length === BATCH_SIZE) await sleep2(BATCH_DELAY_MS);
   }
   while (true) {
     const batch = getSessionSummariesWithoutEmbeddings(BATCH_SIZE);
@@ -27586,7 +27874,7 @@ async function migrateEmbeddings() {
       }
     }
     log(`[migrate-embeddings] Embedded ${sessionsEmbedded} session summaries so far...`);
-    if (batch.length === BATCH_SIZE) await sleep(BATCH_DELAY_MS);
+    if (batch.length === BATCH_SIZE) await sleep2(BATCH_DELAY_MS);
   }
   log(`[migrate-embeddings] Migration complete: ${memoriesEmbedded} memories, ${sessionsEmbedded} session summaries`);
   return { memories: memoriesEmbedded, sessions: sessionsEmbedded };
@@ -28295,11 +28583,11 @@ async function main() {
   } catch {
   }
   try {
-    const { getAdapter: getAdapter5, probeBackendAvailability: probeBackendAvailability2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const { getAdapter: getAdapter4, probeBackendAvailability: probeBackendAvailability2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
     await probeBackendAvailability2();
-    const claude = getAdapter5("claude");
+    const claude = getAdapter4("claude");
     if ("getAuthMode" in claude) claude.getAuthMode();
-    const cursor = getAdapter5("cursor");
+    const cursor = getAdapter4("cursor");
     if ("probeTier" in cursor) cursor.probeTier();
   } catch {
   }
@@ -28319,8 +28607,8 @@ async function main() {
       }
       if (modelCount > 0) {
         try {
-          const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-          const adapter = getAdapter5("ollama");
+          const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+          const adapter = getAdapter4("ollama");
           if ("refreshModelCatalog" in adapter) {
             adapter.refreshModelCatalog();
           }
@@ -29105,7 +29393,7 @@ async function statusCommand(globalOpts, localOpts) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     const chatId = resolveChatId2(globalOpts);
-    const { getAdapterForChat: getAdapterForChat3, getAdapter: getAdapter5, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const { getAdapterForChat: getAdapterForChat2, getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
     let backend2 = null;
     let modelName = "not set";
     let contextMax = 2e5;
@@ -29113,7 +29401,7 @@ async function statusCommand(globalOpts, localOpts) {
       const backendRow = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
       if (backendRow) {
         try {
-          const a = getAdapter5(backendRow.backend);
+          const a = getAdapter4(backendRow.backend);
           backend2 = { id: a.id, displayName: a.displayName };
         } catch {
           backend2 = { id: backendRow.backend, displayName: backendRow.backend };
@@ -29126,7 +29414,7 @@ async function statusCommand(globalOpts, localOpts) {
       if (modelRow) modelName = modelRow.model;
       else if (backend2) {
         try {
-          modelName = getAdapter5(backend2.id).defaultModel;
+          modelName = getAdapter4(backend2.id).defaultModel;
         } catch {
         }
       }
@@ -29593,9 +29881,9 @@ async function sessionLogsList(opts) {
 `));
   console.log(`  ${"Filename".padEnd(55)} ${"Size".padStart(8)}  Chat ID`);
   console.log(`  ${"\u2500".repeat(55)} ${"\u2500".repeat(8)}  ${"\u2500".repeat(15)}`);
-  for (const log4 of logs) {
-    const size = log4.sizeBytes < 1024 ? `${log4.sizeBytes}B` : log4.sizeBytes < 1024 * 1024 ? `${(log4.sizeBytes / 1024).toFixed(1)}K` : `${(log4.sizeBytes / 1024 / 1024).toFixed(1)}M`;
-    console.log(`  ${log4.filename.padEnd(55)} ${size.padStart(8)}  ${log4.chatId}`);
+  for (const log5 of logs) {
+    const size = log5.sizeBytes < 1024 ? `${log5.sizeBytes}B` : log5.sizeBytes < 1024 * 1024 ? `${(log5.sizeBytes / 1024).toFixed(1)}K` : `${(log5.sizeBytes / 1024 / 1024).toFixed(1)}M`;
+    console.log(`  ${log5.filename.padEnd(55)} ${size.padStart(8)}  ${log5.chatId}`);
   }
   console.log(muted(`
   Path: ${SESSION_LOGS_PATH}`));
@@ -30803,7 +31091,7 @@ import { existsSync as existsSync38 } from "fs";
 async function modelList(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
   const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-  const { getAdapter: getAdapter5, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+  const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
   if (existsSync38(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
@@ -30815,7 +31103,7 @@ async function modelList(globalOpts) {
     readDb.close();
   }
   try {
-    const adapter = getAdapter5(backendId);
+    const adapter = getAdapter4(backendId);
     const models = Object.entries(adapter.availableModels).map(([id, info]) => ({
       id,
       label: info.label,
@@ -32139,8 +32427,8 @@ var init_voice = __esm({
 });
 
 // src/cli/commands/heartbeat.ts
-var heartbeat_exports = {};
-__export(heartbeat_exports, {
+var heartbeat_exports2 = {};
+__export(heartbeat_exports2, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
@@ -34587,11 +34875,11 @@ voice.command("set <on|off>").description("Set voice on or off").action(async (v
 });
 var heartbeat = program.command("heartbeat").description("Proactive awareness");
 heartbeat.command("get").description("Show heartbeat status and config").action(async () => {
-  const { heartbeatGet: heartbeatGet2 } = await Promise.resolve().then(() => (init_heartbeat3(), heartbeat_exports));
+  const { heartbeatGet: heartbeatGet2 } = await Promise.resolve().then(() => (init_heartbeat3(), heartbeat_exports2));
   await heartbeatGet2(program.opts());
 });
 heartbeat.command("set <subcommand> [value]").description("Configure heartbeat (on/off/interval/hours/backend/model/thinking/fallbacks)").action(async (subcommand, value) => {
-  const { heartbeatSet: heartbeatSet2 } = await Promise.resolve().then(() => (init_heartbeat3(), heartbeat_exports));
+  const { heartbeatSet: heartbeatSet2 } = await Promise.resolve().then(() => (init_heartbeat3(), heartbeat_exports2));
   await heartbeatSet2(program.opts(), subcommand, value);
 });
 var summarizer = program.command("summarizer").description("Session summarizer config");