cc-claw 0.20.14 → 0.20.15

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.20.14" : (() => {
+    VERSION = true ? "0.20.15" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -1333,7 +1333,8 @@ function initSchema(db3) {
       last_run_at TEXT,
       next_run_at TEXT,
       consecutive_failures INTEGER NOT NULL DEFAULT 0,
-      allow_paid_slots INTEGER NOT NULL DEFAULT 0
+      allow_paid_slots INTEGER NOT NULL DEFAULT 0,
+      credential_slot_id INTEGER
     );
   `);
   try {
@@ -1493,6 +1494,10 @@ function initSchema(db3) {
         db3.exec("ALTER TABLE jobs ADD COLUMN allow_paid_slots INTEGER NOT NULL DEFAULT 0");
       } catch {
       }
+      try {
+        db3.exec("ALTER TABLE jobs ADD COLUMN credential_slot_id INTEGER");
+      } catch {
+      }
       try {
         db3.exec("UPDATE jobs SET job_type = 'reflection' WHERE description LIKE '%reflection analysis%' AND job_type = 'normal'");
       } catch {
@@ -3317,8 +3322,8 @@ function insertJob(params) {
   const db3 = getDb();
   const result = db3.prepare(`
     INSERT INTO jobs (schedule_type, cron, at_time, every_ms, title, description, chat_id,
-      backend, model, thinking, timeout, fallbacks, session_type, channel, target, delivery_mode, timezone, job_type, allow_paid_slots)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      backend, model, thinking, timeout, fallbacks, session_type, channel, target, delivery_mode, timezone, job_type, allow_paid_slots, credential_slot_id)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `).run(
     params.scheduleType,
     params.cron ?? null,
@@ -3338,7 +3343,8 @@ function insertJob(params) {
     params.deliveryMode ?? "announce",
     params.timezone ?? "UTC",
     params.jobType ?? "normal",
-    params.allowPaidSlots ? 1 : 0
+    params.allowPaidSlots ? 1 : 0,
+    params.credentialSlotId ?? null
   );
   return getJobById(Number(result.lastInsertRowid));
 }
@@ -3346,6 +3352,7 @@ function mapJobRow(row) {
   if (!row) return void 0;
   row.fallbacks = row.fallbacks ? JSON.parse(row.fallbacks) : [];
   row.allowPaidSlots = !!row.allowPaidSlots;
+  row.credentialSlotId = row.credentialSlotId ?? null;
   return row;
 }
 function getJobById(id) {
@@ -3400,7 +3407,8 @@ function updateJob(id, fields) {
     deliveryMode: "delivery_mode",
     timezone: "timezone",
     jobType: "job_type",
-    allowPaidSlots: "allow_paid_slots"
+    allowPaidSlots: "allow_paid_slots",
+    credentialSlotId: "credential_slot_id"
   };
   for (const [key, val] of Object.entries(fields)) {
     const col = fieldMap[key];
@@ -3473,7 +3481,7 @@ var init_jobs = __esm({
     session_type as sessionType, channel, target, delivery_mode as deliveryMode,
     timezone, job_type as jobType, enabled, active, created_at as createdAt, last_run_at as lastRunAt,
     next_run_at as nextRunAt, consecutive_failures as consecutiveFailures,
-    allow_paid_slots as allowPaidSlots
+    allow_paid_slots as allowPaidSlots, credential_slot_id as credentialSlotId
   FROM jobs
 `;
   }
@@ -4141,6 +4149,24 @@ var init_store5 = __esm({
   }
 });
 
+// src/backends/types.ts
+function isBackendId(value) {
+  return Object.values(BACKEND).includes(value);
+}
+var BACKEND;
+var init_types = __esm({
+  "src/backends/types.ts"() {
+    "use strict";
+    BACKEND = {
+      CLAUDE: "claude",
+      GEMINI: "gemini",
+      CODEX: "codex",
+      CURSOR: "cursor",
+      OLLAMA: "ollama"
+    };
+  }
+});
+
 // src/env.ts
 import { homedir as homedir2 } from "os";
 function stripProxyVars(env) {
@@ -4223,6 +4249,11 @@ var init_strip_thinking = __esm({
 });
 
 // src/backends/resolve-executable.ts
+var resolve_executable_exports = {};
+__export(resolve_executable_exports, {
+  clearExecutableCache: () => clearExecutableCache,
+  resolveExecutable: () => resolveExecutable
+});
 import { existsSync as existsSync2 } from "fs";
 import { spawnSync } from "child_process";
 function resolveExecutable(config2) {
@@ -4259,6 +4290,9 @@ function resolveExecutable(config2) {
   cache.set(config2.binaryName, fallback);
   return fallback;
 }
+function clearExecutableCache() {
+  cache.clear();
+}
 var cache;
 var init_resolve_executable = __esm({
   "src/backends/resolve-executable.ts"() {
@@ -6494,24 +6528,6 @@ var init_ollama2 = __esm({
   }
 });
 
-// src/backends/types.ts
-function isBackendId(value) {
-  return Object.values(BACKEND).includes(value);
-}
-var BACKEND;
-var init_types = __esm({
-  "src/backends/types.ts"() {
-    "use strict";
-    BACKEND = {
-      CLAUDE: "claude",
-      GEMINI: "gemini",
-      CODEX: "codex",
-      CURSOR: "cursor",
-      OLLAMA: "ollama"
-    };
-  }
-});
-
 // src/backends/index.ts
 var backends_exports = {};
 __export(backends_exports, {
@@ -14978,8 +14994,8 @@ var init_telegram_throttle = __esm({
   "src/channels/telegram-throttle.ts"() {
     "use strict";
     init_log();
-    PER_CHAT_INTERVAL_MS = 350;
-    GLOBAL_INTERVAL_MS = 50;
+    PER_CHAT_INTERVAL_MS = 1e3;
+    GLOBAL_INTERVAL_MS = 100;
     MAX_RETRIES2 = 2;
     RETRY_DELAY_MS = 1e3;
     MAX_QUEUE_SIZE = 100;
@@ -15007,6 +15023,9 @@ var init_telegram_throttle = __esm({
       }
       /** Enqueue a Telegram API call with automatic pacing and 429 handling. */
       async send(chatId, label2, fn) {
+        if (this.isPaused() && label2.startsWith("editText")) {
+          throw new Error("Throttle paused (rate limit active) \u2014 edit skipped");
+        }
         return new Promise((resolve, reject) => {
           if (this.queue.length >= MAX_QUEUE_SIZE) {
             const dropped = this.queue.shift();
@@ -15019,6 +15038,31 @@ var init_telegram_throttle = __esm({
           this.drain();
         });
       }
+      /**
+       * Best-effort send — drops silently if throttle is paused or queue is pressured.
+       * Used for cosmetic calls (typing indicators, reactions) that should count toward
+       * rate limits but must never queue up or amplify 429 spirals.
+       */
+      async tryBestEffort(chatId, label2, fn) {
+        if (this.isPaused()) return void 0;
+        if (this.queue.length > 10) return void 0;
+        const lastChat = this.lastSendPerChat.get(chatId) ?? 0;
+        if (Date.now() - lastChat < PER_CHAT_INTERVAL_MS) return void 0;
+        if (Date.now() - this.lastGlobalSend < GLOBAL_INTERVAL_MS) return void 0;
+        try {
+          const result = await fn();
+          this.recordSend(chatId);
+          return result;
+        } catch (err) {
+          if (is429(err)) {
+            const retrySec = err.parameters?.retry_after ?? 10;
+            this.pausedUntil = Date.now() + retrySec * 1e3;
+            if (this.pauseStartedAt === 0) this.pauseStartedAt = Date.now();
+            warn(`[throttle] Best-effort ${label2} hit 429, pausing for ${retrySec}s`);
+          }
+          return void 0;
+        }
+      }
       /** Check whether the throttle is currently paused (rate-limited). */
       isPaused() {
         return Date.now() < this.pausedUntil;
@@ -15101,12 +15145,13 @@ var init_telegram_throttle = __esm({
       // ── Pause management ────────────────────────────────────────────────
       enterPause(retrySec, failedItem) {
         this.queue.unshift(failedItem);
-        this.pausedUntil = Date.now() + retrySec * 1e3;
+        const bufferedSec = Math.ceil(retrySec * 1.5);
+        this.pausedUntil = Date.now() + bufferedSec * 1e3;
         if (this.pauseStartedAt === 0) this.pauseStartedAt = Date.now();
         for (const qi of this.queue) {
           this.chatsPendingNotification.add(qi.chatId);
         }
-        warn(`[throttle] 429 \u2014 pausing ALL sends for ${retrySec}s (${this.queue.length} items queued)`);
+        warn(`[throttle] 429 \u2014 pausing ALL sends for ${bufferedSec}s (retry_after=${retrySec}s + 50% buffer, ${this.queue.length} items queued)`);
       }
       async sendResumeNotifications() {
         const chats2 = new Set(this.chatsPendingNotification);
@@ -15739,6 +15784,7 @@ var init_profile = __esm({
 var classify_exports = {};
 __export(classify_exports, {
   classifyIntent: () => classifyIntent,
+  classifyIntentAsync: () => classifyIntentAsync,
   getIntentStats: () => getIntentStats,
   resetIntentStats: () => resetIntentStats
 });
@@ -15749,12 +15795,17 @@ function resetIntentStats() {
   intentCounts.chat = 0;
   intentCounts.agentic = 0;
 }
-function classifyIntent(text, chatId) {
+function classifyIntentFast(text, chatId) {
   const trimmed = text.trim();
   if (trimmed.startsWith(">>")) return "agentic";
   if (trimmed.startsWith("/")) return "agentic";
   const lower = trimmed.toLowerCase();
   const normalized = trimmed.replace(/^["'\u201C\u201D\u2018\u2019`\s]+|["'\u201C\u201D\u2018\u2019`\s]+$/g, "");
+  const lowerNoPunct = lower.replace(/[?!.,…]+$/, "").trim();
+  if (CHAT_EXACT.has(lowerNoPunct) || CHAT_EXACT.has(lower)) {
+    log(`[intent] "${lower}" -> chat (exact match)`);
+    return "chat";
+  }
   const sessionId = getSessionId(chatId);
   if (sessionId) {
     const lastTs = getLastMessageTimestamp(chatId);
@@ -15762,47 +15813,148 @@ function classifyIntent(text, chatId) {
       const elapsed = Date.now() - lastTs;
       if (elapsed < 12e4 && trimmed.length < 30) {
         log(`[intent] "${trimmed.slice(0, 30)}" -> agentic (active session, ${(elapsed / 1e3).toFixed(0)}s ago)`);
-        intentCounts.agentic++;
         return "agentic";
       }
     }
   }
-  if (CHAT_EXACT.has(lower)) {
-    log(`[intent] "${lower}" -> chat (exact match)`);
-    intentCounts.chat++;
-    return "chat";
-  }
   if (trimmed.length <= 4 && /^[\p{Emoji}\s]+$/u.test(trimmed)) {
     log(`[intent] "${trimmed}" -> chat (emoji-only)`);
-    intentCounts.chat++;
     return "chat";
   }
   for (const pattern of STRUCTURAL_PATTERNS) {
     if (pattern.test(normalized)) {
       log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (structural: ${pattern})`);
-      intentCounts.agentic++;
       return "agentic";
     }
   }
   for (const pattern of MUTATION_PATTERNS) {
     if (pattern.test(normalized)) {
       log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (mutation: ${pattern})`);
-      intentCounts.agentic++;
       return "agentic";
     }
   }
   for (const pattern of CHAT_QUESTION_PATTERNS) {
     if (pattern.test(normalized)) {
       log(`[intent] "${trimmed.slice(0, 40)}..." -> chat (question: ${pattern})`);
-      intentCounts.chat++;
       return "chat";
     }
   }
-  log(`[intent] "${trimmed.slice(0, 40)}..." -> agentic (default)`);
+  return null;
+}
+async function classifyWithLlm(text) {
+  try {
+    const ollamaResult = await classifyWithOllama(text);
+    if (ollamaResult) return ollamaResult;
+  } catch {
+  }
+  try {
+    const cliResult = await classifyWithSummarizerCli(text);
+    if (cliResult) return cliResult;
+  } catch {
+  }
+  return null;
+}
+async function classifyWithOllama(text) {
+  const ollamaService = await Promise.resolve().then(() => (init_service(), service_exports));
+  const ollamaClient = await Promise.resolve().then(() => (init_client(), client_exports));
+  const servers = ollamaService.listServers();
+  const onlineServer = servers.find((s) => s.status === "online");
+  if (!onlineServer) return null;
+  const models = ollamaService.listModels(onlineServer.name);
+  if (models.length === 0) return null;
+  const sorted = [...models].sort(
+    (a, b) => (a.sizeBytes ?? Infinity) - (b.sizeBytes ?? Infinity)
+  );
+  const model2 = sorted[0].name;
+  const result = await ollamaClient.chat(
+    onlineServer.baseUrl,
+    model2,
+    [{ role: "user", content: LLM_CLASSIFY_PROMPT + text.slice(0, 500) }],
+    { timeoutMs: LLM_CLASSIFY_TIMEOUT_MS, maxTokens: 5, temperature: 0 }
+  );
+  return parseClassifyResponse(result.text);
+}
+async function classifyWithSummarizerCli(text) {
+  const { getSummarizer: getSummarizer3 } = await Promise.resolve().then(() => (init_chat_settings(), chat_settings_exports));
+  const { getAdapter: getAdapter4, getAllAdapters: getAllAdapters5 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+  const config2 = getSummarizer3("__global__");
+  let backendId = config2.backend;
+  let modelName = config2.model;
+  if (!backendId) {
+    const adapters2 = getAllAdapters5();
+    const cheapAdapter = adapters2.find((a) => a.summarizerModel);
+    if (!cheapAdapter) return null;
+    backendId = cheapAdapter.id;
+    modelName = cheapAdapter.summarizerModel;
+  }
+  const adapter = getAdapter4(backendId);
+  if (!adapter) return null;
+  const model2 = modelName ?? adapter.summarizerModel;
+  const { spawn: spawn8 } = await import("child_process");
+  const { resolveExecutable: resolveExecutable4 } = await Promise.resolve().then(() => (init_resolve_executable(), resolve_executable_exports));
+  const exe = resolveExecutable4(adapter.id);
+  if (!exe) return null;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      proc.kill("SIGKILL");
+      resolve(null);
+    }, LLM_CLASSIFY_TIMEOUT_MS);
+    const args = adapter.id === "claude" ? ["-p", LLM_CLASSIFY_PROMPT + text.slice(0, 500), "--model", model2, "--no-input"] : ["-p", LLM_CLASSIFY_PROMPT + text.slice(0, 500), "--model", model2];
+    const proc = spawn8(exe, args, {
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: LLM_CLASSIFY_TIMEOUT_MS + 1e3
+    });
+    let output2 = "";
+    proc.stdout?.on("data", (chunk) => {
+      output2 += chunk.toString();
+    });
+    proc.on("close", () => {
+      clearTimeout(timeout);
+      resolve(parseClassifyResponse(output2));
+    });
+    proc.on("error", () => {
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+function parseClassifyResponse(text) {
+  const lower = text.trim().toLowerCase();
+  if (lower.includes("chat")) return "chat";
+  if (lower.includes("task")) return "agentic";
+  return null;
+}
+function classifyIntent(text, chatId) {
+  const fast = classifyIntentFast(text, chatId);
+  if (fast) {
+    intentCounts[fast]++;
+    return fast;
+  }
+  log(`[intent] "${text.slice(0, 40)}..." -> agentic (default)`);
+  intentCounts.agentic++;
+  return "agentic";
+}
+async function classifyIntentAsync(text, chatId) {
+  const fast = classifyIntentFast(text, chatId);
+  if (fast) {
+    intentCounts[fast]++;
+    return fast;
+  }
+  try {
+    const llmResult = await classifyWithLlm(text);
+    if (llmResult) {
+      log(`[intent] "${text.slice(0, 40)}..." -> ${llmResult} (LLM)`);
+      intentCounts[llmResult]++;
+      return llmResult;
+    }
+  } catch (err) {
+    warn(`[intent] LLM classification failed: ${err instanceof Error ? err.message : err}`);
+  }
+  log(`[intent] "${text.slice(0, 40)}..." -> agentic (default, LLM unavailable)`);
   intentCounts.agentic++;
   return "agentic";
 }
-var intentCounts, CHAT_EXACT, MUTATION_PATTERNS, CHAT_QUESTION_PATTERNS, STRUCTURAL_PATTERNS;
+var intentCounts, CHAT_EXACT, MUTATION_PATTERNS, CHAT_QUESTION_PATTERNS, STRUCTURAL_PATTERNS, LLM_CLASSIFY_PROMPT, LLM_CLASSIFY_TIMEOUT_MS;
 var init_classify = __esm({
   "src/intent/classify.ts"() {
     "use strict";
@@ -15898,6 +16050,13 @@ var init_classify = __esm({
       /\b(error|bug|crash|fail|broken|issue|problem|exception|stack\s?trace)\b/i,
       /\b(function|class|const|let|var|import|export|return|async|await)\b/i
     ];
+    LLM_CLASSIFY_PROMPT = `Classify this message as either "chat" or "task".
+- "chat" = greeting, small talk, acknowledgment, question, opinion, or anything conversational
+- "task" = request to DO something (research, draft, analyze, code, create, fix, etc.)
+Reply with ONLY the word "chat" or "task", nothing else.
+
+Message: `;
+    LLM_CLASSIFY_TIMEOUT_MS = 3e3;
   }
 });
 
@@ -16124,8 +16283,8 @@ async function handleWizardText(chatId, text, channel) {
     case "thinking": {
       const level = text.trim().toLowerCase();
       pending.thinking = level || "auto";
-      pending.step = "timeout";
-      await promptTimeout(chatId, channel);
+      pending.step = "account";
+      await promptAccount(chatId, channel);
       break;
     }
     case "timeout": {
@@ -16218,6 +16377,17 @@ async function handleWizardCallback(chatId, data, channel) {
     await promptThinking(chatId, channel);
   } else if (data.startsWith("sched:thinking:")) {
     pending.thinking = data.slice(15);
+    pending.step = "account";
+    await promptAccount(chatId, channel);
+  } else if (data.startsWith("sched:slot:")) {
+    const val = data.slice(11);
+    if (val === "auto") {
+      pending.credentialSlotId = null;
+    } else {
+      pending.credentialSlotId = parseInt(val, 10);
+    }
+    const slotLabel = resolveSlotLabel(pending.backend, pending.credentialSlotId);
+    await channel.sendText(chatId, `Account: ${slotLabel}`, { parseMode: "plain" });
     pending.step = "timeout";
     await promptTimeout(chatId, channel);
   } else if (data.startsWith("sched:timeout:")) {
@@ -16323,9 +16493,52 @@ async function promptThinking(chatId, channel) {
     await channel.sendKeyboard(chatId, "Thinking/effort level for this job?", buttons);
   } else {
     pending.thinking = "auto";
+    pending.step = "account";
+    await promptAccount(chatId, channel);
+  }
+}
+async function promptAccount(chatId, channel) {
+  const pending = pendingJobs.get(chatId);
+  if (!pending?.backend) {
+    if (pending) pending.step = "timeout";
+    await promptTimeout(chatId, channel);
+    return;
+  }
+  const isGemini = pending.backend === BACKEND.GEMINI;
+  const slots = isGemini ? getGeminiSlots() : getBackendSlots(pending.backend);
+  const enabledSlots = slots.filter((s) => s.enabled);
+  if (enabledSlots.length === 0) {
+    pending.credentialSlotId = null;
     pending.step = "timeout";
     await promptTimeout(chatId, channel);
+    return;
+  }
+  if (typeof channel.sendKeyboard !== "function") {
+    await channel.sendText(chatId, `Enter account slot ID, or "auto" for rotation:`, { parseMode: "plain" });
+    return;
   }
+  const buttons = [
+    [{ label: "\u{1F504} Auto (rotate)", data: "sched:slot:auto" }]
+  ];
+  for (const slot of enabledSlots) {
+    const s = slot;
+    const icon = s.slotType === "api_key" ? "\u{1F511}" : "\u{1F4E7}";
+    const label2 = s.label || s.email || `Slot #${s.id}`;
+    const type = s.slotType === "api_key" ? "API key" : "OAuth";
+    buttons.push([{ label: `${icon} ${label2} (${type})`, data: `sched:slot:${s.id}` }]);
+  }
+  await channel.sendKeyboard(chatId, "Which account should this job use?", buttons);
+}
+function resolveSlotLabel(backend2, slotId) {
+  if (!slotId || !backend2) return "Auto (rotate)";
+  const isGemini = backend2 === BACKEND.GEMINI;
+  const slots = isGemini ? getGeminiSlots() : getBackendSlots(backend2);
+  const slot = slots.find((s) => s.id === slotId);
+  if (!slot) return `Slot #${slotId} (unknown)`;
+  const icon = slot.slotType === "api_key" ? "\u{1F511}" : "\u{1F4E7}";
+  const label2 = slot.label || slot.email || `Slot #${slot.id}`;
+  const type = slot.slotType === "api_key" ? "API key" : "OAuth";
+  return `${icon} ${label2} (${type})`;
 }
 async function promptTimeout(chatId, channel) {
   if (typeof channel.sendKeyboard !== "function") {
@@ -16380,6 +16593,7 @@ async function promptConfirm(chatId, channel) {
   if (!pending) return;
   const backendName = pending.backend ? getAdapter(pending.backend).displayName : "default";
   const timeoutLabel = pending.timeout ? `${pending.timeout}s (${Math.round(pending.timeout / 60)} min)` : `Default (${TIMEOUT_DEFAULT_SECONDS}s)`;
+  const accountLabel = resolveSlotLabel(pending.backend, pending.credentialSlotId);
   const lines = [
     "Job configuration:",
     "",
@@ -16388,6 +16602,7 @@ async function promptConfirm(chatId, channel) {
     `  Timezone: ${pending.timezone ?? "UTC"}`,
     `  Backend:  ${backendName}`,
     `  Model:    ${pending.model ?? "default"}`,
+    `  Account:  ${accountLabel}`,
     `  Thinking: ${pending.thinking ?? "auto"}`,
     `  Timeout:  ${timeoutLabel}`,
     `  Session:  ${pending.sessionType ?? "isolated"}`,
@@ -16445,7 +16660,8 @@ ${pending.task}`, {
     channel: pending.channel ?? null,
     target: pending.target ?? null,
     deliveryMode: pending.deliveryMode ?? "announce",
-    timezone: pending.timezone ?? "UTC"
+    timezone: pending.timezone ?? "UTC",
+    credentialSlotId: pending.credentialSlotId ?? null
   };
   try {
     if (editJobId) {
@@ -16507,7 +16723,8 @@ async function startEditWizard(chatId, jobId, channel) {
     sessionType: job.sessionType,
     deliveryMode: job.deliveryMode,
     channel: job.channel ?? void 0,
-    target: job.target ?? void 0
+    target: job.target ?? void 0,
+    credentialSlotId: job.credentialSlotId ?? void 0
   };
   if (pendingJobs.has(chatId)) cancelWizard(chatId);
   pendingJobs.set(chatId, pending);
@@ -17273,10 +17490,11 @@ var init_live_status = __esm({
     "use strict";
     init_log();
     init_helpers();
-    FLUSH_INTERVAL_DM_MS = 1e3;
-    FLUSH_INTERVAL_GROUP_MS = 3e3;
+    init_telegram_throttle();
+    FLUSH_INTERVAL_DM_MS = 2e3;
+    FLUSH_INTERVAL_GROUP_MS = 5e3;
     MAX_THINKING_CHARS = 800;
-    GLOBAL_MIN_GAP_MS = 500;
+    GLOBAL_MIN_GAP_MS = 1e3;
     globalLastFlushAt = 0;
     TRIM_THRESHOLD = 3500;
     MAX_ENTRIES = 200;
@@ -17382,6 +17600,8 @@ var init_live_status = __esm({
         if (this.consecutiveEditFailures >= _LiveStatusMessage.MAX_EDIT_FAILURES) return;
         if (Date.now() < this.nextFlushAllowedAt) return;
         if (!canFlushGlobally()) return;
+        const throttleState = getThrottleState();
+        if (throttleState?.isPaused) return;
         const deduped = dedupThinking(this.entries);
         const body = renderEntries(deduped, this.modelLabel, Date.now() - this.startTime, this.hasTrimmed);
         if (body === this.lastRendered) return;
@@ -19850,15 +20070,20 @@ async function sendJobDetail(chatId, jobId, channel, messageId) {
 \u26A0\uFE0F ${job.consecutiveFailures} consecutive failures` : "";
   const runs = getJobRuns(jobId, 1);
   const lastRunStatus = runs.length > 0 ? runs[0].status : null;
+  const thinking2 = job.thinking ?? "auto";
+  const accountLabel = resolveSlotLabel(job.backend ?? void 0, job.credentialSlotId);
   const lines = [
     `Job #${job.id}: ${job.title ?? job.description}`,
     buildSectionHeader("", 22),
     ...job.title ? [`Task: ${job.description}`] : [],
     `Runs: ${schedule2}${tz}`,
-    `Backend: ${backend2} | Model: ${model2}`,
+    "",
     `Last run: ${lastRun}${lastRunStatus ? ` (${lastRunStatus})` : ""}`,
     `Next run: ${nextRun}`,
-    `Status: ${status}${failures}`
+    `Status: ${status}${failures}`,
+    "",
+    `\u{1F3F7} ${backend2} \xB7 ${model2} \xB7 ${thinking2}`,
+    `\u{1F464} ${accountLabel}`
   ];
   const text = lines.join("\n");
   if (typeof channel.sendKeyboard !== "function") {
@@ -20071,6 +20296,7 @@ var init_ui = __esm({
     init_format_time();
     init_cron();
     init_humanize();
+    init_wizard();
     init_stt();
     init_helpers();
     ROTATION_MODE_LABELS = {
@@ -25937,7 +26163,7 @@ async function handleText(msg, channel) {
     await channel.sendText(chatId, limitMsg, { parseMode: "plain" });
     return;
   }
-  let intent = classifyIntent(text, chatId);
+  let intent = await classifyIntentAsync(text, chatId);
   const cleanText = text.startsWith(">>") ? text.slice(2).trim() : text;
   let bootstrapTier = intent === "chat" ? "chat" : void 0;
   let maxTurns = void 0;
@@ -25981,9 +26207,10 @@ async function handleText(msg, channel) {
       agentMode: effectiveAgentMode
     });
     if (response.text) {
-      storePendingPlan(chatId, response.text, text);
+      const revisedPlan = response.text.replace(/\[REACT:.+?\]/g, "").replace(/\[SEND_FILE:.+?\]/g, "").replace(/\[GENERATE_IMAGE:.+?\]/g, "").replace(/\[HISTORY_SEARCH:[^\]]+\]/g, "").trim();
+      storePendingPlan(chatId, revisedPlan, text);
       if (typeof channel.sendKeyboard === "function") {
-        await channel.sendKeyboard(chatId, `\u{1F50D} ${response.text}`, [
+        await channel.sendKeyboard(chatId, `\u{1F50D} ${revisedPlan}`, [
           [
             { label: "\u2705 Approve", data: "exec:approve", style: "success" },
             { label: "\u274C Reject", data: "exec:reject", style: "danger" }
@@ -26119,7 +26346,7 @@ Debating: "${question.slice(0, 100)}${question.length > 100 ? "\u2026" : ""}"`,
   })) {
     const planDirective = buildPlanningDirective();
     let typingActive2 = true;
-    const typingLoop2 = async () => {
+    const typingLoop = async () => {
       while (typingActive2) {
         try {
           await channel.sendTyping?.(chatId);
@@ -26128,7 +26355,7 @@ Debating: "${question.slice(0, 100)}${question.length > 100 ? "\u2026" : ""}"`,
         await new Promise((r) => setTimeout(r, 4e3));
       }
     };
-    typingLoop2().catch(() => {
+    typingLoop().catch(() => {
     });
     try {
       const planResponse = await askAgent(chatId, cleanText || text, {
@@ -26169,18 +26396,23 @@ Debating: "${question.slice(0, 100)}${question.length > 100 ? "\u2026" : ""}"`,
     }
     return;
   }
-  let typingActive = true;
-  const typingLoop = async () => {
-    while (typingActive) {
-      try {
-        await channel.sendTyping?.(chatId);
-      } catch {
+  const verboseForTyping = settings.getVerboseLevel();
+  const showThinkingForTyping = settings.getShowThinkingUi();
+  const needsLiveStatusForTyping = verboseForTyping !== "off" || showThinkingForTyping;
+  let typingActive = !needsLiveStatusForTyping;
+  if (typingActive) {
+    const typingLoop = async () => {
+      while (typingActive) {
+        try {
+          await channel.sendTyping?.(chatId);
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 4e3));
       }
-      await new Promise((r) => setTimeout(r, 4e3));
-    }
-  };
-  typingLoop().catch(() => {
-  });
+    };
+    typingLoop().catch(() => {
+    });
+  }
   try {
     const tMode = settings.getMode();
     const tVerbose = settings.getVerboseLevel();
@@ -26803,6 +27035,13 @@ async function runWithRetry(job, model2, runId, t0) {
           const cronBackend = currentBackend;
           setAllowPaidSlots(chatId, cronBackend);
         }
+        if (job.credentialSlotId) {
+          if (currentBackend === BACKEND.GEMINI) {
+            pinChatGeminiSlot(chatId, job.credentialSlotId);
+          } else {
+            pinChatBackendSlot(chatId, currentBackend, job.credentialSlotId);
+          }
+        }
         const response = await askAgent(chatId, job.description, {
           model: currentModel,
           backend: currentBackend,
@@ -26874,6 +27113,7 @@ var init_cron = __esm({
   "src/scheduler/cron.ts"() {
     "use strict";
     init_store5();
+    init_types();
     init_backends();
     init_agent();
     init_log();
@@ -27564,6 +27804,115 @@ ${body.replace(/<[^>]*>/g, "").trim()}</code>
   }
 });
 
+// src/channels/health.ts
+function trackChannel(channel) {
+  healthState.set(channel.name, {
+    status: "healthy",
+    startedAt: Date.now(),
+    lastHealthyAt: Date.now(),
+    lastErrorAt: null,
+    lastError: null,
+    reconnectAttempts: 0
+  });
+}
+function markChannelHealthy(name) {
+  const state = healthState.get(name);
+  if (state) {
+    state.status = "healthy";
+    state.lastHealthyAt = Date.now();
+    state.reconnectAttempts = 0;
+  }
+}
+function markChannelDown(name, error3) {
+  const state = healthState.get(name);
+  if (state) {
+    state.status = "down";
+    state.lastErrorAt = Date.now();
+    state.lastError = error3;
+    warn(`[channel-health] ${name} marked as down: ${error3}`);
+  }
+}
+function getChannelHealth(name) {
+  const state = healthState.get(name);
+  if (!state) return null;
+  return {
+    name,
+    status: state.status,
+    lastHealthyAt: state.lastHealthyAt,
+    lastErrorAt: state.lastErrorAt,
+    lastError: state.lastError,
+    reconnectAttempts: state.reconnectAttempts,
+    uptimeMs: state.status === "healthy" ? Date.now() - state.startedAt : 0
+  };
+}
+async function attemptReconnect(channel, handler) {
+  const state = healthState.get(channel.name);
+  if (!state) return false;
+  if (reconnecting.has(channel.name)) {
+    log(`[channel-health] ${channel.name}: reconnect already in progress, skipping`);
+    return false;
+  }
+  if (state.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+    error(`[channel-health] ${channel.name}: max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached`);
+    return false;
+  }
+  reconnecting.add(channel.name);
+  state.reconnectAttempts++;
+  const backoffMs = RECONNECT_BASE_MS * Math.pow(2, state.reconnectAttempts - 1);
+  log(`[channel-health] ${channel.name}: reconnect attempt ${state.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} in ${backoffMs}ms`);
+  await new Promise((r) => setTimeout(r, backoffMs));
+  try {
+    await channel.stop().catch(() => {
+    });
+    await channel.start(handler);
+    markChannelHealthy(channel.name);
+    log(`[channel-health] ${channel.name}: reconnected successfully`);
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    markChannelDown(channel.name, msg);
+    return false;
+  } finally {
+    reconnecting.delete(channel.name);
+  }
+}
+function startHealthMonitor3(channels, handler) {
+  registeredHandler = handler;
+  for (const ch of channels) {
+    trackChannel(ch);
+  }
+  healthInterval = setInterval(() => {
+    for (const ch of channels) {
+      const health = getChannelHealth(ch.name);
+      if (health?.status === "down" && registeredHandler) {
+        attemptReconnect(ch, registeredHandler).catch(() => {
+        });
+      }
+    }
+  }, HEALTH_CHECK_INTERVAL_MS);
+  log(`[channel-health] Monitoring ${channels.length} channel(s)`);
+}
+function stopHealthMonitor3() {
+  if (healthInterval) {
+    clearInterval(healthInterval);
+    healthInterval = null;
+  }
+}
+var healthState, MAX_RECONNECT_ATTEMPTS, RECONNECT_BASE_MS, HEALTH_CHECK_INTERVAL_MS, healthInterval, registeredHandler, reconnecting;
+var init_health3 = __esm({
+  "src/channels/health.ts"() {
+    "use strict";
+    init_log();
+    healthState = /* @__PURE__ */ new Map();
+    MAX_RECONNECT_ATTEMPTS = 5;
+    RECONNECT_BASE_MS = 5e3;
+    HEALTH_CHECK_INTERVAL_MS = 15e3;
+    healthInterval = null;
+    registeredHandler = null;
+    reconnecting = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/channels/telegram.ts
 import { API_CONSTANTS, Bot, GrammyError as GrammyError2, InlineKeyboard, InputFile } from "grammy";
 function isFastPathMessage(msg) {
@@ -27594,10 +27943,11 @@ var init_telegram2 = __esm({
     "use strict";
     init_telegram();
     init_log();
+    init_health3();
     init_store5();
     init_telegram_throttle();
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat"]);
-    TelegramChannel = class {
+    TelegramChannel = class _TelegramChannel {
       name = "telegram";
       bot;
       allowedChatIds;
@@ -27607,6 +27957,19 @@ var init_telegram2 = __esm({
       // messageId → chatId
       reactionHandlers = [];
       throttle;
+      // ── Polling health tracking ─────────────────────────────────────────
+      /** Timestamp of last update received from Telegram (message, callback, reaction) */
+      lastUpdateAt = 0;
+      /** True while polling is expected to be active (between start() and stop()) */
+      pollingExpected = false;
+      /** Watchdog interval that detects silent polling death */
+      pollingWatchdog = null;
+      /** Max time without any update before we consider polling dead (ms) */
+      static POLLING_SILENCE_THRESHOLD_MS = 2 * 60 * 1e3;
+      // 2 minutes
+      /** How often the watchdog checks for polling health (ms) */
+      static POLLING_WATCHDOG_INTERVAL_MS = 60 * 1e3;
+      // 60 seconds
       constructor() {
         const token = process.env.TELEGRAM_BOT_TOKEN;
         if (!token) {
@@ -27624,6 +27987,10 @@ var init_telegram2 = __esm({
         this.bot = new Bot(token);
         this.throttle = new TelegramThrottle();
         this.throttle.setResumeNotifier(async (chatId, pausedSec, queuedCount) => {
+          if (pausedSec > 60) {
+            log(`[telegram] Skipping resume notification (paused ${pausedSec}s \u2014 too long, would risk another 429)`);
+            return;
+          }
           try {
             await this.bot.api.sendMessage(
               numericChatId(chatId),
@@ -27735,6 +28102,7 @@ var init_telegram2 = __esm({
           { command: "council", description: "Multi-model debate (select models, anonymous rounds)" }
         ]);
         this.bot.on("message", async (ctx) => {
+          this.lastUpdateAt = Date.now();
           const chatId = ctx.chat.id.toString();
           const senderId = ctx.from?.id?.toString() ?? "";
           const authorized = this.isAuthorized(chatId) || this.isAuthorized(senderId);
@@ -27762,6 +28130,7 @@ var init_telegram2 = __esm({
           });
         });
         this.bot.on("callback_query:data", (ctx) => {
+          this.lastUpdateAt = Date.now();
           const userId = ctx.from.id.toString();
           const chatId = ctx.callbackQuery.message?.chat?.id?.toString() ?? userId;
           log(`[telegram] Callback from user ${userId} in chat ${chatId}: ${ctx.callbackQuery.data}`);
@@ -27789,6 +28158,7 @@ var init_telegram2 = __esm({
           });
         });
         this.bot.on("message_reaction", async (ctx) => {
+          this.lastUpdateAt = Date.now();
           const chatId = String(ctx.chat.id);
           const messageId = ctx.messageReaction.message_id;
           if (!this.agentMessageIds.has(messageId)) return;
@@ -27805,6 +28175,7 @@ var init_telegram2 = __esm({
           }
         });
         this.bot.on("inline_query", (ctx) => {
+          this.lastUpdateAt = Date.now();
           if (!this.isAuthorized(ctx.from.id.toString())) return;
           this.handleInlineQuery(ctx).catch((err) => {
             error("[telegram] Inline query error:", err);
@@ -27818,25 +28189,64 @@ var init_telegram2 = __esm({
             error("[telegram] Unhandled error:", err);
           }
         });
-        this.bot.start({
+        this.pollingExpected = true;
+        this.lastUpdateAt = Date.now();
+        const pollingPromise = this.bot.start({
           allowed_updates: [...API_CONSTANTS.ALL_UPDATE_TYPES],
           onStart: () => log("[telegram] Polling for messages...")
-        }).catch((err) => {
-          error("[telegram] Fatal: bot.start() failed:", err);
-          error("[telegram] Check TELEGRAM_BOT_TOKEN in ~/.cc-claw/.env \u2014 it may be invalid or revoked.");
-          error("[telegram] To regenerate: message @BotFather on Telegram, use /revoke, then 'cc-claw setup'");
-          process.exit(1);
         });
+        pollingPromise.then(
+          () => {
+            if (this.pollingExpected) {
+              error("[telegram] CRITICAL: Polling loop exited unexpectedly (resolved without stop)");
+              markChannelDown("telegram", "Polling loop exited unexpectedly");
+            }
+          },
+          (err) => {
+            if (this.pollingExpected) {
+              error("[telegram] Fatal: bot.start() failed:", err);
+              error("[telegram] Check TELEGRAM_BOT_TOKEN in ~/.cc-claw/.env \u2014 it may be invalid or revoked.");
+              error("[telegram] To regenerate: message @BotFather on Telegram, use /revoke, then 'cc-claw setup'");
+              markChannelDown("telegram", `Polling error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
+        );
+        this.pollingWatchdog = setInterval(() => {
+          if (!this.pollingExpected) return;
+          const silenceMs = Date.now() - this.lastUpdateAt;
+          if (silenceMs > _TelegramChannel.POLLING_SILENCE_THRESHOLD_MS) {
+            error(
+              `[telegram] CRITICAL: No updates received for ${Math.round(silenceMs / 1e3)}s \u2014 polling likely dead, triggering reconnect`
+            );
+            markChannelDown("telegram", `No updates for ${Math.round(silenceMs / 1e3)}s`);
+            this.lastUpdateAt = Date.now();
+          }
+        }, _TelegramChannel.POLLING_WATCHDOG_INTERVAL_MS);
       }
       async stop() {
-        await this.bot.stop();
+        this.pollingExpected = false;
+        if (this.pollingWatchdog) {
+          clearInterval(this.pollingWatchdog);
+          this.pollingWatchdog = null;
+        }
+        try {
+          await this.bot.stop();
+        } catch {
+        }
+        const token = process.env.TELEGRAM_BOT_TOKEN;
+        if (token) {
+          this.bot = new Bot(token);
+        }
       }
       async sendTyping(chatId, threadId) {
-        if (this.throttle.isPaused()) return;
         try {
-          await this.bot.api.sendChatAction(numericChatId(chatId), "typing", {
-            ...threadId ? { message_thread_id: threadId } : {}
-          });
+          await this.throttle.tryBestEffort(
+            chatId,
+            "typing",
+            () => this.bot.api.sendChatAction(numericChatId(chatId), "typing", {
+              ...threadId ? { message_thread_id: threadId } : {}
+            })
+          );
         } catch {
         }
       }
@@ -27941,7 +28351,12 @@ var init_telegram2 = __esm({
           );
           return true;
         } catch (err) {
-          warn("[telegram] editText HTML failed, trying plain fallback:", err instanceof Error ? err.message : err);
+          const errMsg = err instanceof Error ? err.message : String(err);
+          if (errMsg.includes("overflow") || errMsg.includes("rate limit") || errMsg.includes("max wait")) {
+            warn("[telegram] editText skipped fallback (throttle overload):", errMsg);
+            return false;
+          }
+          warn("[telegram] editText HTML failed, trying plain fallback:", errMsg);
           try {
             await this.throttle.send(
               chatId,
@@ -28079,9 +28494,13 @@ var init_telegram2 = __esm({
       }
       async reactToMessage(chatId, messageId, emoji) {
         try {
-          await this.bot.api.setMessageReaction(numericChatId(chatId), parseInt(messageId), [
-            { type: "emoji", emoji }
-          ]);
+          await this.throttle.tryBestEffort(
+            chatId,
+            "reaction",
+            () => this.bot.api.setMessageReaction(numericChatId(chatId), parseInt(messageId), [
+              { type: "emoji", emoji }
+            ])
+          );
         } catch (err) {
           log(`[telegram] reactToMessage failed (chat=${chatId} msg=${messageId}): ${err}`);
         }
@@ -28499,115 +28918,6 @@ var init_bootstrap2 = __esm({
   }
 });
 
-// src/channels/health.ts
-function trackChannel(channel) {
-  healthState.set(channel.name, {
-    status: "healthy",
-    startedAt: Date.now(),
-    lastHealthyAt: Date.now(),
-    lastErrorAt: null,
-    lastError: null,
-    reconnectAttempts: 0
-  });
-}
-function markChannelHealthy(name) {
-  const state = healthState.get(name);
-  if (state) {
-    state.status = "healthy";
-    state.lastHealthyAt = Date.now();
-    state.reconnectAttempts = 0;
-  }
-}
-function markChannelDown(name, error3) {
-  const state = healthState.get(name);
-  if (state) {
-    state.status = "down";
-    state.lastErrorAt = Date.now();
-    state.lastError = error3;
-    warn(`[channel-health] ${name} marked as down: ${error3}`);
-  }
-}
-function getChannelHealth(name) {
-  const state = healthState.get(name);
-  if (!state) return null;
-  return {
-    name,
-    status: state.status,
-    lastHealthyAt: state.lastHealthyAt,
-    lastErrorAt: state.lastErrorAt,
-    lastError: state.lastError,
-    reconnectAttempts: state.reconnectAttempts,
-    uptimeMs: state.status === "healthy" ? Date.now() - state.startedAt : 0
-  };
-}
-async function attemptReconnect(channel, handler) {
-  const state = healthState.get(channel.name);
-  if (!state) return false;
-  if (reconnecting.has(channel.name)) {
-    log(`[channel-health] ${channel.name}: reconnect already in progress, skipping`);
-    return false;
-  }
-  if (state.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-    error(`[channel-health] ${channel.name}: max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached`);
-    return false;
-  }
-  reconnecting.add(channel.name);
-  state.reconnectAttempts++;
-  const backoffMs = RECONNECT_BASE_MS * Math.pow(2, state.reconnectAttempts - 1);
-  log(`[channel-health] ${channel.name}: reconnect attempt ${state.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} in ${backoffMs}ms`);
-  await new Promise((r) => setTimeout(r, backoffMs));
-  try {
-    await channel.stop().catch(() => {
-    });
-    await channel.start(handler);
-    markChannelHealthy(channel.name);
-    log(`[channel-health] ${channel.name}: reconnected successfully`);
-    return true;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    markChannelDown(channel.name, msg);
-    return false;
-  } finally {
-    reconnecting.delete(channel.name);
-  }
-}
-function startHealthMonitor3(channels, handler) {
-  registeredHandler = handler;
-  for (const ch of channels) {
-    trackChannel(ch);
-  }
-  healthInterval = setInterval(() => {
-    for (const ch of channels) {
-      const health = getChannelHealth(ch.name);
-      if (health?.status === "down" && registeredHandler) {
-        attemptReconnect(ch, registeredHandler).catch(() => {
-        });
-      }
-    }
-  }, HEALTH_CHECK_INTERVAL_MS);
-  log(`[channel-health] Monitoring ${channels.length} channel(s)`);
-}
-function stopHealthMonitor3() {
-  if (healthInterval) {
-    clearInterval(healthInterval);
-    healthInterval = null;
-  }
-}
-var healthState, MAX_RECONNECT_ATTEMPTS, RECONNECT_BASE_MS, HEALTH_CHECK_INTERVAL_MS, healthInterval, registeredHandler, reconnecting;
-var init_health3 = __esm({
-  "src/channels/health.ts"() {
-    "use strict";
-    init_log();
-    healthState = /* @__PURE__ */ new Map();
-    MAX_RECONNECT_ATTEMPTS = 5;
-    RECONNECT_BASE_MS = 5e3;
-    HEALTH_CHECK_INTERVAL_MS = 15e3;
-    healthInterval = null;
-    registeredHandler = null;
-    reconnecting = /* @__PURE__ */ new Set();
-  }
-});
-
 // src/cli/commands/ai-skill.ts
 var ai_skill_exports = {};
 __export(ai_skill_exports, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-claw",
-  "version": "0.20.14",
+  "version": "0.20.15",
   "description": "CC-Claw: Personal AI assistant on Telegram — multi-backend (Claude, Gemini, Codex, Cursor), sub-agent orchestration, MCP management",
   "type": "module",
   "main": "dist/cli.js",