cc-claw 0.28.0 → 0.29.1

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.28.0" : (() => {
+    VERSION = true ? "0.29.1" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -7559,6 +7559,380 @@ var init_html = __esm({
   }
 });
 
+// src/channels/telegram-throttle.ts
+var telegram_throttle_exports = {};
+__export(telegram_throttle_exports, {
+  CircuitState: () => CircuitState,
+  Priority: () => Priority,
+  TelegramThrottle: () => TelegramThrottle,
+  getThrottleState: () => getThrottleState
+});
+import { GrammyError } from "grammy";
+function perChatInterval(chatId) {
+  return parseInt(chatId) < 0 ? PER_GROUP_INTERVAL_MS : PER_DM_INTERVAL_MS;
+}
+function getThrottleState() {
+  if (!_activeThrottle) return null;
+  return _activeThrottle.getState();
+}
+function is429(err) {
+  return err instanceof GrammyError && err.error_code === 429;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var PER_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 init_telegram_throttle = __esm({
+  "src/channels/telegram-throttle.ts"() {
+    "use strict";
+    init_log();
+    PER_DM_INTERVAL_MS = 1e3;
+    PER_GROUP_INTERVAL_MS = 3500;
+    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_TOTAL_PAUSE_MS = 5 * 60 * 1e3;
+    CIRCUIT_TRIP_THRESHOLD = 3;
+    CIRCUIT_TRIP_WINDOW_MS = 5 * 60 * 1e3;
+    CIRCUIT_COOLDOWN_STEP_SEC = 5;
+    CIRCUIT_RESET_WINDOW_MS = 5 * 60 * 1e3;
+    CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+      CircuitState2["CLOSED"] = "closed";
+      CircuitState2["OPEN"] = "open";
+      CircuitState2["HALF_OPEN"] = "half_open";
+      return CircuitState2;
+    })(CircuitState || {});
+    Priority = /* @__PURE__ */ ((Priority2) => {
+      Priority2[Priority2["P0_CRITICAL"] = 0] = "P0_CRITICAL";
+      Priority2[Priority2["P1_NORMAL"] = 1] = "P1_NORMAL";
+      Priority2[Priority2["P2_COSMETIC"] = 2] = "P2_COSMETIC";
+      return Priority2;
+    })(Priority || {});
+    _activeThrottle = null;
+    TelegramThrottle = class {
+      queue = [];
+      processing = false;
+      lastSendPerChat = /* @__PURE__ */ new Map();
+      perChatQueueCount = /* @__PURE__ */ new Map();
+      // O(1) per-chat depth lookup
+      lastGlobalSend = 0;
+      // Pause state
+      pausedUntil = 0;
+      pauseStartedAt = 0;
+      // Per-chat cosmetic backoff — tryBestEffort() 429s only affect future
+      // best-effort calls for the SAME chat, never triggering a global pause.
+      cosmeticPausedUntil = /* @__PURE__ */ new Map();
+      // Circuit breaker state — tracks repeated 429s and manages recovery
+      circuitState = "closed" /* CLOSED */;
+      circuitTrips = [];
+      // timestamps of recent 429s
+      circuitCooldownUntil = 0;
+      // when OPEN cooldown expires
+      lastSuccessfulSend = 0;
+      // for resetting trip count after 5min of success
+      constructor() {
+        _activeThrottle = this;
+      }
+      /** Enqueue a Telegram API call with automatic pacing and 429 handling.
+       *  Priority controls queue insertion order:
+       *    P0_CRITICAL — keyboard responses, finalize edits, /stop — always first
+       *    P1_NORMAL   — agent responses, cron deliveries — default
+       *    P2_COSMETIC — live-status streaming edits — dropped first on overflow
+       *
+       *  Accepts `Priority | boolean` for backward compatibility during migration.
+       *  `true` maps to P0_CRITICAL, `false`/`undefined` maps to P1_NORMAL. */
+      async send(chatId, label2, fn, priority) {
+        const prio = priority === true ? 0 /* P0_CRITICAL */ : typeof priority === "number" ? priority : 1 /* P1_NORMAL */;
+        if (prio === 2 /* P2_COSMETIC */) {
+          if (this.isPaused()) {
+            throw new Error("Throttle paused (rate limit active) \u2014 edit skipped");
+          }
+          if (this.queue.length >= EDIT_PRESSURE_THRESHOLD) {
+            throw new Error("Throttle queue pressured \u2014 edit skipped");
+          }
+        }
+        return new Promise((resolve3, reject) => {
+          if (this.queue.length >= MAX_QUEUE_SIZE) {
+            let dropIdx = -1;
+            for (let i = this.queue.length - 1; i >= 0; i--) {
+              if (this.queue[i].priority === 2 /* P2_COSMETIC */) {
+                dropIdx = i;
+                break;
+              }
+            }
+            if (dropIdx === -1) {
+              for (let i = this.queue.length - 1; i >= 0; i--) {
+                if (this.queue[i].priority === 1 /* P1_NORMAL */) {
+                  dropIdx = i;
+                  break;
+                }
+              }
+            }
+            if (dropIdx === -1) dropIdx = this.queue.length - 1;
+            const dropped = this.queue.splice(dropIdx, 1)[0];
+            if (dropped) {
+              this.decrementChatCount(dropped.chatId);
+              warn(`[throttle] Queue full (${MAX_QUEUE_SIZE}), dropping P${dropped.priority}: ${dropped.label}`);
+              dropped.reject(new Error("Dropped from send queue (overflow)"));
+            }
+          }
+          const chatQueueCount = this.perChatQueueCount.get(chatId) ?? 0;
+          if (chatQueueCount >= MAX_PER_CHAT_QUEUE && prio !== 0 /* P0_CRITICAL */) {
+            if (prio === 2 /* P2_COSMETIC */) {
+              reject(new Error(`Per-chat queue limit (${MAX_PER_CHAT_QUEUE}) reached \u2014 cosmetic edit dropped`));
+              return;
+            }
+            const p2Idx = this.queue.findIndex((q) => q.chatId === chatId && q.priority === 2 /* P2_COSMETIC */);
+            if (p2Idx >= 0) {
+              const dropped = this.queue.splice(p2Idx, 1)[0];
+              this.decrementChatCount(dropped.chatId);
+              dropped.reject(new Error("Dropped (per-chat P2 eviction)"));
+            } else {
+              reject(new Error(`Per-chat queue limit (${MAX_PER_CHAT_QUEUE}) reached \u2014 normal send dropped`));
+              return;
+            }
+          }
+          const item = { chatId, label: label2, priority: prio, fn, resolve: resolve3, reject };
+          const insertIdx = this.queue.findIndex((q) => q.priority > prio);
+          if (insertIdx === -1) {
+            this.queue.push(item);
+          } else {
+            this.queue.splice(insertIdx, 0, item);
+          }
+          this.perChatQueueCount.set(chatId, (this.perChatQueueCount.get(chatId) ?? 0) + 1);
+          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, opts) {
+        if (this.isPaused()) return void 0;
+        if (this.queue.length > 10) return void 0;
+        const cosmeticUntil = this.cosmeticPausedUntil.get(chatId) ?? 0;
+        if (Date.now() < cosmeticUntil) return void 0;
+        if (cosmeticUntil > 0) this.cosmeticPausedUntil.delete(chatId);
+        if (!opts?.skipRecord) {
+          const lastChat = this.lastSendPerChat.get(chatId) ?? 0;
+          if (Date.now() - lastChat < perChatInterval(chatId)) return void 0;
+          if (Date.now() - this.lastGlobalSend < GLOBAL_INTERVAL_MS) return void 0;
+        }
+        try {
+          const result = await fn();
+          if (!opts?.skipRecord) this.recordSend(chatId);
+          return result;
+        } catch (err) {
+          if (is429(err)) {
+            const retrySec = err.parameters?.retry_after ?? 10;
+            this.cosmeticPausedUntil.set(chatId, Date.now() + retrySec * 1e3);
+            warn(`[throttle] 429 event (cosmetic)`, JSON.stringify({
+              method: label2,
+              chatId,
+              retry_after: retrySec,
+              queue_depth: this.queue.length,
+              circuit_state: this.circuitState,
+              type: "best_effort"
+            }));
+          }
+          return void 0;
+        }
+      }
+      /** Check whether the throttle is currently paused (rate-limited). */
+      isPaused() {
+        return Date.now() < this.pausedUntil;
+      }
+      /** Get structured state for diagnostics / health checks. */
+      getState() {
+        const now = Date.now();
+        const paused = now < this.pausedUntil;
+        return {
+          isPaused: paused,
+          queueDepth: this.queue.length,
+          pausedUntilMs: this.pausedUntil,
+          pauseRemainingSec: paused ? Math.ceil((this.pausedUntil - now) / 1e3) : 0,
+          circuitState: this.circuitState
+        };
+      }
+      // ── Queue processor ─────────────────────────────────────────────────
+      async drain() {
+        if (this.processing) return;
+        this.processing = true;
+        try {
+          while (this.queue.length > 0) {
+            while (this.isPaused()) {
+              if (this.pauseStartedAt > 0 && Date.now() - this.pauseStartedAt > MAX_TOTAL_PAUSE_MS) {
+                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items`);
+                this.flushQueueWithError("Telegram rate limit exceeded max wait time");
+                this.pausedUntil = 0;
+                this.pauseStartedAt = 0;
+                break;
+              }
+              const waitMs = Math.min(this.pausedUntil - Date.now(), 5e3);
+              if (waitMs > 0) await sleep(waitMs);
+            }
+            if (this.queue.length === 0) break;
+            this.updateCircuitState();
+            const item = this.selectNextItem();
+            if (!item) {
+              await sleep(1e3);
+              continue;
+            }
+            const lastChat = this.lastSendPerChat.get(item.chatId) ?? 0;
+            const chatWait = perChatInterval(item.chatId) - (Date.now() - lastChat);
+            if (chatWait > 0) await sleep(chatWait);
+            const globalWait = GLOBAL_INTERVAL_MS - (Date.now() - this.lastGlobalSend);
+            if (globalWait > 0) await sleep(globalWait);
+            try {
+              const result = await this.execWithRetry(item.label, item.fn);
+              this.recordSend(item.chatId);
+              this.pauseStartedAt = 0;
+              this.onSuccessfulSend();
+              item.resolve(result);
+            } catch (err) {
+              if (is429(err)) {
+                const retrySec = err.parameters?.retry_after ?? 10;
+                this.enterPause(retrySec, item);
+                continue;
+              }
+              item.reject(err);
+            }
+          }
+        } finally {
+          this.processing = false;
+        }
+      }
+      /**
+       * Select the next queue item to process, respecting circuit breaker state.
+       * Returns the item (already removed from queue) or null if nothing processable.
+       */
+      selectNextItem() {
+        if (this.circuitState === "closed" /* CLOSED */) {
+          return this.dequeue();
+        }
+        if (this.circuitState === "open" /* OPEN */) {
+          while (this.queue.length > 0 && this.queue[0].priority === 2 /* P2_COSMETIC */) {
+            const dropped = this.dequeue();
+            warn(`[throttle] Circuit OPEN \u2014 dropping P2: ${dropped.label}`);
+            dropped.reject(new Error("Circuit breaker OPEN \u2014 cosmetic item dropped"));
+          }
+          if (this.queue.length > 0 && this.queue[0].priority === 0 /* P0_CRITICAL */) {
+            return this.dequeue();
+          }
+          return null;
+        }
+        if (this.circuitState === "half_open" /* HALF_OPEN */) {
+          return this.dequeue();
+        }
+        return this.dequeue();
+      }
+      /**
+       * Check if circuit breaker should transition states.
+       * OPEN → HALF_OPEN when cooldown expires.
+       */
+      updateCircuitState() {
+        if (this.circuitState === "open" /* OPEN */ && Date.now() >= this.circuitCooldownUntil) {
+          this.circuitState = "half_open" /* HALF_OPEN */;
+          log(`[throttle] Circuit breaker: OPEN \u2192 HALF_OPEN (cooldown expired, probing)`);
+        }
+      }
+      /**
+       * Handle successful send — manage circuit breaker recovery.
+       */
+      onSuccessfulSend() {
+        this.lastSuccessfulSend = Date.now();
+        if (this.circuitState === "half_open" /* HALF_OPEN */) {
+          this.circuitState = "closed" /* CLOSED */;
+          log(`[throttle] Circuit breaker: HALF_OPEN \u2192 CLOSED (probe succeeded)`);
+        }
+        if (this.circuitTrips.length > 0) {
+          const lastTrip = this.circuitTrips[this.circuitTrips.length - 1];
+          if (Date.now() - lastTrip > CIRCUIT_RESET_WINDOW_MS) {
+            this.circuitTrips.length = 0;
+            this.circuitTrips = [];
+            log(`[throttle] Circuit breaker: trip count reset after ${CIRCUIT_RESET_WINDOW_MS / 6e4}min of success`);
+          }
+        }
+      }
+      // ── Retry logic (non-429 errors only) ───────────────────────────────
+      async execWithRetry(label2, fn) {
+        for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
+          try {
+            return await fn();
+          } catch (err) {
+            if (is429(err)) throw err;
+            if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
+              warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
+              await sleep(RETRY_DELAY_MS);
+              continue;
+            }
+            throw err;
+          }
+        }
+        throw new Error("unreachable");
+      }
+      // ── Pause management ────────────────────────────────────────────────
+      enterPause(retrySec, failedItem) {
+        this.queue.unshift(failedItem);
+        const now = Date.now();
+        this.circuitTrips.push(now);
+        this.circuitTrips = this.circuitTrips.filter((t) => now - t < CIRCUIT_TRIP_WINDOW_MS);
+        const bufferSec = this.circuitTrips.length * CIRCUIT_COOLDOWN_STEP_SEC;
+        const totalPauseSec = retrySec + bufferSec;
+        this.pausedUntil = now + totalPauseSec * 1e3;
+        if (this.pauseStartedAt === 0) this.pauseStartedAt = now;
+        if (this.circuitTrips.length >= CIRCUIT_TRIP_THRESHOLD && this.circuitState !== "open" /* OPEN */) {
+          this.circuitState = "open" /* OPEN */;
+          this.circuitCooldownUntil = now + totalPauseSec * 1e3;
+          warn(`[throttle] Circuit breaker TRIPPED \u2192 OPEN (${this.circuitTrips.length} 429s in ${CIRCUIT_TRIP_WINDOW_MS / 6e4}min)`);
+        } else if (this.circuitState === "half_open" /* HALF_OPEN */) {
+          this.circuitState = "open" /* OPEN */;
+          this.circuitCooldownUntil = now + totalPauseSec * 1e3;
+          warn(`[throttle] Circuit breaker probe FAILED \u2192 OPEN (retry_after=${retrySec}s + ${bufferSec}s buffer)`);
+        }
+        warn(`[throttle] 429 event`, JSON.stringify({
+          method: failedItem.label,
+          chatId: failedItem.chatId,
+          priority: failedItem.priority,
+          retry_after: retrySec,
+          buffer: bufferSec,
+          total_pause: totalPauseSec,
+          queue_depth: this.queue.length,
+          circuit_state: this.circuitState,
+          circuit_trip_count: this.circuitTrips.length
+        }));
+      }
+      // ── Helpers ─────────────────────────────────────────────────────────
+      recordSend(chatId) {
+        const now = Date.now();
+        this.lastSendPerChat.set(chatId, now);
+        this.lastGlobalSend = now;
+      }
+      /** Remove and return the first item from the queue, updating per-chat counter. */
+      dequeue() {
+        const item = this.queue.shift();
+        if (item) this.decrementChatCount(item.chatId);
+        return item ?? null;
+      }
+      decrementChatCount(chatId) {
+        const count = (this.perChatQueueCount.get(chatId) ?? 1) - 1;
+        if (count <= 0) this.perChatQueueCount.delete(chatId);
+        else this.perChatQueueCount.set(chatId, count);
+      }
+      flushQueueWithError(message) {
+        while (this.queue.length > 0) {
+          const item = this.dequeue();
+          item.reject(new Error(message));
+        }
+      }
+    };
+  }
+});
+
 // src/dashboard/routes/system.ts
 var handleHealth, handleJobs, handleMemories, handleStats, handleAgents, handleTasks, handleOrchestrations;
 var init_system = __esm({
@@ -7570,8 +7944,10 @@ var init_system = __esm({
     init_store5();
     init_store();
     init_version();
+    init_telegram_throttle();
     handleHealth = (_req, res) => {
-      jsonResponse(res, { status: "ok", version: VERSION, uptime: process.uptime() });
+      const throttle = getThrottleState();
+      jsonResponse(res, { status: "ok", version: VERSION, uptime: process.uptime(), throttle: throttle ?? void 0 });
     };
     handleJobs = (_req, res) => {
       jsonResponse(res, listJobs());
@@ -7936,7 +8312,7 @@ function buildContextPrefix(msg) {
 }
 async function sendOrEditKeyboard(chatId, channel, messageId, text, buttons) {
   if (messageId && typeof channel.editKeyboard === "function") {
-    const ok = await channel.editKeyboard(chatId, messageId, text, buttons, { priority: true });
+    const ok = await channel.editKeyboard(chatId, messageId, text, buttons, { priority: 0 /* P0_CRITICAL */ });
     if (ok) return messageId;
   }
   if (typeof channel.sendKeyboard === "function") {
@@ -7949,6 +8325,7 @@ var TONE_PATTERNS, BLOCKED_PATH_PATTERNS, CLI_INSTALL_HINTS, PERM_MODES, VERBOSE
 var init_helpers = __esm({
   "src/router/helpers.ts"() {
     "use strict";
+    init_telegram_throttle();
     init_store5();
     init_backends();
     TONE_PATTERNS = [
@@ -8728,8 +9105,8 @@ function checkBudget(db3, orchestrationId) {
   }
   const percentUsed = totalCost / budgetLimit * 100;
   const exceeded = totalCost >= budgetLimit;
-  const warning4 = percentUsed >= BUDGET_WARNING_PERCENT * 100;
-  return { totalCost, budgetLimit, percentUsed, exceeded, warning: warning4 };
+  const warning3 = percentUsed >= BUDGET_WARNING_PERCENT * 100;
+  return { totalCost, budgetLimit, percentUsed, exceeded, warning: warning3 };
 }
 function recordAgentCost(db3, orchestrationId, agentCost) {
   updateOrchestrationCost(db3, orchestrationId, agentCost);
@@ -16392,251 +16769,6 @@ var init_health2 = __esm({
   }
 });
 
-// src/channels/telegram-throttle.ts
-var telegram_throttle_exports = {};
-__export(telegram_throttle_exports, {
-  TelegramThrottle: () => TelegramThrottle,
-  getThrottleState: () => getThrottleState
-});
-import { GrammyError } from "grammy";
-function isEditLabel(label2) {
-  return label2.startsWith("editText") || label2.startsWith("editKeyboard");
-}
-function perChatInterval(chatId) {
-  return parseInt(chatId) < 0 ? PER_GROUP_INTERVAL_MS : PER_DM_INTERVAL_MS;
-}
-function getThrottleState() {
-  if (!_activeThrottle) return null;
-  return _activeThrottle.getState();
-}
-function is429(err) {
-  return err instanceof GrammyError && err.error_code === 429;
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var PER_DM_INTERVAL_MS, PER_GROUP_INTERVAL_MS, GLOBAL_INTERVAL_MS, MAX_RETRIES2, RETRY_DELAY_MS, MAX_QUEUE_SIZE, EDIT_PRESSURE_THRESHOLD, MAX_TOTAL_PAUSE_MS, _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;
-    GLOBAL_INTERVAL_MS = 100;
-    MAX_RETRIES2 = 2;
-    RETRY_DELAY_MS = 1e3;
-    MAX_QUEUE_SIZE = 100;
-    EDIT_PRESSURE_THRESHOLD = MAX_QUEUE_SIZE / 2;
-    MAX_TOTAL_PAUSE_MS = 30 * 60 * 1e3;
-    _activeThrottle = null;
-    TelegramThrottle = class {
-      queue = [];
-      processing = false;
-      lastSendPerChat = /* @__PURE__ */ new Map();
-      lastGlobalSend = 0;
-      // Pause state
-      pausedUntil = 0;
-      pauseStartedAt = 0;
-      chatsPendingNotification = /* @__PURE__ */ new Set();
-      resumeNotifier;
-      constructor() {
-        _activeThrottle = this;
-      }
-      /**
-       * Register a callback that fires when the throttle resumes after a pause.
-       * The callback should send a message directly via bot.api (NOT through the throttle).
-       */
-      setResumeNotifier(fn) {
-        this.resumeNotifier = fn;
-      }
-      /** Enqueue a Telegram API call with automatic pacing and 429 handling.
-       *  When `priority` is true the item jumps to the front of the queue —
-       *  used by fast-path commands (/status, /stop, etc.) so their responses
-       *  aren't delayed behind tool-notification or error-message floods. */
-      async send(chatId, label2, fn, priority) {
-        if (isEditLabel(label2)) {
-          if (this.isPaused()) {
-            throw new Error("Throttle paused (rate limit active) \u2014 edit skipped");
-          }
-          if (this.queue.length >= EDIT_PRESSURE_THRESHOLD) {
-            throw new Error("Throttle queue pressured \u2014 edit skipped");
-          }
-        }
-        return new Promise((resolve3, reject) => {
-          if (this.queue.length >= MAX_QUEUE_SIZE) {
-            const editIdx = this.queue.findIndex((q) => isEditLabel(q.label));
-            const dropIdx = editIdx >= 0 ? editIdx : 0;
-            const dropped = this.queue.splice(dropIdx, 1)[0];
-            if (dropped) {
-              warn(`[throttle] Queue full (${MAX_QUEUE_SIZE}), dropping: ${dropped.label}`);
-              dropped.reject(new Error("Dropped from send queue (overflow)"));
-            }
-          }
-          const item = { chatId, label: label2, fn, resolve: resolve3, reject };
-          if (priority) {
-            this.queue.unshift(item);
-          } else {
-            this.queue.push(item);
-          }
-          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, opts) {
-        if (this.isPaused()) return void 0;
-        if (this.queue.length > 10) return void 0;
-        if (!opts?.skipRecord) {
-          const lastChat = this.lastSendPerChat.get(chatId) ?? 0;
-          if (Date.now() - lastChat < perChatInterval(chatId)) return void 0;
-          if (Date.now() - this.lastGlobalSend < GLOBAL_INTERVAL_MS) return void 0;
-        }
-        try {
-          const result = await fn();
-          if (!opts?.skipRecord) 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;
-      }
-      /** Get structured state for diagnostics / health checks. */
-      getState() {
-        const now = Date.now();
-        const paused = now < this.pausedUntil;
-        return {
-          isPaused: paused,
-          queueDepth: this.queue.length,
-          pausedUntilMs: this.pausedUntil,
-          pauseRemainingSec: paused ? Math.ceil((this.pausedUntil - now) / 1e3) : 0
-        };
-      }
-      // ── Queue processor ─────────────────────────────────────────────────
-      async drain() {
-        if (this.processing) return;
-        this.processing = true;
-        try {
-          while (this.queue.length > 0) {
-            while (this.isPaused()) {
-              if (this.pauseStartedAt > 0 && Date.now() - this.pauseStartedAt > MAX_TOTAL_PAUSE_MS) {
-                warn(`[throttle] Max pause duration exceeded (${MAX_TOTAL_PAUSE_MS / 6e4}min), dropping ${this.queue.length} items`);
-                this.flushQueueWithError("Telegram rate limit exceeded max wait time");
-                this.pausedUntil = 0;
-                this.pauseStartedAt = 0;
-                this.chatsPendingNotification.clear();
-                break;
-              }
-              const waitMs = Math.min(this.pausedUntil - Date.now(), 5e3);
-              if (waitMs > 0) await sleep(waitMs);
-            }
-            if (this.queue.length === 0) break;
-            if (this.chatsPendingNotification.size > 0) {
-              await this.sendResumeNotifications();
-            }
-            const item = this.queue[0];
-            const lastChat = this.lastSendPerChat.get(item.chatId) ?? 0;
-            const chatWait = perChatInterval(item.chatId) - (Date.now() - lastChat);
-            if (chatWait > 0) await sleep(chatWait);
-            const globalWait = GLOBAL_INTERVAL_MS - (Date.now() - this.lastGlobalSend);
-            if (globalWait > 0) await sleep(globalWait);
-            this.queue.shift();
-            try {
-              const result = await this.execWithRetry(item.label, item.fn);
-              this.recordSend(item.chatId);
-              this.pauseStartedAt = 0;
-              item.resolve(result);
-            } catch (err) {
-              if (is429(err)) {
-                const retrySec = err.parameters?.retry_after ?? 10;
-                this.enterPause(retrySec, item);
-                continue;
-              }
-              item.reject(err);
-            }
-          }
-        } finally {
-          this.processing = false;
-        }
-      }
-      // ── Retry logic (non-429 errors only) ───────────────────────────────
-      async execWithRetry(label2, fn) {
-        for (let attempt = 0; attempt <= MAX_RETRIES2; attempt++) {
-          try {
-            return await fn();
-          } catch (err) {
-            if (is429(err)) throw err;
-            if (attempt < MAX_RETRIES2 && err instanceof GrammyError) {
-              warn(`[throttle] ${label2} attempt ${attempt + 1}/${MAX_RETRIES2} failed (${err.error_code}), retrying`);
-              await sleep(RETRY_DELAY_MS);
-              continue;
-            }
-            throw err;
-          }
-        }
-        throw new Error("unreachable");
-      }
-      // ── Pause management ────────────────────────────────────────────────
-      enterPause(retrySec, failedItem) {
-        this.queue.unshift(failedItem);
-        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 ${bufferedSec}s (retry_after=${retrySec}s + 50% buffer, ${this.queue.length} items queued)`);
-      }
-      async sendResumeNotifications() {
-        const chats2 = new Set(this.chatsPendingNotification);
-        this.chatsPendingNotification.clear();
-        if (!this.resumeNotifier) return;
-        const pausedSec = this.pauseStartedAt > 0 ? Math.round((Date.now() - this.pauseStartedAt) / 1e3) : 0;
-        for (const chatId of chats2) {
-          const queuedForChat = this.queue.filter((q) => q.chatId === chatId).length;
-          if (queuedForChat === 0) continue;
-          try {
-            await this.resumeNotifier(chatId, pausedSec, queuedForChat);
-            this.recordSend(chatId);
-          } catch (err) {
-            if (is429(err)) {
-              const retrySec = err.parameters?.retry_after ?? 10;
-              this.pausedUntil = Date.now() + retrySec * 1e3;
-              warn(`[throttle] Resume notification hit 429, re-pausing for ${retrySec}s (skipping further notifications)`);
-              return;
-            }
-            warn(`[throttle] Resume notification failed for chat ${chatId}: ${err}`);
-          }
-        }
-        this.pauseStartedAt = 0;
-      }
-      // ── Helpers ─────────────────────────────────────────────────────────
-      recordSend(chatId) {
-        const now = Date.now();
-        this.lastSendPerChat.set(chatId, now);
-        this.lastGlobalSend = now;
-      }
-      flushQueueWithError(message) {
-        while (this.queue.length > 0) {
-          const item = this.queue.shift();
-          item.reject(new Error(message));
-        }
-      }
-    };
-  }
-});
-
 // src/health/checks.ts
 import { existsSync as existsSync16, statSync as statSync5, readFileSync as readFileSync11 } from "fs";
 import { execFileSync as execFileSync2, execSync as execSync2 } from "child_process";
@@ -17978,38 +18110,32 @@ async function sendThinkingKeyboard(chatId, channel, messageId, forModelId) {
   const currentModel = forModelId ?? getModel(chatId) ?? adapter.defaultModel;
   const modelInfo = adapter.availableModels[currentModel];
   const currentLevel = getThinkingLevel(chatId) || "auto";
-  if (!modelInfo || modelInfo.thinking !== "adjustable" || !modelInfo.thinkingLevels) {
-    await sendOrEditKeyboard(
-      chatId,
-      channel,
-      messageId,
-      `Model ${shortModelName(currentModel)} uses fixed thinking \u2014 no adjustment needed.`,
-      [[{ label: "\u2190 Back to Model", data: "menu:model" }]]
-    );
-    return;
-  }
   const showThinkingUi = getShowThinkingUi(chatId);
-  const buttons = modelInfo.thinkingLevels.map((level) => [{
-    label: `${level === currentLevel ? "\u2713 " : ""}${level === "auto" ? "Auto" : capitalize(level)}`,
-    data: `thinking:${level}`,
-    ...level === currentLevel ? { style: "primary" } : {}
-  }]);
+  const canAdjust = modelInfo?.thinking === "adjustable" && modelInfo.thinkingLevels;
+  const buttons = [];
+  if (canAdjust) {
+    for (const level of modelInfo.thinkingLevels) {
+      buttons.push([{
+        label: `${level === currentLevel ? "\u2713 " : ""}${level === "auto" ? "Auto" : capitalize(level)}`,
+        data: `thinking:${level}`,
+        ...level === currentLevel ? { style: "primary" } : {}
+      }]);
+    }
+  }
   buttons.push([{
     label: `${showThinkingUi ? "\u2713 " : ""}\u{1F4AD} Show Thinking`,
     data: "thinking_show_ui:toggle",
     ...showThinkingUi ? { style: "primary" } : {}
   }]);
-  await sendOrEditKeyboard(
-    chatId,
-    channel,
-    messageId,
-    `\u{1F4AD} Thinking Level \u2014 ${shortModelName(currentModel)}
+  const header2 = canAdjust ? `\u{1F4AD} Thinking Level \u2014 ${shortModelName(currentModel)}
 Current: ${capitalize(currentLevel)}
-Show thinking tokens: ${showThinkingUi ? "On" : "Off"}${adapter.id === "cursor" ? `
+Show thinking tokens: ${showThinkingUi ? "On" : "Off"}` : `\u{1F4AD} Thinking \u2014 ${shortModelName(currentModel)}
+Level: Fixed
+Show thinking tokens: ${showThinkingUi ? "On" : "Off"}`;
+  const note = adapter.id === "cursor" ? `
 
-\u26A0\uFE0F ${adapter.displayName} doesn't expose thinking tokens` : ""}`,
-    buttons
-  );
+\u26A0\uFE0F ${adapter.displayName} doesn't expose thinking tokens` : "";
+  await sendOrEditKeyboard(chatId, channel, messageId, `${header2}${note}`, buttons);
 }
 async function sendSkillsPage(chatId, channel, skills2, page, messageId) {
   const approved = skills2.filter((s) => s.status === "approved");
@@ -18810,7 +18936,8 @@ async function sendBackendModelPicker(chatId, backendId, channel, messageId) {
   const summary = backendConfigSummary(chatId, backendId, false);
   if (adapter.type === "api") {
     const apiModels = getApiModels(backendId);
-    if (apiModels.length === 0) {
+    const adapterModelCount = Object.keys(adapter.availableModels).length;
+    if (apiModels.length === 0 && adapterModelCount === 0) {
       await sendOrEditKeyboard(
         chatId,
         channel,
@@ -18825,23 +18952,25 @@ No models configured. Add one with \u2795`,
       );
       return;
     }
-    const modelButtons2 = [];
-    for (const m of apiModels) {
-      const isActive = m.modelId === currentModel;
-      const freeTag = m.isFree && !m.displayName.toLowerCase().includes("free") ? " (free)" : "";
-      modelButtons2.push([
-        {
-          label: `${isActive ? "\u2713 " : ""}${m.displayName}${freeTag}`,
-          data: `apimodel:sel:${m.id}`,
-          ...isActive ? { style: "primary" } : {}
-        },
-        { label: "\u{1F5D1}", data: `apimodel:del:${m.id}` }
-      ]);
+    if (apiModels.length > 0) {
+      const modelButtons2 = [];
+      for (const m of apiModels) {
+        const isActive = m.modelId === currentModel;
+        const freeTag = m.isFree && !m.displayName.toLowerCase().includes("free") ? " (free)" : "";
+        modelButtons2.push([
+          {
+            label: `${isActive ? "\u2713 " : ""}${m.displayName}${freeTag}`,
+            data: `apimodel:sel:${m.id}`,
+            ...isActive ? { style: "primary" } : {}
+          },
+          { label: "\u{1F5D1}", data: `apimodel:del:${m.id}` }
+        ]);
+      }
+      modelButtons2.push([{ label: "\u2795 Add Model", data: `apimodel:add:${backendId}` }]);
+      modelButtons2.push([{ label: "\u2190 Back", data: `bconf:panel:${backendId}` }]);
+      await sendOrEditKeyboard(chatId, channel, messageId, summary, modelButtons2);
+      return;
     }
-    modelButtons2.push([{ label: "\u2795 Add Model", data: `apimodel:add:${backendId}` }]);
-    modelButtons2.push([{ label: "\u2190 Back", data: `bconf:panel:${backendId}` }]);
-    await sendOrEditKeyboard(chatId, channel, messageId, summary, modelButtons2);
-    return;
   }
   const modelButtons = Object.entries(adapter.availableModels).map(([id, info]) => [{
     label: `${id === currentModel ? "\u2713 " : ""}${info.label}`,
@@ -22467,18 +22596,26 @@ var init_ollama2 = __esm({
        */
       async streamDirect(prompt, model2, opts) {
         const cleanPrompt = stripForLocalModel(prompt);
-        let forceThinkOff = false;
+        let disableThinking = false;
         try {
           const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
           const modelRecord = OllamaStore.getModelByName(model2);
-          forceThinkOff = modelRecord?.forceThinkOff ?? false;
+          if (modelRecord?.forceThinkOff) {
+            disableThinking = true;
+          } else if (opts?.thinkingLevel === "off") {
+            disableThinking = true;
+          }
         } catch {
         }
         const apiOpts = {
           timeoutMs: opts?.timeoutMs,
           onStream: opts?.onStream,
           signal: opts?.signal,
-          ...forceThinkOff ? { providerOptions: { ollama: { think: false } } } : {}
+          messageHistory: opts?.messageHistory,
+          permMode: opts?.permMode,
+          thinkingLevel: opts?.thinkingLevel,
+          onThinking: opts?.onThinking,
+          ...disableThinking ? { providerOptions: { ollama: { think: false } } } : {}
         };
         const result = await this.streamDirectWithHistory(
           cleanPrompt,
@@ -22503,9 +22640,10 @@ var init_ollama2 = __esm({
         const { OllamaStore } = (init_ollama(), __toCommonJS(ollama_exports));
         const models = OllamaStore.getAvailableModels();
         for (const m of models) {
+          const isThinkingCapable = m.capability === "thinking" && !m.forceThinkOff;
           this.availableModels[m.name] = {
             label: `${m.name}${m.parameterSize ? ` (${m.parameterSize})` : ""}`,
-            thinking: "none"
+            thinking: isThinkingCapable ? "adjustable" : "none"
           };
           this.pricing[m.name] = { in: 0, out: 0, cache: 0 };
           this.contextWindow[m.name] = m.contextWindow ?? 4096;
@@ -22800,7 +22938,7 @@ var init_backends = __esm({
       ollama: new OllamaAdapter(),
       openrouter: openRouterAdapter
     };
-    CHAT_BACKEND_IDS = ["claude", "gemini", "codex", "cursor", "openrouter"];
+    CHAT_BACKEND_IDS = ["claude", "gemini", "codex", "cursor", "openrouter", "ollama"];
     availableSet = /* @__PURE__ */ new Set();
   }
 });
@@ -24397,13 +24535,152 @@ var init_session_log2 = __esm({
   }
 });
 
-// src/router/live-status.ts
-function canFlushGlobally() {
-  return Date.now() - globalLastFlushAt >= GLOBAL_MIN_GAP_MS;
+// src/channels/edit-coordinator.ts
+var edit_coordinator_exports = {};
+__export(edit_coordinator_exports, {
+  getEditCoordinator: () => getEditCoordinator,
+  resetEditCoordinator: () => resetEditCoordinator
+});
+function getEditCoordinator() {
+  return EditCoordinator.getInstance();
 }
-function markGlobalFlush() {
-  globalLastFlushAt = Date.now();
+function resetEditCoordinator() {
+  EditCoordinator.resetInstance();
 }
+var TICK_INTERVAL_MS, MAX_EDITS_PER_WINDOW, EDIT_WINDOW_MS, EditCoordinator;
+var init_edit_coordinator = __esm({
+  "src/channels/edit-coordinator.ts"() {
+    "use strict";
+    init_log();
+    TICK_INTERVAL_MS = 1e3;
+    MAX_EDITS_PER_WINDOW = 4;
+    EDIT_WINDOW_MS = 6e4;
+    EditCoordinator = class _EditCoordinator {
+      static instance = null;
+      /** Active streams indexed by messageId. */
+      activeStreams = /* @__PURE__ */ new Map();
+      /** Per-message edit tracking for the sliding window cap. */
+      perMessageEditCount = /* @__PURE__ */ new Map();
+      /** Single flush timer shared across all streams. */
+      flushTimer = null;
+      /** Round-robin index — cycles through stream keys. */
+      roundRobinIndex = 0;
+      /** Ordered list of stream keys for round-robin iteration.
+       * Rebuilt on register/unregister to avoid iterator invalidation. */
+      streamKeys = [];
+      constructor() {
+      }
+      static getInstance() {
+        if (!_EditCoordinator.instance) {
+          _EditCoordinator.instance = new _EditCoordinator();
+        }
+        return _EditCoordinator.instance;
+      }
+      /** Reset the singleton (for testing only). */
+      static resetInstance() {
+        if (_EditCoordinator.instance) {
+          _EditCoordinator.instance.shutdown();
+          _EditCoordinator.instance = null;
+        }
+      }
+      /** Register a stream to be managed by the coordinator.
+       * Creates the flush timer if this is the first stream. */
+      register(messageId, stream) {
+        this.activeStreams.set(messageId, stream);
+        this.rebuildKeys();
+        log(`[edit-coordinator] registered stream ${messageId} (${this.activeStreams.size} active)`);
+        if (!this.flushTimer) {
+          this.flushTimer = setInterval(() => this.tick(), TICK_INTERVAL_MS);
+          log(`[edit-coordinator] timer started (${TICK_INTERVAL_MS}ms tick)`);
+        }
+      }
+      /** Unregister a stream (called on finalization).
+       * Cleans up per-message edit tracking. Stops timer if no streams remain. */
+      unregister(messageId) {
+        this.activeStreams.delete(messageId);
+        this.perMessageEditCount.delete(messageId);
+        this.rebuildKeys();
+        log(`[edit-coordinator] unregistered stream ${messageId} (${this.activeStreams.size} remaining)`);
+        if (this.activeStreams.size === 0 && this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+          this.roundRobinIndex = 0;
+          log(`[edit-coordinator] timer stopped (no active streams)`);
+        }
+      }
+      /** Shut down the coordinator — clear timer, remove all streams. */
+      shutdown() {
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+        }
+        this.activeStreams.clear();
+        this.perMessageEditCount.clear();
+        this.streamKeys = [];
+        this.roundRobinIndex = 0;
+      }
+      /** Get the number of active streams (for diagnostics). */
+      get streamCount() {
+        return this.activeStreams.size;
+      }
+      /** Check whether a message can be edited (under the per-message cap). */
+      canEditMessage(messageId) {
+        const record = this.perMessageEditCount.get(messageId);
+        if (!record) return true;
+        const now = Date.now();
+        if (now - record.windowStart >= EDIT_WINDOW_MS) {
+          return true;
+        }
+        return record.count < MAX_EDITS_PER_WINDOW;
+      }
+      /** Record that an edit was made to a message. */
+      recordEdit(messageId) {
+        const now = Date.now();
+        const record = this.perMessageEditCount.get(messageId);
+        if (!record || now - record.windowStart >= EDIT_WINDOW_MS) {
+          this.perMessageEditCount.set(messageId, { count: 1, windowStart: now });
+        } else {
+          record.count++;
+        }
+      }
+      // ── Internal ──────────────────────────────────────────────────────────
+      /** Rebuild the ordered keys array after registration changes. */
+      rebuildKeys() {
+        this.streamKeys = Array.from(this.activeStreams.keys());
+        if (this.streamKeys.length > 0) {
+          this.roundRobinIndex = this.roundRobinIndex % this.streamKeys.length;
+        } else {
+          this.roundRobinIndex = 0;
+        }
+      }
+      /** Timer tick — pick the next stream via round-robin and flush it.
+       * If the selected stream is at its per-message edit cap, try the next one. */
+      async tick() {
+        if (this.streamKeys.length === 0) return;
+        const startIdx = this.roundRobinIndex;
+        let tried = 0;
+        while (tried < this.streamKeys.length) {
+          const idx = (startIdx + tried) % this.streamKeys.length;
+          const messageId = this.streamKeys[idx];
+          const stream = this.activeStreams.get(messageId);
+          if (stream && this.canEditMessage(messageId)) {
+            this.roundRobinIndex = (idx + 1) % this.streamKeys.length;
+            try {
+              await stream.flush();
+              this.recordEdit(messageId);
+            } catch {
+            }
+            return;
+          }
+          tried++;
+        }
+        this.roundRobinIndex = (startIdx + 1) % this.streamKeys.length;
+      }
+    };
+  }
+});
+
+// src/router/live-status.ts
 function dedupThinking(entries) {
   const out = [];
   for (const e of entries) {
@@ -24467,18 +24744,15 @@ function makeLiveStatus(chatId, channel, modelLabel, verboseLevel, showThinking)
   };
   return { liveStatus, toolCb };
 }
-var FLUSH_INTERVAL_DM_MS, FLUSH_INTERVAL_GROUP_MS, MAX_THINKING_CHARS, GLOBAL_MIN_GAP_MS, globalLastFlushAt, TRIM_THRESHOLD, MAX_ENTRIES, SPINNER_FRAMES, HEARTBEAT_TEXTS, LiveStatusMessage;
+var MAX_THINKING_CHARS, TRIM_THRESHOLD, MAX_ENTRIES, SPINNER_FRAMES, HEARTBEAT_TEXTS, LiveStatusMessage;
 var init_live_status = __esm({
   "src/router/live-status.ts"() {
     "use strict";
     init_log();
     init_helpers();
     init_telegram_throttle();
-    FLUSH_INTERVAL_DM_MS = 2e3;
-    FLUSH_INTERVAL_GROUP_MS = 5e3;
+    init_edit_coordinator();
     MAX_THINKING_CHARS = 800;
-    GLOBAL_MIN_GAP_MS = 1e3;
-    globalLastFlushAt = 0;
     TRIM_THRESHOLD = 3500;
     MAX_ENTRIES = 200;
     SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -24494,7 +24768,6 @@ var init_live_status = __esm({
       messageId = null;
       entries = [];
       startTime = Date.now();
-      flushTimer = null;
       lastRendered = "";
       finalized = false;
       /** Earliest time the next flush is allowed (set after 429 backoff) */
@@ -24509,18 +24782,12 @@ 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 = Date.now();
       /** Callback to restart typing indicator as fallback. */
       onTypingFallback;
       /** Set a callback that restarts the typing indicator loop as a fallback. */
       setTypingFallback(cb) {
         this.onTypingFallback = cb;
       }
-      /** Resolve flush interval based on chat type (group chats are rate-limited more aggressively). */
-      get flushIntervalMs() {
-        const numericId = parseInt(this.chatId);
-        return numericId < 0 ? FLUSH_INTERVAL_GROUP_MS : FLUSH_INTERVAL_DM_MS;
-      }
       /** Send the initial status message. Must be called before adding entries. */
       async init() {
         if (!this.channel.sendTextReturningId) return;
@@ -24528,9 +24795,7 @@ var init_live_status = __esm({
           const initial = `\u23F3 ${this.modelLabel} \xB7 Processing\u2026`;
           this.messageId = await this.channel.sendTextReturningId(this.chatId, initial, "plain") ?? null;
           if (this.messageId) {
-            this.lastSuccessfulFlushAt = Date.now();
-            this.flushTimer = setInterval(() => this.flush().catch(() => {
-            }), this.flushIntervalMs);
+            getEditCoordinator().register(this.messageId, this);
           }
         } catch (err) {
           log(`[live-status] init failed: ${err}`);
@@ -24582,21 +24847,22 @@ var init_live_status = __esm({
       }
       /**
        * Finalize the status message: replace the spinner with ✅ and elapsed time.
-       * Stops the flush loop. No-op if no message was created (channel doesn't support editing).
+       * Unregisters from EditCoordinator and sends one final P0_CRITICAL edit that
+       * bypasses the coordinator entirely (finalization must never be skipped).
+       * No-op if no message was created (channel doesn't support editing).
        */
       async finalize(elapsedMs) {
         this.finalized = true;
         this.pendingTools.clear();
-        if (this.flushTimer) {
-          clearInterval(this.flushTimer);
-          this.flushTimer = null;
+        if (this.messageId) {
+          getEditCoordinator().unregister(this.messageId);
         }
         if (!this.messageId || !this.channel.editText) return;
         const elapsedSec = (elapsedMs / 1e3).toFixed(1);
         const deduped = dedupThinking(this.entries);
         const body = renderFinal(deduped, this.modelLabel, elapsedSec, this.hasTrimmed);
         try {
-          await this.channel.editText(this.chatId, this.messageId, body, "plain");
+          await this.channel.editText(this.chatId, this.messageId, body, "plain", 0 /* P0_CRITICAL */);
         } catch (err) {
           log(`[live-status] finalize edit failed: ${err}`);
         }
@@ -24605,7 +24871,16 @@ var init_live_status = __esm({
       getMessageId() {
         return this.messageId;
       }
-      // ── Internal ──────────────────────────────────────────────────────────
+      // ── FlushableStream interface ──────────────────────────────────────────
+      /** Return the chatId this stream belongs to (FlushableStream interface). */
+      getChatId() {
+        return this.chatId;
+      }
+      /**
+       * Flush the current status to Telegram via editMessageText.
+       * Called by the EditCoordinator on each round-robin tick.
+       * Public to satisfy FlushableStream interface — do not call directly.
+       */
       async flush() {
         if (this.finalized || !this.messageId || !this.channel.editText) return;
         if (this.consecutiveEditFailures >= _LiveStatusMessage.MAX_EDIT_FAILURES) {
@@ -24618,10 +24893,9 @@ var init_live_status = __esm({
         if (Date.now() < this.nextFlushAllowedAt) return;
         const throttleState = getThrottleState();
         if (throttleState?.isPaused) return;
-        if (!canFlushGlobally()) return;
         this.spinnerFrame++;
         const deduped = dedupThinking(this.entries);
-        const body = renderEntries(
+        let body = renderEntries(
           deduped,
           this.modelLabel,
           Date.now() - this.startTime,
@@ -24629,17 +24903,21 @@ var init_live_status = __esm({
           this.pendingTools,
           this.spinnerFrame
         );
+        if (throttleState && throttleState.queueDepth > 30) {
+          body += `
+(queue: ${throttleState.queueDepth})`;
+        }
         if (body === this.lastRendered) return;
         this.lastRendered = body;
-        markGlobalFlush();
         try {
-          await this.channel.editText(this.chatId, this.messageId, body, "plain");
+          await this.channel.editText(this.chatId, this.messageId, body, "plain", 2 /* P2_COSMETIC */);
           this.consecutiveEditFailures = 0;
           this.lastSuccessfulFlushAt = Date.now();
         } catch (err) {
           this.handleRateLimit(err);
         }
       }
+      // ── Internal ──────────────────────────────────────────────────────────
       /**
        * Trim entries from the BEGINNING when the rendered body exceeds the threshold.
        * This is the core of the single-message pattern: always show the most recent
@@ -25070,6 +25348,88 @@ var init_response = __esm({
   }
 });
 
+// src/channels/typing-manager.ts
+var typing_manager_exports = {};
+__export(typing_manager_exports, {
+  getTypingManager: () => getTypingManager,
+  resetTypingManager: () => resetTypingManager
+});
+function getTypingManager() {
+  return TypingManager.getInstance();
+}
+function resetTypingManager() {
+  TypingManager.resetInstance();
+}
+var TypingManager;
+var init_typing_manager = __esm({
+  "src/channels/typing-manager.ts"() {
+    "use strict";
+    TypingManager = class _TypingManager {
+      static instance = null;
+      activeChats = /* @__PURE__ */ new Map();
+      static getInstance() {
+        if (!_TypingManager.instance) {
+          _TypingManager.instance = new _TypingManager();
+        }
+        return _TypingManager.instance;
+      }
+      /**
+       * Start showing typing indicator for this chat.
+       * If already showing (another agent acquired), just increments refCount.
+       */
+      acquire(chatId, channel) {
+        const entry = this.activeChats.get(chatId);
+        if (entry) {
+          entry.refCount++;
+          return;
+        }
+        channel.sendTyping?.(chatId).catch(() => {
+        });
+        const timer = setInterval(() => {
+          channel.sendTyping?.(chatId).catch(() => {
+          });
+        }, 4e3);
+        this.activeChats.set(chatId, { refCount: 1, timer });
+      }
+      /**
+       * Stop showing typing for this agent's perspective.
+       * Only stops the timer when refCount reaches 0.
+       */
+      release(chatId) {
+        const entry = this.activeChats.get(chatId);
+        if (!entry) return;
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+          clearInterval(entry.timer);
+          this.activeChats.delete(chatId);
+        }
+      }
+      /** Clean shutdown — clear all timers. */
+      shutdown() {
+        for (const [, entry] of this.activeChats) {
+          clearInterval(entry.timer);
+        }
+        this.activeChats.clear();
+      }
+      /** Expose active chat count for testing/diagnostics. */
+      get size() {
+        return this.activeChats.size;
+      }
+      /** Get ref count for a chat (for testing). */
+      getRefCount(chatId) {
+        return this.activeChats.get(chatId)?.refCount ?? 0;
+      }
+      /** Reset singleton (for testing only). */
+      static resetInstance() {
+        if (_TypingManager.instance) {
+          _TypingManager.instance.shutdown();
+          _TypingManager.instance = null;
+        }
+      }
+    };
+  }
+});
+
 // src/shell/exec.ts
 import { execFile as execFile4 } from "child_process";
 function resolveShell() {
@@ -25685,18 +26045,7 @@ async function handleSideQuest(parentChatId, msg, channel) {
     [{ label: "\u274C Cancel", data: `sq:cancel:${sqId}` }]
   ]);
   const startTime = Date.now();
-  let typingActive = true;
-  const typingLoop = async () => {
-    while (typingActive) {
-      try {
-        await channel.sendTyping?.(parentChatId);
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, 4e3));
-    }
-  };
-  typingLoop().catch(() => {
-  });
+  getTypingManager().acquire(parentChatId, channel);
   try {
     const backend2 = getBackend(parentChatId);
     const model2 = getModel(parentChatId);
@@ -25712,7 +26061,6 @@ async function handleSideQuest(parentChatId, msg, channel) {
       entityType: "main",
       bootstrapProfile: "interactive"
     });
-    typingActive = false;
     const userText = msg.text ?? "";
     const truncated = userText.length > 60 ? userText.slice(0, 57) + "\u2026" : userText;
     const header2 = `\u{1F5FA} <b>Side quest: "${truncated}"</b>
@@ -25736,10 +26084,9 @@ async function handleSideQuest(parentChatId, msg, channel) {
       log(`[reflection] Side quest signal detection error: ${e}`);
     }
   } catch (err) {
-    typingActive = false;
     await channel.sendText(parentChatId, `\u{1F5FA} Side quest failed: ${err.message}`, { parseMode: "plain" });
   } finally {
-    typingActive = false;
+    getTypingManager().release(parentChatId);
     const activeSet = activeSideQuests.get(parentChatId);
     if (activeSet) {
       activeSet.delete(sqId);
@@ -25751,6 +26098,7 @@ async function handleSideQuest(parentChatId, msg, channel) {
 var init_sidequest = __esm({
   "src/router/sidequest.ts"() {
     "use strict";
+    init_typing_manager();
     init_agent();
     init_log();
     init_store5();
@@ -26192,19 +26540,27 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
       break;
     }
     case "apply": {
-      const { applyInsight: applyInsight2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
-      const { advanceReviewSession: advanceReviewSession2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-      const result = await applyInsight2(parseInt(idStr, 10));
-      advanceReviewSession2(getDb(), chatId, parseInt(idStr, 10), "applied");
-      await sendOrEditKeyboard(
-        chatId,
-        channel,
-        messageId,
-        `\u2705 ${result.message}`,
-        []
-      );
-      await new Promise((r) => setTimeout(r, 800));
-      await sendCurrentProposalInPlace(chatId, channel, messageId);
+      const id = parseInt(idStr, 10);
+      if (processingInsights.has(id)) break;
+      processingInsights.add(id);
+      await sendOrEditKeyboard(chatId, channel, messageId, "\u23F3 Applying...", []);
+      try {
+        const { applyInsight: applyInsight2 } = await Promise.resolve().then(() => (init_apply(), apply_exports));
+        const { advanceReviewSession: advanceReviewSession2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
+        const result = await applyInsight2(id);
+        advanceReviewSession2(getDb(), chatId, id, "applied");
+        await sendOrEditKeyboard(
+          chatId,
+          channel,
+          messageId,
+          `\u2705 ${result.message}`,
+          []
+        );
+        await new Promise((r) => setTimeout(r, 800));
+        await sendCurrentProposalInPlace(chatId, channel, messageId);
+      } finally {
+        processingInsights.delete(id);
+      }
       break;
     }
     case "skip": {
@@ -26214,10 +26570,17 @@ async function handleEvolveCallback(chatId, data, channel, messageId) {
       break;
     }
     case "reject": {
-      const { updateInsightStatus: updateInsightStatus2, advanceReviewSession: advanceReviewSession2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
-      updateInsightStatus2(getDb(), parseInt(idStr, 10), "rejected");
-      advanceReviewSession2(getDb(), chatId, parseInt(idStr, 10), "rejected");
-      await sendCurrentProposalInPlace(chatId, channel, messageId);
+      const rejId = parseInt(idStr, 10);
+      if (processingInsights.has(rejId)) break;
+      processingInsights.add(rejId);
+      try {
+        const { updateInsightStatus: updateInsightStatus2, advanceReviewSession: advanceReviewSession2 } = await Promise.resolve().then(() => (init_store4(), store_exports4));
+        updateInsightStatus2(getDb(), rejId, "rejected");
+        advanceReviewSession2(getDb(), chatId, rejId, "rejected");
+        await sendCurrentProposalInPlace(chatId, channel, messageId);
+      } finally {
+        processingInsights.delete(rejId);
+      }
       break;
     }
     case "discuss": {
@@ -26464,11 +26827,13 @@ async function handleReflectCallback(chatId, data, channel, messageId) {
     );
   }
 }
+var processingInsights;
 var init_evolve2 = __esm({
   "src/router/evolve.ts"() {
     "use strict";
     init_store5();
     init_helpers();
+    processingInsights = /* @__PURE__ */ new Set();
   }
 });
 
@@ -28637,12 +29002,12 @@ async function handleStopCommand(chatId, commandArgs, msg, channel) {
   await channel.sendText(
     chatId,
     stopped ? "Stopping current task..." : "Nothing is running.",
-    { parseMode: "plain", priority: true }
+    { parseMode: "plain", priority: 0 /* P0_CRITICAL */ }
   );
   if (stopped && typeof channel.sendKeyboard === "function") {
     await channel.sendKeyboard(chatId, "", [
       [{ label: "\u{1F195} New Chat", data: "menu:newchat" }]
-    ], { priority: true });
+    ], { priority: 0 /* P0_CRITICAL */ });
   }
 }
 async function handleVoiceCommand(chatId, commandArgs, msg, channel) {
@@ -29009,7 +29374,7 @@ async function handleClearCommand(chatId, _commandArgs, _msg, channel) {
   clearChatPaidSlots(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: true });
+  await channel.sendText(chatId, "\u{1F9FD} Session cleared. No summary saved.", { parseMode: "plain", priority: 0 /* P0_CRITICAL */ });
 }
 async function handleSummarizeCommand(chatId, commandArgs, msg, channel) {
   if (commandArgs?.toLowerCase() === "all") {
@@ -29192,9 +29557,9 @@ async function handleStatusCommand(chatId, commandArgs, msg, channel) {
         { label: "Change Mode", data: "menu:permissions" },
         { label: "Change Style", data: "menu:style" }
       ]
-    ], { priority: true });
+    ], { priority: 0 /* P0_CRITICAL */ });
   } else {
-    await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain", priority: true });
+    await channel.sendText(chatId, lines.join("\n"), { parseMode: "plain", priority: 0 /* P0_CRITICAL */ });
   }
 }
 async function handleBackendCommand2(chatId, commandArgs, msg, channel) {
@@ -30202,6 +30567,7 @@ async function handleCouncilCommand(chatId, commandArgs, msg, channel) {
 var init_command_handlers = __esm({
   "src/router/command-handlers.ts"() {
     "use strict";
+    init_telegram_throttle();
     init_format();
     init_log();
     init_format_time();
@@ -33194,7 +33560,9 @@ function withThread(channel, threadId) {
     // These operate on existing messages — no threadId needed
     editText: channel.editText?.bind(channel),
     editKeyboard: channel.editKeyboard?.bind(channel),
-    reactToMessage: channel.reactToMessage?.bind(channel)
+    reactToMessage: channel.reactToMessage?.bind(channel),
+    isDraftCapable: channel.isDraftCapable?.bind(channel),
+    sendMessageDraft: channel.sendMessageDraft?.bind(channel)
   };
 }
 var init_thread_wrapper = __esm({
@@ -34116,18 +34484,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
     isSideQuest: hasSqPrefix
   })) {
     const planDirective = buildPlanningDirective();
-    let typingActive2 = true;
-    const typingLoop2 = async () => {
-      while (typingActive2) {
-        try {
-          await channel.sendTyping?.(chatId);
-        } catch {
-        }
-        await new Promise((r) => setTimeout(r, 4e3));
-      }
-    };
-    typingLoop2().catch(() => {
-    });
+    getTypingManager().acquire(chatId, channel);
     try {
       const planResponse = await askAgent(chatId, cleanText || text, {
         cwd: settings.getCwd(),
@@ -34137,7 +34494,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         agentMode: effectiveAgentMode,
         planningDirective: planDirective
       });
-      typingActive2 = false;
+      getTypingManager().release(chatId);
       if (planResponse.text) {
         let planText = planResponse.text.replace(/\[REACT:.+?\]/g, "").replace(/\[SEND_FILE:.+?\]/g, "").replace(/\[GENERATE_IMAGE:.+?\]/g, "").replace(/\[HISTORY_SEARCH:[^\]]+\]/g, "").trim();
         const PLAN_DISPLAY_LIMIT = 3500;
@@ -34162,23 +34519,12 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         await channel.sendText(chatId, "(No plan generated \u2014 proceeding normally)", { parseMode: "plain" });
       }
     } catch (err) {
-      typingActive2 = false;
+      getTypingManager().release(chatId);
       await channel.sendText(chatId, `\u26A0\uFE0F Planning error: ${err.message}`, { parseMode: "plain" });
     }
     return;
   }
-  let typingActive = true;
-  const typingLoop = async () => {
-    while (typingActive) {
-      try {
-        await channel.sendTyping?.(chatId);
-      } catch {
-      }
-      await new Promise((r) => setTimeout(r, 4e3));
-    }
-  };
-  typingLoop().catch(() => {
-  });
+  getTypingManager().acquire(chatId, channel);
   try {
     const tMode = settings.getMode();
     const tVerbose = settings.getVerboseLevel();
@@ -34222,6 +34568,28 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         }
       };
     }
+    const DRAFT_FLUSH_INTERVAL_MS = 500;
+    const useDraftStreaming = channel.sendMessageDraft && channel.isDraftCapable?.(chatId);
+    const draftState = useDraftStreaming ? { accumulated: "", draftId: Date.now() & 2147483647, dirty: false, flushTimer: null } : null;
+    let onStreamCb;
+    if (draftState) {
+      draftState.flushTimer = setInterval(() => {
+        if (draftState.dirty) {
+          draftState.dirty = false;
+          channel.sendMessageDraft(chatId, draftState.draftId, draftState.accumulated);
+        }
+      }, DRAFT_FLUSH_INTERVAL_MS);
+      onStreamCb = (chunk) => {
+        draftState.accumulated += chunk;
+        draftState.dirty = true;
+      };
+    }
+    const stopDraftTimer2 = () => {
+      if (draftState?.flushTimer) {
+        clearInterval(draftState.flushTimer);
+        draftState.flushTimer = null;
+      }
+    };
     let toolUseCount = 0;
     const sigT0 = Date.now();
     const response = await askAgent(chatId, cleanText || text, {
@@ -34234,6 +34602,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
       agentMode: effectiveAgentMode,
       ...effectiveThinking ? { thinkingLevel: effectiveThinking } : {},
       chatContext: { chatTitle: msg.chatTitle, threadId: msg.threadId },
+      onStream: onStreamCb,
       onThinking: liveStatus || sessionLog ? (chunk) => {
         if (liveStatus) liveStatus.addThinking(chunk);
         if (sessionLog) sessionLog.logThinking(chunk);
@@ -34271,6 +34640,7 @@ You're still in discussion mode \u2014 try again or click a button to exit.`, {
         });
       }
     });
+    stopDraftTimer2();
     const elapsedMs = Date.now() - sigT0;
     const elapsedSec = (elapsedMs / 1e3).toFixed(1);
     if (liveStatus && response.thinkingText?.trim()) {
@@ -34436,7 +34806,8 @@ Approve paid usage for this session?`,
     const userMsg = diagnoseAgentError(errMsg, chatId);
     await channel.sendText(chatId, userMsg, { parseMode: "plain" });
   } finally {
-    typingActive = false;
+    stopDraftTimer();
+    getTypingManager().release(chatId);
     const pending = pendingInterrupts.get(chatId);
     if (pending) {
       pendingInterrupts.delete(chatId);
@@ -34471,6 +34842,7 @@ var init_router2 = __esm({
     init_gate();
     init_helpers();
     init_response();
+    init_typing_manager();
     init_shell();
     init_ui();
     init_api_models();
@@ -35765,6 +36137,11 @@ function isFastPathMessage(msg) {
 function sanitizeForTelegram(text) {
   return text.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x9F\uFFFD\uFFFE\uFFFF]/g, "");
 }
+function isDraftCapable(chatId) {
+  if (isSyntheticChatId(chatId)) return false;
+  const numId = numericChatId(chatId);
+  return !isNaN(numId) && numId > 0;
+}
 function numericChatId(chatId) {
   if (chatId.startsWith("sq:") || chatId.startsWith("cron:")) {
     throw new Error(`Synthetic chatId "${chatId}" passed to Telegram API`);
@@ -35780,6 +36157,7 @@ var init_telegram2 = __esm({
     init_log();
     init_health3();
     init_store5();
+    init_agent();
     init_telegram_throttle();
     FAST_PATH_COMMANDS = /* @__PURE__ */ new Set(["stop", "status", "new", "newchat", "clear"]);
     TelegramChannel = class _TelegramChannel {
@@ -35798,18 +36176,23 @@ var init_telegram2 = __esm({
       mediaGroupBuffer = /* @__PURE__ */ new Map();
       static MEDIA_GROUP_DEBOUNCE_MS = 500;
       // ── Polling health tracking ─────────────────────────────────────────
-      /** Timestamp of last update received from Telegram (message, callback, reaction) */
-      lastUpdateAt = 0;
+      /** Timestamp of last successful API keepalive ping (updated every 2 minutes) */
+      lastPollingCheckAt = 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 = 5 * 60 * 1e3;
-      // 5 minutes
+      /** Keepalive interval: pings bot.api.getMe() to confirm API connection is alive */
+      keepaliveInterval = null;
+      /** Max time without a successful keepalive ping before we consider polling dead (ms) */
+      static POLLING_SILENCE_THRESHOLD_MS = 10 * 60 * 1e3;
+      // 10 minutes
       /** How often the watchdog checks for polling health (ms) */
       static POLLING_WATCHDOG_INTERVAL_MS = 60 * 1e3;
       // 60 seconds
+      /** How often to ping bot.api.getMe() as a keepalive (ms) */
+      static POLLING_KEEPALIVE_INTERVAL_MS = 2 * 60 * 1e3;
+      // 2 minutes
       constructor() {
         const token = process.env.TELEGRAM_BOT_TOKEN;
         if (!token) {
@@ -35927,7 +36310,6 @@ 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);
@@ -35968,7 +36350,6 @@ 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}`);
@@ -35996,7 +36377,6 @@ 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;
@@ -36013,7 +36393,6 @@ 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);
@@ -36028,7 +36407,16 @@ var init_telegram2 = __esm({
           }
         });
         this.pollingExpected = true;
-        this.lastUpdateAt = Date.now();
+        this.lastPollingCheckAt = Date.now();
+        this.keepaliveInterval = setInterval(async () => {
+          if (!this.pollingExpected) return;
+          try {
+            await this.bot.api.getMe();
+            this.lastPollingCheckAt = Date.now();
+          } catch (err) {
+            error("[telegram] Keepalive ping failed:", err);
+          }
+        }, _TelegramChannel.POLLING_KEEPALIVE_INTERVAL_MS);
         const pollingPromise = this.bot.start({
           allowed_updates: [...API_CONSTANTS.ALL_UPDATE_TYPES],
           onStart: () => log("[telegram] Polling for messages...")
@@ -36051,13 +36439,13 @@ var init_telegram2 = __esm({
         );
         this.pollingWatchdog = setInterval(() => {
           if (!this.pollingExpected) return;
-          const silenceMs = Date.now() - this.lastUpdateAt;
+          const silenceMs = Date.now() - this.lastPollingCheckAt;
           if (silenceMs > _TelegramChannel.POLLING_SILENCE_THRESHOLD_MS) {
             log(
-              `[telegram] No updates received for ${Math.round(silenceMs / 1e3)}s \u2014 triggering reconnect`
+              `[telegram] No polling confirmation for ${Math.round(silenceMs / 1e3)}s \u2014 triggering reconnect`
             );
-            markChannelDown("telegram", `No updates for ${Math.round(silenceMs / 1e3)}s`);
-            this.lastUpdateAt = Date.now();
+            markChannelDown("telegram", `No polling confirmation for ${Math.round(silenceMs / 1e3)}s`);
+            this.lastPollingCheckAt = Date.now();
           }
         }, _TelegramChannel.POLLING_WATCHDOG_INTERVAL_MS);
       }
@@ -36067,6 +36455,10 @@ var init_telegram2 = __esm({
           clearInterval(this.pollingWatchdog);
           this.pollingWatchdog = null;
         }
+        if (this.keepaliveInterval) {
+          clearInterval(this.keepaliveInterval);
+          this.keepaliveInterval = null;
+        }
         try {
           await this.bot.stop();
         } catch {
@@ -36180,15 +36572,18 @@ var init_telegram2 = __esm({
           return void 0;
         }
       }
-      async editText(chatId, messageId, text, parseMode) {
+      async editText(chatId, messageId, text, parseMode, priority) {
         const formatted = sanitizeForTelegram(parseMode === "html" ? text : formatForTelegram(text));
+        const isCritical = priority === true || priority === 0 /* P0_CRITICAL */;
+        const label2 = isCritical ? "finalizeStatus" : "editText:html";
         try {
           await this.throttle.send(
             chatId,
-            "editText:html",
+            label2,
             () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
               parse_mode: "HTML"
-            })
+            }),
+            priority
           );
           return true;
         } catch (err) {
@@ -36201,12 +36596,13 @@ var init_telegram2 = __esm({
           try {
             await this.throttle.send(
               chatId,
-              "editText:fallback",
+              priority ? "finalizeStatus:fallback" : "editText:fallback",
               () => this.bot.api.editMessageText(
                 numericChatId(chatId),
                 parseInt(messageId),
                 formatted.replace(/<[^>]+>/g, "")
-              )
+              ),
+              priority
             );
             return true;
           } catch (err2) {
@@ -36352,6 +36748,44 @@ var init_telegram2 = __esm({
           log(`[telegram] reactToMessage failed (chat=${chatId} msg=${messageId}): ${err}`);
         }
       }
+      /**
+       * Check whether a chat supports native draft streaming.
+       * sendMessageDraft only works in private/DM chats (positive chat IDs).
+       */
+      isDraftCapable(chatId) {
+        return isDraftCapable(chatId);
+      }
+      /**
+       * Send a streaming draft update to a DM chat using Telegram's native
+       * sendMessageDraft API (Bot API 9.3+). The draft shows an animated
+       * typing bubble with the text content, replacing editMessageText for
+       * DM streaming. Subsequent calls with the same draft_id produce smooth
+       * animated transitions.
+       *
+       * Draft updates are cosmetic — if one gets dropped, the next update
+       * will contain the full accumulated text. Uses tryBestEffort so drafts
+       * never block critical sends.
+       *
+       * @param chatId  - Private chat ID (must be positive / draft-capable)
+       * @param draftId - Non-zero integer, consistent per response for smooth animation
+       * @param text    - Plain text content (no parse_mode during streaming)
+       */
+      async sendMessageDraft(chatId, draftId, text) {
+        if (!this.isDraftCapable(chatId)) {
+          log(`[telegram] sendMessageDraft skipped \u2014 chat ${chatId} is not draft-capable`);
+          return;
+        }
+        try {
+          await this.throttle.tryBestEffort(
+            chatId,
+            "draft",
+            () => this.bot.api.sendMessageDraft(numericChatId(chatId), draftId, sanitizeForTelegram(text))
+          );
+          log(`[telegram] sendMessageDraft sent (chat=${chatId}, draftId=${draftId}, len=${text.length})`);
+        } catch (err) {
+          log(`[telegram] sendMessageDraft failed (chat=${chatId}): ${err}`);
+        }
+      }
       /** Get the underlying Grammy Bot instance (for scheduler, etc.) */
       getBot() {
         return this.bot;
@@ -37571,6 +38005,16 @@ ${lines.join("\n")}`;
       } catch {
       }
       ;
+      try {
+        const { getEditCoordinator: getEditCoordinator2 } = await Promise.resolve().then(() => (init_edit_coordinator(), edit_coordinator_exports));
+        getEditCoordinator2().shutdown();
+      } catch {
+      }
+      try {
+        const { getTypingManager: getTypingManager2 } = await Promise.resolve().then(() => (init_typing_manager(), typing_manager_exports));
+        getTypingManager2().shutdown();
+      } catch {
+      }
       shutdownOrchestrator();
       shutdownScheduler();
       flushMemoryHalfLifeUpdates();
@@ -38130,6 +38574,7 @@ async function statusCommand(globalOpts, localOpts) {
     const dbStat = existsSync35(DB_PATH) ? statSync10(DB_PATH) : null;
     let daemonRunning = false;
     let daemonInfo = {};
+    let throttleData;
     try {
       const { apiGet: apiGet2 } = await Promise.resolve().then(() => (init_api_client(), api_client_exports));
       const healthRes = await apiGet2("/api/health");
@@ -38137,6 +38582,9 @@ async function statusCommand(globalOpts, localOpts) {
       if (healthRes.ok && healthRes.data?.uptime) {
         daemonInfo.uptime_seconds = Math.floor(healthRes.data.uptime);
       }
+      if (healthRes.ok && healthRes.data?.throttle) {
+        throttleData = healthRes.data.throttle;
+      }
     } catch {
     }
     const contextUsed = (usageRow?.last_input_tokens ?? 0) + (usageRow?.last_cache_read_tokens ?? 0);
@@ -38158,7 +38606,8 @@ async function statusCommand(globalOpts, localOpts) {
         output_tokens: usageRow?.output_tokens ?? 0,
         cache_read_tokens: usageRow?.cache_read_tokens ?? 0
       },
-      db: { path: DB_PATH, sizeBytes: dbStat?.size ?? 0, exists: !!dbStat }
+      db: { path: DB_PATH, sizeBytes: dbStat?.size ?? 0, exists: !!dbStat },
+      throttle: throttleData
     };
     try {
       const { OllamaStore } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
@@ -38190,6 +38639,14 @@ async function statusCommand(globalOpts, localOpts) {
       if (localOpts.deep) {
         lines.push(kvLine("Daemon", s.daemon.running ? success(`running${s.daemon.uptime_seconds ? ` (uptime ${formatUptime2(s.daemon.uptime_seconds)})` : ""}`) : error2("offline")));
       }
+      if (s.throttle) {
+        const t = s.throttle;
+        const queueStr = t.queueDepth > 0 ? warning(`${t.queueDepth} queued`) : success("0 queued");
+        const pauseStr = t.isPaused ? error2(`PAUSED (${t.pauseRemainingSec}s remaining)`) : "";
+        const circuitStr = t.circuitState !== "closed" ? warning(t.circuitState.toUpperCase()) : "";
+        const parts = [queueStr, pauseStr, circuitStr].filter(Boolean).join(", ");
+        lines.push(kvLine("Throttle", parts));
+      }
       lines.push(
         "",
         divider("Usage (this session)"),
@@ -38585,9 +39042,9 @@ async function sessionLogsList(opts) {
 `));
   console.log(`  ${"Filename".padEnd(55)} ${"Size".padStart(8)}  Chat ID`);
   console.log(`  ${"\u2500".repeat(55)} ${"\u2500".repeat(8)}  ${"\u2500".repeat(15)}`);
-  for (const log6 of logs) {
-    const size = log6.sizeBytes < 1024 ? `${log6.sizeBytes}B` : log6.sizeBytes < 1024 * 1024 ? `${(log6.sizeBytes / 1024).toFixed(1)}K` : `${(log6.sizeBytes / 1024 / 1024).toFixed(1)}M`;
-    console.log(`  ${log6.filename.padEnd(55)} ${size.padStart(8)}  ${log6.chatId}`);
+  for (const log5 of logs) {
+    const size = log5.sizeBytes < 1024 ? `${log5.sizeBytes}B` : log5.sizeBytes < 1024 * 1024 ? `${(log5.sizeBytes / 1024).toFixed(1)}K` : `${(log5.sizeBytes / 1024 / 1024).toFixed(1)}M`;
+    console.log(`  ${log5.filename.padEnd(55)} ${size.padStart(8)}  ${log5.chatId}`);
   }
   console.log(muted(`
   Path: ${SESSION_LOGS_PATH}`));