cc-claw 0.29.1 → 0.29.3

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.29.1" : (() => {
+    VERSION = true ? "0.29.3" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -2813,6 +2813,7 @@ __export(chat_settings_exports, {
   GLOBAL_SUMMARIZER_SENTINEL: () => GLOBAL_SUMMARIZER_SENTINEL,
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
+  clearAllSummarizerOverrides: () => clearAllSummarizerOverrides,
   clearChatPaidSlots: () => clearChatPaidSlots,
   clearCwd: () => clearCwd,
   clearExecMode: () => clearExecMode,
@@ -2820,6 +2821,7 @@ __export(chat_settings_exports, {
   clearModelMap: () => clearModelMap,
   clearSummarizer: () => clearSummarizer,
   clearThinkingLevel: () => clearThinkingLevel,
+  countSummarizerOverrides: () => countSummarizerOverrides,
   deleteBookmark: () => deleteBookmark,
   determineEscalationTarget: () => determineEscalationTarget,
   findBookmarksByPrefix: () => findBookmarksByPrefix,
@@ -2840,6 +2842,7 @@ __export(chat_settings_exports, {
   getShowThinkingUi: () => getShowThinkingUi,
   getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
+  getSummarizerWithSource: () => getSummarizerWithSource,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
   getVerboseLevel: () => getVerboseLevel,
@@ -3184,6 +3187,35 @@ function setSummarizer(chatId, backend2, model2) {
 function clearSummarizer(chatId) {
   getDb().prepare("DELETE FROM chat_summarizer WHERE chat_id = ?").run(chatId);
 }
+function clearAllSummarizerOverrides() {
+  const result = getDb().prepare(
+    "DELETE FROM chat_summarizer WHERE chat_id != ?"
+  ).run(GLOBAL_SUMMARIZER_SENTINEL);
+  return result.changes;
+}
+function getSummarizerWithSource(chatId) {
+  const perChat = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(chatId);
+  const globalRow = getDb().prepare(
+    "SELECT backend, model FROM chat_summarizer WHERE chat_id = ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
+  const hasPerChat = perChat && (perChat.backend || perChat.model);
+  const globalConfig = globalRow && (globalRow.backend || globalRow.model) ? globalRow : { backend: null, model: null };
+  if (hasPerChat) {
+    return { config: perChat, source: "per-chat", globalConfig };
+  }
+  if (globalConfig.backend || globalConfig.model) {
+    return { config: globalConfig, source: "global", globalConfig };
+  }
+  return { config: { backend: null, model: null }, source: "auto", globalConfig };
+}
+function countSummarizerOverrides() {
+  const row = getDb().prepare(
+    "SELECT COUNT(*) as cnt FROM chat_summarizer WHERE chat_id != ?"
+  ).get(GLOBAL_SUMMARIZER_SENTINEL);
+  return row.cnt;
+}
 function getAgentMode(chatId) {
   const row = getDb().prepare("SELECT mode FROM chat_agent_mode WHERE chat_id = ?").get(chatId);
   return row?.mode ?? "auto";
@@ -3325,7 +3357,7 @@ function getUsage(chatId) {
 }
 function addUsage(chatId, input, output2, cacheRead, model2, backend2, contextSize) {
   const db3 = getDb();
-  const finalContextSize = contextSize ?? input + cacheRead;
+  const finalContextSize = contextSize === null ? 0 : contextSize ?? input + cacheRead;
   db3.prepare(`
     INSERT INTO chat_usage (chat_id, input_tokens, output_tokens, cache_read_tokens, request_count, last_input_tokens, last_cache_read_tokens, context_size, updated_at)
     VALUES (?, ?, ?, ?, 1, ?, ?, ?, datetime('now'))
@@ -4593,6 +4625,12 @@ var init_session_log = __esm({
 });
 
 // src/memory/api-context.ts
+var api_context_exports = {};
+__export(api_context_exports, {
+  buildApiMessages: () => buildApiMessages,
+  estimateContextUsage: () => estimateContextUsage,
+  estimateTokens: () => estimateTokens
+});
 import { getEncoding } from "js-tiktoken";
 function estimateTokens(text) {
   return enc.encode(text).length;
@@ -4621,7 +4659,7 @@ async function buildApiMessages(chatId, userMessage, systemPrompt, contextWindow
     return { role: "assistant", content: entry.text };
   });
   const currentUserMessage = { role: "user", content: userMessage };
-  const tokenBudget = Math.floor(contextWindow * 0.85);
+  const tokenBudget = Math.floor(contextWindow * 0.95);
   const fixedMessages = [systemMessage, currentUserMessage];
   const fixedTokens = fixedMessages.reduce((sum, m) => sum + enc.encode(typeof m.content === "string" ? m.content : JSON.stringify(m.content)).length, 0);
   const historyBudget = tokenBudget - fixedTokens;
@@ -4637,12 +4675,30 @@ async function buildApiMessages(chatId, userMessage, systemPrompt, contextWindow
   }
   return [systemMessage, ...truncatedHistory, currentUserMessage];
 }
-var enc;
+function estimateContextUsage(chatId, contextWindow) {
+  const logEntries = getLog(chatId);
+  if (logEntries.length === 0) {
+    estimateCache.delete(chatId);
+    return { estimatedTokens: 0, contextWindow, percentage: 0 };
+  }
+  const cached = estimateCache.get(chatId);
+  if (cached && cached.logSize === logEntries.length) {
+    const percentage2 = contextWindow > 0 ? cached.tokens / contextWindow * 100 : 0;
+    return { estimatedTokens: cached.tokens, contextWindow, percentage: percentage2 };
+  }
+  const text = logEntries.map((e) => e.text).join("\n");
+  const estimatedTokens = estimateTokens(text);
+  estimateCache.set(chatId, { logSize: logEntries.length, tokens: estimatedTokens });
+  const percentage = contextWindow > 0 ? estimatedTokens / contextWindow * 100 : 0;
+  return { estimatedTokens, contextWindow, percentage };
+}
+var enc, estimateCache;
 var init_api_context = __esm({
   "src/memory/api-context.ts"() {
     "use strict";
     init_session_log();
     enc = getEncoding("cl100k_base");
+    estimateCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -4838,6 +4894,7 @@ __export(store_exports5, {
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
   clearAllSessions: () => clearAllSessions,
+  clearAllSummarizerOverrides: () => clearAllSummarizerOverrides,
   clearBackendLimit: () => clearBackendLimit,
   clearChatBackendSlot: () => clearChatBackendSlot,
   clearChatGeminiSlot: () => clearChatGeminiSlot,
@@ -4852,6 +4909,7 @@ __export(store_exports5, {
   clearThinkingLevel: () => clearThinkingLevel,
   clearUsage: () => clearUsage,
   completeJobRun: () => completeJobRun,
+  countSummarizerOverrides: () => countSummarizerOverrides,
   deleteBookmark: () => deleteBookmark,
   deleteMemoryById: () => deleteMemoryById,
   deleteSessionSummary: () => deleteSessionSummary,
@@ -4923,6 +4981,7 @@ __export(store_exports5, {
   getShowThinkingUi: () => getShowThinkingUi,
   getSkillSuggestionsEnabled: () => getSkillSuggestionsEnabled,
   getSummarizer: () => getSummarizer,
+  getSummarizerWithSource: () => getSummarizerWithSource,
   getThinkingLevel: () => getThinkingLevel,
   getToolsMap: () => getToolsMap,
   getUnsummarizedChatIds: () => getUnsummarizedChatIds,
@@ -7581,19 +7640,20 @@ function is429(err) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, EDIT_PRESSURE_THRESHOLD, MAX_PER_CHAT_QUEUE, MAX_TOTAL_PAUSE_MS, CIRCUIT_TRIP_THRESHOLD, CIRCUIT_TRIP_WINDOW_MS, CIRCUIT_COOLDOWN_STEP_SEC, CIRCUIT_RESET_WINDOW_MS, CircuitState, Priority, _activeThrottle, TelegramThrottle;
+var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, P0_PACING_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, EDIT_PRESSURE_THRESHOLD, MAX_PER_CHAT_QUEUE, MAX_TOTAL_PAUSE_MS, CIRCUIT_TRIP_THRESHOLD, CIRCUIT_TRIP_WINDOW_MS, CIRCUIT_COOLDOWN_STEP_SEC, CIRCUIT_RESET_WINDOW_MS, CircuitState, Priority, _activeThrottle, TelegramThrottle;
 var init_telegram_throttle = __esm({
   "src/channels/telegram-throttle.ts"() {
     "use strict";
     init_log();
     PER_DM_INTERVAL_MS = 1e3;
     PER_GROUP_INTERVAL_MS = 3500;
+    P0_PACING_MS = 150;
     GLOBAL_INTERVAL_MS = 100;
     MAX_RETRIES2 = 2;
     RETRY_DELAY_MS = 1e3;
     MAX_QUEUE_SIZE = 60;
     EDIT_PRESSURE_THRESHOLD = MAX_QUEUE_SIZE / 2;
-    MAX_PER_CHAT_QUEUE = 15;
+    MAX_PER_CHAT_QUEUE = 30;
     MAX_TOTAL_PAUSE_MS = 5 * 60 * 1e3;
     CIRCUIT_TRIP_THRESHOLD = 3;
     CIRCUIT_TRIP_WINDOW_MS = 5 * 60 * 1e3;
@@ -7766,16 +7826,17 @@ var init_telegram_throttle = __esm({
           while (this.queue.length > 0) {
             while (this.isPaused()) {
               if (this.pauseStartedAt > 0 && Date.now() - this.pauseStartedAt > MAX_TOTAL_PAUSE_MS) {
-                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items`);
+                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items (pause remains until ${new Date(this.pausedUntil).toISOString()})`);
                 this.flushQueueWithError("Telegram rate limit exceeded max wait time");
-                this.pausedUntil = 0;
-                this.pauseStartedAt = 0;
                 break;
               }
               const waitMs = Math.min(this.pausedUntil - Date.now(), 5e3);
               if (waitMs > 0) await sleep(waitMs);
             }
             if (this.queue.length === 0) break;
+            if (!this.isPaused() && this.pauseStartedAt > 0) {
+              this.pauseStartedAt = 0;
+            }
             this.updateCircuitState();
             const item = this.selectNextItem();
             if (!item) {
@@ -7783,7 +7844,8 @@ var init_telegram_throttle = __esm({
               continue;
             }
             const lastChat = this.lastSendPerChat.get(item.chatId) ?? 0;
-            const chatWait = perChatInterval(item.chatId) - (Date.now() - lastChat);
+            const interval = item.priority === 0 /* P0_CRITICAL */ ? P0_PACING_MS : perChatInterval(item.chatId);
+            const chatWait = interval - (Date.now() - lastChat);
             if (chatWait > 0) await sleep(chatWait);
             const globalWait = GLOBAL_INTERVAL_MS - (Date.now() - this.lastGlobalSend);
             if (globalWait > 0) await sleep(globalWait);
@@ -7865,6 +7927,7 @@ var init_telegram_throttle = __esm({
             return await fn();
           } catch (err) {
             if (is429(err)) throw err;
+            if (err instanceof GrammyError && err.error_code >= 400 && err.error_code < 500) throw err;
             if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
               warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
               await sleep(RETRY_DELAY_MS);
@@ -13382,7 +13445,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
           const cap = getOllamaTranscriptCap(ollamaModel);
           const key = `${ollamaAdapter.id}:${ollamaModel}`;
           tried.add(key);
-          const directFn = (prompt) => ollamaAdapter.streamDirect(prompt, ollamaModel);
+          const directFn = (prompt) => ollamaAdapter.streamDirect(prompt, ollamaModel, { thinkingLevel: "off" });
           const result = await attemptSummarizeDirect(chatId, directFn, "ollama", ollamaModel, entries, cap);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, "ollama", ollamaModel);
@@ -13400,7 +13463,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${targetAdapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = targetAdapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => targetAdapter.streamDirect(p, model2), targetAdapter.id, model2, entries, getTranscriptCap(model2)) : await attemptSummarize(chatId, targetAdapter, model2, entries);
+          const result = targetAdapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => targetAdapter.streamDirect(p, model2, { thinkingLevel: "off" }), targetAdapter.id, model2, entries, getTranscriptCap(model2)) : await attemptSummarize(chatId, targetAdapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, targetAdapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -13418,7 +13481,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         const key = `${adapter.id}:${model2}`;
         if (!tried.has(key)) {
           tried.add(key);
-          const result = adapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => adapter.streamDirect(p, model2), adapter.id, model2, entries, adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2)) : await attemptSummarize(chatId, adapter, model2, entries);
+          const result = adapter.streamDirect ? await attemptSummarizeDirect(chatId, (p) => adapter.streamDirect(p, model2, { thinkingLevel: "off" }), adapter.id, model2, entries, adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2)) : await attemptSummarize(chatId, adapter, model2, entries);
           if (result.success) {
             await extractAndLogSignals(result.rawText, chatId, adapter.id, model2);
             if (clearLogAfter) clearLog(chatId);
@@ -13440,7 +13503,7 @@ async function summarizeWithFallbackChain(chatId, targetBackendId, excludeBacken
         let result;
         if (adapter.streamDirect) {
           const cap = adapter.id === "ollama" ? getOllamaTranscriptCap(model2) : getTranscriptCap(model2);
-          const directFn = (prompt) => adapter.streamDirect(prompt, model2);
+          const directFn = (prompt) => adapter.streamDirect(prompt, model2, { thinkingLevel: "off" });
           result = await attemptSummarizeDirect(chatId, directFn, adapter.id, model2, entries, cap);
         } else {
           result = await attemptSummarize(chatId, adapter, model2, entries);
@@ -13953,6 +14016,17 @@ function killProcessGroup(proc, signal = "SIGTERM") {
     }
   }
 }
+function runCompaction(chatId, reason, onCompaction) {
+  return summarizeWithFallbackChain(chatId).then((saved) => {
+    if (saved) {
+      clearSession(chatId);
+      clearUsage(chatId);
+      onCompaction?.(chatId);
+    }
+  }).catch((err) => {
+    warn(`[agent] Compaction failed for ${chatId} (${reason}): ${err}`);
+  });
+}
 function sweepStaleChatEntries() {
   for (const [chatId, state] of activeChats) {
     if (state.process && state.process.exitCode !== null) {
@@ -14088,18 +14162,24 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
     let contentSilenceTimer;
     const silenceTimeoutMs = CONTENT_SILENCE_TIMEOUT_MS;
     let silenceResetCount = 0;
-    const MAX_SILENCE_RESETS = 20;
+    const MAX_SILENCE_RESETS = 3;
     function resetContentSilenceTimer() {
       if (silenceTimeoutMs <= 0) return;
       if (contentSilenceTimer) clearTimeout(contentSilenceTimer);
       contentSilenceTimer = setTimeout(() => {
         if (cancelState.cancelled || timedOut) return;
         if (pendingTools.size > 0 && silenceResetCount < MAX_SILENCE_RESETS) {
-          silenceResetCount++;
-          const tools2 = Array.from(pendingTools.values()).map((t) => typeof t === "string" ? t : t.name).join(", ");
-          log(`[agent] Content silence timer fired but ${pendingTools.size} tool(s) still running (${tools2}) \u2014 resetting (${silenceResetCount}/${MAX_SILENCE_RESETS})`);
-          resetContentSilenceTimer();
-          return;
+          const now = Date.now();
+          const hungTool = Array.from(pendingTools.values()).find((t) => now - t.startedAt > silenceTimeoutMs);
+          if (hungTool) {
+            warn(`[agent] Tool "${hungTool.name}" has been running for ${Math.round((now - hungTool.startedAt) / 1e3)}s \u2014 treating as hung, killing`);
+          } else {
+            silenceResetCount++;
+            const tools2 = Array.from(pendingTools.values()).map((t) => `${t.name} (${Math.round((now - t.startedAt) / 1e3)}s)`).join(", ");
+            log(`[agent] Content silence timer fired but ${pendingTools.size} tool(s) still running (${tools2}) \u2014 resetting (${silenceResetCount}/${MAX_SILENCE_RESETS})`);
+            resetContentSilenceTimer();
+            return;
+          }
         }
         warn(`[agent] Content silence timeout after ${silenceTimeoutMs / 1e3}s for ${adapter.id} \u2014 no content events, killing`);
         timedOut = true;
@@ -14178,7 +14258,7 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
             sawToolEvents = true;
             if (opts?.onToolAction && ev.toolName) {
               const toolInput = ev.toolInput ?? {};
-              if (ev.toolId) pendingTools.set(ev.toolId, { name: ev.toolName, input: toolInput });
+              if (ev.toolId) pendingTools.set(ev.toolId, { name: ev.toolName, input: toolInput, startedAt: Date.now() });
               opts.onToolAction(ev.toolName, toolInput, void 0, ev.toolId).catch((err) => {
                 error("[agent] tool action error:", err);
               });
@@ -14222,7 +14302,6 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
               input += ev.usage.input;
               output2 += ev.usage.output;
               cacheRead += ev.usage.cacheRead;
-              contextSize = ev.usage.input + (ev.usage.cacheRead ?? 0);
             }
             break;
           case "result":
@@ -14240,7 +14319,6 @@ function spawnQuery(adapter, config2, model2, cancelState, thinkingLevel, timeou
               input = ev.usage.input;
               output2 = ev.usage.output;
               cacheRead = ev.usage.cacheRead;
-              contextSize = ev.usage.input + (ev.usage.cacheRead ?? 0);
             }
             if (adapter.shouldKillOnResult()) {
               try {
@@ -14323,7 +14401,7 @@ Partial output: ${accumulatedText.slice(-500)}`;
         return;
       }
       const cleanedResult = stripThinkingContent(resultText || accumulatedText);
-      resolve3({ resultText: cleanedResult, thinkingText: accumulatedThinking, sessionId, input, output: output2, cacheRead, contextSize, sawToolEvents, sawResultEvent });
+      resolve3({ resultText: cleanedResult, thinkingText: accumulatedThinking, sessionId, input, output: output2, cacheRead, contextSize: null, sawToolEvents, sawResultEvent });
     });
   });
 }
@@ -14542,9 +14620,12 @@ async function askAgentImpl(chatId, userMessage, opts) {
     activeChats.set(chatId, cancelState2);
     try {
       let messageHistory;
+      let apiContextSize;
       if (adapter.type === "api") {
         const contextWindow = adapter.contextWindow[resolvedModel2] ?? 8192;
-        messageHistory = await buildApiMessages(chatId, userMessage, fullPrompt, contextWindow);
+        const { buildApiMessages: buildMsgs, estimateContextUsage: estimateContextUsage2 } = await Promise.resolve().then(() => (init_api_context(), api_context_exports));
+        messageHistory = await buildMsgs(chatId, userMessage, fullPrompt, contextWindow);
+        apiContextSize = estimateContextUsage2(chatId, contextWindow).estimatedTokens;
       }
       const sdResult = await adapter.streamDirect(fullPrompt, resolvedModel2, {
         timeoutMs: timeoutMs ?? 3e5,
@@ -14560,23 +14641,29 @@ async function askAgentImpl(chatId, userMessage, opts) {
       });
       if (!isSyntheticChatId(chatId)) {
         appendToLog(chatId, userMessage, sdResult.text, adapter.id, resolvedModel2, null);
-        const AUTO_SUMMARIZE_THRESHOLD = 30;
-        const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
-        if (pairCount >= AUTO_SUMMARIZE_THRESHOLD) {
-          log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
-          summarizeWithFallbackChain(chatId).then((saved) => {
-            if (saved) {
-              clearSession(chatId);
-              opts?.onCompaction?.(chatId);
-            }
-          }).catch((err) => {
-            warn(`[agent] Auto-summarize failed for chat ${chatId}: ${err}`);
-          });
+        if (apiContextSize && adapter.type === "api" && !compactionInFlight.has(chatId)) {
+          const contextWindow = adapter.contextWindow[resolvedModel2] ?? 8192;
+          const contextPct = apiContextSize / contextWindow * 100;
+          if (contextPct >= 85) {
+            compactionInFlight.add(chatId);
+            log(`[agent] Context at ${contextPct.toFixed(0)}% for ${chatId} \u2014 triggering background compaction`);
+            opts?.onCompaction?.(chatId, "triggered");
+            runCompaction(chatId, "context-85%", opts?.onCompaction).finally(() => {
+              compactionInFlight.delete(chatId);
+            });
+          }
+        }
+        if (adapter.type !== "api" || !compactionInFlight.has(chatId)) {
+          const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
+          if (pairCount >= 30) {
+            log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
+            runCompaction(chatId, "30-pair-threshold", opts?.onCompaction);
+          }
         }
       }
       const sdUsage = sdResult.usage ?? { input: 0, output: 0 };
       if (sdUsage.input + sdUsage.output > 0) {
-        addUsage(chatId, sdUsage.input, sdUsage.output, 0, resolvedModel2);
+        addUsage(chatId, sdUsage.input, sdUsage.output, 0, resolvedModel2, adapter.id, apiContextSize);
       }
       if (cancelState2.cancelled) {
         return { text: "Stopped.", usage: { input: sdUsage.input, output: sdUsage.output, cacheRead: 0 } };
@@ -14878,18 +14965,10 @@ async function askAgentImpl(chatId, userMessage, opts) {
   }
   if (result.resultText && !isSyntheticChatId(chatId)) {
     appendToLog(chatId, userMessage, result.resultText, adapter.id, model2 ?? null, result.sessionId ?? null);
-    const AUTO_SUMMARIZE_THRESHOLD = 30;
     const pairCount = profile !== "chat" ? getMessagePairCount(chatId) : 0;
-    if (pairCount >= AUTO_SUMMARIZE_THRESHOLD) {
+    if (pairCount >= 30) {
       log(`[agent] Auto-summarizing chat ${chatId} after ${pairCount} turns`);
-      summarizeWithFallbackChain(chatId).then((saved) => {
-        if (saved) {
-          clearSession(chatId);
-          opts?.onCompaction?.(chatId);
-        }
-      }).catch((err) => {
-        warn(`[agent] Auto-summarize failed for chat ${chatId}: ${err}`);
-      });
+      runCompaction(chatId, "30-pair-threshold", opts?.onCompaction);
     }
   }
   return {
@@ -14917,7 +14996,7 @@ function injectMcpConfig(adapterId, args, mcpConfigPath) {
   if (!flag) return args;
   return [...args, ...flag, mcpConfigPath, "--strict-mcp-config"];
 }
-var activeChats, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
+var activeChats, compactionInFlight, staleSweepTimer, chatLocks, SPAWN_TIMEOUT_MS, FIRST_RESPONSE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_MS, CONTENT_SILENCE_TIMEOUT_ERROR, FIRST_RESPONSE_TIMEOUT_ERROR, FREE_SLOTS_EXHAUSTED, GEMINI_FALLBACK_CHAIN, GEMINI_DOWNGRADE_MODELS, MCP_CONFIG_FLAG;
 var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
@@ -14934,7 +15013,6 @@ var init_agent = __esm({
     init_strip_thinking();
     init_text_utils();
     init_session_log();
-    init_api_context();
     init_summarize();
     init_quota();
     init_store5();
@@ -14945,6 +15023,7 @@ var init_agent = __esm({
     init_unified_config();
     init_mcp_config();
     activeChats = /* @__PURE__ */ new Map();
+    compactionInFlight = /* @__PURE__ */ new Set();
     chatLocks = /* @__PURE__ */ new Map();
     SPAWN_TIMEOUT_MS = 10 * 60 * 1e3;
     FIRST_RESPONSE_TIMEOUT_MS = parseInt(process.env.GEMINI_FIRST_RESPONSE_TIMEOUT_MS ?? "30000", 10);
@@ -15112,7 +15191,9 @@ async function runWeeklySweep(chatId, channel, backendId, model2) {
       buttons.push([{ label: "Review Now", data: "mem:opt:start", style: "success" }]);
     }
     buttons.push([{ label: "Dismiss", data: "mem:sweep:dismiss" }]);
-    await sendOrEditKeyboard(chatId, channel, void 0, lines.join("\n"), buttons);
+    if (channel) {
+      await sendOrEditKeyboard(chatId, channel, void 0, lines.join("\n"), buttons);
+    }
     return { suggestionsCount, cleanedUp };
   } catch (err) {
     const msg = errorMessage(err);
@@ -22597,6 +22678,7 @@ var init_ollama2 = __esm({
       async streamDirect(prompt, model2, opts) {
         const cleanPrompt = stripForLocalModel(prompt);
         let disableThinking = false;
+        let modelContextWindow;
         try {
           const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
           const modelRecord = OllamaStore.getModelByName(model2);
@@ -22605,8 +22687,14 @@ var init_ollama2 = __esm({
           } else if (opts?.thinkingLevel === "off") {
             disableThinking = true;
           }
+          if (modelRecord?.contextWindow && modelRecord.contextWindow > 4096) {
+            modelContextWindow = modelRecord.contextWindow;
+          }
         } catch {
         }
+        const ollamaProviderOpts = {};
+        if (disableThinking) ollamaProviderOpts.think = false;
+        if (modelContextWindow) ollamaProviderOpts.num_ctx = modelContextWindow;
         const apiOpts = {
           timeoutMs: opts?.timeoutMs,
           onStream: opts?.onStream,
@@ -22615,7 +22703,7 @@ var init_ollama2 = __esm({
           permMode: opts?.permMode,
           thinkingLevel: opts?.thinkingLevel,
           onThinking: opts?.onThinking,
-          ...disableThinking ? { providerOptions: { ollama: { think: false } } } : {}
+          ...Object.keys(ollamaProviderOpts).length > 0 ? { providerOptions: { ollama: ollamaProviderOpts } } : {}
         };
         const result = await this.streamDirectWithHistory(
           cleanPrompt,
@@ -22701,7 +22789,28 @@ var init_openrouter = __esm({
       }
       summarizerModel = DEFAULT_FREE_MODEL;
       pricing = {};
-      contextWindow = {};
+      _contextWindowCache = null;
+      _contextWindowCacheSize = 0;
+      get contextWindow() {
+        try {
+          const { getApiModels: getApiModels2 } = (init_api_models(), __toCommonJS(api_models_exports));
+          const models = getApiModels2("openrouter");
+          if (this._contextWindowCache && models.length === this._contextWindowCacheSize) {
+            return this._contextWindowCache;
+          }
+          const result = {};
+          for (const m of models) {
+            if (m.contextWindow) {
+              result[m.modelId] = m.contextWindow;
+            }
+          }
+          this._contextWindowCache = result;
+          this._contextWindowCacheSize = models.length;
+          return result;
+        } catch {
+          return {};
+        }
+      }
       // ── Vercel AI SDK provider ────────────────────────────────────────
       /**
        * Create the Vercel AI SDK LanguageModel for a given model ID.
@@ -24547,7 +24656,7 @@ function getEditCoordinator() {
 function resetEditCoordinator() {
   EditCoordinator.resetInstance();
 }
-var TICK_INTERVAL_MS, MAX_EDITS_PER_WINDOW, EDIT_WINDOW_MS, EditCoordinator;
+var TICK_INTERVAL_MS, MAX_EDITS_PER_WINDOW, EDIT_WINDOW_MS, MIN_FLUSH_GAP_DM_MS, MIN_FLUSH_GAP_GROUP_MS, EditCoordinator;
 var init_edit_coordinator = __esm({
   "src/channels/edit-coordinator.ts"() {
     "use strict";
@@ -24555,10 +24664,14 @@ var init_edit_coordinator = __esm({
     TICK_INTERVAL_MS = 1e3;
     MAX_EDITS_PER_WINDOW = 4;
     EDIT_WINDOW_MS = 6e4;
+    MIN_FLUSH_GAP_DM_MS = 2e3;
+    MIN_FLUSH_GAP_GROUP_MS = 4e3;
     EditCoordinator = class _EditCoordinator {
       static instance = null;
       /** Active streams indexed by messageId. */
       activeStreams = /* @__PURE__ */ new Map();
+      /** Last flush timestamp per stream — prevents flushing faster than the throttle can drain. */
+      lastFlushAt = /* @__PURE__ */ new Map();
       /** Per-message edit tracking for the sliding window cap. */
       perMessageEditCount = /* @__PURE__ */ new Map();
       /** Single flush timer shared across all streams. */
@@ -24599,6 +24712,7 @@ var init_edit_coordinator = __esm({
       unregister(messageId) {
         this.activeStreams.delete(messageId);
         this.perMessageEditCount.delete(messageId);
+        this.lastFlushAt.delete(messageId);
         this.rebuildKeys();
         log(`[edit-coordinator] unregistered stream ${messageId} (${this.activeStreams.size} remaining)`);
         if (this.activeStreams.size === 0 && this.flushTimer) {
@@ -24616,6 +24730,7 @@ var init_edit_coordinator = __esm({
         }
         this.activeStreams.clear();
         this.perMessageEditCount.clear();
+        this.lastFlushAt.clear();
         this.streamKeys = [];
         this.roundRobinIndex = 0;
       }
@@ -24644,6 +24759,17 @@ var init_edit_coordinator = __esm({
         }
       }
       // ── Internal ──────────────────────────────────────────────────────────
+      /** Check whether enough time has passed since the last flush for this stream.
+       * Group chats need longer gaps (4s) to match the throttle's group pacing (3.5s).
+       * Without this, the coordinator pushes edits faster than the throttle drains them,
+       * causing per-chat queue buildup. */
+      canFlushStream(messageId, stream) {
+        const last = this.lastFlushAt.get(messageId);
+        if (last === void 0) return true;
+        const chatId = stream.getChatId();
+        const minGap = parseInt(chatId) < 0 ? MIN_FLUSH_GAP_GROUP_MS : MIN_FLUSH_GAP_DM_MS;
+        return Date.now() - last >= minGap;
+      }
       /** Rebuild the ordered keys array after registration changes. */
       rebuildKeys() {
         this.streamKeys = Array.from(this.activeStreams.keys());
@@ -24663,11 +24789,12 @@ var init_edit_coordinator = __esm({
           const idx = (startIdx + tried) % this.streamKeys.length;
           const messageId = this.streamKeys[idx];
           const stream = this.activeStreams.get(messageId);
-          if (stream && this.canEditMessage(messageId)) {
+          if (stream && this.canEditMessage(messageId) && this.canFlushStream(messageId, stream)) {
             this.roundRobinIndex = (idx + 1) % this.streamKeys.length;
             try {
               await stream.flush();
               this.recordEdit(messageId);
+              this.lastFlushAt.set(messageId, Date.now());
             } catch {
             }
             return;
@@ -24782,6 +24909,7 @@ var init_live_status = __esm({
       /** Spinner frame counter — advances on each flush for animation. */
       spinnerFrame = 0;
       /** Timestamp of last successful edit — used for heartbeat force-through. */
+      lastSuccessfulFlushAt = 0;
       /** Callback to restart typing indicator as fallback. */
       onTypingFallback;
       /** Set a callback that restarts the typing indicator loop as a fallback. */
@@ -25360,10 +25488,12 @@ function getTypingManager() {
 function resetTypingManager() {
   TypingManager.resetInstance();
 }
-var TypingManager;
+var MAX_TYPING_DURATION_MS, TypingManager;
 var init_typing_manager = __esm({
   "src/channels/typing-manager.ts"() {
     "use strict";
+    init_log();
+    MAX_TYPING_DURATION_MS = 15 * 60 * 1e3;
     TypingManager = class _TypingManager {
       static instance = null;
       activeChats = /* @__PURE__ */ new Map();
@@ -25385,11 +25515,17 @@ var init_typing_manager = __esm({
         }
         channel.sendTyping?.(chatId).catch(() => {
         });
+        const acquiredAt = Date.now();
         const timer = setInterval(() => {
+          if (Date.now() - acquiredAt > MAX_TYPING_DURATION_MS) {
+            warn(`[typing-manager] Auto-releasing chat ${chatId} after ${MAX_TYPING_DURATION_MS / 6e4}min (likely leak)`);
+            this.forceRelease(chatId);
+            return;
+          }
           channel.sendTyping?.(chatId).catch(() => {
           });
         }, 4e3);
-        this.activeChats.set(chatId, { refCount: 1, timer });
+        this.activeChats.set(chatId, { refCount: 1, timer, acquiredAt });
       }
       /**
        * Stop showing typing for this agent's perspective.
@@ -25404,6 +25540,13 @@ var init_typing_manager = __esm({
           this.activeChats.delete(chatId);
         }
       }
+      /** Force-release a chat regardless of refCount (for leak recovery). */
+      forceRelease(chatId) {
+        const entry = this.activeChats.get(chatId);
+        if (!entry) return;
+        clearInterval(entry.timer);
+        this.activeChats.delete(chatId);
+      }
       /** Clean shutdown — clear all timers. */
       shutdown() {
         for (const [, entry] of this.activeChats) {
@@ -29319,6 +29462,7 @@ async function handleNewchatCommand(chatId, commandArgs, msg, channel) {
   const summarized = await summarizeSession(chatId);
   clearSession(chatId);
   clearChatPaidSlots(chatId);
+  clearUsage(chatId);
   setSessionStartedAt(chatId);
   logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: "New session started", detail: { field: "session", action: "reset", summarized } });
   if (typeof channel.sendKeyboard === "function" && oldSessionId) {
@@ -29372,6 +29516,7 @@ async function handleClearCommand(chatId, _commandArgs, _msg, channel) {
   stopAllSideQuests(chatId);
   clearSession(chatId);
   clearChatPaidSlots(chatId);
+  clearUsage(chatId);
   setSessionStartedAt(chatId);
   logActivity(getDb(), { chatId, source: "telegram", eventType: "config_changed", summary: "Session cleared (no summary)", detail: { field: "session", action: "clear" } });
   await channel.sendText(chatId, "\u{1F9FD} Session cleared. No summary saved.", { parseMode: "plain", priority: 0 /* P0_CRITICAL */ });
@@ -29448,6 +29593,17 @@ async function handleSummarizeCommand(chatId, commandArgs, msg, channel) {
     }
   }
 }
+function formatSummarizerLabel(backend2, model2, fallbackModel) {
+  if (backend2 === "off") return "Off";
+  if (backend2) return `${backend2}: ${model2 ?? "default"}`;
+  return `Auto (${fallbackModel ?? "default"})`;
+}
+function summarizerStatusLine(chatId, adapter) {
+  const { config: config2, source } = getSummarizerWithSource(chatId);
+  const label2 = formatSummarizerLabel(config2.backend, config2.model, adapter?.summarizerModel);
+  if (source === "auto") return label2.toLowerCase();
+  return `${label2} (${source === "global" ? "global" : "per-chat"})`;
+}
 async function handleStatusCommand(chatId, commandArgs, msg, channel) {
   const sessionId = getSessionId(chatId);
   const cwd = getCwd(chatId);
@@ -29464,12 +29620,21 @@ async function handleStatusCommand(chatId, commandArgs, msg, channel) {
   const thinking2 = getThinkingLevel(chatId);
   const mode = getMode(chatId);
   const modelSig = getModelSignature(chatId);
-  const contextMax = adapter?.contextWindow[model2] ?? 2e5;
-  const contextUsed = usage2.context_size;
-  const contextPct = contextMax > 0 ? contextUsed / contextMax * 100 : 0;
-  const ctxBar = buildBar(contextPct);
-  const usedK = (contextUsed / 1e3).toFixed(1);
-  const maxK = (contextMax / 1e3).toFixed(0);
+  let contextLine;
+  if (adapter?.type === "api") {
+    const { estimateContextUsage: estimateContextUsage2 } = await Promise.resolve().then(() => (init_api_context(), api_context_exports));
+    const contextMax = adapter.contextWindow[model2] ?? 8192;
+    const ctxEst = estimateContextUsage2(chatId, contextMax);
+    const ctxBar = buildBar(ctxEst.percentage);
+    const usedK = (ctxEst.estimatedTokens / 1e3).toFixed(1);
+    const maxK = (contextMax / 1e3).toFixed(0);
+    contextLine = `\u{1F4D0} Context: ${ctxBar} ${usedK}K/${maxK}K (${ctxEst.percentage.toFixed(1)}%) \xB7 compacts at 85%`;
+  } else {
+    const pairCount = getMessagePairCount(chatId);
+    const threshold = 30;
+    const remaining = Math.max(0, threshold - pairCount);
+    contextLine = `\u{1F4D0} Session: ${pairCount}/${threshold} messages \xB7 compacts in ${remaining}`;
+  }
   const bootRow = getDb().prepare("SELECT value FROM meta WHERE key = 'boot_time'").get();
   let uptimeStr = "unknown";
   if (bootRow) {
@@ -29532,11 +29697,12 @@ async function handleStatusCommand(chatId, commandArgs, msg, channel) {
     `\u{1F4AD} Think: ${thinking2} \xB7 Mode: ${mode}`,
     `\u{1F916} Agents: ${getAgentMode(chatId)}`,
     `\u{1F507} Voice: ${voice2 ? "on" : "off"} \xB7 Sig: ${modelSig}`,
+    `\u{1F4DD} Summarizer: ${summarizerStatusLine(chatId, adapter)}`,
     ``,
     buildSectionHeader("Session"),
     `\u{1F4CB} ${sessionId ?? "no active session"}`,
     `\u{1F4C1} ${cwd ?? "default workspace"}`,
-    `\u{1F4D0} Context: ${ctxBar} ${usedK}K/${maxK}K (${contextPct.toFixed(1)}%)`,
+    contextLine,
     ...sqCount > 0 ? [`\u{1F5FA} Side quests: ${sqCount} active`] : [],
     ``,
     buildSectionHeader("Usage"),
@@ -29947,8 +30113,17 @@ async function handleSummarizerCommand(chatId, commandArgs, msg, channel) {
   } catch {
     adapter = null;
   }
-  const current = getSummarizer(chatId);
-  const currentLabel = current.backend === "off" ? "Off" : current.backend ? `${current.backend}:${current.model ?? "default"}` : `Auto (${adapter?.summarizerModel ?? "default"})`;
+  const { config: current, source, globalConfig } = getSummarizerWithSource(chatId);
+  const overrideCount = countSummarizerOverrides();
+  const currentLabel = formatSummarizerLabel(current.backend, current.model, adapter?.summarizerModel);
+  const sourceTag = source === "per-chat" ? "per-chat override" : source === "global" ? "global default" : "auto";
+  const headerLines = [`Summarizer: ${currentLabel} (${sourceTag})`];
+  if (globalConfig.backend) {
+    headerLines.push(`Global default: ${formatSummarizerLabel(globalConfig.backend, globalConfig.model)}`);
+  }
+  if (overrideCount > 0) {
+    headerLines.push(`${overrideCount} chat${overrideCount === 1 ? "" : "s"} with per-chat overrides`);
+  }
   if (typeof channel.sendKeyboard === "function") {
     const isAuto = !current.backend && current.backend !== "off";
     const isOff = current.backend === "off";
@@ -29996,7 +30171,14 @@ async function handleSummarizerCommand(chatId, commandArgs, msg, channel) {
         }]);
       }
     }
-    await channel.sendKeyboard(chatId, `Session summarizer (current: ${currentLabel}):`, buttons);
+    if (overrideCount > 0) {
+      buttons.push([{
+        label: `Clear All Overrides (${overrideCount})`,
+        data: "summarizer:clearall",
+        style: "danger"
+      }]);
+    }
+    await channel.sendKeyboard(chatId, headerLines.join("\n"), buttons);
   } else {
     await channel.sendText(chatId, `Summarizer: ${currentLabel}
 
@@ -31519,14 +31701,40 @@ ${value ? "Full tool inputs/results will be saved to ~/.cc-claw/logs/sessions/"
     if (rest === "auto") {
       clearSummarizer(chatId);
       await channel.sendText(chatId, "Summarizer set to auto (uses active backend).", { parseMode: "plain" });
-    } else if (rest === "off") {
-      setSummarizer(chatId, "off", null);
-      await channel.sendText(chatId, "Session summarization disabled.", { parseMode: "plain" });
+    } else if (rest === "clearall") {
+      const cleared = clearAllSummarizerOverrides();
+      await channel.sendText(chatId, `Cleared ${cleared} per-chat override${cleared === 1 ? "" : "s"}. All chats now use the global default.`, { parseMode: "plain" });
+    } else if (rest.startsWith("promote:")) {
+      const promoteValue = rest.slice(8);
+      const db3 = getDb();
+      const promote = db3.transaction(() => {
+        if (promoteValue === "off") {
+          setGlobalSummarizer("off", null);
+        } else {
+          const [bk, ...modelParts] = promoteValue.split(":");
+          setGlobalSummarizer(bk, modelParts.join(":") || null);
+        }
+        return clearAllSummarizerOverrides();
+      });
+      const cleared = promote();
+      const label2 = promoteValue === "off" ? "Off" : promoteValue;
+      const clearedNote = cleared > 0 ? ` Cleared ${cleared} per-chat override${cleared === 1 ? "" : "s"}.` : "";
+      await channel.sendText(chatId, `Global summarizer set to ${label2}.${clearedNote} All chats now use this default.`, { parseMode: "plain" });
     } else {
-      const [bk, ...modelParts] = rest.split(":");
-      const mdl = modelParts.join(":") || null;
+      const isOff = rest === "off";
+      const bk = isOff ? "off" : rest.split(":")[0];
+      const mdl = isOff ? null : rest.split(":").slice(1).join(":") || null;
       setSummarizer(chatId, bk, mdl);
-      await channel.sendText(chatId, `Summarizer pinned to ${bk}:${mdl ?? "default"}.`, { parseMode: "plain" });
+      const displayLabel = isOff ? "Off" : `${bk}:${mdl ?? "default"}`;
+      const confirmMsg = isOff ? "Session summarization disabled for this chat." : `Summarizer pinned to ${displayLabel} for this chat.`;
+      const promoteData = `summarizer:promote:${rest}`;
+      if (typeof channel.sendKeyboard === "function") {
+        await channel.sendKeyboard(chatId, confirmMsg, [
+          [{ label: "Set as Global Default", data: promoteData }]
+        ]);
+      } else {
+        await channel.sendText(chatId, confirmMsg, { parseMode: "plain" });
+      }
     }
   } else if (data.startsWith("perms:")) {
     let chosen = data.slice(6);
@@ -34525,6 +34733,8 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     return;
   }
   getTypingManager().acquire(chatId, channel);
+  let stopDraftTimer = () => {
+  };
   try {
     const tMode = settings.getMode();
     const tVerbose = settings.getVerboseLevel();
@@ -34584,7 +34794,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         draftState.dirty = true;
       };
     }
-    const stopDraftTimer2 = () => {
+    stopDraftTimer = () => {
       if (draftState?.flushTimer) {
         clearInterval(draftState.flushTimer);
         draftState.flushTimer = null;
@@ -34620,9 +34830,14 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         } catch {
         }
       },
-      onCompaction: (cid) => {
-        channel.sendText(cid, "\u{1F4BE} Context saved to memory.").catch(() => {
-        });
+      onCompaction: (cid, phase) => {
+        if (phase === "triggered") {
+          channel.sendText(cid, "\u{1F4BE} Context compaction triggered \u2014 saving conversation to memory...").catch(() => {
+          });
+        } else {
+          channel.sendText(cid, "\u{1F4BE} Context saved to memory.").catch(() => {
+          });
+        }
       },
       onSlotRotation: (cid, from, to) => {
         const slots = getGeminiSlots();
@@ -34640,7 +34855,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         });
       }
     });
-    stopDraftTimer2();
+    stopDraftTimer();
     const elapsedMs = Date.now() - sigT0;
     const elapsedSec = (elapsedMs / 1e3).toFixed(1);
     if (liveStatus && response.thinkingText?.trim()) {
@@ -36230,7 +36445,7 @@ var init_telegram2 = __esm({
         };
       }
       async start(handler) {
-        await this.bot.api.setMyCommands([
+        await this.throttle.send(this.primaryChatId, "setMyCommands", () => this.bot.api.setMyCommands([
           // Core
           { command: "menu", description: "Home screen \u2014 quick-access keyboard" },
           { command: "m", description: "Home screen (alias for /menu)" },
@@ -36308,7 +36523,7 @@ var init_telegram2 = __esm({
           // Context & info
           { command: "info", description: "Current chat context (ID, topic, sender, settings)" },
           { command: "council", description: "Multi-model debate (select models, anonymous rounds)" }
-        ]);
+        ]));
         this.bot.on("message", async (ctx) => {
           const chatId = ctx.chat.id.toString();
           const senderId = ctx.from?.id?.toString() ?? "";
@@ -36354,15 +36569,13 @@ var init_telegram2 = __esm({
           const chatId = ctx.callbackQuery.message?.chat?.id?.toString() ?? userId;
           log(`[telegram] Callback from user ${userId} in chat ${chatId}: ${ctx.callbackQuery.data}`);
           if (!this.isAuthorized(userId) && !this.isAuthorized(chatId)) {
-            ctx.answerCallbackQuery("Unauthorized").catch(() => {
-            });
+            this.throttle.tryBestEffort(chatId, "answerCallbackQuery:unauth", () => ctx.answerCallbackQuery("Unauthorized"));
             return;
           }
           const data = ctx.callbackQuery.data;
           const messageId = ctx.callbackQuery.message?.message_id?.toString();
           const threadId = ctx.callbackQuery.message?.message_thread_id;
-          ctx.answerCallbackQuery().catch(() => {
-          });
+          this.throttle.tryBestEffort(chatId, "answerCallbackQuery", () => ctx.answerCallbackQuery());
           (async () => {
             let ch = this;
             if (threadId) {
@@ -36411,7 +36624,7 @@ var init_telegram2 = __esm({
         this.keepaliveInterval = setInterval(async () => {
           if (!this.pollingExpected) return;
           try {
-            await this.bot.api.getMe();
+            await this.throttle.tryBestEffort(this.primaryChatId, "getMe:keepalive", () => this.bot.api.getMe());
             this.lastPollingCheckAt = Date.now();
           } catch (err) {
             error("[telegram] Keepalive ping failed:", err);
@@ -36551,7 +36764,7 @@ var init_telegram2 = __esm({
         );
       }
       async downloadFile(fileId) {
-        const file = await this.bot.api.getFile(fileId);
+        const file = await this.throttle.send(this.primaryChatId, "getFile", () => this.bot.api.getFile(fileId));
         const fileUrl = `https://api.telegram.org/file/bot${process.env.TELEGRAM_BOT_TOKEN}/${file.file_path}`;
         const response = await fetch(fileUrl);
         return Buffer.from(await response.arrayBuffer());
@@ -36840,7 +37053,11 @@ var init_telegram2 = __esm({
             }
           }
         }
-        await ctx.answerInlineQuery(results.slice(0, 10), { cache_time: 30 });
+        await this.throttle.tryBestEffort(
+          this.primaryChatId,
+          "answerInlineQuery",
+          () => ctx.answerInlineQuery(results.slice(0, 10), { cache_time: 30 })
+        );
       }
       trackAgentMessage(messageId, chatId) {
         if (this.agentMessageIds.size >= 1e4) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-claw",
-  "version": "0.29.1",
+  "version": "0.29.3",
   "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",