cc-claw 0.20.7 → 0.20.9

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.20.7" : (() => {
+    VERSION = true ? "0.20.9" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -1625,6 +1625,30 @@ function initSchema(db3) {
       created_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
   `);
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN backend TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN model TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN fallbacks TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN target TEXT");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN channel TEXT NOT NULL DEFAULT 'telegram'");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE chat_heartbeat ADD COLUMN thinking TEXT");
+  } catch {
+  }
   db3.exec(`
     CREATE TABLE IF NOT EXISTS cwd_bookmarks (
       chatId TEXT NOT NULL,
@@ -3440,36 +3464,89 @@ function getHeartbeatConfig(chatId) {
   return getDb().prepare(
     `SELECT chat_id as chatId, enabled, interval_ms as intervalMs,
       active_start as activeStart, active_end as activeEnd,
-      last_beat_at as lastBeatAt, next_beat_at as nextBeatAt
+      last_beat_at as lastBeatAt, next_beat_at as nextBeatAt,
+      backend, model, fallbacks, target, channel, thinking
      FROM chat_heartbeat WHERE chat_id = ?`
   ).get(chatId);
 }
 function setHeartbeatConfig(chatId, config2) {
   getDb().prepare(`
-    INSERT INTO chat_heartbeat (chat_id, enabled, interval_ms, active_start, active_end)
-    VALUES (?, ?, ?, ?, ?)
-    ON CONFLICT(chat_id) DO UPDATE SET
-      enabled = COALESCE(?, enabled),
-      interval_ms = COALESCE(?, interval_ms),
-      active_start = COALESCE(?, active_start),
-      active_end = COALESCE(?, active_end)
-  `).run(
-    chatId,
-    config2.enabled !== void 0 ? config2.enabled ? 1 : 0 : 0,
-    config2.intervalMs ?? 18e5,
-    config2.activeStart ?? "08:00",
-    config2.activeEnd ?? "22:00",
-    config2.enabled !== void 0 ? config2.enabled ? 1 : 0 : null,
-    config2.intervalMs ?? null,
-    config2.activeStart ?? null,
-    config2.activeEnd ?? null
-  );
+    INSERT OR IGNORE INTO chat_heartbeat (chat_id) VALUES (?)
+  `).run(chatId);
+  const updates = [];
+  const values = [];
+  if (config2.enabled !== void 0) {
+    updates.push("enabled = ?");
+    values.push(config2.enabled ? 1 : 0);
+  }
+  if (config2.intervalMs !== void 0) {
+    updates.push("interval_ms = ?");
+    values.push(config2.intervalMs);
+  }
+  if (config2.activeStart !== void 0) {
+    updates.push("active_start = ?");
+    values.push(config2.activeStart);
+  }
+  if (config2.activeEnd !== void 0) {
+    updates.push("active_end = ?");
+    values.push(config2.activeEnd);
+  }
+  if ("backend" in config2) {
+    updates.push("backend = ?");
+    values.push(config2.backend ?? null);
+  }
+  if ("model" in config2) {
+    updates.push("model = ?");
+    values.push(config2.model ?? null);
+  }
+  if ("fallbacks" in config2) {
+    updates.push("fallbacks = ?");
+    values.push(config2.fallbacks ?? null);
+  }
+  if ("target" in config2) {
+    updates.push("target = ?");
+    values.push(config2.target ?? null);
+  }
+  if (config2.channel !== void 0) {
+    updates.push("channel = ?");
+    values.push(config2.channel);
+  }
+  if ("thinking" in config2) {
+    updates.push("thinking = ?");
+    values.push(config2.thinking ?? null);
+  }
+  if (updates.length > 0) {
+    values.push(chatId);
+    getDb().prepare(
+      `UPDATE chat_heartbeat SET ${updates.join(", ")} WHERE chat_id = ?`
+    ).run(...values);
+  }
+}
+function updateHeartbeatField(chatId, field, value) {
+  const allowedFields = ["backend", "model", "fallbacks", "target", "channel", "thinking", "enabled", "interval_ms", "active_start", "active_end"];
+  if (!allowedFields.includes(field)) throw new Error(`Invalid heartbeat field: ${field}`);
+  getDb().prepare(`
+    INSERT OR IGNORE INTO chat_heartbeat (chat_id) VALUES (?)
+  `).run(chatId);
+  getDb().prepare(
+    `UPDATE chat_heartbeat SET ${field} = ? WHERE chat_id = ?`
+  ).run(value, chatId);
 }
 function updateHeartbeatTimestamps(chatId, lastBeat, nextBeat) {
   getDb().prepare(
     "UPDATE chat_heartbeat SET last_beat_at = ?, next_beat_at = ? WHERE chat_id = ?"
   ).run(lastBeat, nextBeat, chatId);
 }
+function parseHeartbeatFallbacks(fallbacksJson) {
+  if (!fallbacksJson) return [];
+  try {
+    const parsed = JSON.parse(fallbacksJson);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((f) => f && typeof f.backend === "string");
+  } catch {
+    return [];
+  }
+}
 function getActiveWatches(chatId) {
   return getDb().prepare(
     `SELECT id, chat_id as chatId, description, expires_at as expiresAt, created_at as createdAt
@@ -3940,6 +4017,7 @@ __export(store_exports5, {
   markSlotExhausted: () => markSlotExhausted,
   markSlotSuccess: () => markSlotSuccess,
   openDatabaseReadOnly: () => openDatabaseReadOnly,
+  parseHeartbeatFallbacks: () => parseHeartbeatFallbacks,
   pinChatBackendSlot: () => pinChatBackendSlot,
   pinChatGeminiSlot: () => pinChatGeminiSlot,
   pruneJobRuns: () => pruneJobRuns,
@@ -3997,6 +4075,7 @@ __export(store_exports5, {
   toggleShowThinkingUi: () => toggleShowThinkingUi,
   toggleTool: () => toggleTool,
   touchBookmark: () => touchBookmark,
+  updateHeartbeatField: () => updateHeartbeatField,
   updateHeartbeatTimestamps: () => updateHeartbeatTimestamps,
   updateJob: () => updateJob,
   updateJobEnabled: () => updateJobEnabled,
@@ -6120,8 +6199,8 @@ async function healthCheck(serverName) {
   }
   if (needsCatalogRefresh) {
     try {
-      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter4("ollama");
+      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter5("ollama");
       if ("refreshModelCatalog" in adapter) {
         adapter.refreshModelCatalog();
       }
@@ -6867,21 +6946,33 @@ You are an expert user and operator of the CC-Claw architecture. Because you are
 - **Dry Run & Webhooks**: Jobs aren't just for Telegram messages. Using \`--delivery dry_run\`, you can test jobs internally (output is logged to the database but not spammed to chat). You can also route AI output directly to external APIs using \`--delivery webhook\`.
 - **Auditing**: Every cron execution and its output is permanently logged in the database's \`message_log\` for verifiable auditing.
 
-## 5. System Controls & Modes
+## 5. Heartbeat & Watches (Proactive Monitoring)
+- **Heartbeat**: A periodic awareness cycle that checks system health and user-defined watches. Configured via \`/heartbeat\`.
+- **Active Hours**: Heartbeat only fires within configured active hours (default 08:00-22:00).
+- **Smart Suppression**: When nothing needs attention, the AI responds with \`HEARTBEAT_OK\` and no message is delivered to the user.
+- **Delivery Parity**: Like cron jobs, heartbeat supports custom backend, model, fallback chain, thinking level, and delivery target.
+- **Watches**: AI-executable awareness tasks added via \`/watch\`. These are instructions the heartbeat AI will check using its available tools.
+  - \`/watch add Check my email for urgent messages\` \u2014 adds a persistent watch
+  - \`/watch add Monitor Ollama server health for 24h\` \u2014 adds a time-limited watch
+  - \`/watch list\` \u2014 shows all active watches
+  - \`/watch remove <id>\` \u2014 removes a watch
+- **\u26A0\uFE0F HEARTBEAT MANAGEMENT**: Heartbeat and watch configuration MUST be done exclusively through \`/heartbeat\` and \`/watch\` slash commands. NEVER modify the \`chat_heartbeat\` or \`heartbeat_watches\` database tables directly.
+
+## 6. System Controls & Modes
 - **Permission Modes**: Command execution is gated. \`safe\` mode requires user approval for mutations, \`yolo\` auto-runs everything without asking, and \`plan\` is strictly read-only for drafting proposals.
 - **Global Settings**: The user controls your behavior system-wide using commands like \`/response_style\` (concise, normal, detailed) to enforce verbosity constraints, and \`/voice_config\` to select Text-to-Speech voices from premium providers like ElevenLabs, Grok (xAI), or local macOS.
 - **Telegram UX**: Most slash commands use interactive inline keyboards with colored buttons. \`/menu\` (or \`/m\`) is the home screen. \`/usage\` unifies cost, limits, and usage tracking. Inline mode (\`@botname query\`) searches memories from any chat.
 
-## 6. Integrations & MCP
+## 7. Integrations & MCP
 - **Skills**: You can load specific workflows from the \`~/.cc-claw/workspace/skills/\` directory.
 - **Files**: You can send physical files to the user across Telegram by simply writing \`[SEND_FILE:/absolute/path/to/file]\` in your response.
 - **MCP Ecosystem**: You are deeply natively integrated with Model Context Protocol (MCP) servers (like Perplexity, NotebookLM, Context7) granting you immense external reach.
 
-## 7. CLI Reference
+## 8. CLI Reference
 - Run \\\`cc-claw --ai\\\` for a comprehensive command reference covering all CLI and Telegram commands
 - Use \\\`cc-claw --ai --install\\\` to install the skill to all backend skill directories
 
-## 8. CRITICAL RULES \u2014 Memory & State
+## 9. CRITICAL RULES \u2014 Memory & State
 - NEVER use native CLI memory tools (Gemini's save_memory, Claude's memory, etc.) \u2014 they are backend-local
 - NEVER modify the SQLite database directly (no INSERT/UPDATE/DELETE SQL)
 - ALWAYS use CC-Claw slash commands (/remember, /evolve, etc.) or the cc-claw CLI
@@ -9489,8 +9580,8 @@ async function spawnSubAgent(chatId, opts) {
   if (!runner) throw new Error(`Unknown runner: ${opts.runner}`);
   if (opts.model) {
     try {
-      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter4(opts.runner);
+      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter5(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}`);
@@ -9871,8 +9962,8 @@ async function handleAgentComplete(agentId, chatId, resultText, usage2, mcpsAdde
     const runner = getRunner(agent.runnerId);
     if (runner) {
       try {
-        const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-        const adapter = getAdapter4(agent.runnerId);
+        const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+        const adapter = getAdapter5(agent.runnerId);
         const model2 = agent.model ?? adapter.defaultModel;
         const pricing = adapter.pricing[model2];
         if (pricing) {
@@ -10621,7 +10712,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: getAdapterForChat2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+        const { getAdapterForChat: getAdapterForChat3 } = 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 };
@@ -10631,7 +10722,7 @@ var init_chat = __esm({
         const cwd = body.cwd ?? getCwd3(chatId);
         const model2 = body.model ?? getModel3(chatId) ?? (() => {
           try {
-            return getAdapterForChat2(chatId).defaultModel;
+            return getAdapterForChat3(chatId).defaultModel;
           } catch {
             return void 0;
           }
@@ -15654,8 +15745,8 @@ async function handleAdd(chatId, channel, name, host, port) {
   }
   const models = await OllamaService.discoverModels(name);
   try {
-    const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-    const adapter = getAdapter4("ollama");
+    const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const adapter = getAdapter5("ollama");
     if ("refreshModelCatalog" in adapter) {
       adapter.refreshModelCatalog();
     }
@@ -15708,8 +15799,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: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const adapter = getAdapter4("ollama");
+      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter5("ollama");
       if ("refreshModelCatalog" in adapter) {
         adapter.refreshModelCatalog();
       }
@@ -17878,8 +17969,197 @@ 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 readFileSync9, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync19 } from "fs";
 import { join as join19 } from "path";
 function initHeartbeat(channelReg) {
   registry2 = channelReg;
@@ -17921,6 +18201,14 @@ function stopAllHeartbeats() {
 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();
@@ -17933,6 +18221,11 @@ function startAllHeartbeats() {
   } 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})`);
@@ -17940,15 +18233,17 @@ async function runHeartbeat(chatId, config2) {
   }
   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" });
+    const response = await askAgent(chatId, prompt, {
+      bootstrapTier: "heartbeat",
+      backend: resolvedBackend,
+      model: resolvedModel,
+      timeoutMs: 12e4
+    });
     if (response.usage) {
-      let heartbeatModel;
-      try {
-        heartbeatModel = getModel(chatId) ?? getAdapterForChat(chatId).defaultModel;
-      } catch {
-        heartbeatModel = getModel(chatId) ?? "unknown";
-      }
+      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();
@@ -17959,14 +18254,62 @@ async function runHeartbeat(chatId, config2) {
       log(`[heartbeat] ${chatId}: nothing to report`);
       return;
     }
-    const channel = registry2?.get("telegram");
-    if (channel) {
-      await channel.sendText(chatId, response.text);
-    }
+    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();
@@ -17985,55 +18328,25 @@ function isWithinActiveHours(start, end) {
 }
 function assembleHeartbeatPrompt(chatId) {
   const sections = [];
-  sections.push("You are running a periodic heartbeat check. Review the following and decide if anything needs the user's attention. If nothing is noteworthy, respond with exactly HEARTBEAT_OK and nothing else.");
-  const healthLines = [];
-  const report = getHealthReport();
-  if (report.failingJobs.length > 0) {
-    healthLines.push("Scheduler issues:");
-    for (const j of report.failingJobs) {
-      healthLines.push(`  - Job #${j.id} "${j.description}": ${j.failures} consecutive failures`);
-    }
-  }
-  const recentRuns = getJobRuns(void 0, 20);
-  const failedSinceLastBeat = recentRuns.filter((r) => r.status === "failed");
-  if (failedSinceLastBeat.length > 0) {
-    healthLines.push(`${failedSinceLastBeat.length} job run(s) failed recently.`);
-  }
-  for (const backend2 of getAllBackendIds()) {
-    const limitMsg = checkBackendLimits(backend2);
-    if (limitMsg) healthLines.push(limitMsg);
-  }
-  try {
-    const { OllamaService } = (init_ollama(), __toCommonJS(ollama_exports));
-    const servers = OllamaService.listServers();
-    if (servers.length > 0) {
-      const offline = servers.filter((s) => s.status === "offline");
-      if (offline.length > 0) {
-        healthLines.push(`Ollama: ${offline.length}/${servers.length} server(s) offline: ${offline.map((s) => s.name).join(", ")}`);
-      }
-    }
-  } catch {
-  }
-  if (healthLines.length > 0) {
-    sections.push(`[System health]
-${healthLines.join("\n")}`);
-  } else {
-    sections.push("[System health]\nAll systems normal. No failures or limit warnings.");
-  }
+  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) => {
+    const watchLines = watches.map((w, i) => {
       const expiry = w.expiresAt ? ` (expires: ${w.expiresAt})` : "";
-      return `  - ${w.description}${expiry}`;
+      return `${i + 1}. ${w.description}${expiry}`;
     });
-    sections.push(`[Active watches]
+    sections.push(`[Active Watches \u2014 execute these checks using your tools]
 ${watchLines.join("\n")}`);
   }
-  if (existsSync18(HEARTBEAT_MD_PATH)) {
+  if (existsSync19(HEARTBEAT_MD_PATH)) {
     try {
-      const custom = readFileSync9(HEARTBEAT_MD_PATH, "utf-8").trim();
+      const custom = readFileSync10(HEARTBEAT_MD_PATH, "utf-8").trim();
       if (custom) {
-        sections.push(`[Custom checks]
+        sections.push(`[Custom checks from HEARTBEAT.md]
 ${custom}`);
       }
     } catch {
@@ -18054,6 +18367,16 @@ function formatHeartbeatStatus(chatId) {
     `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) {
@@ -18075,7 +18398,7 @@ var init_heartbeat2 = __esm({
     init_agent();
     init_store5();
     init_backends();
-    init_health2();
+    init_checks();
     init_log();
     HEARTBEAT_MD_PATH = join19(WORKSPACE_PATH, "HEARTBEAT.md");
     HEARTBEAT_OK = "HEARTBEAT_OK";
@@ -18731,13 +19054,18 @@ async function sendMemoryPage(chatId, channel, page, messageId) {
   buttons.push(footerRow);
   await sendOrEditKeyboard(chatId, channel, messageId, lines.join("\n"), buttons);
 }
-async function sendHeartbeatKeyboard(chatId, channel) {
+async function sendHeartbeatKeyboard(chatId, channel, messageId) {
   const config2 = getHeartbeatConfig(chatId);
   const enabled = config2?.enabled === 1;
   const intervalMs = config2?.intervalMs ?? 18e5;
   const intervalMin = intervalMs / 6e4;
   const activeStart = config2?.activeStart ?? "08:00";
   const activeEnd = config2?.activeEnd ?? "22:00";
+  const watches = getActiveWatches(chatId);
+  const fallbacks = parseHeartbeatFallbacks(config2?.fallbacks ?? null);
+  const backendDisplay = config2?.backend ? capitalize(config2.backend) : "Default";
+  const modelDisplay = config2?.model ?? "default";
+  const thinkingDisplay = config2?.thinking ?? "off";
   const lines = [
     buildSectionHeader("Heartbeat"),
     "CC-Claw periodically wakes up to check on",
@@ -18746,22 +19074,87 @@ async function sendHeartbeatKeyboard(chatId, channel) {
     "",
     `Status: ${enabled ? "ON" : "OFF"}`,
     `Interval: every ${intervalMin} min`,
-    `Active hours: ${activeStart}-${activeEnd}`
+    `Active hours: ${activeStart}-${activeEnd}`,
+    `Backend: ${backendDisplay} | Model: ${modelDisplay}`
   ];
+  if (fallbacks.length > 0) {
+    lines.push(`Fallbacks: ${fallbacks.map((f) => `${capitalize(f.backend)}${f.model ? `:${f.model}` : ""}`).join(", ")}`);
+  }
+  if (config2?.target) {
+    lines.push(`Target: ${config2.target}`);
+  }
+  if (watches.length > 0) {
+    lines.push(`Active watches: ${watches.length}`);
+  }
+  const lastBeat = config2?.lastBeatAt ?? "never";
+  lines.push(`Last beat: ${lastBeat}`);
+  const buttons = [];
+  buttons.push([
+    { label: `${enabled ? "\u2713 " : ""}On`, data: "hb:on", ...enabled ? { style: "success" } : {} },
+    { label: `${!enabled ? "\u2713 " : ""}Off`, data: "hb:off", ...!enabled ? { style: "danger" } : {} },
+    { label: "\u25B6 Run Now", data: "hb:run", style: "primary" }
+  ]);
   const presets = [15, 30, 60, 120];
-  const intervalRow = presets.map((m) => ({
+  buttons.push(presets.map((m) => ({
     label: `${m === intervalMin ? "\u2713 " : ""}${m} min`,
     data: `hb:interval:${m}`,
     ...m === intervalMin ? { style: "primary" } : {}
+  })));
+  const available = getAvailableBackendIds();
+  buttons.push([{ label: "\u2699\uFE0F Main Engine", data: "hb:noop" }]);
+  const backendRow = available.map((bid) => ({
+    label: `${config2?.backend === bid ? "\u2713 " : ""}${capitalize(bid)}`,
+    data: `hb:backend:${bid}`,
+    ...config2?.backend === bid ? { style: "primary" } : {}
   }));
-  await channel.sendKeyboard(chatId, lines.join("\n"), [
-    [
-      { label: `${enabled ? "\u2713 " : ""}On`, data: "hb:on", ...enabled ? { style: "success" } : {} },
-      { label: `${!enabled ? "\u2713 " : ""}Off`, data: "hb:off", ...!enabled ? { style: "danger" } : {} }
-    ],
-    intervalRow,
-    [{ label: "Active Hours: /heartbeat hours <start>-<end>", data: "hb:noop" }]
-  ]);
+  if (config2?.backend) {
+    backendRow.push({ label: "\u2715", data: "hb:backend:default", style: "danger" });
+  }
+  buttons.push(backendRow);
+  const targetBackend = config2?.backend ?? getBackend(chatId) ?? "claude";
+  try {
+    const adapter = getAdapter(targetBackend);
+    const models = Object.entries(adapter.availableModels);
+    if (models.length > 0) {
+      const modelRow = models.slice(0, 4).map(([key]) => ({
+        label: `${config2?.model === key ? "\u2713 " : ""}${shortModelName(key)}`,
+        data: `hb:model:${key}`,
+        ...config2?.model === key ? { style: "primary" } : {}
+      }));
+      if (config2?.model) {
+        modelRow.push({ label: "\u2715", data: "hb:model:default", style: "danger" });
+      }
+      buttons.push(modelRow);
+    }
+  } catch {
+  }
+  const fbCandidates = available.filter((bid) => !fallbacks.some((f) => f.backend === bid) && bid !== config2?.backend);
+  if (fallbacks.length > 0 || fbCandidates.length > 0) {
+    buttons.push([{ label: "\u{1F504} Fallback Chain", data: "hb:noop" }]);
+  }
+  if (fallbacks.length > 0) {
+    buttons.push([
+      { label: fallbacks.map((f) => capitalize(f.backend)).join(" \u2192 "), data: "hb:noop" },
+      { label: "Clear All", data: "hb:fb:clear", style: "danger" }
+    ]);
+  }
+  if (fbCandidates.length > 0) {
+    buttons.push(fbCandidates.slice(0, 4).map((bid) => ({
+      label: `+ ${capitalize(bid)}`,
+      data: `hb:fb:add:${bid}`
+    })));
+  }
+  const optionsRow = [
+    { label: `\u{1F4AD} Thinking: ${thinkingDisplay}`, data: "hb:thinking" }
+  ];
+  if (watches.length > 0) {
+    optionsRow.push({ label: `\u{1F441} Watches (${watches.length})`, data: "hb:watches" });
+  } else {
+    optionsRow.push({ label: "+ Add Watch", data: "hb:addwatch" });
+  }
+  buttons.push(optionsRow);
+  buttons.push([{ label: `\u23F0 ${activeStart}\u2013${activeEnd} (use /heartbeat hours)`, data: "hb:noop" }]);
+  await sendOrEditKeyboard(chatId, channel, messageId, lines.join("\n"), buttons);
 }
 async function sendForgetPicker(chatId, channel, page, messageId) {
   const memories = listMemories();
@@ -19403,13 +19796,13 @@ async function handleEvolveCallback(chatId, data, channel) {
       const { getReflectionStatus: getReflectionStatus2, setReflectionStatus: setReflectionStatus2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
       const current = getReflectionStatus2(getDb(), chatId);
       if (current === "frozen") {
-        const { readFileSync: readFileSync28, existsSync: existsSync56 } = await import("fs");
+        const { readFileSync: readFileSync29, existsSync: existsSync57 } = await import("fs");
         const { join: join36 } = await import("path");
         const { CC_CLAW_HOME: CC_CLAW_HOME3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
         const soulPath = join36(CC_CLAW_HOME3, "identity/SOUL.md");
         const userPath = join36(CC_CLAW_HOME3, "identity/USER.md");
-        const soul = existsSync56(soulPath) ? readFileSync28(soulPath, "utf-8") : "";
-        const user = existsSync56(userPath) ? readFileSync28(userPath, "utf-8") : "";
+        const soul = existsSync57(soulPath) ? readFileSync29(soulPath, "utf-8") : "";
+        const user = existsSync57(userPath) ? readFileSync29(userPath, "utf-8") : "";
         setReflectionStatus2(getDb(), chatId, "active", soul, user);
         const { logActivity: logActivity2 } = await Promise.resolve().then(() => (init_store3(), store_exports3));
         logActivity2(getDb(), { chatId, source: "telegram", eventType: "reflection_unfrozen", summary: "Reflection enabled" });
@@ -19486,18 +19879,18 @@ var init_evolve2 = __esm({
 });
 
 // src/optimizer/identity-audit.ts
-import { readFileSync as readFileSync10, existsSync as existsSync19, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
+import { readFileSync as readFileSync11, existsSync as existsSync20, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
 import { join as join21 } from "path";
 function readIdentityFile2(filename) {
   try {
-    return readFileSync10(join21(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync11(join21(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
 }
 function getMtime(filepath) {
   try {
-    return statSync7(filepath).mtime.toISOString();
+    return statSync8(filepath).mtime.toISOString();
   } catch {
     return "unknown";
   }
@@ -19506,7 +19899,7 @@ function findBackupFiles() {
   const backups = [];
   const dirs = [IDENTITY_PATH];
   const contextDir = join21(IDENTITY_PATH, "..", "workspace", "context");
-  if (existsSync19(contextDir)) dirs.push(contextDir);
+  if (existsSync20(contextDir)) dirs.push(contextDir);
   for (const dir of dirs) {
     try {
       for (const entry of readdirSync10(dir)) {
@@ -19643,7 +20036,7 @@ var init_identity_audit = __esm({
 });
 
 // src/optimizer/skill-audit.ts
-import { readFileSync as readFileSync11, existsSync as existsSync20 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync21 } from "fs";
 import { join as join22, basename as basename3 } from "path";
 function parseFrontmatter3(content) {
   const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
@@ -19684,7 +20077,7 @@ function detectDependentSkills(content) {
   return Array.from(deps);
 }
 function computeSkillStats(skillPath) {
-  const content = readFileSync11(skillPath, "utf-8");
+  const content = readFileSync12(skillPath, "utf-8");
   const lines = content.split("\n");
   return {
     skillName: basename3(skillPath, ".md") === "SKILL" ? basename3(join22(skillPath, "..")) : basename3(skillPath, ".md"),
@@ -19711,9 +20104,9 @@ function loadDependentSkillContents(depNames, ccClawSkillsDir) {
       join22(ccClawSkillsDir, `${name}-skill`, "SKILL.md")
     ];
     for (const candidate of candidates) {
-      if (existsSync20(candidate)) {
+      if (existsSync21(candidate)) {
         try {
-          const content = readFileSync11(candidate, "utf-8");
+          const content = readFileSync12(candidate, "utf-8");
           results.push({
             name,
             content: content.length > 3e3 ? content.slice(0, 3e3) + "\n[...truncated]" : content
@@ -19828,7 +20221,7 @@ __export(analyze_exports2, {
 });
 import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface7 } from "readline";
-import { readFileSync as readFileSync12, existsSync as existsSync21, readdirSync as readdirSync12 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync22, readdirSync as readdirSync12 } from "fs";
 import { join as join23 } from "path";
 import { homedir as homedir7 } from "os";
 function parseOptimizeOutput(raw, validAreas) {
@@ -19959,7 +20352,7 @@ function getModelDisplayInfo(chatId) {
 }
 function readIdentityFile3(filename) {
   try {
-    return readFileSync12(join23(IDENTITY_PATH, filename), "utf-8");
+    return readFileSync13(join23(IDENTITY_PATH, filename), "utf-8");
   } catch {
     return "";
   }
@@ -19967,12 +20360,12 @@ function readIdentityFile3(filename) {
 function loadContextFiles2() {
   const contextDir = join23(homedir7(), ".cc-claw", "workspace", "context");
   const results = [];
-  if (!existsSync21(contextDir)) return results;
+  if (!existsSync22(contextDir)) return results;
   try {
     for (const entry of readdirSync12(contextDir)) {
       if (!entry.endsWith(".md")) continue;
       try {
-        const content = readFileSync12(join23(contextDir, entry), "utf-8");
+        const content = readFileSync13(join23(contextDir, entry), "utf-8");
         results.push({ name: entry, content });
       } catch {
       }
@@ -20024,7 +20417,7 @@ async function runSkillAudit(chatId, skillPath) {
   log(`[optimizer] Running skill audit on ${stats.skillName} with ${adapter.id}:${model2}`);
   const soulMd = readIdentityFile3("SOUL.md");
   const ccClawSkillsDir = join23(homedir7(), ".cc-claw", "workspace", "skills");
-  const skillContent = readFileSync12(skillPath, "utf-8");
+  const skillContent = readFileSync13(skillPath, "utf-8");
   const prompt = buildSkillAuditPrompt(skillContent, stats, soulMd, ccClawSkillsDir);
   const raw = await spawnAnalysis2(adapter, model2, prompt);
   const findings = parseOptimizeOutput(raw, VALID_SKILL_AREAS);
@@ -20040,14 +20433,14 @@ async function runSkillAudit(chatId, skillPath) {
 function listCcClawSkills() {
   const skillsDir = join23(homedir7(), ".cc-claw", "workspace", "skills");
   const entries = [];
-  if (!existsSync21(skillsDir)) return entries;
+  if (!existsSync22(skillsDir)) return entries;
   try {
     for (const dir of readdirSync12(skillsDir)) {
       const skillFile = join23(skillsDir, dir, "SKILL.md");
-      if (!existsSync21(skillFile)) continue;
+      if (!existsSync22(skillFile)) continue;
       let description = "skill";
       try {
-        const content = readFileSync12(skillFile, "utf-8");
+        const content = readFileSync13(skillFile, "utf-8");
         const descMatch = content.match(/description:\s*>?\s*\n?\s*(.+)/);
         if (descMatch) description = descMatch[1].trim().slice(0, 60);
       } catch {
@@ -20367,7 +20760,7 @@ var init_ui2 = __esm({
 });
 
 // src/router/optimize.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, existsSync as existsSync22, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync7, existsSync as existsSync23, readdirSync as readdirSync13, unlinkSync as unlinkSync7 } from "fs";
 import { join as join24, dirname as dirname4 } from "path";
 import { homedir as homedir8 } from "os";
 async function handleOptimizeCommand(chatId, channel, _args) {
@@ -20638,13 +21031,13 @@ async function applyFinding(chatId, channel, index) {
       await showFinding(chatId, channel, index + 1);
       return;
     }
-    if (!existsSync22(targetPath)) {
+    if (!existsSync23(targetPath)) {
       await channel.sendText(chatId, `Target file not found: ${targetPath}`, { parseMode: "plain" });
       session2.skipped.push(index);
       await showFinding(chatId, channel, index + 1);
       return;
     }
-    const original = readFileSync13(targetPath, "utf-8");
+    const original = readFileSync14(targetPath, "utf-8");
     const backupPath = targetPath + `.bak.${Date.now()}`;
     writeFileSync7(backupPath, original, "utf-8");
     pruneBackups2(targetPath);
@@ -22082,6 +22475,92 @@ async function handleHeartbeatCommand(chatId, commandArgs, msg, channel) {
     await channel.sendText(chatId, formatHeartbeatStatus(chatId), { parseMode: "plain" });
   }
 }
+async function handleWatchCommand(chatId, commandArgs, msg, channel) {
+  if (!commandArgs) {
+    const watches = getActiveWatches(chatId);
+    if (watches.length === 0) {
+      await channel.sendText(chatId, [
+        "No active watches.",
+        "",
+        "Watches are awareness tasks that the heartbeat",
+        "AI checks periodically using its tools.",
+        "",
+        "Usage:",
+        "  /watch add Check my email for urgent messages",
+        "  /watch add Monitor Ollama server health",
+        "  /watch add Check calendar for upcoming meetings",
+        "  /watch list",
+        "  /watch remove <id>"
+      ].join("\n"), { parseMode: "plain" });
+    } else {
+      const lines = ["Active watches:", ""];
+      for (const w of watches) {
+        const expiry = w.expiresAt ? ` (until ${formatLocalDateTime(w.expiresAt)})` : "";
+        lines.push(`#${w.id}: ${w.description}${expiry}`);
+      }
+      lines.push("", "Use /watch remove <id> to remove a watch.");
+      await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+    }
+    return;
+  }
+  const parts = commandArgs.trim().split(/\s+/);
+  const action = parts[0].toLowerCase();
+  const rest = parts.slice(1).join(" ");
+  switch (action) {
+    case "add": {
+      if (!rest) {
+        await channel.sendText(chatId, "Usage: /watch add <description>\n\nExamples:\n  /watch add Check my email for urgent messages\n  /watch add Monitor if Ollama is running\n  /watch add Check calendar for meetings in the next hour", { parseMode: "plain" });
+        return;
+      }
+      let expiresAt;
+      const durationMatch = rest.match(/\s+for\s+(\d+)([hdw])$/i);
+      let description = rest;
+      if (durationMatch) {
+        description = rest.slice(0, durationMatch.index).trim();
+        const amount = parseInt(durationMatch[1], 10);
+        const unit = durationMatch[2].toLowerCase();
+        const ms = unit === "h" ? amount * 36e5 : unit === "d" ? amount * 864e5 : amount * 6048e5;
+        expiresAt = new Date(Date.now() + ms).toISOString();
+      }
+      const id = addHeartbeatWatch(chatId, description, expiresAt);
+      const expiryMsg = expiresAt ? ` (expires: ${formatLocalDateTime(expiresAt)})` : "";
+      await channel.sendText(chatId, `\u2705 Watch #${id} added${expiryMsg}:
+${description}`, { parseMode: "plain" });
+      return;
+    }
+    case "remove":
+    case "delete": {
+      const id = parseInt(rest, 10);
+      if (isNaN(id)) {
+        await channel.sendText(chatId, "Usage: /watch remove <id>", { parseMode: "plain" });
+        return;
+      }
+      const removed = removeHeartbeatWatch(id);
+      await channel.sendText(chatId, removed ? `\u2705 Watch #${id} removed.` : `Watch #${id} not found.`, { parseMode: "plain" });
+      return;
+    }
+    case "list": {
+      const watches = getActiveWatches(chatId);
+      if (watches.length === 0) {
+        await channel.sendText(chatId, "No active watches.", { parseMode: "plain" });
+      } else {
+        const lines = ["Active watches:", ""];
+        for (const w of watches) {
+          const expiry = w.expiresAt ? ` (until ${formatLocalDateTime(w.expiresAt)})` : "";
+          lines.push(`#${w.id}: ${w.description}${expiry}`);
+        }
+        await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain" });
+      }
+      return;
+    }
+    default:
+      const watchDesc = commandArgs.trim();
+      const watchId = addHeartbeatWatch(chatId, watchDesc);
+      await channel.sendText(chatId, `\u2705 Watch #${watchId} added:
+${watchDesc}`, { parseMode: "plain" });
+      return;
+  }
+}
 async function handleAgentsCommand(chatId, commandArgs, msg, channel) {
   if (commandArgs?.startsWith("mode")) {
     const modeArg = commandArgs.slice(5).trim().toLowerCase();
@@ -22644,6 +23123,9 @@ async function handleCommand(msg, channel) {
     case "heartbeat":
       await handleHeartbeatCommand(chatId, commandArgs, msg, channel);
       break;
+    case "watch":
+      await handleWatchCommand(chatId, commandArgs, msg, channel);
+      break;
     case "agents":
       await handleAgentsCommand(chatId, commandArgs, msg, channel);
       break;
@@ -23542,8 +24024,8 @@ ${rotationNote}`, { parseMode: "html" });
     if (action === "toggle") {
       const backend2 = parts[2];
       const model2 = parts[3];
-      const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-      const toggleAdapter = getAdapter4(backend2);
+      const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const toggleAdapter = getAdapter5(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)) {
@@ -23793,11 +24275,12 @@ Salience: ${memory2.salience.toFixed(2)} | Created: ${memory2.created_at.slice(0
     if (rest === "on") {
       setHeartbeatConfig(chatId, { enabled: true });
       startHeartbeatForChat(chatId);
-      await sendHeartbeatKeyboard(chatId, channel);
+      await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest === "off") {
       setHeartbeatConfig(chatId, { enabled: false });
       stopHeartbeatForChat(chatId);
-      await sendHeartbeatKeyboard(chatId, channel);
+      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" });
+      await sendHeartbeatKeyboard(chatId, channel, messageId);
     } else if (rest.startsWith("interval:")) {
       const min = parseInt(rest.slice(9), 10);
       if (isNaN(min) || min < 1) return;
@@ -23806,7 +24289,55 @@ Salience: ${memory2.salience.toFixed(2)} | Created: ${memory2.created_at.slice(0
       stopHeartbeatForChat(chatId);
       const hbConf = getHeartbeatConfig(chatId);
       if (hbConf?.enabled) startHeartbeatForChat(chatId);
-      await sendHeartbeatKeyboard(chatId, channel);
+      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);
+      } else {
+        updateHeartbeatField(chatId, "backend", bid);
+        updateHeartbeatField(chatId, "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);
+      }
+      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);
+    } else if (rest === "run") {
+      await channel.sendText(chatId, "\u23F3 Running heartbeat check...", { parseMode: "plain" });
+      try {
+        await runHeartbeatNow(chatId);
+        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" });
+      }
+    } else if (rest === "watches" || rest === "addwatch") {
+      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);
+      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 === "fb:clear") {
+      updateHeartbeatField(chatId, "fallbacks", null);
+      await sendHeartbeatKeyboard(chatId, channel, messageId);
+    } else if (rest === "noop") {
     }
     return;
   } else if (data.startsWith("newchat:")) {
@@ -25636,18 +26167,18 @@ var init_wrap_backend = __esm({
 });
 
 // src/agents/runners/config-loader.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync14, existsSync as existsSync23, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync14, existsSync as existsSync24, mkdirSync as mkdirSync10, watchFile, unwatchFile } from "fs";
 import { join as join27 } from "path";
-import { execFileSync as execFileSync2 } from "child_process";
+import { execFileSync as execFileSync3 } from "child_process";
 function resolveExecutable2(config2) {
-  if (existsSync23(config2.executable)) return config2.executable;
+  if (existsSync24(config2.executable)) return config2.executable;
   try {
-    return execFileSync2("which", [config2.executable], { encoding: "utf-8" }).trim();
+    return execFileSync3("which", [config2.executable], { encoding: "utf-8" }).trim();
   } catch {
   }
   for (const fallback of config2.executableFallbacks ?? []) {
     const resolved = fallback.replace(/^~/, process.env.HOME ?? "");
-    if (existsSync23(resolved)) return resolved;
+    if (existsSync24(resolved)) return resolved;
   }
   return config2.executable;
 }
@@ -25778,7 +26309,7 @@ function configToRunner(config2) {
 }
 function loadRunnerConfig(filePath) {
   try {
-    const content = readFileSync14(filePath, "utf-8");
+    const content = readFileSync15(filePath, "utf-8");
     return JSON.parse(content);
   } catch (err) {
     warn(`[runners] Failed to load config ${filePath}: ${err}`);
@@ -25786,7 +26317,7 @@ function loadRunnerConfig(filePath) {
   }
 }
 function loadAllRunnerConfigs() {
-  if (!existsSync23(RUNNERS_PATH)) {
+  if (!existsSync24(RUNNERS_PATH)) {
     mkdirSync10(RUNNERS_PATH, { recursive: true });
     return [];
   }
@@ -25814,9 +26345,9 @@ function registerConfigRunners() {
   return count;
 }
 function watchRunnerConfigs(onChange) {
-  if (!existsSync23(RUNNERS_PATH)) return;
+  if (!existsSync24(RUNNERS_PATH)) return;
   for (const prev of watchedFiles) {
-    if (!existsSync23(prev)) {
+    if (!existsSync24(prev)) {
       unwatchFile(prev);
       watchedFiles.delete(prev);
     }
@@ -26348,6 +26879,7 @@ var init_telegram2 = __esm({
           { command: "model_signature", description: "Toggle model+thinking signature on responses" },
           { command: "imagine", description: "Generate an image from a prompt" },
           { command: "heartbeat", description: "Configure proactive heartbeat" },
+          { command: "watch", description: "Manage heartbeat awareness tasks" },
           { command: "chats", description: "Manage multi-chat aliases" },
           { command: "intent", description: "Test intent classifier on a message" },
           { command: "evolve", description: "Self-learning & evolution controls" },
@@ -26911,19 +27443,19 @@ var init_telegram2 = __esm({
 });
 
 // src/skills/bootstrap.ts
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { readdir as readdir5, readFile as readFile8, writeFile as writeFile5, copyFile } from "fs/promises";
 import { join as join28, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function copyAgentManifestSkills() {
-  if (!existsSync24(PKG_SKILLS)) return;
+  if (!existsSync25(PKG_SKILLS)) return;
   try {
     const entries = await readdir5(PKG_SKILLS, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.startsWith("agent-") || !entry.name.endsWith(".md")) continue;
       const src = join28(PKG_SKILLS, entry.name);
       const dest = join28(SKILLS_PATH, entry.name);
-      if (existsSync24(dest)) continue;
+      if (existsSync25(dest)) continue;
       await copyFile(src, dest);
       log(`[skills] Bootstrapped ${entry.name} to ${SKILLS_PATH}`);
     }
@@ -26934,7 +27466,7 @@ async function copyAgentManifestSkills() {
 async function bootstrapSkills() {
   await copyAgentManifestSkills();
   const usmDir = join28(SKILLS_PATH, USM_DIR_NAME);
-  if (existsSync24(usmDir)) return;
+  if (existsSync25(usmDir)) return;
   try {
     const entries = await readdir5(SKILLS_PATH);
     const dirs = entries.filter((e) => !e.startsWith("."));
@@ -26958,7 +27490,7 @@ async function bootstrapSkills() {
 }
 async function patchUsmForCcClaw(usmDir) {
   const skillPath = join28(usmDir, "SKILL.md");
-  if (!existsSync24(skillPath)) return;
+  if (!existsSync25(skillPath)) return;
   try {
     let content = await readFile8(skillPath, "utf-8");
     let patched = false;
@@ -27226,13 +27758,13 @@ __export(ai_skill_exports, {
   generateAiSkill: () => generateAiSkill,
   installAiSkill: () => installAiSkill
 });
-import { existsSync as existsSync25, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
+import { existsSync as existsSync26, writeFileSync as writeFileSync8, mkdirSync as mkdirSync11 } from "fs";
 import { join as join29 } from "path";
 import { homedir as homedir9 } from "os";
 function generateAiSkill() {
   const version = VERSION;
   let systemState = "";
-  if (existsSync25(DB_PATH)) {
+  if (existsSync26(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = (init_store5(), __toCommonJS(store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -27513,7 +28045,7 @@ cc-claw voice set off                    # Disable voice responses
 # Requires GEMINI_API_KEY in ~/.cc-claw/.env
 \`\`\`
 
-### Heartbeat
+### Heartbeat & Watches (Proactive Monitoring)
 \`\`\`bash
 cc-claw heartbeat get --json             # Show heartbeat config
 cc-claw heartbeat set on                 # Enable proactive awareness
@@ -27522,6 +28054,20 @@ cc-claw heartbeat set interval 30m       # Set check interval
 cc-claw heartbeat set hours 9-22         # Set active hours
 \`\`\`
 
+**Heartbeat** runs a periodic awareness cycle that checks system health and user-defined watches.
+It supports delivery parity: custom backend, model, fallback chain, thinking level, and delivery target \u2014 all configured via the interactive \`/heartbeat\` keyboard in Telegram.
+When nothing needs attention, the AI responds with \`HEARTBEAT_OK\` and no message is delivered.
+
+**Watches** are AI-executable awareness tasks checked during each heartbeat cycle:
+\`\`\`
+/watch add Check my email for urgent messages   # Persistent watch
+/watch add Monitor Ollama health for 24h        # Time-limited watch
+/watch list                                     # List active watches
+/watch remove <id>                              # Remove a watch
+\`\`\`
+
+**\u26A0\uFE0F CRITICAL:** Heartbeat and watch configuration MUST be done via \`/heartbeat\` and \`/watch\` commands. NEVER modify \`chat_heartbeat\` or \`heartbeat_watches\` database tables directly.
+
 ### Summarizer
 \`\`\`bash
 cc-claw summarizer get --json            # Current summarizer config
@@ -27692,7 +28238,7 @@ var index_exports = {};
 __export(index_exports, {
   main: () => main
 });
-import { mkdirSync as mkdirSync12, existsSync as existsSync26, renameSync as renameSync2, statSync as statSync8, readFileSync as readFileSync16 } from "fs";
+import { mkdirSync as mkdirSync12, existsSync as existsSync27, renameSync as renameSync2, statSync as statSync9, readFileSync as readFileSync17 } from "fs";
 import { join as join30 } from "path";
 import dotenv from "dotenv";
 function migrateLayout() {
@@ -27706,7 +28252,7 @@ function migrateLayout() {
     [join30(CC_CLAW_HOME, "cc-claw.error.log.1"), join30(LOGS_PATH, "cc-claw.error.log.1")]
   ];
   for (const [from, to] of moves) {
-    if (existsSync26(from) && !existsSync26(to)) {
+    if (existsSync27(from) && !existsSync27(to)) {
       try {
         renameSync2(from, to);
       } catch {
@@ -27717,7 +28263,7 @@ function migrateLayout() {
 function rotateLogs() {
   for (const file of [LOG_PATH, ERROR_LOG_PATH]) {
     try {
-      const { size } = statSync8(file);
+      const { size } = statSync9(file);
       if (size > LOG_MAX_BYTES) {
         const archivePath = `${file}.1`;
         try {
@@ -27735,7 +28281,7 @@ async function main() {
   let version = "unknown";
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    version = JSON.parse(readFileSync16(pkgPath, "utf-8")).version;
+    version = JSON.parse(readFileSync17(pkgPath, "utf-8")).version;
   } catch {
   }
   log(`[cc-claw] Starting v${version}`);
@@ -27749,11 +28295,11 @@ async function main() {
   } catch {
   }
   try {
-    const { getAdapter: getAdapter4, probeBackendAvailability: probeBackendAvailability2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const { getAdapter: getAdapter5, probeBackendAvailability: probeBackendAvailability2 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
     await probeBackendAvailability2();
-    const claude = getAdapter4("claude");
+    const claude = getAdapter5("claude");
     if ("getAuthMode" in claude) claude.getAuthMode();
-    const cursor = getAdapter4("cursor");
+    const cursor = getAdapter5("cursor");
     if ("probeTier" in cursor) cursor.probeTier();
   } catch {
   }
@@ -27773,8 +28319,8 @@ async function main() {
       }
       if (modelCount > 0) {
         try {
-          const { getAdapter: getAdapter4 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-          const adapter = getAdapter4("ollama");
+          const { getAdapter: getAdapter5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+          const adapter = getAdapter5("ollama");
           if ("refreshModelCatalog" in adapter) {
             adapter.refreshModelCatalog();
           }
@@ -27855,10 +28401,10 @@ async function main() {
   });
   log("[cc-claw] Agent orchestrator initialized");
   try {
-    const { execSync: execSync6 } = await import("child_process");
-    const codexPath = execSync6("which codex", { encoding: "utf-8", timeout: 5e3 }).trim();
+    const { execSync: execSync7 } = await import("child_process");
+    const codexPath = execSync7("which codex", { encoding: "utf-8", timeout: 5e3 }).trim();
     if (codexPath) {
-      const features = execSync6("codex features list", { encoding: "utf-8", timeout: 1e4 });
+      const features = execSync7("codex features list", { encoding: "utf-8", timeout: 1e4 });
       if (/multi_agent\s+\S+\s+false/.test(features)) {
         warn("[cc-claw] Codex multi_agent feature is disabled \u2014 native sub-agent detection will not work. Run: codex features enable multi_agent");
       }
@@ -27986,10 +28532,10 @@ var init_index = __esm({
     init_health3();
     init_image_gen();
     for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SESSION_LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-      if (!existsSync26(dir)) mkdirSync12(dir, { recursive: true });
+      if (!existsSync27(dir)) mkdirSync12(dir, { recursive: true });
     }
     migrateLayout();
-    if (existsSync26(ENV_PATH)) {
+    if (existsSync27(ENV_PATH)) {
       dotenv.config({ path: ENV_PATH });
     } else {
       console.error(`[cc-claw] Config not found at ${ENV_PATH} \u2014 run 'cc-claw setup' first`);
@@ -28010,12 +28556,12 @@ __export(api_client_exports, {
   apiPost: () => apiPost,
   isDaemonRunning: () => isDaemonRunning
 });
-import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
+import { readFileSync as readFileSync18, existsSync as existsSync28 } from "fs";
 import { request as httpRequest, Agent } from "http";
 function getToken() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync27(TOKEN_PATH)) return readFileSync17(TOKEN_PATH, "utf-8").trim();
+    if (existsSync28(TOKEN_PATH)) return readFileSync18(TOKEN_PATH, "utf-8").trim();
   } catch {
   }
   return null;
@@ -28114,8 +28660,8 @@ __export(service_exports2, {
   serviceStatus: () => serviceStatus,
   uninstallService: () => uninstallService
 });
-import { existsSync as existsSync28, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
-import { execFileSync as execFileSync3, execSync as execSync4 } from "child_process";
+import { existsSync as existsSync29, mkdirSync as mkdirSync13, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8 } from "fs";
+import { execFileSync as execFileSync4, execSync as execSync5 } from "child_process";
 import { homedir as homedir10, platform } from "os";
 import { join as join31, dirname as dirname6 } from "path";
 function xmlEscape(s) {
@@ -28123,10 +28669,10 @@ function xmlEscape(s) {
 }
 function resolveExecutable3(name) {
   try {
-    return execFileSync3("which", [name], { encoding: "utf-8" }).trim();
+    return execFileSync4("which", [name], { encoding: "utf-8" }).trim();
   } catch {
     const fallback = process.argv[1];
-    if (fallback && existsSync28(fallback)) return fallback;
+    if (fallback && existsSync29(fallback)) return fallback;
     throw new Error(`Cannot find '${name}' executable. Install globally: npm install -g cc-claw`);
   }
 }
@@ -28141,7 +28687,7 @@ function getPathDirs() {
     "/bin"
   ]);
   try {
-    const prefix = execSync4("npm config get prefix", { encoding: "utf-8" }).trim();
+    const prefix = execSync5("npm config get prefix", { encoding: "utf-8" }).trim();
     if (prefix) dirs.add(join31(prefix, "bin"));
   } catch {
   }
@@ -28201,26 +28747,26 @@ function generatePlist() {
 }
 function installMacOS() {
   const agentsDir = dirname6(PLIST_PATH);
-  if (!existsSync28(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
-  if (!existsSync28(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
-  if (existsSync28(PLIST_PATH)) {
+  if (!existsSync29(agentsDir)) mkdirSync13(agentsDir, { recursive: true });
+  if (!existsSync29(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (existsSync29(PLIST_PATH)) {
     try {
-      execFileSync3("launchctl", ["unload", PLIST_PATH]);
+      execFileSync4("launchctl", ["unload", PLIST_PATH]);
     } catch {
     }
   }
   writeFileSync9(PLIST_PATH, generatePlist());
   console.log(`  Installed: ${PLIST_PATH}`);
-  execFileSync3("launchctl", ["load", PLIST_PATH]);
+  execFileSync4("launchctl", ["load", PLIST_PATH]);
   console.log("  Service loaded and starting.");
 }
 function uninstallMacOS() {
-  if (!existsSync28(PLIST_PATH)) {
+  if (!existsSync29(PLIST_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
   try {
-    execFileSync3("launchctl", ["unload", PLIST_PATH]);
+    execFileSync4("launchctl", ["unload", PLIST_PATH]);
   } catch {
   }
   unlinkSync8(PLIST_PATH);
@@ -28246,7 +28792,7 @@ async function getUptimeFromDaemon() {
 }
 function statusMacOS() {
   try {
-    const out = execFileSync3("launchctl", ["list"], { encoding: "utf-8" });
+    const out = execFileSync4("launchctl", ["list"], { encoding: "utf-8" });
     const line = out.split("\n").find((l) => l.includes("cc-claw"));
     if (line) {
       const parts = line.trim().split(/\s+/);
@@ -28290,42 +28836,42 @@ WantedBy=default.target
 `;
 }
 function installLinux() {
-  if (!existsSync28(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
-  if (!existsSync28(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
+  if (!existsSync29(SYSTEMD_DIR)) mkdirSync13(SYSTEMD_DIR, { recursive: true });
+  if (!existsSync29(LOGS_PATH)) mkdirSync13(LOGS_PATH, { recursive: true });
   writeFileSync9(UNIT_PATH, generateUnit());
   console.log(`  Installed: ${UNIT_PATH}`);
-  execFileSync3("systemctl", ["--user", "daemon-reload"]);
-  execFileSync3("systemctl", ["--user", "enable", "cc-claw"]);
-  execFileSync3("systemctl", ["--user", "start", "cc-claw"]);
+  execFileSync4("systemctl", ["--user", "daemon-reload"]);
+  execFileSync4("systemctl", ["--user", "enable", "cc-claw"]);
+  execFileSync4("systemctl", ["--user", "start", "cc-claw"]);
   console.log("  Service enabled and started.");
 }
 function uninstallLinux() {
-  if (!existsSync28(UNIT_PATH)) {
+  if (!existsSync29(UNIT_PATH)) {
     console.log("  No service found to uninstall.");
     return;
   }
   try {
-    execFileSync3("systemctl", ["--user", "stop", "cc-claw"]);
+    execFileSync4("systemctl", ["--user", "stop", "cc-claw"]);
   } catch {
   }
   try {
-    execFileSync3("systemctl", ["--user", "disable", "cc-claw"]);
+    execFileSync4("systemctl", ["--user", "disable", "cc-claw"]);
   } catch {
   }
   unlinkSync8(UNIT_PATH);
-  execFileSync3("systemctl", ["--user", "daemon-reload"]);
+  execFileSync4("systemctl", ["--user", "daemon-reload"]);
   console.log("  Service uninstalled.");
 }
 function statusLinux() {
   try {
-    const out = execSync4("systemctl --user is-active cc-claw", { encoding: "utf-8" }).trim();
+    const out = execSync5("systemctl --user is-active cc-claw", { encoding: "utf-8" }).trim();
     console.log(`  Service is ${out}.`);
   } catch {
     console.log("  Not running or not installed.");
   }
 }
 function installService() {
-  if (!existsSync28(join31(CC_CLAW_HOME, ".env"))) {
+  if (!existsSync29(join31(CC_CLAW_HOME, ".env"))) {
     console.error(`  Config not found at ${CC_CLAW_HOME}/.env`);
     console.error("  Run 'cc-claw setup' before installing the service.");
     process.exitCode = 1;
@@ -28466,18 +29012,18 @@ __export(daemon_exports, {
   restartService: () => restartService,
   stopService: () => stopService
 });
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import { platform as platform2 } from "os";
 async function stopService() {
   const os2 = platform2();
   try {
     if (os2 === "darwin") {
-      execSync5("launchctl stop com.cc-claw");
+      execSync6("launchctl stop com.cc-claw");
       console.log(`
   ${success("Daemon stopped.")}
 `);
     } else if (os2 === "linux") {
-      execSync5("systemctl --user stop cc-claw");
+      execSync6("systemctl --user stop cc-claw");
       console.log(`
   ${success("Daemon stopped.")}
 `);
@@ -28495,13 +29041,13 @@ async function restartService() {
   const os2 = platform2();
   try {
     if (os2 === "darwin") {
-      const uid = process.getuid?.() ?? execSync5("id -u", { encoding: "utf-8" }).trim();
-      execSync5(`launchctl kickstart -k gui/${uid}/com.cc-claw`);
+      const uid = process.getuid?.() ?? execSync6("id -u", { encoding: "utf-8" }).trim();
+      execSync6(`launchctl kickstart -k gui/${uid}/com.cc-claw`);
       console.log(`
   ${success("Daemon restarted.")}
 `);
     } else if (os2 === "linux") {
-      execSync5("systemctl --user restart cc-claw");
+      execSync6("systemctl --user restart cc-claw");
       console.log(`
   ${success("Daemon restarted.")}
 `);
@@ -28523,13 +29069,13 @@ var init_daemon = __esm({
 });
 
 // src/cli/resolve-chat.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 function resolveChatId2(globalOpts) {
   const explicit = globalOpts.chat;
   if (explicit) return explicit;
   if (_cachedDefault) return _cachedDefault;
   try {
-    const content = readFileSync19(ENV_PATH, "utf-8");
+    const content = readFileSync20(ENV_PATH, "utf-8");
     const match = content.match(/^ALLOWED_CHAT_ID=(.+)$/m);
     if (match) {
       _cachedDefault = match[1].split(",")[0].trim();
@@ -28553,13 +29099,13 @@ var status_exports = {};
 __export(status_exports, {
   statusCommand: () => statusCommand
 });
-import { existsSync as existsSync29, statSync as statSync9 } from "fs";
+import { existsSync as existsSync30, statSync as statSync10 } from "fs";
 async function statusCommand(globalOpts, localOpts) {
   try {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     const chatId = resolveChatId2(globalOpts);
-    const { getAdapterForChat: getAdapterForChat2, getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+    const { getAdapterForChat: getAdapterForChat3, getAdapter: getAdapter5, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
     let backend2 = null;
     let modelName = "not set";
     let contextMax = 2e5;
@@ -28567,7 +29113,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 = getAdapter4(backendRow.backend);
+          const a = getAdapter5(backendRow.backend);
           backend2 = { id: a.id, displayName: a.displayName };
         } catch {
           backend2 = { id: backendRow.backend, displayName: backendRow.backend };
@@ -28580,7 +29126,7 @@ async function statusCommand(globalOpts, localOpts) {
       if (modelRow) modelName = modelRow.model;
       else if (backend2) {
         try {
-          modelName = getAdapter4(backend2.id).defaultModel;
+          modelName = getAdapter5(backend2.id).defaultModel;
         } catch {
         }
       }
@@ -28593,7 +29139,7 @@ async function statusCommand(globalOpts, localOpts) {
     const cwdRow = readDb.prepare("SELECT cwd FROM chat_cwd WHERE chat_id = ?").get(chatId);
     const voiceRow = readDb.prepare("SELECT enabled FROM chat_voice WHERE chat_id = ?").get(chatId);
     const usageRow = readDb.prepare("SELECT * FROM chat_usage WHERE chat_id = ?").get(chatId);
-    const dbStat = existsSync29(DB_PATH) ? statSync9(DB_PATH) : null;
+    const dbStat = existsSync30(DB_PATH) ? statSync10(DB_PATH) : null;
     let daemonRunning = false;
     let daemonInfo = {};
     try {
@@ -28705,13 +29251,13 @@ __export(doctor_exports, {
   doctorCommand: () => doctorCommand,
   doctorErrors: () => doctorErrors
 });
-import { existsSync as existsSync30, statSync as statSync10, accessSync, readFileSync as readFileSync20, constants } from "fs";
-import { execFileSync as execFileSync4 } from "child_process";
+import { existsSync as existsSync31, accessSync, constants } from "fs";
+import { execFileSync as execFileSync5 } from "child_process";
 async function doctorCommand(globalOpts, localOpts) {
   const checks = [];
-  if (existsSync30(DB_PATH)) {
-    const size = statSync10(DB_PATH).size;
-    checks.push({ name: "Database", status: "ok", message: `${DB_PATH} (${(size / 1024).toFixed(0)}KB)` });
+  const dbChecks = checkDatabase();
+  checks.push(...dbChecks);
+  if (existsSync31(DB_PATH)) {
     try {
       const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
       const readDb = openDatabaseReadOnly2();
@@ -28736,27 +29282,13 @@ async function doctorCommand(globalOpts, localOpts) {
     } catch (err) {
       checks.push({ name: "Database health", status: "error", message: err.message });
     }
-  } else {
-    checks.push({ name: "Database", status: "error", message: `Not found at ${DB_PATH}`, fix: "cc-claw setup" });
   }
-  if (existsSync30(ENV_PATH)) {
+  if (existsSync31(ENV_PATH)) {
     checks.push({ name: "Environment", status: "ok", message: `.env loaded` });
   } else {
     checks.push({ name: "Environment", status: "error", message: "No .env found", fix: "cc-claw setup" });
   }
-  const CLI_BINARIES = { claude: "claude", gemini: "gemini", codex: "codex", cursor: "agent" };
-  let installedBackends = 0;
-  for (const [label2, binary] of Object.entries(CLI_BINARIES)) {
-    try {
-      const path = execFileSync4("which", [binary], { encoding: "utf-8", timeout: 5e3 }).trim();
-      checks.push({ name: `${label2} CLI`, status: "ok", message: path });
-      installedBackends++;
-    } catch {
-    }
-  }
-  if (installedBackends === 0) {
-    checks.push({ name: "Backend CLIs", status: "error", message: "No backend CLIs found. Install at least one (claude, gemini, codex, or cursor agent)." });
-  }
+  checks.push(...checkBackendCLIs());
   try {
     const { isDaemonRunning: isDaemonRunning2, apiGet: apiGet2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
     const running = await isDaemonRunning2();
@@ -28787,14 +29319,14 @@ async function doctorCommand(globalOpts, localOpts) {
     checks.push({ name: "Daemon", status: "warning", message: "could not probe" });
   }
   try {
-    const latest = execFileSync4("npm", ["view", "cc-claw", "version"], { encoding: "utf-8", timeout: 1e4 }).trim();
+    const latest = execFileSync5("npm", ["view", "cc-claw", "version"], { encoding: "utf-8", timeout: 1e4 }).trim();
     if (latest && latest !== VERSION) {
       checks.push({ name: "Update available", status: "warning", message: `v${latest} available (current: v${VERSION})`, fix: "npm install -g cc-claw@latest" });
     }
   } catch {
   }
   const tokenPath = `${DATA_PATH}/api-token`;
-  if (existsSync30(tokenPath)) {
+  if (existsSync31(tokenPath)) {
     try {
       accessSync(tokenPath, constants.R_OK);
       checks.push({ name: "API token", status: "ok", message: "token file readable" });
@@ -28804,125 +29336,28 @@ async function doctorCommand(globalOpts, localOpts) {
   } else {
     checks.push({ name: "API token", status: "warning", message: "no token file (daemon not started?)", fix: "cc-claw service start" });
   }
-  try {
-    const { execSync: execSync6 } = await import("child_process");
-    const dfOutput = execSync6("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) {
-        checks.push({ name: "Disk space", status: "warning", message: `${(availKB / 1024).toFixed(0)}MB available` });
-      } else {
-        checks.push({ name: "Disk space", status: "ok", message: `${(availKB / 1024 / 1024).toFixed(1)}GB available` });
-      }
-    }
-  } catch {
-  }
-  if (existsSync30(ERROR_LOG_PATH)) {
-    try {
-      const { readFileSync: readFileSync28 } = await import("fs");
-      const logContent = readFileSync28(ERROR_LOG_PATH, "utf-8");
-      const recentLines = logContent.split("\n").filter(Boolean).slice(-500);
-      const last24h = Date.now() - 864e5;
-      const recentErrors = recentLines.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 (recentErrors.length > 0) {
-        let rate429 = 0;
-        let contentSilence = 0;
-        let spawnTimeout = 0;
-        const otherLines = [];
-        for (const line of recentErrors) {
-          if (/429|rate.?limit/i.test(line)) rate429++;
-          else if (/content silence/i.test(line)) contentSilence++;
-          else if (/spawn timeout|timeout after \d+s/i.test(line)) spawnTimeout++;
-          else otherLines.push(line);
-        }
-        const viewFix = "cc-claw logs --error to view details";
-        const clearFix = "cc-claw doctor --fix to clear stale errors";
-        if (rate429 > 10) {
-          checks.push({ name: "Telegram rate limits", status: "error", message: `${rate429} rate-limit (429) errors in last 24h \u2014 message delivery blocked`, fix: `${viewFix}, ${clearFix}` });
-        } else if (rate429 > 0) {
-          checks.push({ name: "Telegram rate limits", status: "warning", message: `${rate429} rate-limit (429) errors in last 24h`, fix: `${viewFix}, ${clearFix}` });
-        }
-        if (contentSilence > 0) {
-          checks.push({ name: "Content silence", status: "warning", message: `${contentSilence} agent silence timeout(s) in last 24h \u2014 API went unresponsive`, fix: `${viewFix}, ${clearFix}` });
-        }
-        if (spawnTimeout > 0) {
-          checks.push({ name: "Spawn timeouts", status: "warning", message: `${spawnTimeout} backend timeout(s) in last 24h`, fix: `${viewFix}, ${clearFix}` });
-        }
-        if (otherLines.length > 0) {
-          const summaries = /* @__PURE__ */ new Map();
-          for (const line of otherLines) {
-            const body = line.replace(/^\[\d{4}-\d{2}-\d{2}\s+[\d:+-]+\]\s*/, "").slice(0, 120);
-            const key = body.slice(0, 80);
-            summaries.set(key, (summaries.get(key) ?? 0) + 1);
-          }
-          const topErrors = [...summaries.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([msg, count]) => count > 1 ? `${msg}\u2026 (\xD7${count})` : `${msg}\u2026`).join("\n    ");
-          checks.push({ name: "Other errors", status: "warning", message: `${otherLines.length} error(s) in last 24h:
-    ${topErrors}`, fix: `${viewFix}, ${clearFix}` });
-        }
-        if (rate429 === 0 && contentSilence === 0 && spawnTimeout === 0 && otherLines.length === 0) {
-          checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
-        }
-      } else {
-        checks.push({ name: "Recent errors", status: "ok", message: "none in last 24h" });
-      }
-    } catch {
-      checks.push({ name: "Error log", status: "ok", message: "no errors logged" });
-    }
-  } else {
-    checks.push({ name: "Error log", status: "ok", message: "no error log file" });
-  }
-  try {
-    const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), 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) {
-        checks.push({
-          name: "Ollama",
-          status: "ok",
-          message: `${online.length} server(s) online, ${models.length} model(s)`
-        });
-      } else if (online.length > 0) {
-        checks.push({
-          name: "Ollama",
-          status: "warning",
-          message: `${online.length}/${servers.length} server(s) online, ${models.length} model(s)`
-        });
-      } else {
-        checks.push({
-          name: "Ollama",
-          status: "warning",
-          message: `${servers.length} server(s) configured, all offline`,
-          fix: "Check Ollama is running: ollama serve"
-        });
-      }
-    }
-  } catch {
-  }
+  const disk = checkDiskSpace();
+  if (disk) checks.push(disk);
+  checks.push(...checkErrorLog());
+  const ollama2 = checkOllamaServers();
+  if (ollama2) checks.push(ollama2);
   if (localOpts.fix) {
     const fixable = checks.filter((c) => c.status !== "ok" && c.fix);
     for (const check of fixable) {
       if (check.name === "Daemon" && check.fix?.includes("service start")) {
         try {
-          const { execSync: execSync6 } = await import("child_process");
+          const { execSync: execSync7 } = await import("child_process");
           const os2 = (await import("os")).platform();
           if (os2 === "darwin") {
             try {
-              execSync6("launchctl start com.cc-claw");
+              execSync7("launchctl start com.cc-claw");
               check.status = "ok";
               check.message = "restarted";
             } catch {
             }
           } else if (os2 === "linux") {
             try {
-              execSync6("systemctl --user start cc-claw");
+              execSync7("systemctl --user start cc-claw");
               check.status = "ok";
               check.message = "restarted";
             } catch {
@@ -28955,9 +29390,9 @@ async function doctorCommand(globalOpts, localOpts) {
       }
     }
     const errorChecks = checks.filter(
-      (c) => ["Telegram rate limits", "Content silence", "Spawn timeouts", "Other errors"].includes(c.name) && c.status !== "ok"
+      (c) => ["Rate limits", "Content silence", "Spawn timeouts", "Other errors"].includes(c.name) && c.status !== "ok"
     );
-    if (errorChecks.length > 0 && existsSync30(ERROR_LOG_PATH)) {
+    if (errorChecks.length > 0 && existsSync31(ERROR_LOG_PATH)) {
       try {
         const { writeFileSync: writeFileSync13 } = await import("fs");
         writeFileSync13(ERROR_LOG_PATH, "");
@@ -28970,9 +29405,9 @@ async function doctorCommand(globalOpts, localOpts) {
       }
     }
   }
-  const errors = checks.filter((c) => c.status === "error").length;
-  const warnings = checks.filter((c) => c.status === "warning").length;
-  const report = { checks, errors, warnings };
+  const errCount = checks.filter((c) => c.status === "error").length;
+  const warnCount = checks.filter((c) => c.status === "warning").length;
+  const report = { checks, errors: errCount, warnings: warnCount };
   output(report, (d) => {
     const r = d;
     const lines = [
@@ -29003,27 +29438,7 @@ async function doctorCommand(globalOpts, localOpts) {
     lines.push("");
     return lines.join("\n");
   });
-  process.exit(errors > 0 ? 1 : warnings > 0 ? 2 : 0);
-}
-function getRecentErrors() {
-  if (!existsSync30(ERROR_LOG_PATH)) return null;
-  const logContent = readFileSync20(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: [] };
-  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);
-  }
-  return { lines, classified };
+  process.exit(errCount > 0 ? 1 : warnCount > 0 ? 2 : 0);
 }
 function stripTimestamp(line) {
   const match = line.match(/^\[(\d{4}-\d{2}-\d{2})\s+([\d:+-]+)\]\s*(.*)/);
@@ -29038,9 +29453,8 @@ async function doctorErrors(globalOpts) {
 `);
     return;
   }
-  const { classified } = result;
-  const total = classified.rate429.length + classified.contentSilence.length + classified.spawnTimeout.length + classified.other.length;
-  output({ total, classified }, () => {
+  const { rate429, contentSilence, spawnTimeout, other, total } = result;
+  output({ total, classified: result }, () => {
     const lines = [
       "",
       box("Recent Errors (last 24h)"),
@@ -29072,10 +29486,10 @@ async function doctorErrors(globalOpts) {
       }
       lines.push("");
     };
-    renderCategory("Telegram rate limits", classified.rate429, 5);
-    renderCategory("Content silence timeouts", classified.contentSilence, 5);
-    renderCategory("Spawn timeouts", classified.spawnTimeout, 5);
-    renderCategory("Other errors", classified.other, 10);
+    renderCategory("Telegram rate limits", rate429, 5);
+    renderCategory("Content silence timeouts", contentSilence, 5);
+    renderCategory("Spawn timeouts", spawnTimeout, 5);
+    renderCategory("Other errors", other, 10);
     if (total === 0) {
       lines.push(`  ${success("No errors in last 24h.")}`);
     } else {
@@ -29098,6 +29512,7 @@ var init_doctor = __esm({
     init_format2();
     init_paths();
     init_version();
+    init_checks();
   }
 });
 
@@ -29106,15 +29521,15 @@ var logs_exports = {};
 __export(logs_exports, {
   logsCommand: () => logsCommand
 });
-import { existsSync as existsSync31, readFileSync as readFileSync21, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync22, watchFile as watchFile2, unwatchFile as unwatchFile2 } from "fs";
 async function logsCommand(opts) {
   const logFile = opts.error ? ERROR_LOG_PATH : LOG_PATH;
-  if (!existsSync31(logFile)) {
+  if (!existsSync32(logFile)) {
     outputError("LOG_NOT_FOUND", `Log file not found: ${logFile}`);
     process.exit(1);
   }
   const maxLines = parseInt(opts.lines ?? "100", 10);
-  const content = readFileSync21(logFile, "utf-8");
+  const content = readFileSync22(logFile, "utf-8");
   const allLines = content.split("\n");
   const tailLines = allLines.slice(-maxLines);
   console.log(muted(`  \u2500\u2500 ${logFile} (last ${tailLines.length} lines) \u2500\u2500`));
@@ -29124,7 +29539,7 @@ async function logsCommand(opts) {
     let lastLength = content.length;
     watchFile2(logFile, { interval: 500 }, () => {
       try {
-        const newContent = readFileSync21(logFile, "utf-8");
+        const newContent = readFileSync22(logFile, "utf-8");
         if (newContent.length > lastLength) {
           const newPart = newContent.slice(lastLength);
           process.stdout.write(newPart);
@@ -29156,7 +29571,7 @@ __export(session_logs_exports, {
   sessionLogsList: () => sessionLogsList,
   sessionLogsTail: () => sessionLogsTail
 });
-import { readFileSync as readFileSync22, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
+import { readFileSync as readFileSync23, watchFile as watchFile3, unwatchFile as unwatchFile3 } from "fs";
 async function sessionLogsList(opts) {
   const logs = listSessionLogs();
   if (logs.length === 0) {
@@ -29213,12 +29628,12 @@ async function sessionLogsTail(opts) {
     console.log(muted("\n  Following... (Ctrl+C to stop)\n"));
     let lastLength = 0;
     try {
-      lastLength = readFileSync22(targetPath, "utf-8").length;
+      lastLength = readFileSync23(targetPath, "utf-8").length;
     } catch {
     }
     watchFile3(targetPath, { interval: 500 }, () => {
       try {
-        const content = readFileSync22(targetPath, "utf-8");
+        const content = readFileSync23(targetPath, "utf-8");
         if (content.length > lastLength) {
           process.stdout.write(content.slice(lastLength));
           lastLength = content.length;
@@ -29262,11 +29677,11 @@ __export(gemini_exports, {
   geminiReorder: () => geminiReorder,
   geminiRotation: () => geminiRotation
 });
-import { existsSync as existsSync33, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync23, chmodSync } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync14, writeFileSync as writeFileSync10, readFileSync as readFileSync24, chmodSync } from "fs";
 import { join as join32 } from "path";
 import { createInterface as createInterface8 } from "readline";
 function requireDb() {
-  if (!existsSync33(DB_PATH)) {
+  if (!existsSync34(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -29292,8 +29707,8 @@ function resolveOAuthEmail(configHome) {
   if (!configHome) return null;
   try {
     const accountsPath = join32(configHome, ".gemini", "google_accounts.json");
-    if (!existsSync33(accountsPath)) return null;
-    const accounts = JSON.parse(readFileSync23(accountsPath, "utf-8"));
+    if (!existsSync34(accountsPath)) return null;
+    const accounts = JSON.parse(readFileSync24(accountsPath, "utf-8"));
     return accounts.active || null;
   } catch {
     return null;
@@ -29376,7 +29791,7 @@ async function geminiAddKey(globalOpts, opts) {
 async function geminiAddAccount(globalOpts, opts) {
   await requireWriteDb();
   const slotsDir = join32(CC_CLAW_HOME, "gemini-slots");
-  if (!existsSync33(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
+  if (!existsSync34(slotsDir)) mkdirSync14(slotsDir, { recursive: true });
   const { addGeminiSlot: addGeminiSlot2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
   const tempId = Date.now();
   const slotDir = join32(slotsDir, `slot-${tempId}`);
@@ -29390,9 +29805,9 @@ async function geminiAddAccount(globalOpts, opts) {
   console.log("  Sign in with the Google account you want for this slot.");
   console.log("  After sign-in, type /quit to return here.");
   console.log("");
-  const { execSync: execSync6 } = await import("child_process");
+  const { execSync: execSync7 } = await import("child_process");
   try {
-    execSync6(`GEMINI_CLI_HOME=${slotDir} gemini`, {
+    execSync7(`GEMINI_CLI_HOME=${slotDir} gemini`, {
       stdio: "inherit",
       env: { ...process.env, GEMINI_CLI_HOME: slotDir, GEMINI_API_KEY: void 0, GOOGLE_API_KEY: void 0 },
       cwd: slotDir
@@ -29400,7 +29815,7 @@ async function geminiAddAccount(globalOpts, opts) {
   } catch {
   }
   const oauthPath = join32(slotDir, ".gemini", "oauth_creds.json");
-  if (!existsSync33(oauthPath)) {
+  if (!existsSync34(oauthPath)) {
     console.log(error2("\n  No OAuth credentials found. Sign-in may have failed."));
     console.log("  The slot directory is preserved at: " + slotDir);
     console.log("  Re-run: cc-claw gemini add-account\n");
@@ -29520,7 +29935,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
     return;
   }
   const settingsPath = join32(slot.configHome, ".gemini", "settings.json");
-  if (!existsSync33(settingsPath)) {
+  if (!existsSync34(settingsPath)) {
     mkdirSync14(join32(slot.configHome, ".gemini"), { recursive: true });
     writeFileSync10(settingsPath, JSON.stringify({
       security: { auth: { selectedType: "oauth-personal" } }
@@ -29531,9 +29946,9 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   console.log("  Sign in with the same Google account when prompted.");
   console.log("  After sign-in, type /quit to return here.");
   console.log("");
-  const { execSync: execSync6 } = await import("child_process");
+  const { execSync: execSync7 } = await import("child_process");
   try {
-    execSync6(`gemini`, {
+    execSync7(`gemini`, {
       stdio: "inherit",
       env: {
         ...process.env,
@@ -29546,7 +29961,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   } catch {
   }
   const oauthPath = join32(slot.configHome, ".gemini", "oauth_creds.json");
-  if (!existsSync33(oauthPath)) {
+  if (!existsSync34(oauthPath)) {
     console.log(error2("\n  Re-login failed \u2014 no OAuth credentials found."));
     console.log(`  Try again: cc-claw gemini re-login ${idOrLabel}
 `);
@@ -29556,7 +29971,7 @@ async function geminiRelogin(globalOpts, idOrLabel) {
   setGeminiSlotEnabled2(slotId, true);
   let accountEmail = slot.label;
   try {
-    const accounts = JSON.parse(readFileSync23(join32(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
+    const accounts = JSON.parse(readFileSync24(join32(slot.configHome, ".gemini", "google_accounts.json"), "utf-8"));
     if (accounts.active) accountEmail = accounts.active;
   } catch {
   }
@@ -29615,11 +30030,11 @@ __export(backend_cmd_factory_exports, {
   makeReorder: () => makeReorder,
   registerBackendSlotCommands: () => registerBackendSlotCommands
 });
-import { existsSync as existsSync34, mkdirSync as mkdirSync15, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync15, readFileSync as readFileSync25 } from "fs";
 import { join as join33 } from "path";
 import { createInterface as createInterface9 } from "readline";
 function requireDb2() {
-  if (!existsSync34(DB_PATH)) {
+  if (!existsSync35(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -29709,7 +30124,7 @@ function makeAddAccount(backend2, displayName) {
     }
     await requireWriteDb2();
     const slotsDir = join33(CC_CLAW_HOME, config2.slotsSubdir);
-    if (!existsSync34(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
+    if (!existsSync35(slotsDir)) mkdirSync15(slotsDir, { recursive: true });
     const tempId = Date.now();
     const slotDir = join33(slotsDir, `slot-${tempId}`);
     mkdirSync15(slotDir, { recursive: true, mode: 448 });
@@ -29719,14 +30134,14 @@ function makeAddAccount(backend2, displayName) {
     console.log(`  Sign in with the account you want for this slot.`);
     console.log(`  After sign-in completes, return here.`);
     console.log("");
-    const { execSync: execSync6 } = await import("child_process");
+    const { execSync: execSync7 } = await import("child_process");
     const loginEnv = {
       ...process.env,
       [config2.envKey]: config2.envValue(slotDir),
       ...config2.envOverrides
     };
     try {
-      execSync6(config2.loginCommand.join(" "), {
+      execSync7(config2.loginCommand.join(" "), {
         stdio: "inherit",
         env: loginEnv,
         cwd: slotDir
@@ -29871,14 +30286,14 @@ function makeRelogin(backend2, displayName) {
     console.log(`  Re-authenticating ${displayName} slot "${slot.label || `#${slot.id}`}"...`);
     console.log(`  Sign in with the same account when the browser opens.`);
     console.log("");
-    const { execSync: execSync6 } = await import("child_process");
+    const { execSync: execSync7 } = await import("child_process");
     const loginEnv = {
       ...process.env,
       [config2.envKey]: config2.envValue(slot.configHome),
       ...config2.envOverrides
     };
     try {
-      execSync6(config2.loginCommand.join(" "), {
+      execSync7(config2.loginCommand.join(" "), {
         stdio: "inherit",
         env: loginEnv,
         cwd: slot.configHome
@@ -29967,17 +30382,17 @@ var init_backend_cmd_factory = __esm({
         verifyCredentials: (slotDir) => {
           const claudeJson = join33(slotDir, ".claude.json");
           const claudeJsonNested = join33(slotDir, ".claude", ".claude.json");
-          if (existsSync34(claudeJson)) {
+          if (existsSync35(claudeJson)) {
             try {
-              const data = JSON.parse(readFileSync24(claudeJson, "utf-8"));
+              const data = JSON.parse(readFileSync25(claudeJson, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
             }
           }
-          if (existsSync34(claudeJsonNested)) {
+          if (existsSync35(claudeJsonNested)) {
             try {
-              const data = JSON.parse(readFileSync24(claudeJsonNested, "utf-8"));
+              const data = JSON.parse(readFileSync25(claudeJsonNested, "utf-8"));
               return Boolean(data.oauthAccount);
             } catch {
               return false;
@@ -29987,8 +30402,8 @@ var init_backend_cmd_factory = __esm({
         },
         extractLabel: (slotDir) => {
           try {
-            const { execSync: execSync6 } = __require("child_process");
-            const out = execSync6("claude auth status", {
+            const { execSync: execSync7 } = __require("child_process");
+            const out = execSync7("claude auth status", {
               encoding: "utf-8",
               env: { ...process.env, HOME: slotDir, ANTHROPIC_API_KEY: void 0 },
               timeout: 1e4
@@ -29999,8 +30414,8 @@ var init_backend_cmd_factory = __esm({
           }
           try {
             const claudeJson = join33(slotDir, ".claude.json");
-            if (existsSync34(claudeJson)) {
-              const data = JSON.parse(readFileSync24(claudeJson, "utf-8"));
+            if (existsSync35(claudeJson)) {
+              const data = JSON.parse(readFileSync25(claudeJson, "utf-8"));
               if (data.oauthAccount?.emailAddress) return data.oauthAccount.emailAddress;
             }
           } catch {
@@ -30015,11 +30430,11 @@ var init_backend_cmd_factory = __esm({
         envValue: (slotDir) => slotDir,
         envOverrides: { OPENAI_API_KEY: void 0 },
         verifyCredentials: (slotDir) => {
-          return existsSync34(join33(slotDir, "auth.json"));
+          return existsSync35(join33(slotDir, "auth.json"));
         },
         extractLabel: (slotDir) => {
           try {
-            const authData = JSON.parse(readFileSync24(join33(slotDir, "auth.json"), "utf-8"));
+            const authData = JSON.parse(readFileSync25(join33(slotDir, "auth.json"), "utf-8"));
             if (authData.email) return authData.email;
             if (authData.account_name) return authData.account_name;
             if (authData.user?.email) return authData.user.email;
@@ -30043,9 +30458,9 @@ __export(ollama_exports3, {
   ollamaRemove: () => ollamaRemove,
   ollamaTest: () => ollamaTest
 });
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync36 } from "fs";
 function requireDb3() {
-  if (!existsSync35(DB_PATH)) {
+  if (!existsSync36(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -30304,12 +30719,12 @@ __export(backend_exports, {
   backendList: () => backendList,
   backendSet: () => backendSet
 });
-import { existsSync as existsSync36 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 async function backendList(globalOpts) {
   const { getAvailableAdapters: getAvailableAdapters3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   const chatId = resolveChatId2(globalOpts);
   let activeBackend = null;
-  if (existsSync36(DB_PATH)) {
+  if (existsSync37(DB_PATH)) {
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
     try {
@@ -30340,7 +30755,7 @@ async function backendList(globalOpts) {
 }
 async function backendGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync36(DB_PATH)) {
+  if (!existsSync37(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -30384,13 +30799,13 @@ __export(model_exports, {
   modelList: () => modelList,
   modelSet: () => modelSet
 });
-import { existsSync as existsSync37 } from "fs";
+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: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+  const { getAdapter: getAdapter5, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
   let backendId = "claude";
-  if (existsSync37(DB_PATH)) {
+  if (existsSync38(DB_PATH)) {
     const readDb = openDatabaseReadOnly2();
     try {
       const row = readDb.prepare("SELECT backend FROM chat_backend WHERE chat_id = ?").get(chatId);
@@ -30400,7 +30815,7 @@ async function modelList(globalOpts) {
     readDb.close();
   }
   try {
-    const adapter = getAdapter4(backendId);
+    const adapter = getAdapter5(backendId);
     const models = Object.entries(adapter.availableModels).map(([id, info]) => ({
       id,
       label: info.label,
@@ -30423,7 +30838,7 @@ async function modelList(globalOpts) {
 }
 async function modelGet(globalOpts) {
   const chatId = resolveChatId2(globalOpts);
-  if (!existsSync37(DB_PATH)) {
+  if (!existsSync38(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30467,9 +30882,9 @@ __export(memory_exports2, {
   memoryList: () => memoryList,
   memorySearch: () => memorySearch
 });
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync39 } from "fs";
 async function memoryList(globalOpts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -30493,7 +30908,7 @@ async function memoryList(globalOpts) {
   });
 }
 async function memorySearch(globalOpts, query) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30515,7 +30930,7 @@ async function memorySearch(globalOpts, query) {
   });
 }
 async function memoryHistory(globalOpts, opts) {
-  if (!existsSync38(DB_PATH)) {
+  if (!existsSync39(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30563,7 +30978,7 @@ __export(cron_exports2, {
   cronList: () => cronList,
   cronRuns: () => cronRuns
 });
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 function parseFallbacks(raw) {
   return raw.slice(0, 3).map((f) => {
     const [backend2, ...rest] = f.split(":");
@@ -30584,7 +30999,7 @@ function parseAndValidateTimeout(raw) {
   return val;
 }
 async function cronList(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30622,7 +31037,7 @@ async function cronList(globalOpts) {
   });
 }
 async function cronHealth(globalOpts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30783,7 +31198,7 @@ async function cronEdit(globalOpts, id, opts) {
   }
 }
 async function cronRuns(globalOpts, jobId, opts) {
-  if (!existsSync39(DB_PATH)) {
+  if (!existsSync40(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30830,9 +31245,9 @@ __export(agents_exports, {
   runnersList: () => runnersList,
   tasksList: () => tasksList
 });
-import { existsSync as existsSync40 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 async function agentsList(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30863,7 +31278,7 @@ async function agentsList(globalOpts) {
   });
 }
 async function tasksList(globalOpts) {
-  if (!existsSync40(DB_PATH)) {
+  if (!existsSync41(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -30991,10 +31406,10 @@ __export(db_exports, {
   dbPath: () => dbPath,
   dbStats: () => dbStats
 });
-import { existsSync as existsSync41, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
+import { existsSync as existsSync42, statSync as statSync11, copyFileSync as copyFileSync3, mkdirSync as mkdirSync16 } from "fs";
 import { dirname as dirname7 } from "path";
 async function dbStats(globalOpts) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -31002,7 +31417,7 @@ async function dbStats(globalOpts) {
   const readDb = openDatabaseReadOnly2();
   const mainSize = statSync11(DB_PATH).size;
   const walPath = DB_PATH + "-wal";
-  const walSize = existsSync41(walPath) ? statSync11(walPath).size : 0;
+  const walSize = existsSync42(walPath) ? statSync11(walPath).size : 0;
   const tableNames = readDb.prepare(
     "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts%' ORDER BY name"
   ).all();
@@ -31036,7 +31451,7 @@ async function dbPath(globalOpts) {
   output({ path: DB_PATH }, (d) => d.path);
 }
 async function dbBackup(globalOpts, destPath) {
-  if (!existsSync41(DB_PATH)) {
+  if (!existsSync42(DB_PATH)) {
     outputError("DB_NOT_FOUND", `Database not found at ${DB_PATH}`);
     process.exit(1);
   }
@@ -31045,7 +31460,7 @@ async function dbBackup(globalOpts, destPath) {
     mkdirSync16(dirname7(dest), { recursive: true });
     copyFileSync3(DB_PATH, dest);
     const walPath = DB_PATH + "-wal";
-    if (existsSync41(walPath)) copyFileSync3(walPath, dest + "-wal");
+    if (existsSync42(walPath)) copyFileSync3(walPath, dest + "-wal");
     output({ path: dest, sizeBytes: statSync11(dest).size }, (d) => {
       const b = d;
       return `
@@ -31074,9 +31489,9 @@ __export(usage_exports, {
   usageCost: () => usageCost,
   usageTokens: () => usageTokens
 });
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 function ensureDb() {
-  if (!existsSync42(DB_PATH)) {
+  if (!existsSync43(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -31266,9 +31681,9 @@ __export(config_exports2, {
   configList: () => configList,
   configSet: () => configSet
 });
-import { existsSync as existsSync43, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync26 } from "fs";
 async function configList(globalOpts) {
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31302,7 +31717,7 @@ async function configGet(globalOpts, key) {
     outputError("INVALID_KEY", `Unknown config key "${key}". Valid keys: ${RUNTIME_KEYS.join(", ")}`);
     process.exit(1);
   }
-  if (!existsSync43(DB_PATH)) {
+  if (!existsSync44(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31348,11 +31763,11 @@ async function configSet(globalOpts, key, value) {
   }
 }
 async function configEnv(_globalOpts) {
-  if (!existsSync43(ENV_PATH)) {
+  if (!existsSync44(ENV_PATH)) {
     outputError("ENV_NOT_FOUND", `No .env file at ${ENV_PATH}. Run cc-claw setup.`);
     process.exit(1);
   }
-  const content = readFileSync25(ENV_PATH, "utf-8");
+  const content = readFileSync26(ENV_PATH, "utf-8");
   const entries = {};
   const secretPatterns = /TOKEN|KEY|SECRET|PASSWORD|CREDENTIALS/i;
   for (const line of content.split("\n")) {
@@ -31402,9 +31817,9 @@ __export(session_exports, {
   sessionGet: () => sessionGet,
   sessionNew: () => sessionNew
 });
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync45 } from "fs";
 async function sessionGet(globalOpts) {
-  if (!existsSync44(DB_PATH)) {
+  if (!existsSync45(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31465,9 +31880,9 @@ __export(permissions_exports, {
   verboseGet: () => verboseGet,
   verboseSet: () => verboseSet
 });
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 function ensureDb2() {
-  if (!existsSync45(DB_PATH)) {
+  if (!existsSync46(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31614,9 +32029,9 @@ __export(cwd_exports, {
   cwdGet: () => cwdGet,
   cwdSet: () => cwdSet
 });
-import { existsSync as existsSync46 } from "fs";
+import { existsSync as existsSync47 } from "fs";
 async function cwdGet(globalOpts) {
-  if (!existsSync46(DB_PATH)) {
+  if (!existsSync47(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31678,9 +32093,9 @@ __export(voice_exports, {
   voiceGet: () => voiceGet,
   voiceSet: () => voiceSet
 });
-import { existsSync as existsSync47 } from "fs";
+import { existsSync as existsSync48 } from "fs";
 async function voiceGet(globalOpts) {
-  if (!existsSync47(DB_PATH)) {
+  if (!existsSync48(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31729,9 +32144,9 @@ __export(heartbeat_exports, {
   heartbeatGet: () => heartbeatGet,
   heartbeatSet: () => heartbeatSet
 });
-import { existsSync as existsSync48 } from "fs";
+import { existsSync as existsSync49 } from "fs";
 async function heartbeatGet(globalOpts) {
-  if (!existsSync48(DB_PATH)) {
+  if (!existsSync49(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31746,8 +32161,25 @@ async function heartbeatGet(globalOpts) {
     intervalMinutes: row.interval_ms / 6e4,
     activeStart: row.active_start,
     activeEnd: row.active_end,
-    lastBeatAt: row.last_beat_at
-  } : { enabled: false, intervalMs: 18e5, intervalMinutes: 30, activeStart: "08:00", activeEnd: "22:00", lastBeatAt: null };
+    lastBeatAt: row.last_beat_at,
+    backend: row.backend ?? null,
+    model: row.model ?? null,
+    fallbacks: row.fallbacks ?? null,
+    thinking: row.thinking ?? null,
+    target: row.target ?? null
+  } : {
+    enabled: false,
+    intervalMs: 18e5,
+    intervalMinutes: 30,
+    activeStart: "08:00",
+    activeEnd: "22:00",
+    lastBeatAt: null,
+    backend: null,
+    model: null,
+    fallbacks: null,
+    thinking: null,
+    target: null
+  };
   output(data, (d) => {
     const h = d;
     const lines = [
@@ -31757,9 +32189,30 @@ async function heartbeatGet(globalOpts) {
       kvLine("Status", h.enabled ? success("on") : muted("off")),
       kvLine("Interval", `${h.intervalMinutes}m`),
       kvLine("Active hours", `${h.activeStart} - ${h.activeEnd}`),
-      kvLine("Last beat", h.lastBeatAt ?? muted("never")),
-      ""
+      kvLine("Backend", h.backend ?? muted("default")),
+      kvLine("Model", h.model ?? muted("default")),
+      kvLine("Thinking", h.thinking ?? muted("off"))
     ];
+    if (h.fallbacks) {
+      try {
+        const parsed = JSON.parse(h.fallbacks);
+        const chain = parsed.map((f) => `${f.backend}${f.model ? `:${f.model}` : ""}`).join(" \u2192 ");
+        lines.push(kvLine("Fallbacks", chain));
+      } catch {
+        lines.push(kvLine("Fallbacks", h.fallbacks));
+      }
+    } else {
+      lines.push(kvLine("Fallbacks", muted("none")));
+    }
+    if (h.target) {
+      lines.push(kvLine("Target", h.target));
+    }
+    lines.push(kvLine("Last beat", h.lastBeatAt ?? muted("never")));
+    if (!h.enabled) {
+      lines.push("");
+      lines.push(`  ${warning("\u26A0 Heartbeat is disabled \u2014 you won't receive proactive alerts.")}`);
+    }
+    lines.push("");
     return lines.join("\n");
   });
 }
@@ -31781,7 +32234,7 @@ async function heartbeatSet(globalOpts, subcommand, value) {
       body.enabled = false;
       successMsg = "Heartbeat disabled.";
       break;
-    case "interval":
+    case "interval": {
       if (!value) {
         outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set interval <value>");
         process.exit(1);
@@ -31797,7 +32250,8 @@ async function heartbeatSet(globalOpts, subcommand, value) {
       body.intervalMs = ms;
       successMsg = `Heartbeat interval: ${ms / 6e4}m`;
       break;
-    case "hours":
+    }
+    case "hours": {
       if (!value) {
         outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set hours <start>-<end>");
         process.exit(1);
@@ -31811,8 +32265,71 @@ async function heartbeatSet(globalOpts, subcommand, value) {
       body.activeEnd = `${hourMatch[2].padStart(2, "0")}:00`;
       successMsg = `Active hours: ${body.activeStart} - ${body.activeEnd}`;
       break;
+    }
+    case "backend": {
+      if (!value) {
+        outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set backend <name|default>");
+        process.exit(1);
+      }
+      if (value === "default") {
+        body.backend = null;
+        body.model = null;
+        successMsg = "Heartbeat backend: default (chat-level)";
+      } else {
+        body.backend = value;
+        body.model = null;
+        successMsg = `Heartbeat backend: ${value}`;
+      }
+      break;
+    }
+    case "model": {
+      if (!value) {
+        outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set model <name|default>");
+        process.exit(1);
+      }
+      if (value === "default") {
+        body.model = null;
+        successMsg = "Heartbeat model: default";
+      } else {
+        body.model = value;
+        successMsg = `Heartbeat model: ${value}`;
+      }
+      break;
+    }
+    case "thinking": {
+      if (!value) {
+        outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set thinking <off|low|medium|high>");
+        process.exit(1);
+      }
+      const valid = ["off", "low", "medium", "high"];
+      if (!valid.includes(value)) {
+        outputError("INVALID_THINKING", `Valid values: ${valid.join(", ")}`);
+        process.exit(1);
+      }
+      body.thinking = value === "off" ? null : value;
+      successMsg = `Heartbeat thinking: ${value}`;
+      break;
+    }
+    case "fallbacks": {
+      if (!value) {
+        outputError("MISSING_VALUE", "Usage: cc-claw heartbeat set fallbacks <backend1,backend2|clear>");
+        process.exit(1);
+      }
+      if (value === "clear" || value === "none") {
+        body.fallbacks = null;
+        successMsg = "Heartbeat fallbacks: cleared";
+      } else {
+        const chain = value.split(",").map((s) => {
+          const [backend2, model2] = s.trim().split(":");
+          return model2 ? { backend: backend2, model: model2 } : { backend: backend2 };
+        });
+        body.fallbacks = JSON.stringify(chain);
+        successMsg = `Heartbeat fallbacks: ${chain.map((f) => f.backend).join(" \u2192 ")}`;
+      }
+      break;
+    }
     default:
-      outputError("UNKNOWN_SUBCOMMAND", `Unknown: "${subcommand}". Use: on, off, interval, hours`);
+      outputError("UNKNOWN_SUBCOMMAND", `Unknown: "${subcommand}". Use: on, off, interval, hours, backend, model, thinking, fallbacks`);
       process.exit(1);
   }
   const res = await apiPost2("/api/heartbeat/set", body);
@@ -31840,9 +32357,9 @@ __export(summarizer_exports, {
   summarizerGet: () => summarizerGet,
   summarizerSet: () => summarizerSet
 });
-import { existsSync as existsSync49 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 async function summarizerGet(globalOpts) {
-  if (!existsSync49(DB_PATH)) {
+  if (!existsSync50(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31886,9 +32403,9 @@ __export(thinking_exports, {
   thinkingGet: () => thinkingGet,
   thinkingSet: () => thinkingSet
 });
-import { existsSync as existsSync50 } from "fs";
+import { existsSync as existsSync51 } from "fs";
 async function thinkingGet(globalOpts) {
-  if (!existsSync50(DB_PATH)) {
+  if (!existsSync51(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -31932,9 +32449,9 @@ __export(chats_exports, {
   chatsList: () => chatsList,
   chatsRemoveAlias: () => chatsRemoveAlias
 });
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 async function chatsList(_globalOpts) {
-  if (!existsSync51(DB_PATH)) {
+  if (!existsSync52(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32062,9 +32579,9 @@ var mcps_exports2 = {};
 __export(mcps_exports2, {
   mcpsList: () => mcpsList
 });
-import { existsSync as existsSync52 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 async function mcpsList(_globalOpts) {
-  if (!existsSync52(DB_PATH)) {
+  if (!existsSync53(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found.");
     process.exit(1);
   }
@@ -32101,11 +32618,11 @@ __export(chat_exports2, {
   chatSend: () => chatSend
 });
 import { request as httpRequest2 } from "http";
-import { readFileSync as readFileSync26, existsSync as existsSync53 } from "fs";
+import { readFileSync as readFileSync27, existsSync as existsSync54 } from "fs";
 function getToken2() {
   if (process.env.CC_CLAW_API_TOKEN) return process.env.CC_CLAW_API_TOKEN;
   try {
-    if (existsSync53(TOKEN_PATH2)) return readFileSync26(TOKEN_PATH2, "utf-8").trim();
+    if (existsSync54(TOKEN_PATH2)) return readFileSync27(TOKEN_PATH2, "utf-8").trim();
   } catch {
   }
   return null;
@@ -32785,9 +33302,9 @@ __export(evolve_exports2, {
   evolveStatus: () => evolveStatus,
   evolveUndo: () => evolveUndo
 });
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 function ensureDb3() {
-  if (!existsSync54(DB_PATH)) {
+  if (!existsSync55(DB_PATH)) {
     outputError("DB_NOT_FOUND", "Database not found. Run cc-claw setup first.");
     process.exit(1);
   }
@@ -33261,8 +33778,8 @@ var init_optimize2 = __esm({
 
 // src/setup.ts
 var setup_exports = {};
-import { existsSync as existsSync55, writeFileSync as writeFileSync12, readFileSync as readFileSync27, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
-import { execFileSync as execFileSync5 } from "child_process";
+import { existsSync as existsSync56, writeFileSync as writeFileSync12, readFileSync as readFileSync28, copyFileSync as copyFileSync4, mkdirSync as mkdirSync18, statSync as statSync12 } from "fs";
+import { execFileSync as execFileSync6 } from "child_process";
 import { createInterface as createInterface11 } from "readline";
 import { join as join35 } from "path";
 function divider2() {
@@ -33326,7 +33843,7 @@ async function setup() {
   let foundAnyBackend = false;
   for (const bk of backends) {
     try {
-      const path = execFileSync5("which", [bk.cmd], { encoding: "utf-8" }).trim();
+      const path = execFileSync6("which", [bk.cmd], { encoding: "utf-8" }).trim();
       console.log(green(`  ${bk.name} CLI found: ${path}`));
       foundAnyBackend = true;
     } catch {
@@ -33339,21 +33856,21 @@ async function setup() {
   }
   console.log("");
   for (const dir of [CC_CLAW_HOME, DATA_PATH, LOGS_PATH, SKILLS_PATH, RUNNERS_PATH, AGENTS_PATH]) {
-    if (!existsSync55(dir)) mkdirSync18(dir, { recursive: true });
+    if (!existsSync56(dir)) mkdirSync18(dir, { recursive: true });
   }
   const env = {};
-  const envSource = existsSync55(ENV_PATH) ? ENV_PATH : existsSync55(".env") ? ".env" : null;
+  const envSource = existsSync56(ENV_PATH) ? ENV_PATH : existsSync56(".env") ? ".env" : null;
   if (envSource) {
     console.log(yellow(`  Found existing config at ${envSource} \u2014 your values will be preserved`));
     console.log(yellow("  unless you enter new ones. Just press Enter to keep existing values.\n"));
-    const existing = readFileSync27(envSource, "utf-8");
+    const existing = readFileSync28(envSource, "utf-8");
     for (const line of existing.split("\n")) {
       const match = line.match(/^([^#=]+)=(.*)$/);
       if (match) env[match[1].trim()] = match[2].trim();
     }
   }
   const cwdDb = join35(process.cwd(), "cc-claw.db");
-  if (existsSync55(cwdDb) && !existsSync55(DB_PATH)) {
+  if (existsSync56(cwdDb) && !existsSync56(DB_PATH)) {
     const { size } = statSync12(cwdDb);
     console.log(yellow(`  Found existing database at ${cwdDb} (${(size / 1024).toFixed(0)}KB)`));
     const migrate = await confirm("Copy database to ~/.cc-claw/? (preserves memories & history)", true);
@@ -34073,7 +34590,7 @@ heartbeat.command("get").description("Show heartbeat status and config").action(
   const { heartbeatGet: heartbeatGet2 } = await Promise.resolve().then(() => (init_heartbeat3(), heartbeat_exports));
   await heartbeatGet2(program.opts());
 });
-heartbeat.command("set <subcommand> [value]").description("Configure heartbeat (on/off/interval <val>/hours <range>)").action(async (subcommand, value) => {
+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));
   await heartbeatSet2(program.opts(), subcommand, value);
 });
@@ -34246,8 +34763,8 @@ async function run(argv = process.argv) {
   if (argv.includes("--version") || argv.includes("-V")) {
     console.log(VERSION);
     try {
-      const { execFileSync: execFileSync6 } = await import("child_process");
-      const latest = execFileSync6("npm", ["view", "cc-claw", "version"], { encoding: "utf-8", timeout: 1e4 }).trim();
+      const { execFileSync: execFileSync7 } = await import("child_process");
+      const latest = execFileSync7("npm", ["view", "cc-claw", "version"], { encoding: "utf-8", timeout: 1e4 }).trim();
       if (latest && latest !== VERSION) {
         console.log(`
 Update available: v${latest} (current: v${VERSION})`);