cc-claw 0.27.2 → 0.29.0

package/dist/cli.js

@@ -33,7 +33,7 @@ var VERSION;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    VERSION = true ? "0.27.2" : (() => {
+    VERSION = true ? "0.29.0" : (() => {
       try {
         return JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf-8")).version ?? "unknown";
       } catch {
@@ -62,7 +62,8 @@ __export(paths_exports, {
   SKILLS_PATH: () => SKILLS_PATH,
   WHISPER_MODELS_PATH: () => WHISPER_MODELS_PATH,
   WORKSPACE_PATH: () => WORKSPACE_PATH,
-  readApiToken: () => readApiToken
+  readApiToken: () => readApiToken,
+  resolveRealHome: () => resolveRealHome
 });
 import { homedir, userInfo } from "os";
 import { join as join2 } from "path";
@@ -1209,6 +1210,64 @@ var init_store4 = __esm({
   }
 });
 
+// src/memory/classify.ts
+function classifyMemory(_trigger, content) {
+  for (const { category, patterns } of CATEGORY_PATTERNS) {
+    for (const pattern of patterns) {
+      if (pattern.test(content)) {
+        return category;
+      }
+    }
+  }
+  return "uncategorized";
+}
+var CATEGORY_PATTERNS;
+var init_classify = __esm({
+  "src/memory/classify.ts"() {
+    "use strict";
+    CATEGORY_PATTERNS = [
+      {
+        category: "decision",
+        patterns: [
+          /\b(decided|chose|picked|selected|opted)\b/i,
+          /\b(switched to|migrated to|moved to|changed to)\b/i,
+          /\b(replaced .+ with|went with|settled on)\b/i,
+          /\b(over|instead of|rather than)\b.*\b(because|due to|since)\b/i
+        ]
+      },
+      {
+        category: "preference",
+        patterns: [
+          /\b(prefer(?:s|red|ring)?)\b/i,
+          /\b(likes?|loved?|enjoys?|hates?|dislikes?)\b/i,
+          /\b(always uses?|never uses?|favorite|favourite)\b/i,
+          /\b(wants? to|doesn't want|rather|instead of)\b/i
+        ]
+      },
+      {
+        category: "event",
+        patterns: [
+          /\b(yesterday|today|this morning|last week|last month)\b/i,
+          /\b(on (monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b/i,
+          /\b(happened|occurred|took place|attended|deployed|launched|released)\b/i,
+          /\b(had a (meeting|call|chat|discussion|session))\b/i
+        ]
+      },
+      {
+        category: "fact",
+        patterns: [
+          /\b(works? at|employed at|job is)\b/i,
+          /\b(lives? in|located in|based in)\b/i,
+          /\b(is a|is an|role is|position is)\b/i,
+          /\b(uses?|runs? on|built with|powered by|written in)\b/i,
+          /\b(name is|called|known as)\b/i,
+          /\b(timezone|time zone)\b/i
+        ]
+      }
+    ];
+  }
+});
+
 // src/memory/schema.ts
 function initSchema(db3) {
   db3.exec(`
@@ -1628,6 +1687,10 @@ function initSchema(db3) {
     db3.exec(`ALTER TABLE chat_voice ADD COLUMN stt_model TEXT DEFAULT 'small.en'`);
   } catch {
   }
+  try {
+    db3.exec(`ALTER TABLE chat_voice ADD COLUMN stt_echo INTEGER DEFAULT 0`);
+  } catch {
+  }
   db3.exec(`
     CREATE TABLE IF NOT EXISTS backend_limits (
       backend TEXT NOT NULL,
@@ -1754,6 +1817,44 @@ function initSchema(db3) {
     db3.exec("ALTER TABLE session_summaries ADD COLUMN embedding TEXT");
   } catch {
   }
+  try {
+    db3.exec("ALTER TABLE memories ADD COLUMN category TEXT NOT NULL DEFAULT 'uncategorized'");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE memories ADD COLUMN half_life_days REAL NOT NULL DEFAULT 14.0");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE memories ADD COLUMN superseded_by INTEGER DEFAULT NULL");
+  } catch {
+  }
+  try {
+    db3.exec("ALTER TABLE memories ADD COLUMN superseded_at TEXT DEFAULT NULL");
+  } catch {
+  }
+  try {
+    const alreadyDone = db3.prepare("SELECT value FROM meta WHERE key = 'schema_category_backfill_done'").get();
+    if (!alreadyDone) {
+      const allUncategorized = db3.prepare("SELECT id, trigger, content FROM memories WHERE category = 'uncategorized'").all();
+      if (allUncategorized.length > 0) {
+        const updateStmt = db3.prepare("UPDATE memories SET category = ? WHERE id = ?");
+        const backfillTxn = db3.transaction(() => {
+          for (const mem of allUncategorized) {
+            const category = classifyMemory(mem.trigger, mem.content);
+            if (category !== "uncategorized") {
+              updateStmt.run(category, mem.id);
+            }
+          }
+        });
+        backfillTxn();
+        log(`[schema] Backfilled categories for ${allUncategorized.length} memories`);
+      }
+      db3.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("schema_category_backfill_done", "1");
+    }
+  } catch (err) {
+    warn(`[schema] Category backfill skipped: ${err}`);
+  }
   try {
     db3.exec("ALTER TABLE message_log ADD COLUMN message_type TEXT DEFAULT 'text'");
   } catch {
@@ -1975,32 +2076,32 @@ function applySalienceDecay(db3) {
   if (lastDecay) {
     const daysSinceLastDecay = (Date.now() - (/* @__PURE__ */ new Date(lastDecay.replace(" ", "T") + "Z")).getTime()) / (1e3 * 60 * 60 * 24);
     if (daysSinceLastDecay < 0.01) return;
-    db3.prepare(`
-      UPDATE memories
-      SET salience = salience * POWER(0.98, ?)
-      WHERE salience >= 0.1
-    `).run(daysSinceLastDecay);
     db3.prepare(`
       UPDATE session_summaries
       SET salience = salience * POWER(0.995, ?)
       WHERE salience >= 0.1
     `).run(daysSinceLastDecay);
   } else {
-    db3.prepare(`
-      UPDATE memories
-      SET salience = salience * POWER(0.98, julianday('now') - julianday(last_accessed))
-      WHERE salience >= 0.1
-    `).run();
     db3.prepare(`
       UPDATE session_summaries
       SET salience = salience * POWER(0.995, julianday('now') - julianday(created_at))
       WHERE salience >= 0.1
     `).run();
   }
-  db3.prepare("DELETE FROM memories WHERE salience < 0.1").run();
   db3.prepare("DELETE FROM session_summaries WHERE salience < 0.1").run();
   db3.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('last_salience_decay', ?)").run(now);
 }
+function getMetaValue(key) {
+  const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
+  const db3 = getDb2();
+  const row = db3.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+  return row?.value;
+}
+function setMetaValue(key, value) {
+  const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
+  const db3 = getDb2();
+  db3.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run(key, value);
+}
 function backfillJobTitles(database) {
   const rows = database.prepare(
     "SELECT id, description FROM jobs WHERE active = 1 AND (title IS NULL OR title LIKE 'No thinking%' OR title LIKE 'You must%' OR title LIKE 'You MUST%')"
@@ -2032,6 +2133,8 @@ var init_schema = __esm({
     init_store3();
     init_identity();
     init_store4();
+    init_log();
+    init_classify();
   }
 });
 
@@ -2311,33 +2414,32 @@ var init_embeddings = __esm({
 });
 
 // src/memory/memories.ts
-function queueMemorySalienceBoost(memoryId, boost) {
-  const current = pendingMemorySalienceUpdates.get(memoryId) ?? 0;
-  pendingMemorySalienceUpdates.set(memoryId, current + boost);
-  if (!memorySalienceFlushTimer) {
-    memorySalienceFlushTimer = setTimeout(flushMemorySalienceUpdates, 6e4);
+function queueHalfLifeExtension(memoryId) {
+  pendingHalfLifeExtensions.set(memoryId, (pendingHalfLifeExtensions.get(memoryId) ?? 0) + 1);
+  if (!memoryHalfLifeFlushTimer) {
+    memoryHalfLifeFlushTimer = setTimeout(flushMemoryHalfLifeUpdates, 6e4);
   }
 }
-function flushMemorySalienceUpdates() {
-  if (pendingMemorySalienceUpdates.size === 0) {
-    memorySalienceFlushTimer = null;
+function flushMemoryHalfLifeUpdates() {
+  if (pendingHalfLifeExtensions.size === 0) {
+    memoryHalfLifeFlushTimer = null;
     return;
   }
   try {
     const db3 = getDb();
     const stmt = db3.prepare(
-      "UPDATE memories SET salience = MAX(0, MIN(1.0, salience + ?)), access_count = access_count + 1, last_accessed = datetime('now') WHERE id = ?"
+      "UPDATE memories SET half_life_days = MIN(90, half_life_days + 2), access_count = access_count + 1, last_accessed = datetime('now') WHERE id = ?"
     );
     const txn = db3.transaction(() => {
-      for (const [id, boost] of pendingMemorySalienceUpdates) {
-        stmt.run(boost, id);
+      for (const [id] of pendingHalfLifeExtensions) {
+        stmt.run(id);
       }
     });
     txn();
   } catch {
   }
-  pendingMemorySalienceUpdates.clear();
-  memorySalienceFlushTimer = null;
+  pendingHalfLifeExtensions.clear();
+  memoryHalfLifeFlushTimer = null;
 }
 function invalidateMemoryEmbeddingCache() {
   embeddingCache = null;
@@ -2361,7 +2463,7 @@ function getMemoriesWithoutEmbeddings(limit = 100) {
 }
 function getAllMemoriesWithEmbeddingsUncached() {
   return getDb().prepare(
-    "SELECT * FROM memories WHERE embedding IS NOT NULL AND salience >= 0.1"
+    "SELECT * FROM memories WHERE embedding IS NOT NULL AND salience >= 0.1 AND superseded_by IS NULL"
   ).all();
 }
 function getAllMemoriesWithEmbeddings() {
@@ -2373,8 +2475,13 @@ function getAllMemoriesWithEmbeddings() {
   embeddingCache = { data, timestamp: now };
   return data;
 }
-function saveMemoryWithEmbedding(trigger, content, type = "semantic") {
-  const id = saveMemory(trigger, content, type);
+function saveMemoryWithEmbedding(trigger, content, type = "semantic", category = "uncategorized", halfLifeDays = 14) {
+  const db3 = getDb();
+  const result = db3.prepare(
+    "INSERT INTO memories (trigger, content, type, category, half_life_days) VALUES (?, ?, ?, ?, ?)"
+  ).run(trigger, content, type, category, halfLifeDays);
+  const id = Number(result.lastInsertRowid);
+  invalidateMemoryEmbeddingCache();
   const textToEmbed = `${trigger}: ${content}`;
   embedForStorage(textToEmbed).then((emb) => {
     if (emb) {
@@ -2402,33 +2509,45 @@ function searchMemories(queryText, limit = 3) {
     SELECT m.*, fts.rank AS _ftsRank FROM memories m
     JOIN memories_fts fts ON m.id = fts.rowid
     WHERE memories_fts MATCH ?
+    AND m.superseded_by IS NULL
     ORDER BY fts.rank
     LIMIT ?
   `).all(ftsQuery, limit);
   for (const mem of ftsResults) {
-    queueMemorySalienceBoost(mem.id, 0.1);
+    queueHalfLifeExtension(mem.id);
   }
   return ftsResults;
 }
 function searchMemoriesReadOnly(readDb, queryText, limit = 3) {
   const ftsQuery = toFts5Query(queryText);
   if (!ftsQuery) return [];
-  return readDb.prepare(`
-    SELECT m.*, fts.rank AS _ftsRank FROM memories m
-    JOIN memories_fts fts ON m.id = fts.rowid
-    WHERE memories_fts MATCH ?
-    ORDER BY fts.rank
-    LIMIT ?
-  `).all(ftsQuery, limit);
+  try {
+    return readDb.prepare(`
+      SELECT m.*, fts.rank AS _ftsRank FROM memories m
+      JOIN memories_fts fts ON m.id = fts.rowid
+      WHERE memories_fts MATCH ?
+      AND m.superseded_by IS NULL
+      ORDER BY fts.rank
+      LIMIT ?
+    `).all(ftsQuery, limit);
+  } catch {
+    return readDb.prepare(`
+      SELECT m.*, fts.rank AS _ftsRank FROM memories m
+      JOIN memories_fts fts ON m.id = fts.rowid
+      WHERE memories_fts MATCH ?
+      ORDER BY fts.rank
+      LIMIT ?
+    `).all(ftsQuery, limit);
+  }
 }
 function getRecentMemories(limit = 5) {
   return getDb().prepare(
-    "SELECT * FROM memories ORDER BY last_accessed DESC LIMIT ?"
+    "SELECT * FROM memories WHERE superseded_by IS NULL ORDER BY last_accessed DESC LIMIT ?"
   ).all(limit);
 }
 function listMemories() {
   return getDb().prepare(
-    "SELECT * FROM memories WHERE salience >= 0.1 ORDER BY salience DESC LIMIT 50"
+    "SELECT * FROM memories WHERE salience >= 0.1 AND superseded_by IS NULL ORDER BY salience DESC LIMIT 50"
   ).all();
 }
 function forgetMemory(keyword) {
@@ -2449,17 +2568,52 @@ function deleteMemoryById(id) {
 }
 function getAllMemoriesForOptimization() {
   return getDb().prepare(
-    "SELECT * FROM memories WHERE salience >= 0.1 ORDER BY salience DESC"
+    "SELECT * FROM memories WHERE salience >= 0.1 AND superseded_by IS NULL ORDER BY salience DESC"
   ).all();
 }
 function restoreMemory(memory2) {
-  getDb().prepare(`
-    INSERT OR REPLACE INTO memories (id, trigger, content, type, salience, access_count, created_at, last_accessed, embedding)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(memory2.id, memory2.trigger, memory2.content, memory2.type, memory2.salience, memory2.access_count, memory2.created_at, memory2.last_accessed, memory2.embedding);
+  const db3 = getDb();
+  db3.prepare(
+    `INSERT OR REPLACE INTO memories
+     (id, trigger, content, type, salience, access_count, created_at, last_accessed, embedding,
+      category, half_life_days, superseded_by, superseded_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    memory2.id,
+    memory2.trigger,
+    memory2.content,
+    memory2.type,
+    memory2.salience,
+    memory2.access_count,
+    memory2.created_at,
+    memory2.last_accessed,
+    memory2.embedding,
+    memory2.category ?? "uncategorized",
+    memory2.half_life_days ?? 14,
+    memory2.superseded_by ?? null,
+    memory2.superseded_at ?? null
+  );
   invalidateMemoryEmbeddingCache();
 }
-var embeddingCache, EMBEDDING_CACHE_TTL_MS, pendingMemorySalienceUpdates, memorySalienceFlushTimer, STOP_WORDS;
+function markSuperseded(memoryId, supersededById) {
+  if (memoryId === supersededById) return;
+  const db3 = getDb();
+  db3.prepare(
+    `UPDATE memories SET superseded_by = ?, superseded_at = datetime('now') WHERE id = ?`
+  ).run(supersededById, memoryId);
+}
+function cleanupSuperseded(gracePeriodDays = 14) {
+  const db3 = getDb();
+  const result = db3.prepare(
+    `DELETE FROM memories WHERE superseded_by IS NOT NULL AND superseded_at < datetime('now', '-' || ? || ' days')`
+  ).run(gracePeriodDays);
+  return result.changes;
+}
+function updateMemoryCategory(id, category) {
+  const db3 = getDb();
+  db3.prepare("UPDATE memories SET category = ? WHERE id = ?").run(category, id);
+}
+var embeddingCache, EMBEDDING_CACHE_TTL_MS, pendingHalfLifeExtensions, memoryHalfLifeFlushTimer, STOP_WORDS;
 var init_memories = __esm({
   "src/memory/memories.ts"() {
     "use strict";
@@ -2468,8 +2622,8 @@ var init_memories = __esm({
     init_log();
     embeddingCache = null;
     EMBEDDING_CACHE_TTL_MS = 3e4;
-    pendingMemorySalienceUpdates = /* @__PURE__ */ new Map();
-    memorySalienceFlushTimer = null;
+    pendingHalfLifeExtensions = /* @__PURE__ */ new Map();
+    memoryHalfLifeFlushTimer = null;
     STOP_WORDS = /* @__PURE__ */ new Set([
       "a",
       "an",
@@ -4492,6 +4646,175 @@ var init_api_context = __esm({
   }
 });
 
+// src/text-utils.ts
+var text_utils_exports = {};
+__export(text_utils_exports, {
+  appendTextChunk: () => appendTextChunk,
+  jaccardSimilarity: () => jaccardSimilarity,
+  tokenizeText: () => tokenizeText
+});
+function appendTextChunk(accumulated, chunk) {
+  if (!accumulated) return chunk;
+  if (!chunk) return accumulated;
+  return accumulated + chunk;
+}
+function tokenizeText(text, minLen = 3) {
+  return new Set(
+    text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length >= minLen)
+  );
+}
+function jaccardSimilarity(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const term of a) {
+    if (b.has(term)) intersection++;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+var init_text_utils = __esm({
+  "src/text-utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/memory/supersede.ts
+function detectSupersession(newTrigger, newContent, newCategory, existingMemories, newEmbedding) {
+  if (existingMemories.length === 0) return null;
+  const hasChangeSignal = CHANGE_SIGNALS.some((re) => re.test(newContent));
+  const newTerms = tokenizeText(newContent);
+  let bestId = null;
+  let bestScore = 0;
+  for (const mem of existingMemories) {
+    if (mem.superseded_by != null) continue;
+    let score = 0;
+    if (normalizeTrigger(mem.trigger) === normalizeTrigger(newTrigger)) {
+      score += 3;
+    }
+    if (newCategory !== "uncategorized" && mem.category !== "uncategorized") {
+      if (newCategory === mem.category) {
+        score += 1;
+      } else {
+        continue;
+      }
+    }
+    if (newEmbedding && mem.embedding) {
+      try {
+        const memEmbedding = JSON.parse(mem.embedding);
+        const sim = cosineSimilarity(newEmbedding, memEmbedding);
+        if (sim >= EMBEDDING_THRESHOLD) {
+          score += 3;
+        }
+      } catch {
+      }
+    }
+    const memTerms = tokenizeText(mem.content);
+    const overlap = jaccardSimilarity(newTerms, memTerms);
+    if (overlap >= KEYWORD_OVERLAP_THRESHOLD) {
+      score += 2;
+    }
+    if (hasChangeSignal) {
+      score += 2;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = mem.id;
+    }
+  }
+  return bestScore >= SUPERSESSION_SCORE_THRESHOLD ? bestId : null;
+}
+function normalizeTrigger(trigger) {
+  return trigger.toLowerCase().trim().replace(/[\s_-]+/g, "-");
+}
+var CHANGE_SIGNALS, EMBEDDING_THRESHOLD, KEYWORD_OVERLAP_THRESHOLD, SUPERSESSION_SCORE_THRESHOLD;
+var init_supersede = __esm({
+  "src/memory/supersede.ts"() {
+    "use strict";
+    init_embeddings();
+    init_text_utils();
+    CHANGE_SIGNALS = [
+      /\bswitched to\b/i,
+      /\bchanged to\b/i,
+      /\bnow uses?\b/i,
+      /\bno longer\b/i,
+      /\breplaced\b/i,
+      /\bmigrated to\b/i,
+      /\bmoved to\b/i,
+      /\bstopped using\b/i,
+      /\bupdated to\b/i
+    ];
+    EMBEDDING_THRESHOLD = 0.75;
+    KEYWORD_OVERLAP_THRESHOLD = 0.4;
+    SUPERSESSION_SCORE_THRESHOLD = 4;
+  }
+});
+
+// src/memory/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  cleanup: () => cleanup,
+  forget: () => forget,
+  list: () => list,
+  recall: () => recall,
+  remember: () => remember
+});
+async function remember(tag, content, opts = {}) {
+  const category = opts.category ?? classifyMemory(tag, content);
+  const type = opts.type ?? "semantic";
+  const candidates = getAllMemoriesWithEmbeddings();
+  const id = saveMemoryWithEmbedding(tag, content, type, category, DEFAULT_HALF_LIFE);
+  let supersededId = null;
+  try {
+    const queryEmbedding = await embedQuery(content);
+    supersededId = detectSupersession(tag, content, category, candidates, queryEmbedding);
+    if (supersededId != null) {
+      markSuperseded(supersededId, id);
+      log(`[engine] Memory #${supersededId} superseded by #${id} ("${tag}")`);
+    }
+  } catch (err) {
+    log(`[engine] Supersession check skipped: ${err}`);
+  }
+  const result = { id, category };
+  if (supersededId != null) result.superseded = supersededId;
+  return result;
+}
+function recall(query, opts = {}) {
+  const limit = opts.limit ?? 5;
+  let results = searchMemories(query, limit);
+  if (opts.category) {
+    results = results.filter((m) => m.category === opts.category);
+  }
+  return results;
+}
+function list(_opts = {}) {
+  return listMemories();
+}
+function forget(keywordOrId) {
+  if (typeof keywordOrId === "number") {
+    return deleteMemoryById(keywordOrId) ? 1 : 0;
+  }
+  return forgetMemory(keywordOrId);
+}
+function cleanup(gracePeriodDays = 14) {
+  const deleted = cleanupSuperseded(gracePeriodDays);
+  if (deleted > 0) {
+    log(`[engine] Cleaned up ${deleted} superseded memories past ${gracePeriodDays}-day grace period`);
+  }
+  return deleted;
+}
+var DEFAULT_HALF_LIFE;
+var init_engine = __esm({
+  "src/memory/engine.ts"() {
+    "use strict";
+    init_memories();
+    init_classify();
+    init_supersede();
+    init_embeddings();
+    init_log();
+    DEFAULT_HALF_LIFE = 14;
+  }
+});
+
 // src/memory/store.ts
 var store_exports5 = {};
 __export(store_exports5, {
@@ -4508,7 +4831,10 @@ __export(store_exports5, {
   buildApiMessages: () => buildApiMessages,
   cancelJobById: () => cancelJobById,
   checkBackendLimits: () => checkBackendLimits,
+  classifyMemory: () => classifyMemory,
   cleanExpiredWatches: () => cleanExpiredWatches,
+  cleanup: () => cleanup,
+  cleanupSuperseded: () => cleanupSuperseded,
   clearAgentMode: () => clearAgentMode,
   clearAllPaidSlots: () => clearAllPaidSlots,
   clearAllSessions: () => clearAllSessions,
@@ -4529,11 +4855,13 @@ __export(store_exports5, {
   deleteBookmark: () => deleteBookmark,
   deleteMemoryById: () => deleteMemoryById,
   deleteSessionSummary: () => deleteSessionSummary,
+  detectSupersession: () => detectSupersession,
   determineEscalationTarget: () => determineEscalationTarget,
   estimateTokens: () => estimateTokens,
   findBookmarksByPrefix: () => findBookmarksByPrefix,
-  flushMemorySalienceUpdates: () => flushMemorySalienceUpdates,
+  flushMemoryHalfLifeUpdates: () => flushMemoryHalfLifeUpdates,
   flushSummarySalienceUpdates: () => flushSummarySalienceUpdates,
+  forget: () => forget,
   forgetMemory: () => forgetMemory,
   getActiveJobs: () => getActiveJobs,
   getActiveWatches: () => getActiveWatches,
@@ -4576,6 +4904,7 @@ __export(store_exports5, {
   getMemoryById: () => getMemoryById,
   getMessagePairById: () => getMessagePairById,
   getMessagePairs: () => getMessagePairs,
+  getMetaValue: () => getMetaValue,
   getMode: () => getMode,
   getModel: () => getModel,
   getModelSignature: () => getModelSignature,
@@ -4606,6 +4935,7 @@ __export(store_exports5, {
   insertJobRun: () => insertJobRun,
   invalidateMemoryEmbeddingCache: () => invalidateMemoryEmbeddingCache,
   invalidateSummaryEmbeddingCache: () => invalidateSummaryEmbeddingCache,
+  list: () => list,
   listMemories: () => listMemories,
   listSessionSummaries: () => listSessionSummaries,
   markBackendSlotExhausted: () => markBackendSlotExhausted,
@@ -4613,14 +4943,18 @@ __export(store_exports5, {
   markMessageLogSummarized: () => markMessageLogSummarized,
   markSlotExhausted: () => markSlotExhausted,
   markSlotSuccess: () => markSlotSuccess,
+  markSuperseded: () => markSuperseded,
   openDatabaseReadOnly: () => openDatabaseReadOnly,
   parseHeartbeatFallbacks: () => parseHeartbeatFallbacks,
   pinChatBackendSlot: () => pinChatBackendSlot,
   pinChatGeminiSlot: () => pinChatGeminiSlot,
   pruneJobRuns: () => pruneJobRuns,
   pruneMessageLog: () => pruneMessageLog,
+  queueHalfLifeExtension: () => queueHalfLifeExtension,
+  recall: () => recall,
   reenableBackendSlot: () => reenableBackendSlot,
   reenableSlot: () => reenableSlot,
+  remember: () => remember,
   removeApiModel: () => removeApiModel,
   removeApiModelById: () => removeApiModelById,
   removeBackendSlot: () => removeBackendSlot,
@@ -4659,6 +4993,7 @@ __export(store_exports5, {
   setGeminiSlotEnabled: () => setGeminiSlotEnabled,
   setGlobalSummarizer: () => setGlobalSummarizer,
   setHeartbeatConfig: () => setHeartbeatConfig,
+  setMetaValue: () => setMetaValue,
   setMode: () => setMode,
   setModel: () => setModel,
   setModelSignature: () => setModelSignature,
@@ -4683,6 +5018,7 @@ __export(store_exports5, {
   updateJobEnabled: () => updateJobEnabled,
   updateJobLastRun: () => updateJobLastRun,
   updateJobNextRun: () => updateJobNextRun,
+  updateMemoryCategory: () => updateMemoryCategory,
   updateMemoryEmbedding: () => updateMemoryEmbedding,
   updateSessionSummaryEmbedding: () => updateSessionSummaryEmbedding,
   upsertBookmark: () => upsertBookmark
@@ -4727,6 +5063,10 @@ var init_store5 = __esm({
     init_backend_slots();
     init_api_models();
     init_api_context();
+    init_schema();
+    init_classify();
+    init_supersede();
+    init_engine();
     _testDbPath = null;
   }
 });
@@ -4945,6 +5285,11 @@ var init_resolve_executable = __esm({
 });
 
 // src/backends/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  ClaudeAdapter: () => ClaudeAdapter,
+  tryRefreshOAuthSlot: () => tryRefreshOAuthSlot
+});
 import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { execFile as execFileCb, spawnSync as spawnSync2 } from "child_process";
 import { promisify } from "util";
@@ -5021,6 +5366,14 @@ async function getValidOAuthToken(configHome) {
   }
   return accessToken;
 }
+async function tryRefreshOAuthSlot(slot) {
+  if (slot.slotType !== "oauth" || !slot.configHome) return false;
+  const credsPath = join4(slot.configHome, ".claude", ".credentials.json");
+  const oauth = readOAuthCredentials(credsPath);
+  if (!oauth?.refreshToken) return false;
+  const fresh = await refreshOAuthToken(credsPath, oauth.refreshToken, oauth.scopes);
+  return fresh !== null;
+}
 var execFileAsync, OAUTH_TOKEN_ENDPOINT, OAUTH_CLIENT_ID, REFRESH_THRESHOLD_MS, REFRESH_COOLDOWN_MS, lastRefreshAttempt, ADAPTIVE_MODELS, ClaudeAdapter;
 var init_claude = __esm({
   "src/backends/claude.ts"() {
@@ -6446,7 +6799,8 @@ function isSensitivePath(filePath) {
   if (SENSITIVE_EXACT.has(normalized)) return true;
   return SENSITIVE_PATTERNS.some((pattern) => pattern.test(normalized));
 }
-function createRestrictedBashTool(chatId, permMode, whitelist) {
+function createRestrictedBashTool(chatId, permMode, opts) {
+  const { whitelist, shellTimeoutMs } = opts ?? {};
   const isYolo = permMode === "yolo";
   return tool({
     description: isYolo ? `Run any shell command. Use this for ALL external CLI tools. No restrictions. Format: restrictedBash({command: 'gsearch "query" --type news'})` : "Run a whitelisted shell command. Use this for ANY external CLI tool \u2014 do NOT call CLIs as separate tools by name, always route them through restrictedBash. Format: restrictedBash({command: 'toolname args...'})",
@@ -6460,12 +6814,18 @@ function createRestrictedBashTool(chatId, permMode, whitelist) {
         return { error: "Empty command" };
       }
       if (!isYolo) {
-        const list = whitelist ?? getApiCliWhitelist(chatId);
-        const entry = list.find((w) => w.cli === firstWord);
+        const list2 = whitelist ?? getApiCliWhitelist(chatId);
+        const entry = list2.find((w) => w.cli === firstWord);
         if (!entry) {
-          const allowed = list.map((w) => w.cli).join(", ") || "(none)";
+          const allowed = list2.map((w) => w.cli).join(", ") || "(none)";
           return {
-            error: `Command "${firstWord}" is not whitelisted. Allowed commands: ${allowed}. IMPORTANT: Stop retrying. Tell the user exactly this: "I tried to run '${firstWord}' but it's not in your approved tools list. Go to /tools \u2192 Add Command \u2192 type '${firstWord}' to allow it, then ask me again."`
+            blockedCommand: firstWord,
+            allowedCommands: allowed,
+            userMessage: `\u274C \`${firstWord}\` is not in your approved tools list.
+Allowed: ${allowed}
+
+To fix: go to /tools \u2192 Add Command \u2192 type \`${firstWord}\``,
+            instruction: "STOP. Do not retry. Reply to the user with ONLY the userMessage field above, verbatim. Do not add explanation."
           };
         }
         const dangerousPatterns = /[;|&`$(){}]|>>|<<|\n/;
@@ -6474,13 +6834,18 @@ function createRestrictedBashTool(chatId, permMode, whitelist) {
         }
       }
       log(`[api-tools] Executing whitelisted command: ${trimmed.slice(0, 100)}`);
+      const effectiveTimeoutMs = shellTimeoutMs ?? RESTRICTED_BASH_TIMEOUT_MS;
       try {
-        const result = await executeShell(trimmed, { timeoutMs: RESTRICTED_BASH_TIMEOUT_MS });
+        const result = await executeShell(trimmed, { timeoutMs: effectiveTimeoutMs });
         return result;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         warn(`[api-tools] Shell exec failed: ${msg}`);
-        return { error: `Command failed: ${msg}` };
+        const isTimeout = msg.includes("timed out");
+        return isTimeout ? {
+          error: `Command timed out after ${Math.round(effectiveTimeoutMs / 1e3)}s`,
+          suggestion: "Tell the user the command took too long and timed out. They can increase the job timeout via /editjob."
+        } : { error: `Command failed: ${msg}` };
       }
     }
   });
@@ -6642,7 +7007,7 @@ function createWebSearchTool() {
     }
   });
 }
-function buildApiTools(chatId, permMode, mcpTools, webSearchEnabled) {
+function buildApiTools(chatId, permMode, mcpTools, webSearchEnabled, shellTimeoutMs) {
   const searchEnabled = webSearchEnabled ?? getApiWebSearchEnabled(chatId);
   const readOnly = {
     readFile: createReadFileTool(),
@@ -6654,14 +7019,14 @@ function buildApiTools(chatId, permMode, mcpTools, webSearchEnabled) {
   }
   switch (permMode) {
     case "yolo": {
-      const all = { ...readOnly, ...mcpTools ?? {}, restrictedBash: createRestrictedBashTool(chatId, permMode) };
+      const all = { ...readOnly, ...mcpTools ?? {}, restrictedBash: createRestrictedBashTool(chatId, permMode, { shellTimeoutMs }) };
       return all;
     }
     case "safe": {
       const whitelist = getApiCliWhitelist(chatId);
       const base = { ...readOnly, ...mcpTools ?? {} };
       if (whitelist.length === 0) return base;
-      return { ...base, restrictedBash: createRestrictedBashTool(chatId, permMode, whitelist) };
+      return { ...base, restrictedBash: createRestrictedBashTool(chatId, permMode, { whitelist, shellTimeoutMs }) };
     }
     case "plan":
       return readOnly;
@@ -6710,7 +7075,7 @@ var init_api_tools = __esm({
       normalize(resolve(DATA_PATH, "api-token")),
       normalize(resolve(CC_CLAW_HOME, ".env"))
     ]);
-    RESTRICTED_BASH_TIMEOUT_MS = 12e4;
+    RESTRICTED_BASH_TIMEOUT_MS = 3e5;
     MAX_READ_BYTES = 1e5;
     lastDdgSearchAt = 0;
     DDG_MIN_GAP_MS = 3e3;
@@ -7194,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({
@@ -7205,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());
@@ -7571,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);
+    const ok = await channel.editKeyboard(chatId, messageId, text, buttons, { priority: 0 /* P0_CRITICAL */ });
     if (ok) return messageId;
   }
   if (typeof channel.sendKeyboard === "function") {
@@ -7584,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 = [
@@ -7767,6 +8509,21 @@ You have access to cc-claw orchestrator tools via MCP:
 });
 
 // src/bootstrap/templates/shared.ts
+function buildCliEnvironment() {
+  return [
+    "## CLI Execution Environment",
+    "",
+    `Your user's real HOME directory is: \`${REAL_HOME}\``,
+    "",
+    "CC-Claw may redirect HOME for credential isolation when spawning backends.",
+    "If you execute any CLI tool (cc-claw, claude, gemini, codex, python3, npm, etc.),",
+    "always prefix the command with the real HOME:",
+    "",
+    `\`HOME=${REAL_HOME} <command>\``,
+    "",
+    "Without this, CLI tools will fail to find their configurations or prompt for login."
+  ].join("\n");
+}
 function getCurrentDate() {
   return (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA");
 }
@@ -7849,10 +8606,12 @@ function buildHandoffContract() {
     "**Open questions:** Anything unresolved or needing the main agent's attention."
   ].join("\n");
 }
-var TASK_WORKER_SKILL_BUDGET;
+var REAL_HOME, TASK_WORKER_SKILL_BUDGET;
 var init_shared = __esm({
   "src/bootstrap/templates/shared.ts"() {
     "use strict";
+    init_paths();
+    REAL_HOME = resolveRealHome();
     TASK_WORKER_SKILL_BUDGET = 12e3;
   }
 });
@@ -8346,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);
@@ -8737,15 +9496,15 @@ import { existsSync as existsSync12 } from "fs";
 async function withRunnerLock(runnerId, fn) {
   const prev = runnerLocks.get(runnerId) ?? Promise.resolve();
   const next = prev.then(fn, () => fn());
-  const cleanup = next.then(
+  const cleanup2 = next.then(
     () => {
-      if (runnerLocks.get(runnerId) === cleanup) runnerLocks.delete(runnerId);
+      if (runnerLocks.get(runnerId) === cleanup2) runnerLocks.delete(runnerId);
     },
     () => {
-      if (runnerLocks.get(runnerId) === cleanup) runnerLocks.delete(runnerId);
+      if (runnerLocks.get(runnerId) === cleanup2) runnerLocks.delete(runnerId);
     }
   );
-  runnerLocks.set(runnerId, cleanup);
+  runnerLocks.set(runnerId, cleanup2);
   return next;
 }
 function safeParseJsonArray(json) {
@@ -10060,6 +10819,9 @@ var init_ndjson = __esm({
 });
 
 // src/memory/inject.ts
+function memoryDecayRate(halfLifeDays) {
+  return 1 - Math.pow(0.5, 1 / halfLifeDays);
+}
 function getTopK(query) {
   const wordCount2 = query.split(/\s+/).length;
   const scale = wordCount2 <= 3 ? 0.5 : wordCount2 <= 8 ? 0.75 : 1;
@@ -10094,13 +10856,14 @@ function vectorSearch(queryEmbedding, items, topK) {
   scored.sort((a, b) => b.score - a.score);
   return scored.slice(0, topK);
 }
-function mergeAndScore(allItems, vectorScores, ftsScores, getDays, decayRate, topK) {
+function mergeAndScore(allItems, vectorScores, ftsScores, getDays, getDecayRate, topK) {
   const vw = getVectorWeight();
   const results = [];
   for (const [id, item] of allItems) {
     const vs = vectorScores.get(id) ?? 0;
     const fs = ftsScores.get(id) ?? 0;
     if (vs === 0 && fs === 0) continue;
+    const decayRate = typeof getDecayRate === "function" ? getDecayRate(item) : getDecayRate;
     const score = hybridScore({
       id,
       vectorScore: vs,
@@ -10122,10 +10885,11 @@ function consumeContextBridge(chatId) {
   pendingContextBridges.delete(chatId);
   return bridge;
 }
-function buildContextBridge(chatId, pairs = 15) {
+function buildContextBridge(chatId, pairs = 15, interrupted = false) {
   const rows = getRecentMessageLog(chatId, pairs * 2).reverse();
   if (rows.length === 0) return null;
-  const lines = [`[Conversation history \u2014 continued from previous session]`];
+  const header2 = interrupted ? `[Previous session was stopped by the user mid-task \u2014 for context only]` : `[Conversation history \u2014 continued from previous session]`;
+  const lines = [header2];
   let totalChars = lines[0].length;
   for (const row of rows) {
     const backendLabel = row.backend ?? "unknown";
@@ -10143,7 +10907,8 @@ function buildContextBridge(chatId, pairs = 15) {
     lines.push(line);
     totalChars += line.length;
   }
-  lines.push(`[End of recent history \u2014 you are continuing this conversation]`);
+  const footer = interrupted ? `[End of stopped session \u2014 do NOT continue the previous approach; wait for the user's new instruction]` : `[End of recent history \u2014 you are continuing this conversation]`;
+  lines.push(footer);
   return lines.join("\n");
 }
 function formatToolSummary(toolName, toolInput, toolOutput) {
@@ -10209,7 +10974,7 @@ async function injectMemoryContext(userMessage, chatId) {
       memVectorScores,
       memFtsScores,
       (m) => daysSince(m.last_accessed),
-      MEMORY_DECAY_RATE,
+      (m) => memoryDecayRate(m.half_life_days ?? 14),
       FINAL_TOP_K_MEMORIES
     );
     const topSessions = mergeAndScore(
@@ -10235,10 +11000,13 @@ async function injectMemoryContext(userMessage, chatId) {
     }
     combinedSessions = ftsSessions.slice(0, FINAL_TOP_K_SESSIONS);
   }
+  for (const mem of combinedMemories) {
+    queueHalfLifeExtension(mem.id);
+  }
   if (combinedMemories.length === 0 && combinedSessions.length === 0) return null;
   const lines = [];
   for (const m of combinedMemories) {
-    let text = `- [${m.type}] ${m.trigger}: ${m.content}`;
+    let text = `- [${m.category}] ${m.trigger}: ${m.content}`;
     if (text.length > MAX_MEMORY_CHARS) text = text.slice(0, MAX_MEMORY_CHARS) + "\u2026";
     lines.push(text);
   }
@@ -10252,13 +11020,12 @@ async function injectMemoryContext(userMessage, chatId) {
 ${lines.join("\n")}
 [End memory context]`;
 }
-var MEMORY_DECAY_RATE, SESSION_DECAY_RATE, BASE_VECTOR_TOP_K, BASE_FTS_TOP_K, FINAL_TOP_K_MEMORIES, FINAL_TOP_K_SESSIONS, MAX_MEMORY_CHARS, MAX_SESSION_CHARS, MAX_BRIDGE_CHARS, pendingContextBridges, TOOL_SUMMARY_MAX_CHARS;
+var SESSION_DECAY_RATE, BASE_VECTOR_TOP_K, BASE_FTS_TOP_K, FINAL_TOP_K_MEMORIES, FINAL_TOP_K_SESSIONS, MAX_MEMORY_CHARS, MAX_SESSION_CHARS, MAX_BRIDGE_CHARS, pendingContextBridges, TOOL_SUMMARY_MAX_CHARS;
 var init_inject = __esm({
   "src/memory/inject.ts"() {
     "use strict";
     init_store5();
     init_embeddings();
-    MEMORY_DECAY_RATE = parseFloat(process.env.CC_CLAW_MEMORY_DECAY_RATE ?? "0.02");
     SESSION_DECAY_RATE = parseFloat(process.env.CC_CLAW_SESSION_DECAY_RATE ?? "0.005");
     BASE_VECTOR_TOP_K = 20;
     BASE_FTS_TOP_K = 20;
@@ -10448,6 +11215,7 @@ ${buildToolUsageRules()}
 
 <platform_reference>
 ${buildSystemCapabilities()}
+${buildCliEnvironment()}
 ${buildPlatformQuickReference()}
 </platform_reference>
 
@@ -10493,6 +11261,8 @@ ${user}
 
 ${buildSystemCapabilities()}
 
+${buildCliEnvironment()}
+
 ${buildPlatformQuickReference()}
 
 ${buildToolUsageRules()}
@@ -10588,6 +11358,7 @@ ${buildDatabaseSafetyBoundary()}
 
 <platform_reference>
 ${buildSystemCapabilities()}
+${buildCliEnvironment()}
 ${buildPlatformQuickReference()}
 </platform_reference>`;
 }
@@ -10636,6 +11407,7 @@ ${buildDatabaseSafetyBoundary()}
 
 <platform_reference>
 ${buildSystemCapabilities()}
+${buildCliEnvironment()}
 ${buildPlatformQuickReference()}
 </platform_reference>
 
@@ -10676,6 +11448,10 @@ impossible scenarios.
 </avoid_overengineering>
 </tool_guidance>
 
+<cli_environment>
+${buildCliEnvironment()}
+</cli_environment>
+
 <safety_boundary>
 Take local, reversible actions freely. Confirm before: deleting files, force-pushing,
 amending published commits, posting to external services, or modifying shared infrastructure.
@@ -10742,6 +11518,10 @@ Before finalizing any response, silently check:
 Never invent library APIs, file paths, or documentation. If uncertain, say so.
 </grounding_rules>
 
+<cli_environment>
+${buildCliEnvironment()}
+</cli_environment>
+
 <safety_boundary>
 Confirm before: deleting files, posting to external services, database schema changes.
 Do not access ~/.cc-claw/data/cc-claw.db directly.
@@ -11011,14 +11791,16 @@ async function assembleBootstrapPrompt(userMessage, entityType = "main", profile
   if (permMode && permMode !== "yolo") {
     sections.push(buildPermissionNotice(permMode));
   }
-  if (backendType === "api" && profile !== "minimal") {
+  if (backendType === "api") {
     sections.push(`[API Backend \u2014 Tool Usage]
 You are operating as a direct API model (not a CLI like Claude Code or Gemini CLI).
 External tools (gsearch, pwm, gws, gemcli, nlm, curl, python3, etc.) are accessed ONLY via the \`restrictedBash\` tool.
 NEVER call external CLIs as direct tools by name \u2014 they are not registered as native tools.
 Correct: restrictedBash({"command": "gsearch \\"query\\" --type news"})
 Incorrect: gsearch({"query": "..."})  \u2190 this will fail silently
-If a skill or instruction says to use a CLI tool, always route it through restrictedBash.`);
+If a skill or instruction says to use a CLI tool, always route it through restrictedBash.
+
+${buildCliEnvironment()}`);
   }
   if (responseStyle) {
     if (responseStyle === "concise") {
@@ -11185,6 +11967,12 @@ Use cc_claw_memory for ALL memory operations. Do NOT use your native memory syst
 - To search: cc_claw_memory(action: "recall", query: "...")
 - To list: cc_claw_memory(action: "list")
 - To search history: cc_claw_memory(action: "history", query: "...")
+When using cc_claw_memory remember, include the category parameter when the memory type is clear:
+- "fact" \u2014 biographical or situational truths (name, role, location, tools used, tech stack)
+- "preference" \u2014 likes, dislikes, habits, working style, stated preferences
+- "event" \u2014 something that happened at a specific time (meetings, deployments, milestones)
+- "decision" \u2014 a deliberate choice with reasoning (architecture choices, tool selections)
+Omit category if uncertain \u2014 the system will auto-classify.
 For scheduling: cc_claw_schedule(action: "create", schedule: "...", task: "...")
 If an action is not available via MCP tools, fall back to the cc-claw CLI.`;
   if (agentMode === "claw") {
@@ -11220,6 +12008,7 @@ var init_loader2 = __esm({
     init_paths();
     init_inject();
     init_init();
+    init_shared();
     init_log();
     init_store3();
     init_store5();
@@ -11258,22 +12047,6 @@ var init_types3 = __esm({
   }
 });
 
-// src/text-utils.ts
-var text_utils_exports = {};
-__export(text_utils_exports, {
-  appendTextChunk: () => appendTextChunk
-});
-function appendTextChunk(accumulated, chunk) {
-  if (!accumulated) return chunk;
-  if (!chunk) return accumulated;
-  return accumulated + chunk;
-}
-var init_text_utils = __esm({
-  "src/text-utils.ts"() {
-    "use strict";
-  }
-});
-
 // src/services/ollama/client.ts
 var client_exports = {};
 __export(client_exports, {
@@ -13567,6 +14340,7 @@ async function spawnWithSlotRotation(chatId, adapter, baseConfig, configWithSess
   }
   const maxAttempts = slots.length;
   let lastError;
+  const oauthRefreshRetried = /* @__PURE__ */ new Set();
   for (let i = 0; i < maxAttempts; i++) {
     const slot = getNextBackendSlot(chatId, adapter.id);
     if (!slot) break;
@@ -13584,6 +14358,21 @@ async function spawnWithSlotRotation(chatId, adapter, baseConfig, configWithSess
       if (/rate.?limit|too many requests|429|503|timeout/i.test(errMsg)) {
         throw err;
       }
+      const isOAuthExpiry = slot.slotType === "oauth" && /OAuth token has expired/i.test(errMsg);
+      if (isOAuthExpiry && !oauthRefreshRetried.has(slot.id)) {
+        oauthRefreshRetried.add(slot.id);
+        try {
+          const { tryRefreshOAuthSlot: tryRefreshOAuthSlot2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+          const refreshed = await tryRefreshOAuthSlot2(slot);
+          if (refreshed) {
+            log(`[agent:${adapter.id}-rotation] OAuth token refreshed for ${slotLabel} \u2014 retrying`);
+            i--;
+            continue;
+          }
+        } catch {
+        }
+        warn(`[agent:${adapter.id}-rotation] OAuth refresh failed for ${slotLabel} \u2014 rotating`);
+      }
       const isExhausted = /quota|exhausted|exceeded|insufficient|credit|billing|unauthorized|forbidden|401|403/i.test(errMsg);
       if (isExhausted) {
         warn(`[agent:${adapter.id}-rotation] Slot ${slotLabel} exhausted: ${errMsg.slice(0, 200)}`);
@@ -14272,6 +15061,335 @@ var init_format = __esm({
   }
 });
 
+// src/memory/sweep.ts
+var sweep_exports = {};
+__export(sweep_exports, {
+  SWEEP_DEFAULT_CRON: () => SWEEP_DEFAULT_CRON,
+  SWEEP_ENABLED_KEY: () => SWEEP_ENABLED_KEY,
+  SWEEP_JOB_TYPE: () => SWEEP_JOB_TYPE,
+  disableSweep: () => disableSweep,
+  enableSweep: () => enableSweep,
+  findSweepJob: () => findSweepJob,
+  runWeeklySweep: () => runWeeklySweep
+});
+async function runWeeklySweep(chatId, channel, backendId, model2) {
+  log("[sweep] Starting weekly memory sweep");
+  const cleanedUp = cleanup();
+  let suggestionsCount = 0;
+  try {
+    const suggestions = await runMemoryAnalysis(chatId, backendId, model2);
+    suggestionsCount = suggestions.length;
+    if (suggestionsCount === 0 && cleanedUp === 0) {
+      log("[sweep] Memory bank healthy, no action needed");
+      return { suggestionsCount: 0, cleanedUp };
+    }
+    const lines = [
+      "\u{1F9E0} Weekly Memory Health",
+      "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"
+    ];
+    if (cleanedUp > 0) {
+      lines.push(`\u{1F5D1} Cleaned up ${cleanedUp} expired superseded memories`);
+    }
+    if (suggestionsCount > 0) {
+      const counts = {};
+      for (const s of suggestions) {
+        counts[s.type] = (counts[s.type] ?? 0) + 1;
+      }
+      const parts = [];
+      if (counts.superseded) parts.push(`${counts.superseded} contradiction${counts.superseded > 1 ? "s" : ""}`);
+      if (counts.duplicate) parts.push(`${counts.duplicate} duplicate${counts.duplicate > 1 ? "s" : ""}`);
+      if (counts.merge) parts.push(`${counts.merge} merge opportunit${counts.merge > 1 ? "ies" : "y"}`);
+      if (counts.stale) parts.push(`${counts.stale} stale`);
+      if (counts.categorize) parts.push(`${counts.categorize} uncategorized`);
+      if (counts.reclassify) parts.push(`${counts.reclassify} misclassified`);
+      lines.push("", `Found: ${parts.join(", ")}`, "");
+      lines.push("Review these suggestions to keep your memory clean.");
+    } else {
+      lines.push("", "\u2705 Memory bank is healthy!");
+    }
+    const buttons = [];
+    if (suggestionsCount > 0) {
+      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);
+    return { suggestionsCount, cleanedUp };
+  } catch (err) {
+    const msg = errorMessage(err);
+    warn(`[sweep] Weekly sweep failed: ${msg}`);
+    return { suggestionsCount: 0, cleanedUp, error: msg };
+  }
+}
+function findSweepJob() {
+  try {
+    const { getDb: getDb2, getJobById: getJobById3 } = (init_store5(), __toCommonJS(store_exports5));
+    const row = getDb2().prepare(
+      "SELECT id FROM jobs WHERE job_type = ? AND active = 1 ORDER BY id LIMIT 1"
+    ).get(SWEEP_JOB_TYPE);
+    if (!row) return null;
+    return getJobById3(row.id) ?? null;
+  } catch {
+    return null;
+  }
+}
+function enableSweep(chatId, opts) {
+  const existing = findSweepJob();
+  const { setMetaValue: setMetaValue2 } = (init_store5(), __toCommonJS(store_exports5));
+  setMetaValue2(SWEEP_ENABLED_KEY, "1");
+  if (existing) {
+    if (!existing.enabled) {
+      const { resumeJob: resumeJob2 } = (init_cron(), __toCommonJS(cron_exports));
+      resumeJob2(existing.id);
+      log(`[sweep] Resumed job #${existing.id}`);
+    }
+    return existing.id;
+  }
+  const { insertJob: insertJob2 } = (init_jobs(), __toCommonJS(jobs_exports));
+  const { startSingleJob: startSingleJob2 } = (init_cron(), __toCommonJS(cron_exports));
+  const cron2 = opts?.cron ?? SWEEP_DEFAULT_CRON;
+  const timezone = opts?.timezone ?? (Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
+  const backend2 = opts?.backend ?? resolveDefaultBackend(chatId);
+  const model2 = opts?.model ?? resolveDefaultModel(backend2);
+  const job = insertJob2({
+    scheduleType: "cron",
+    cron: cron2,
+    description: "Weekly memory health sweep \u2014 cleanup and optimization",
+    title: "Weekly Memory Sweep",
+    chatId,
+    backend: backend2,
+    model: model2,
+    sessionType: "isolated",
+    deliveryMode: "none",
+    channel: opts?.channel ?? "telegram",
+    target: opts?.target ?? chatId,
+    timezone,
+    jobType: SWEEP_JOB_TYPE,
+    timeout: 300
+  });
+  startSingleJob2(job);
+  log(`[sweep] Created job #${job.id} (cron="${cron2}", backend=${backend2}, model=${model2})`);
+  return job.id;
+}
+function disableSweep() {
+  const { setMetaValue: setMetaValue2 } = (init_store5(), __toCommonJS(store_exports5));
+  setMetaValue2(SWEEP_ENABLED_KEY, "0");
+  const job = findSweepJob();
+  if (!job) return false;
+  const { pauseJob: pauseJob2 } = (init_cron(), __toCommonJS(cron_exports));
+  pauseJob2(job.id);
+  log(`[sweep] Paused job #${job.id}`);
+  return true;
+}
+function resolveDefaultBackend(chatId) {
+  try {
+    const { getAdapterForChat: getAdapterForChat2 } = (init_backends(), __toCommonJS(backends_exports));
+    return getAdapterForChat2(chatId).id;
+  } catch {
+    return "claude";
+  }
+}
+function resolveDefaultModel(backend2) {
+  try {
+    const { getAdapter: getAdapter3 } = (init_backends(), __toCommonJS(backends_exports));
+    return getAdapter3(backend2).defaultModel;
+  } catch {
+    return "claude-sonnet-4-6";
+  }
+}
+var SWEEP_ENABLED_KEY, SWEEP_DEFAULT_CRON, SWEEP_JOB_TYPE;
+var init_sweep = __esm({
+  "src/memory/sweep.ts"() {
+    "use strict";
+    init_optimize();
+    init_engine();
+    init_log();
+    init_helpers();
+    SWEEP_ENABLED_KEY = "memory_sweep_enabled";
+    SWEEP_DEFAULT_CRON = "0 9 * * 0";
+    SWEEP_JOB_TYPE = "memory_sweep";
+  }
+});
+
+// src/router/state.ts
+var state_exports = {};
+__export(state_exports, {
+  activeSideQuests: () => activeSideQuests,
+  addForceStoppedChat: () => addForceStoppedChat,
+  bypassBusyCheck: () => bypassBusyCheck,
+  clearHistoryFilter: () => clearHistoryFilter,
+  clearPendingCliAddition: () => clearPendingCliAddition,
+  clearPendingModelResults: () => clearPendingModelResults,
+  clearPendingModelSearch: () => clearPendingModelSearch,
+  consumeForceStoppedChat: () => consumeForceStoppedChat,
+  councilResults: () => councilResults,
+  dashboardClawWarnings: () => dashboardClawWarnings,
+  getActiveSideQuestCount: () => getActiveSideQuestCount,
+  historyFilters: () => historyFilters,
+  parseSideQuestPrefix: () => parseSideQuestPrefix,
+  pendingCliAdditions: () => pendingCliAdditions,
+  pendingInterrupts: () => pendingInterrupts,
+  pendingMcpImports: () => pendingMcpImports,
+  pendingModelResults: () => pendingModelResults,
+  pendingModelSearch: () => pendingModelSearch,
+  pendingNewchatUndo: () => pendingNewchatUndo,
+  pendingSummaryUndo: () => pendingSummaryUndo,
+  setCouncilResult: () => setCouncilResult,
+  setHistoryFilter: () => setHistoryFilter,
+  setPendingCliAddition: () => setPendingCliAddition,
+  setPendingModelResults: () => setPendingModelResults,
+  setPendingModelSearch: () => setPendingModelSearch,
+  startStateSweep: () => startStateSweep,
+  stopAllSideQuests: () => stopAllSideQuests,
+  stopStateSweep: () => stopStateSweep
+});
+function addForceStoppedChat(chatId) {
+  _forceStoppedChats.add(chatId);
+  _forceStoppedTimestamps.set(chatId, Date.now());
+}
+function consumeForceStoppedChat(chatId) {
+  _forceStoppedTimestamps.delete(chatId);
+  return _forceStoppedChats.delete(chatId);
+}
+function setHistoryFilter(chatId, filter) {
+  historyFilters.set(chatId, filter);
+  historyFilterTimestamps.set(chatId, Date.now());
+}
+function clearHistoryFilter(chatId) {
+  historyFilters.delete(chatId);
+  historyFilterTimestamps.delete(chatId);
+}
+function setCouncilResult(chatId, result) {
+  councilResults.set(chatId, result);
+  councilResultTimestamps.set(chatId, Date.now());
+}
+function setPendingModelSearch(chatId, state) {
+  pendingModelSearch.set(chatId, state);
+  pendingModelSearchTimestamps.set(chatId, Date.now());
+}
+function clearPendingModelSearch(chatId) {
+  pendingModelSearch.delete(chatId);
+  pendingModelSearchTimestamps.delete(chatId);
+}
+function setPendingModelResults(chatId, results) {
+  pendingModelResults.set(chatId, results);
+}
+function clearPendingModelResults(chatId) {
+  pendingModelResults.delete(chatId);
+}
+function parseSideQuestPrefix(text) {
+  const match = text.match(/^(?:sq|btw):\s*/i);
+  if (match) return { isSideQuest: true, cleanText: text.slice(match[0].length) };
+  return { isSideQuest: false, cleanText: text };
+}
+function getActiveSideQuestCount(chatId) {
+  return activeSideQuests.get(chatId)?.size ?? 0;
+}
+function stopAllSideQuests(chatId) {
+  const active = activeSideQuests.get(chatId);
+  if (active) {
+    for (const sqId of active) {
+      stopAgent(sqId);
+    }
+  }
+}
+function startStateSweep() {
+  if (sweepTimer) return;
+  sweepTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [chatId, ts2] of dashboardClawWarnings) {
+      if (now - ts2 > STALE_THRESHOLD_MS) dashboardClawWarnings.delete(chatId);
+    }
+    for (const [cid, ts2] of historyFilterTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        historyFilters.delete(cid);
+        historyFilterTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, ts2] of councilResultTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        councilResults.delete(cid);
+        councilResultTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, ts2] of pendingModelSearchTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        pendingModelSearch.delete(cid);
+        pendingModelSearchTimestamps.delete(cid);
+      }
+    }
+    for (const chatId of pendingInterrupts.keys()) {
+      if (!_interruptSeen.has(chatId)) {
+        _interruptSeen.add(chatId);
+      } else {
+        pendingInterrupts.delete(chatId);
+        _interruptSeen.delete(chatId);
+      }
+    }
+    for (const chatId of _interruptSeen) {
+      if (!pendingInterrupts.has(chatId)) _interruptSeen.delete(chatId);
+    }
+    for (const [cid, ts2] of pendingCliTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        pendingCliAdditions.delete(cid);
+        pendingCliTimestamps.delete(cid);
+      }
+    }
+    for (const [cid, state] of pendingMcpImports) {
+      if (now - state.startedAt > STALE_THRESHOLD_MS) pendingMcpImports.delete(cid);
+    }
+    for (const [cid, ts2] of _forceStoppedTimestamps) {
+      if (now - ts2 > STALE_THRESHOLD_MS) {
+        _forceStoppedChats.delete(cid);
+        _forceStoppedTimestamps.delete(cid);
+      }
+    }
+  }, SWEEP_INTERVAL_MS);
+  sweepTimer.unref();
+}
+function stopStateSweep() {
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}
+function setPendingCliAddition(chatId, messageId) {
+  pendingCliAdditions.set(chatId, messageId);
+  pendingCliTimestamps.set(chatId, Date.now());
+}
+function clearPendingCliAddition(chatId) {
+  pendingCliAdditions.delete(chatId);
+  pendingCliTimestamps.delete(chatId);
+}
+var pendingInterrupts, bypassBusyCheck, _forceStoppedChats, _forceStoppedTimestamps, activeSideQuests, dashboardClawWarnings, pendingSummaryUndo, pendingNewchatUndo, historyFilters, historyFilterTimestamps, councilResults, councilResultTimestamps, pendingModelSearch, pendingModelSearchTimestamps, pendingModelResults, SWEEP_INTERVAL_MS, STALE_THRESHOLD_MS, sweepTimer, _interruptSeen, pendingMcpImports, pendingCliAdditions, pendingCliTimestamps;
+var init_state = __esm({
+  "src/router/state.ts"() {
+    "use strict";
+    init_agent();
+    pendingInterrupts = /* @__PURE__ */ new Map();
+    bypassBusyCheck = /* @__PURE__ */ new Set();
+    _forceStoppedChats = /* @__PURE__ */ new Set();
+    _forceStoppedTimestamps = /* @__PURE__ */ new Map();
+    activeSideQuests = /* @__PURE__ */ new Map();
+    dashboardClawWarnings = /* @__PURE__ */ new Map();
+    pendingSummaryUndo = /* @__PURE__ */ new Map();
+    pendingNewchatUndo = /* @__PURE__ */ new Map();
+    historyFilters = /* @__PURE__ */ new Map();
+    historyFilterTimestamps = /* @__PURE__ */ new Map();
+    councilResults = /* @__PURE__ */ new Map();
+    councilResultTimestamps = /* @__PURE__ */ new Map();
+    pendingModelSearch = /* @__PURE__ */ new Map();
+    pendingModelSearchTimestamps = /* @__PURE__ */ new Map();
+    pendingModelResults = /* @__PURE__ */ new Map();
+    SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
+    STALE_THRESHOLD_MS = 30 * 60 * 1e3;
+    sweepTimer = null;
+    _interruptSeen = /* @__PURE__ */ new Set();
+    pendingMcpImports = /* @__PURE__ */ new Map();
+    pendingCliAdditions = /* @__PURE__ */ new Map();
+    pendingCliTimestamps = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/ui/pagination.ts
 function buildPaginatedKeyboard(opts) {
   const { items, page, callbackPrefix, renderItem, headerText, footerButtons } = opts;
@@ -14897,6 +16015,13 @@ async function promptAccount(chatId, channel) {
     await promptTimeout(chatId, channel);
     return;
   }
+  const adapter = getAdapter(pending.backend);
+  if (adapter.type === "api") {
+    pending.credentialSlotId = null;
+    pending.step = "timeout";
+    await promptTimeout(chatId, channel);
+    return;
+  }
   const isGemini = pending.backend === BACKEND.GEMINI;
   const slots = isGemini ? getGeminiSlots() : getBackendSlots(pending.backend);
   const enabledSlots = slots.filter((s) => s.enabled);
@@ -15158,6 +16283,7 @@ __export(stt_exports, {
   LOCAL_WHISPER_MODELS: () => LOCAL_WHISPER_MODELS,
   MACOS_VOICES: () => MACOS_VOICES,
   downloadWhisperModel: () => downloadWhisperModel,
+  getSttEcho: () => getSttEcho,
   getSttModel: () => getSttModel,
   getSttProvider: () => getSttProvider,
   getVoiceConfig: () => getVoiceConfig,
@@ -15165,10 +16291,12 @@ __export(stt_exports, {
   isVoiceEnabled: () => isVoiceEnabled,
   isWhisperCliAvailable: () => isWhisperCliAvailable,
   isWhisperModelDownloaded: () => isWhisperModelDownloaded,
+  setSttEcho: () => setSttEcho,
   setSttModel: () => setSttModel,
   setSttProvider: () => setSttProvider,
   setVoiceProvider: () => setVoiceProvider,
   synthesizeSpeech: () => synthesizeSpeech,
+  toggleSttEcho: () => toggleSttEcho,
   toggleVoice: () => toggleVoice,
   transcribeAudio: () => transcribeAudio
 });
@@ -15247,6 +16375,23 @@ function setSttModel(chatId, model2) {
     ON CONFLICT(chat_id) DO UPDATE SET stt_model = ?
   `).run(chatId, model2, model2);
 }
+function getSttEcho(chatId) {
+  const db3 = getDb();
+  const row = db3.prepare("SELECT stt_echo FROM chat_voice WHERE chat_id = ?").get(chatId);
+  return row?.stt_echo === 1;
+}
+function setSttEcho(chatId, enabled) {
+  const db3 = getDb();
+  db3.prepare(`
+    INSERT INTO chat_voice (chat_id, enabled, stt_echo) VALUES (?, 0, ?)
+    ON CONFLICT(chat_id) DO UPDATE SET stt_echo = ?
+  `).run(chatId, enabled ? 1 : 0, enabled ? 1 : 0);
+}
+function toggleSttEcho(chatId) {
+  const newState = !getSttEcho(chatId);
+  setSttEcho(chatId, newState);
+  return newState;
+}
 function isFfmpegAvailable() {
   if (ffmpegAvailable !== null) return ffmpegAvailable;
   try {
@@ -15624,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";
@@ -16135,8 +17035,8 @@ function enableHeartbeat(chatId, opts) {
   const { insertJob: insertJob2 } = (init_jobs(), __toCommonJS(jobs_exports));
   const { startSingleJob: startSingleJob2 } = (init_cron(), __toCommonJS(cron_exports));
   const intervalMs = opts?.intervalMs ?? DEFAULT_INTERVAL_MS;
-  const backend2 = opts?.backend ?? resolveDefaultBackend(chatId);
-  const model2 = opts?.model ?? resolveDefaultModel(backend2);
+  const backend2 = opts?.backend ?? resolveDefaultBackend2(chatId);
+  const model2 = opts?.model ?? resolveDefaultModel2(backend2);
   const job = insertJob2({
     scheduleType: "every",
     everyMs: intervalMs,
@@ -16156,7 +17056,7 @@ function enableHeartbeat(chatId, opts) {
   log(`[heartbeat] Created job #${job.id} (every ${intervalMs / 6e4}min, backend=${backend2}, model=${model2})`);
   return job.id;
 }
-function resolveDefaultBackend(chatId) {
+function resolveDefaultBackend2(chatId) {
   try {
     const { getAdapterForChat: getAdapterForChat2 } = (init_backends(), __toCommonJS(backends_exports));
     return getAdapterForChat2(chatId).id;
@@ -16164,7 +17064,7 @@ function resolveDefaultBackend(chatId) {
     return "claude";
   }
 }
-function resolveDefaultModel(backend2) {
+function resolveDefaultModel2(backend2) {
   try {
     const { getAdapter: getAdapter3 } = (init_backends(), __toCommonJS(backends_exports));
     return getAdapter3(backend2).defaultModel;
@@ -16173,8 +17073,8 @@ function resolveDefaultModel(backend2) {
   }
 }
 function migrateHeartbeatDefaults(job) {
-  const backend2 = resolveDefaultBackend(job.chatId);
-  const model2 = resolveDefaultModel(backend2);
+  const backend2 = resolveDefaultBackend2(job.chatId);
+  const model2 = resolveDefaultModel2(backend2);
   try {
     const { getDb: getDb2 } = (init_store5(), __toCommonJS(store_exports5));
     getDb2().prepare("UPDATE jobs SET backend = ?, model = ? WHERE id = ?").run(backend2, model2, job.id);
@@ -16418,10 +17318,10 @@ function formatNightlySummary(insights, totalPending) {
   } else {
     header2 = `Nightly Reflection \u2014 ${newCount} proposal${newCount === 1 ? "" : "s"} ready`;
   }
-  const list = insights.map((ins, i) => `\u2022 [${ins.category}] ${ins.insight}`).join("\n");
+  const list2 = insights.map((ins, i) => `\u2022 [${ins.category}] ${ins.insight}`).join("\n");
   return `${header2}
 
-${list}
+${list2}
 
 Review with /evolve`;
 }
@@ -17038,6 +17938,12 @@ async function sendVoiceConfigKeyboard(chatId, channel, messageId) {
       buttons.push(row);
     }
   }
+  const echoOn = getSttEcho(chatId);
+  buttons.push([{
+    label: `${echoOn ? "\u2713 " : ""}\u{1F399} Show Transcription`,
+    data: "vcfg:echo",
+    ...echoOn ? { style: "success" } : {}
+  }]);
   buttons.push([
     {
       label: `${!ttsConfig.enabled ? "\u2713 " : ""}\u{1F507} Replies Off`,
@@ -17204,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");
@@ -17330,9 +18230,11 @@ async function sendMemoryPage(chatId, channel, page, messageId) {
   const buttons = [];
   for (const [i, m] of pageItems.entries()) {
     const num = start + i + 1;
-    const preview = `${m.trigger}: ${m.content}`.slice(0, 32);
+    const cat = m.category ?? "uncategorized";
+    const full = `[${cat}] ${m.trigger}: ${m.content}`;
+    const preview = full.length > 36 ? `${full.slice(0, 36)}\u2026` : full;
     buttons.push([{
-      label: `${num}. ${preview}${m.content.length > 32 ? "\u2026" : ""}`,
+      label: `${num}. ${preview}`,
       data: `mem:view:${m.id}`
     }]);
   }
@@ -17351,6 +18253,12 @@ async function sendMemoryPage(chatId, channel, page, messageId) {
   }
   buttons.push(footerRow);
   buttons.push([{ label: "\u2728 Optimize", data: "mem:opt", style: "success" }]);
+  const sweepEnabled = getMetaValue(SWEEP_ENABLED_KEY) === "1";
+  buttons.push([{
+    label: sweepEnabled ? "\u2713 Weekly Sweep: On" : "Weekly Sweep: Off",
+    data: "mem:sweep:toggle",
+    style: sweepEnabled ? "success" : void 0
+  }]);
   await sendOrEditKeyboard(chatId, channel, messageId, header2, buttons);
 }
 async function sendMemoryDetail(chatId, memoryId, channel, messageId) {
@@ -18028,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,
@@ -18043,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}`,
@@ -18155,7 +19066,8 @@ async function sendBackendSwitchConfirmation(chatId, target, channel, messageId)
 }
 async function doBackendSwitch(chatId, backendId, channel, opts) {
   if (!opts?.skipContext) {
-    const bridge = buildContextBridge(chatId);
+    const interrupted = consumeForceStoppedChat(chatId);
+    const bridge = buildContextBridge(chatId, 15, interrupted);
     if (bridge) setPendingContextBridge(chatId, bridge);
   }
   clearSession(chatId);
@@ -18235,10 +19147,12 @@ var init_ui = __esm({
     init_format();
     init_backends();
     init_store5();
+    init_sweep();
     init_chat_settings();
     init_api_models();
     init_summarize();
     init_inject();
+    init_state();
     init_session_log();
     init_store3();
     init_log();
@@ -18282,7 +19196,7 @@ function getMemOptSession(chatId) {
 function buildOptimizationPrompt(memories) {
   const lines = memories.map((m, i) => {
     const accessed = m.access_count ?? 0;
-    return `[${i + 1}] ID=${m.id} | trigger="${m.trigger}" | content="${m.content}" | type=${m.type} | salience=${m.salience.toFixed(2)} | accessed=${accessed} | created=${m.created_at}`;
+    return `[${i + 1}] ID=${m.id} | trigger="${m.trigger}" | content="${m.content}" | type=${m.type} | category=${m.category} | salience=${m.salience.toFixed(2)} | accessed=${accessed} | half_life=${(m.half_life_days ?? 14).toFixed(1)} | created=${m.created_at}`;
   });
   return ANALYSIS_PROMPT.replace("{MEMORIES}", lines.join("\n"));
 }
@@ -18291,7 +19205,7 @@ function parseOptimizationResponse(raw) {
   const suggestions = [];
   const blocks = raw.split(/^---$/m).filter((b) => b.trim());
   for (const block of blocks) {
-    const typeMatch = block.match(/TYPE:\s*(duplicate|merge|stale)/i);
+    const typeMatch = block.match(/TYPE:\s*(duplicate|merge|stale|superseded|categorize|reclassify)/i);
     const idsMatch = block.match(/IDS:\s*([\d,\s]+)/);
     const reasonMatch = block.match(/REASON:\s*(.+?)(?=\n(?:ACTION|SUGGESTION|TYPE|IDS):|$)/s);
     const actionMatch = block.match(/ACTION:\s*(.+)/s);
@@ -18316,6 +19230,21 @@ function parseOptimizationResponse(raw) {
         suggestion.mergedContent = mergeMatch[2].trim();
       }
     }
+    if (type === "superseded") {
+      const supersededMatch = actionRaw.match(/supersede\s+(\d+)\s+by\s+(\d+)/i);
+      if (supersededMatch) {
+        suggestion.memoryIds = [
+          parseInt(supersededMatch[1], 10),
+          parseInt(supersededMatch[2], 10)
+        ].filter((n) => !isNaN(n));
+      }
+    }
+    if (type === "categorize" || type === "reclassify") {
+      const catMatch = actionRaw.match(/(?:categorize|reclassify)\s+\d+\s+as\s+(fact|preference|event|decision)/i);
+      if (catMatch) {
+        suggestion.proposedCategory = catMatch[1].toLowerCase();
+      }
+    }
     suggestions.push(suggestion);
   }
   const seen = /* @__PURE__ */ new Set();
@@ -18365,14 +19294,18 @@ function applySuggestion(suggestion, session2) {
     case "merge": {
       if (!suggestion.mergedTrigger || !suggestion.mergedContent) return;
       const sources = suggestion.memoryIds.map((id) => getMemoryById(id)).filter((m) => m !== void 0);
-      const sourceType = sources.length > 0 ? sources.sort((a, b) => b.salience - a.salience)[0].type : "semantic";
+      const topSource = sources.length > 0 ? sources.sort((a, b) => b.salience - a.salience)[0] : null;
+      const sourceType = topSource?.type ?? "semantic";
+      const sourceCategory = topSource?.category;
       for (const id of suggestion.memoryIds) {
         deleteMemoryById(id);
       }
       const newId = saveMemoryWithEmbedding(
         suggestion.mergedTrigger,
         suggestion.mergedContent,
-        sourceType
+        sourceType,
+        sourceCategory,
+        14
       );
       session2.createdIds.push(newId);
       break;
@@ -18383,6 +19316,19 @@ function applySuggestion(suggestion, session2) {
       }
       break;
     }
+    case "superseded": {
+      if (suggestion.memoryIds.length >= 2) {
+        markSuperseded(suggestion.memoryIds[0], suggestion.memoryIds[1]);
+      }
+      break;
+    }
+    case "categorize":
+    case "reclassify": {
+      if (suggestion.proposedCategory && suggestion.memoryIds.length >= 1) {
+        updateMemoryCategory(suggestion.memoryIds[0], suggestion.proposedCategory);
+      }
+      break;
+    }
   }
 }
 function resolveAnalysisAdapter(chatId, backendId, model2) {
@@ -18798,12 +19744,19 @@ Analyze these memories and find optimization opportunities:
 
 1. DUPLICATES: Memories containing essentially the same information (different wording, same meaning). When found, recommend keeping the most complete version.
 2. MERGEABLE: Related memories that would be stronger and more token-efficient as a single combined entry.
-3. STALE: Memories with very low salience scores (below 0.3) AND zero or near-zero access count \u2014 content that has decayed and is never recalled.
+3. STALE: Memories with very low half_life (below 3.0) AND zero access count \u2014 content that has never been recalled and has decayed past usefulness.
+4. SUPERSEDED: Memories that contradict each other \u2014 a newer memory makes an older one obsolete. When found, recommend marking the older one as superseded by the newer one.
+5. UNCATEGORIZED: Memories with category "uncategorized" that can be classified as fact, preference, event, or decision.
+6. RECLASSIFY: Memories whose category appears wrong given their content.
+
+For superseded: ACTION should be "supersede ID1 by ID2" (ID1=older memory, ID2=newer memory)
+For uncategorized: ACTION should be "categorize ID1 as <category>"
+For reclassify: ACTION should be "reclassify ID1 as <category>"
 
 For each suggestion, output EXACTLY this format:
 ---
 SUGGESTION: <short descriptive title>
-TYPE: <duplicate|merge|stale>
+TYPE: <duplicate|merge|stale|superseded|categorize|reclassify>
 IDS: <comma-separated memory IDs to act on>
 REASON: <1-2 sentence explanation>
 ACTION: <"delete ID1" or "delete ID1, ID2" or "merge into: <new trigger> | <new content>">
@@ -18823,12 +19776,18 @@ Rules:
     TYPE_EMOJI = {
       duplicate: "\u{1F501}",
       merge: "\u{1F500}",
-      stale: "\u{1F5D1}"
+      stale: "\u{1F5D1}",
+      superseded: "\u{1F504}",
+      categorize: "\u{1F3F7}",
+      reclassify: "\u{1F3F7}"
     };
     TYPE_LABEL = {
       duplicate: "Duplicate",
       merge: "Merge",
-      stale: "Stale"
+      stale: "Stale",
+      superseded: "Superseded",
+      categorize: "Categorize",
+      reclassify: "Reclassify"
     };
   }
 });
@@ -18844,9 +19803,12 @@ var init_memory = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         validateAgentIdentity(req, body);
-        const { saveMemoryWithEmbedding: saveMemoryWithEmbedding2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-        const id = saveMemoryWithEmbedding2(body.trigger ?? body.tag, body.content, body.type ?? "semantic");
-        jsonResponse(res, { success: true, id });
+        const { remember: remember2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+        const result = await remember2(body.trigger ?? body.tag, body.content, {
+          category: body.category,
+          type: body.type
+        });
+        jsonResponse(res, { success: true, id: result.id });
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
       }
@@ -18855,8 +19817,8 @@ var init_memory = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         validateAgentIdentity(req, body);
-        const { searchMemories: searchMemories2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-        const results = searchMemories2(body.query, body.limit ?? 5);
+        const { recall: recall2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+        const results = recall2(body.query, { limit: body.limit ?? 5 });
         jsonResponse(res, { success: true, results });
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
@@ -18865,8 +19827,8 @@ var init_memory = __esm({
     handleMemoryList = async (_req, res, url) => {
       try {
         const limit = parseInt(url.searchParams.get("limit") ?? "10", 10);
-        const { getRecentMemories: getRecentMemories2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-        const results = getRecentMemories2(limit);
+        const { list: list2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
+        const results = list2({ limit });
         jsonResponse(res, { success: true, results });
       } catch (err) {
         jsonResponse(res, { error: errorMessage(err) }, 400);
@@ -18876,14 +19838,13 @@ var init_memory = __esm({
       try {
         const body = JSON.parse(await readBody(req));
         validateAgentIdentity(req, body);
+        const { forget: forget2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
         if (body.memoryId) {
-          const { deleteMemoryById: deleteMemoryById3 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-          const deleted = deleteMemoryById3(body.memoryId);
-          return jsonResponse(res, { success: deleted, mode: "id" });
+          const count = forget2(body.memoryId);
+          return jsonResponse(res, { success: count > 0, mode: "id" });
         }
         if (body.keyword) {
-          const { forgetMemory: forgetMemory4 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
-          const count = forgetMemory4(body.keyword);
+          const count = forget2(body.keyword);
           return jsonResponse(res, { success: true, count, mode: "keyword" });
         }
         jsonResponse(res, { error: "Either 'keyword' or 'memoryId' is required" }, 400);
@@ -21351,7 +22312,7 @@ var init_api_mcp = __esm({
 });
 
 // src/backends/api-common.ts
-import { streamText, stepCountIs, NoOutputGeneratedError } from "ai";
+import { streamText, stepCountIs, NoOutputGeneratedError, APICallError } from "ai";
 function toModelMessage(msg) {
   switch (msg.role) {
     case "system":
@@ -21425,7 +22386,7 @@ var init_api_common = __esm({
         } catch (err) {
           log(`[api-common] MCP tools unavailable: ${err instanceof Error ? err.message : String(err)}`);
         }
-        const tools2 = buildApiTools(chatId, permMode, mcpTools, getApiWebSearchEnabled(chatId));
+        const tools2 = buildApiTools(chatId, permMode, mcpTools, getApiWebSearchEnabled(chatId), timeoutMs > 0 ? timeoutMs : void 0);
         const hasTools = Object.keys(tools2).length > 0;
         let abortSignal = signal;
         let timeoutHandle;
@@ -21485,6 +22446,9 @@ var init_api_common = __esm({
           const usage2 = await result.usage;
           const providerMeta = await result.providerMetadata;
           const cost = this.extractCost(providerMeta);
+          if (fullText === "" && !usage2.inputTokens) {
+            throw new Error(`${this.backendId}: empty response with no tokens \u2014 possible rate limit or quota exhaustion on free tier`);
+          }
           return {
             text: fullText,
             cost,
@@ -21494,6 +22458,9 @@ var init_api_common = __esm({
             } : void 0
           };
         } catch (err) {
+          if (err instanceof APICallError && err.statusCode === 429) {
+            throw new Error(`${this.backendId}: rate limit (429) \u2014 free tier quota may be exhausted. Retry later or switch to a paid model.`);
+          }
           if (abortSignal?.aborted || signal?.aborted || err instanceof Error && (err.name === "AbortError" || err.message.toLowerCase().includes("abort") || err.message.toLowerCase().includes("cancel"))) {
             return { text: "", cost: null };
           }
@@ -21629,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,
@@ -21665,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;
@@ -21962,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();
   }
 });
@@ -22158,14 +23134,14 @@ var init_delivery = __esm({
 });
 
 // src/scheduler/retry.ts
-import { APICallError } from "ai";
+import { APICallError as APICallError2 } from "ai";
 function isExhaustedMessage(text) {
   return EXHAUSTED_PATTERNS.some((p) => p.test(text));
 }
 function classifyError(err) {
   const msg = err instanceof Error ? err.message : String(err);
   if (/spawn timeout/i.test(msg)) return "permanent";
-  if (err instanceof APICallError && err.isRetryable) {
+  if (err instanceof APICallError2 && err.isRetryable) {
     return "transient";
   }
   for (const pattern of EXHAUSTED_PATTERNS) {
@@ -22577,7 +23553,7 @@ async function classifyIntentAsync(text, chatId) {
   return "agentic";
 }
 var intentCounts, CHAT_EXACT, MUTATION_PATTERNS, CHAT_QUESTION_PATTERNS, STRUCTURAL_PATTERNS, LLM_CLASSIFY_PROMPT, LLM_CLASSIFY_TIMEOUT_MS;
-var init_classify = __esm({
+var init_classify2 = __esm({
   "src/intent/classify.ts"() {
     "use strict";
     init_store5();
@@ -23324,7 +24300,7 @@ function classifyAgentIntent(message) {
   return NOT_DETECTED;
 }
 var AGENT_SIGNAL_PATTERNS, CLAW_SIGNAL_PATTERNS, NEGATIVE_PATTERNS;
-var init_classify2 = __esm({
+var init_classify3 = __esm({
   "src/agents/classify.ts"() {
     "use strict";
     AGENT_SIGNAL_PATTERNS = [
@@ -23559,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) {
@@ -23629,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"];
@@ -23656,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) */
@@ -23671,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;
@@ -23690,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}`);
@@ -23744,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}`);
         }
@@ -23767,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) {
@@ -23780,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,
@@ -23791,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
@@ -24232,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() {
@@ -24546,6 +25744,9 @@ async function handleVoice(msg, channel) {
       await channel.sendText(chatId, "Couldn't transcribe the voice message. Make sure a transcription provider is configured via /voice.", { parseMode: "plain" });
       return;
     }
+    if (getSttEcho(chatId)) {
+      await channel.sendText(chatId, `\u{1F399} ${transcript}`, { parseMode: "plain" });
+    }
     const vBackendId = getBackend(chatId) ?? "claude";
     const vLimitMsg = checkBackendLimits(vBackendId);
     if (vLimitMsg) {
@@ -24829,168 +26030,6 @@ var init_media = __esm({
   }
 });
 
-// src/router/state.ts
-var state_exports = {};
-__export(state_exports, {
-  activeSideQuests: () => activeSideQuests,
-  bypassBusyCheck: () => bypassBusyCheck,
-  clearHistoryFilter: () => clearHistoryFilter,
-  clearPendingCliAddition: () => clearPendingCliAddition,
-  clearPendingModelResults: () => clearPendingModelResults,
-  clearPendingModelSearch: () => clearPendingModelSearch,
-  councilResults: () => councilResults,
-  dashboardClawWarnings: () => dashboardClawWarnings,
-  getActiveSideQuestCount: () => getActiveSideQuestCount,
-  historyFilters: () => historyFilters,
-  parseSideQuestPrefix: () => parseSideQuestPrefix,
-  pendingCliAdditions: () => pendingCliAdditions,
-  pendingInterrupts: () => pendingInterrupts,
-  pendingMcpImports: () => pendingMcpImports,
-  pendingModelResults: () => pendingModelResults,
-  pendingModelSearch: () => pendingModelSearch,
-  pendingNewchatUndo: () => pendingNewchatUndo,
-  pendingSummaryUndo: () => pendingSummaryUndo,
-  setCouncilResult: () => setCouncilResult,
-  setHistoryFilter: () => setHistoryFilter,
-  setPendingCliAddition: () => setPendingCliAddition,
-  setPendingModelResults: () => setPendingModelResults,
-  setPendingModelSearch: () => setPendingModelSearch,
-  startStateSweep: () => startStateSweep,
-  stopAllSideQuests: () => stopAllSideQuests,
-  stopStateSweep: () => stopStateSweep
-});
-function setHistoryFilter(chatId, filter) {
-  historyFilters.set(chatId, filter);
-  historyFilterTimestamps.set(chatId, Date.now());
-}
-function clearHistoryFilter(chatId) {
-  historyFilters.delete(chatId);
-  historyFilterTimestamps.delete(chatId);
-}
-function setCouncilResult(chatId, result) {
-  councilResults.set(chatId, result);
-  councilResultTimestamps.set(chatId, Date.now());
-}
-function setPendingModelSearch(chatId, state) {
-  pendingModelSearch.set(chatId, state);
-  pendingModelSearchTimestamps.set(chatId, Date.now());
-}
-function clearPendingModelSearch(chatId) {
-  pendingModelSearch.delete(chatId);
-  pendingModelSearchTimestamps.delete(chatId);
-}
-function setPendingModelResults(chatId, results) {
-  pendingModelResults.set(chatId, results);
-}
-function clearPendingModelResults(chatId) {
-  pendingModelResults.delete(chatId);
-}
-function parseSideQuestPrefix(text) {
-  const match = text.match(/^(?:sq|btw):\s*/i);
-  if (match) return { isSideQuest: true, cleanText: text.slice(match[0].length) };
-  return { isSideQuest: false, cleanText: text };
-}
-function getActiveSideQuestCount(chatId) {
-  return activeSideQuests.get(chatId)?.size ?? 0;
-}
-function stopAllSideQuests(chatId) {
-  const active = activeSideQuests.get(chatId);
-  if (active) {
-    for (const sqId of active) {
-      stopAgent(sqId);
-    }
-  }
-}
-function startStateSweep() {
-  if (sweepTimer) return;
-  sweepTimer = setInterval(() => {
-    const now = Date.now();
-    for (const [chatId, ts2] of dashboardClawWarnings) {
-      if (now - ts2 > STALE_THRESHOLD_MS) dashboardClawWarnings.delete(chatId);
-    }
-    for (const [cid, ts2] of historyFilterTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        historyFilters.delete(cid);
-        historyFilterTimestamps.delete(cid);
-      }
-    }
-    for (const [cid, ts2] of councilResultTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        councilResults.delete(cid);
-        councilResultTimestamps.delete(cid);
-      }
-    }
-    for (const [cid, ts2] of pendingModelSearchTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        pendingModelSearch.delete(cid);
-        pendingModelSearchTimestamps.delete(cid);
-      }
-    }
-    for (const chatId of pendingInterrupts.keys()) {
-      if (!_interruptSeen.has(chatId)) {
-        _interruptSeen.add(chatId);
-      } else {
-        pendingInterrupts.delete(chatId);
-        _interruptSeen.delete(chatId);
-      }
-    }
-    for (const chatId of _interruptSeen) {
-      if (!pendingInterrupts.has(chatId)) _interruptSeen.delete(chatId);
-    }
-    for (const [cid, ts2] of pendingCliTimestamps) {
-      if (now - ts2 > STALE_THRESHOLD_MS) {
-        pendingCliAdditions.delete(cid);
-        pendingCliTimestamps.delete(cid);
-      }
-    }
-    for (const [cid, state] of pendingMcpImports) {
-      if (now - state.startedAt > STALE_THRESHOLD_MS) pendingMcpImports.delete(cid);
-    }
-  }, SWEEP_INTERVAL_MS);
-  sweepTimer.unref();
-}
-function stopStateSweep() {
-  if (sweepTimer) {
-    clearInterval(sweepTimer);
-    sweepTimer = null;
-  }
-}
-function setPendingCliAddition(chatId, messageId) {
-  pendingCliAdditions.set(chatId, messageId);
-  pendingCliTimestamps.set(chatId, Date.now());
-}
-function clearPendingCliAddition(chatId) {
-  pendingCliAdditions.delete(chatId);
-  pendingCliTimestamps.delete(chatId);
-}
-var pendingInterrupts, bypassBusyCheck, activeSideQuests, dashboardClawWarnings, pendingSummaryUndo, pendingNewchatUndo, historyFilters, historyFilterTimestamps, councilResults, councilResultTimestamps, pendingModelSearch, pendingModelSearchTimestamps, pendingModelResults, SWEEP_INTERVAL_MS, STALE_THRESHOLD_MS, sweepTimer, _interruptSeen, pendingMcpImports, pendingCliAdditions, pendingCliTimestamps;
-var init_state = __esm({
-  "src/router/state.ts"() {
-    "use strict";
-    init_agent();
-    pendingInterrupts = /* @__PURE__ */ new Map();
-    bypassBusyCheck = /* @__PURE__ */ new Set();
-    activeSideQuests = /* @__PURE__ */ new Map();
-    dashboardClawWarnings = /* @__PURE__ */ new Map();
-    pendingSummaryUndo = /* @__PURE__ */ new Map();
-    pendingNewchatUndo = /* @__PURE__ */ new Map();
-    historyFilters = /* @__PURE__ */ new Map();
-    historyFilterTimestamps = /* @__PURE__ */ new Map();
-    councilResults = /* @__PURE__ */ new Map();
-    councilResultTimestamps = /* @__PURE__ */ new Map();
-    pendingModelSearch = /* @__PURE__ */ new Map();
-    pendingModelSearchTimestamps = /* @__PURE__ */ new Map();
-    pendingModelResults = /* @__PURE__ */ new Map();
-    SWEEP_INTERVAL_MS = 30 * 60 * 1e3;
-    STALE_THRESHOLD_MS = 30 * 60 * 1e3;
-    sweepTimer = null;
-    _interruptSeen = /* @__PURE__ */ new Set();
-    pendingMcpImports = /* @__PURE__ */ new Map();
-    pendingCliAdditions = /* @__PURE__ */ new Map();
-    pendingCliTimestamps = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/router/sidequest.ts
 import { randomUUID as randomUUID3 } from "crypto";
 async function handleSideQuest(parentChatId, msg, channel) {
@@ -25006,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);
@@ -25033,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>
@@ -25057,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);
@@ -25072,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();
@@ -25513,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": {
@@ -25535,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": {
@@ -25785,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();
   }
 });
 
@@ -27954,15 +28998,16 @@ async function handleStopCommand(chatId, commandArgs, msg, channel) {
   const stopped = stopAgent(chatId);
   stopAllSideQuests(chatId);
   cancelAllAgents(chatId);
+  if (stopped) addForceStoppedChat(chatId);
   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) {
@@ -27984,7 +29029,7 @@ async function handleRememberCommand(chatId, commandArgs, msg, channel) {
   }
   const content = commandArgs.replace(/^that\s+/i, "");
   const trigger = content.split(/\s+/).slice(0, 3).join(" ");
-  saveMemoryWithEmbedding(trigger, content, "semantic");
+  await remember(trigger, content);
   await channel.sendText(chatId, "Got it, I'll remember that.", { parseMode: "plain" });
   if (typeof channel.sendKeyboard === "function") {
     await channel.sendKeyboard(chatId, "", [
@@ -28069,11 +29114,15 @@ async function handleStopallCommand(chatId, commandArgs, msg, channel) {
 }
 async function handleEditjobCommand(chatId, commandArgs, msg, channel) {
   if (!commandArgs) {
-    await channel.sendText(chatId, "Usage: /editjob <job-id>", { parseMode: "plain" });
+    await sendJobsBoard(chatId, channel, 1);
     return;
   }
   const editId = parseInt(commandArgs, 10);
-  await startEditWizard(chatId, editId, channel);
+  if (isNaN(editId)) {
+    await sendJobsBoard(chatId, channel, 1);
+    return;
+  }
+  await sendJobDetail(chatId, editId, channel);
 }
 async function handleJobsCommand(chatId, commandArgs, msg, channel) {
   await sendJobsBoard(chatId, channel, 1);
@@ -28325,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") {
@@ -28508,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) {
@@ -28629,7 +29678,7 @@ async function handleMemoryCommand(chatId, commandArgs, msg, channel) {
       return;
     }
     deleteMemoryById(editId);
-    saveMemoryWithEmbedding(mem.trigger, newContent, mem.type);
+    await remember(mem.trigger, newContent, { category: mem.category });
     await channel.sendText(chatId, `Memory #${editId} updated.`, { parseMode: "plain" });
     return;
   }
@@ -28814,9 +29863,9 @@ Recent directories:` : "Recent directories:";
       const buttons = recents.map((r) => [{ label: r.alias, data: `cwdpick:${r.alias}` }]);
       await channel.sendKeyboard(chatId, text, buttons);
     } else {
-      const list = recents.map((r) => `  ${r.alias} \u2192 ${r.path}`).join("\n");
+      const list2 = recents.map((r) => `  ${r.alias} \u2192 ${r.path}`).join("\n");
       await channel.sendText(chatId, `${text}
-${list}`, { parseMode: "plain" });
+${list2}`, { parseMode: "plain" });
     }
     return;
   }
@@ -28971,12 +30020,12 @@ async function handleGeminiAccountsCommand(chatId, commandArgs, msg, channel) {
     await channel.sendKeyboard(chatId, "Gemini Accounts & Rotation:", rows);
   } else {
     const currentMode = getGeminiRotationMode();
-    const list = slots.filter((s) => s.enabled).map((s) => {
+    const list2 = slots.filter((s) => s.enabled).map((s) => {
       const icon = s.slotType === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
       return `${icon} ${s.label || `slot-${s.id}`} (#${s.id})`;
     }).join("\n");
     await channel.sendText(chatId, `Slots:
-${list}
+${list2}
 
 Rotation mode: ${currentMode}
 Use: /gemini_accounts <name> to pin`, { parseMode: "plain" });
@@ -29003,12 +30052,12 @@ Add with: <code>cc-claw ${slotBackend} add-key</code>`, { parseMode: "html" });
     await channel.sendKeyboard(chatId, `${slotDisplayName} Accounts & Rotation:`, rows);
   } else {
     const currentMode = getBackendRotationMode(slotBackend);
-    const list = slots.filter((s) => s.enabled).map((s) => {
+    const list2 = slots.filter((s) => s.enabled).map((s) => {
       const icon = s.slotType === "oauth" ? "\u{1F468}\u{1F3FD}\u200D\u{1F4BB}" : "\u{1F511}";
       return `${icon} ${s.label || `slot-${s.id}`} (#${s.id})`;
     }).join("\n");
     await channel.sendText(chatId, `${slotDisplayName} Slots:
-${list}
+${list2}
 
 Rotation mode: ${currentMode}
 Use: /${command} <name> to pin`, { parseMode: "plain" });
@@ -29339,10 +30388,10 @@ async function handleTasksCommand(chatId, commandArgs, msg, channel) {
     { label: "Abandoned", emoji: "\u{1F6AB}", status: "abandoned" }
   ];
   for (const { label: label2, emoji, status } of sections) {
-    const list = byStatus[status];
-    if (list.length === 0) continue;
+    const list2 = byStatus[status];
+    if (list2.length === 0) continue;
     lines.push(`${emoji} ${label2}:`);
-    for (const t of list) {
+    for (const t of list2) {
       const assignee = t.assignee ? ` (\u2192 ${t.assignee.slice(0, 8)})` : "";
       lines.push(`  #${t.id}: ${t.subject}${assignee}`);
     }
@@ -29518,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();
@@ -29525,11 +30575,12 @@ var init_command_handlers = __esm({
     init_image_gen();
     init_stt();
     init_agent();
-    init_classify();
+    init_classify2();
     init_install();
     init_profile();
     init_heartbeat2();
     init_discover();
+    init_engine();
     init_store5();
     init_summarize();
     init_session_log();
@@ -30662,6 +31713,9 @@ ${progressMsg}`,
     }
     setSttProvider(chatId, provider);
     await sendVoiceConfigKeyboard(chatId, channel, messageId);
+  } else if (data === "vcfg:echo") {
+    toggleSttEcho(chatId);
+    await sendVoiceConfigKeyboard(chatId, channel, messageId);
   } else if (data.startsWith("vcfg:")) {
     const parts = data.slice(5).split(":");
     const action = parts[0];
@@ -30692,14 +31746,15 @@ ${progressMsg}`,
     await handleWizardCallback(chatId, data, channel);
   } else if (data.startsWith("job:")) {
     async function showJobAccountPicker(cid, jobId, backend2, model2, thinking2, ch) {
-      const isGemini = backend2 === "gemini";
-      const slots = isGemini ? getGeminiSlots() : getBackendSlots(backend2);
+      const { getAdapter: getAdapter3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
+      const adapter = getAdapter3(backend2);
+      const isApiBackend = adapter.type === "api";
+      const isGemini = backend2 === BACKEND.GEMINI;
+      const slots = isApiBackend ? [] : isGemini ? getGeminiSlots() : getBackendSlots(backend2);
       const enabledSlots = slots.filter((s) => s.enabled);
       if (enabledSlots.length === 0 || typeof ch.sendKeyboard !== "function") {
         const { updateJob: updateJobFields } = await Promise.resolve().then(() => (init_store5(), store_exports5));
         updateJobFields(jobId, { backend: backend2, model: model2, thinking: thinking2, credentialSlotId: null });
-        const { getAdapter: getAdapter3 } = await Promise.resolve().then(() => (init_backends(), backends_exports));
-        const adapter = getAdapter3(backend2);
         await ch.sendText(cid, `Job #${jobId} updated: ${adapter.displayName} / ${model2} / ${thinking2}`, { parseMode: "plain" });
         await sendJobDetail(cid, jobId, ch);
         return;
@@ -31573,6 +32628,22 @@ Salience: ${memory2.salience.toFixed(2)} | Created: ${memory2.created_at.slice(0
     } else if (rest.startsWith("opt")) {
       const { handleMemOptCallback: handleMemOptCallback2 } = await Promise.resolve().then(() => (init_optimize(), optimize_exports));
       await handleMemOptCallback2(chatId, rest, channel, messageId);
+    } else if (rest === "sweep:dismiss") {
+      if (messageId && channel.editText) {
+        await channel.editText(chatId, messageId, "\u2705 Memory sweep dismissed.", "plain").catch(() => {
+        });
+      }
+    } else if (rest === "sweep:toggle") {
+      const { getMetaValue: getMetaValue2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+      const { SWEEP_ENABLED_KEY: SWEEP_ENABLED_KEY2, enableSweep: enableSweep2, disableSweep: disableSweep2 } = await Promise.resolve().then(() => (init_sweep(), sweep_exports));
+      const currentlyEnabled = getMetaValue2(SWEEP_ENABLED_KEY2) === "1";
+      if (currentlyEnabled) {
+        disableSweep2();
+      } else {
+        enableSweep2(chatId);
+      }
+      const { sendMemoryPage: sendMemoryPage3 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+      await sendMemoryPage3(chatId, channel, 1, messageId);
     } else if (rest === "noop") {
     }
     return;
@@ -32489,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({
@@ -33169,7 +34242,8 @@ Try a different keyword.`,
   if (rememberMatch) {
     const content = rememberMatch[1];
     const trigger = content.split(/\s+/).slice(0, 3).join(" ");
-    saveMemoryWithEmbedding(trigger, content, "semantic");
+    remember(trigger, content).catch(() => {
+    });
     await channel.sendText(chatId, "Got it, I'll remember that.", { parseMode: "plain" });
     return;
   }
@@ -33410,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(),
@@ -33431,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;
@@ -33456,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();
@@ -33730,7 +34782,7 @@ Approve paid usage for this session?`,
     const userMsg = diagnoseAgentError(errMsg, chatId);
     await channel.sendText(chatId, userMsg, { parseMode: "plain" });
   } finally {
-    typingActive = false;
+    getTypingManager().release(chatId);
     const pending = pendingInterrupts.get(chatId);
     if (pending) {
       pendingInterrupts.delete(chatId);
@@ -33748,12 +34800,13 @@ var init_router2 = __esm({
     init_agent();
     init_retry();
     init_quota();
-    init_classify();
+    init_classify2();
+    init_engine();
     init_store5();
     init_backends();
     init_wizard();
     init_ollama3();
-    init_classify2();
+    init_classify3();
     init_session_log2();
     init_live_status();
     init_detect();
@@ -33764,6 +34817,7 @@ var init_router2 = __esm({
     init_gate();
     init_helpers();
     init_response();
+    init_typing_manager();
     init_shell();
     init_ui();
     init_api_models();
@@ -34021,6 +35075,28 @@ async function executeJob(job) {
 async function runWithRetry(job, model2, runId, t0) {
   let lastError;
   const chatId = job.sessionType === "isolated" ? `cron:${job.id}:${runId}` : job.chatId;
+  if (job.jobType === "memory_sweep") {
+    const { runWeeklySweep: runWeeklySweep2 } = await Promise.resolve().then(() => (init_sweep(), sweep_exports));
+    const { getChannelRegistry: getChannelRegistry2 } = await Promise.resolve().then(() => (init_delivery(), delivery_exports));
+    const channelName = job.channel ?? "telegram";
+    const channel = getChannelRegistry2()?.get(channelName);
+    const deliveryTarget = job.target ?? job.chatId;
+    if (!channel) {
+      warn(`[sweep] Job #${job.id}: channel "${channelName}" not found \u2014 sweep ran silently`);
+    }
+    const result = await runWeeklySweep2(
+      deliveryTarget,
+      channel,
+      resolveJobBackendId(job) ?? void 0,
+      job.model ?? void 0
+    );
+    const parts = [];
+    if (result.cleanedUp > 0) parts.push(`cleaned up ${result.cleanedUp} expired memories`);
+    if (result.suggestionsCount > 0) parts.push(`found ${result.suggestionsCount} suggestions`);
+    if (result.error) parts.push(`error: ${result.error}`);
+    const summary = parts.length > 0 ? parts.join(", ") : "memory bank healthy, no action needed";
+    return { text: summary };
+  }
   if (job.jobType === "reflection") {
     const { runNightlyReflection: runNightlyReflection2 } = await Promise.resolve().then(() => (init_analyze(), analyze_exports));
     const { formatNightlySummary: formatNightlySummary2 } = await Promise.resolve().then(() => (init_propose(), propose_exports));
@@ -35036,6 +36112,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`);
@@ -35051,6 +36132,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 {
@@ -35069,18 +36151,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) {
@@ -35198,7 +36285,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);
@@ -35239,7 +36325,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}`);
@@ -35267,7 +36352,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;
@@ -35284,7 +36368,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);
@@ -35299,7 +36382,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...")
@@ -35322,13 +36414,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);
       }
@@ -35338,6 +36430,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 {
@@ -35451,15 +36547,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) {
@@ -35472,12 +36571,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) {
@@ -35503,7 +36603,7 @@ var init_telegram2 = __esm({
         }
         return keyboard;
       }
-      async editKeyboard(chatId, messageId, text, buttons) {
+      async editKeyboard(chatId, messageId, text, buttons, opts) {
         const keyboard = this.buildInlineKeyboard(buttons);
         const formatted = sanitizeForTelegram(formatForTelegram(text));
         try {
@@ -35513,7 +36613,8 @@ var init_telegram2 = __esm({
             () => this.bot.api.editMessageText(numericChatId(chatId), parseInt(messageId), formatted, {
               parse_mode: "HTML",
               reply_markup: keyboard
-            })
+            }),
+            opts?.priority
           );
           return true;
         } catch (err) {
@@ -35527,7 +36628,8 @@ var init_telegram2 = __esm({
                 parseInt(messageId),
                 formatted.replace(/<[^>]+>/g, ""),
                 { reply_markup: keyboard }
-              )
+              ),
+              opts?.priority
             );
             return true;
           } catch (err2) {
@@ -35621,6 +36723,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;
@@ -36606,7 +37746,7 @@ async function main() {
   pruneMessageLog(30, 2e3);
   bootstrapBuiltinMcps(getDb());
   try {
-    const { resetIntentStats: resetIntentStats2 } = await Promise.resolve().then(() => (init_classify(), classify_exports));
+    const { resetIntentStats: resetIntentStats2 } = await Promise.resolve().then(() => (init_classify2(), classify_exports));
     resetIntentStats2();
   } catch {
   }
@@ -36782,6 +37922,22 @@ ${lines.join("\n")}`;
   migrateEmbeddings().catch((err) => error("[cc-claw] Embedding migration failed:", err));
   initHeartbeat(channelRegistry);
   startAllHeartbeats();
+  try {
+    const { getMetaValue: getMetaValue2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
+    const { SWEEP_ENABLED_KEY: SWEEP_ENABLED_KEY2, findSweepJob: findSweepJob2, enableSweep: enableSweep2 } = await Promise.resolve().then(() => (init_sweep(), sweep_exports));
+    const sweepEnabled = getMetaValue2(SWEEP_ENABLED_KEY2);
+    if (sweepEnabled === "1") {
+      if (!findSweepJob2()) {
+        const primaryChatId = (process.env.ALLOWED_CHAT_ID ?? "").split(",")[0]?.trim();
+        if (primaryChatId) {
+          enableSweep2(primaryChatId);
+          log("[sweep] Restored weekly memory sweep job from meta setting");
+        }
+      }
+    }
+  } catch (err) {
+    warn(`[sweep] Failed to restore sweep job: ${err instanceof Error ? err.message : String(err)}`);
+  }
   startHealthMonitor3(channelRegistry.list(), handleMessage);
   Promise.resolve().then(() => (init_health(), health_exports)).then(({ startHealthMonitor: startMcpHealthMonitor }) => {
     startMcpHealthMonitor(getDb());
@@ -36824,9 +37980,19 @@ ${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();
-      flushMemorySalienceUpdates();
+      flushMemoryHalfLifeUpdates();
       flushSummarySalienceUpdates();
       await Promise.race([
         summarizeAllPending(),
@@ -37383,6 +38549,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");
@@ -37390,6 +38557,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);
@@ -37411,7 +38581,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));
@@ -37443,6 +38614,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)"),
@@ -37779,6 +38958,7 @@ async function logsCommand(opts) {
   console.log(muted(`  \u2500\u2500 ${logFile} (last ${tailLines.length} lines) \u2500\u2500`));
   console.log(tailLines.join("\n"));
   if (opts.follow) {
+    globalThis._cliStayAlive = true;
     console.log(muted("\n  Following... (Ctrl+C to stop)\n"));
     let lastLength = content.length;
     watchFile2(logFile, { interval: 500 }, () => {
@@ -37837,9 +39017,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}`));
@@ -37869,6 +39049,7 @@ async function sessionLogsTail(opts) {
     console.log(line);
   }
   if (opts.follow) {
+    globalThis._cliStayAlive = true;
     console.log(muted("\n  Following... (Ctrl+C to stop)\n"));
     let lastLength = 0;
     try {
@@ -37976,9 +39157,9 @@ async function geminiList(globalOpts) {
     email: s.slot_type === "oauth" ? resolveOAuthEmail(s.config_home) : null
   }));
   output(enriched, (data) => {
-    const list = data;
+    const list2 = data;
     const lines = ["", divider("Gemini Credential Slots"), ""];
-    for (const s of list) {
+    for (const s of list2) {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const inCooldown = s.cooldown_until && s.cooldown_until > now;
       const icon = !s.enabled ? error2("\u25CB disabled") : inCooldown ? warning("\u25D1 cooldown") : success("\u25CF active");
@@ -38301,7 +39482,7 @@ async function resolveSlotId2(backend2, idOrLabel) {
   return match?.id ?? null;
 }
 function makeList(backend2, displayName) {
-  return async function list(_globalOpts) {
+  return async function list2(_globalOpts) {
     requireDb2();
     const { openDatabaseReadOnly: openDatabaseReadOnly2 } = await Promise.resolve().then(() => (init_store5(), store_exports5));
     const readDb = openDatabaseReadOnly2();
@@ -38316,9 +39497,9 @@ Add one with: cc-claw ${backend2} add-account  or  cc-claw ${backend2} add-key`)
       return;
     }
     output(slots, (data) => {
-      const list2 = data;
+      const list3 = data;
       const lines = ["", divider(`${displayName} Credential Slots`), ""];
-      for (const s of list2) {
+      for (const s of list3) {
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const inCooldown = s.cooldown_until && s.cooldown_until > now;
         const icon = !s.enabled ? error2("\u25CB disabled") : inCooldown ? warning("\u25D1 cooldown") : success("\u25CF active");
@@ -38782,9 +39963,9 @@ async function ollamaList(globalOpts) {
     modelCount: modelCounts.get(s.id) ?? 0
   }));
   output(data, (d) => {
-    const list = d;
+    const list2 = d;
     const lines = ["", divider("Ollama Servers"), ""];
-    for (const s of list) {
+    for (const s of list2) {
       const dot = statusDot(s.status === "online" ? "active" : "offline");
       lines.push(`  ${dot}  ${s.name} ${muted(`(${s.host}:${s.port})`)}`);
       lines.push(`       Models: ${s.modelCount} \xB7 Status: ${s.status === "online" ? success("online") : error2("offline")}`);
@@ -38936,13 +40117,13 @@ async function ollamaDiscover(globalOpts, opts) {
     contextWindow: m.contextWindow,
     sizeBytes: m.sizeBytes
   })), (d) => {
-    const list = d;
-    if (list.length === 0) {
+    const list2 = d;
+    if (list2.length === 0) {
       return "\n  No models found. Check server connectivity.\n";
     }
     const lines = [`
-  ${success(`\u2713 Discovered ${list.length} model(s):`)}`, ""];
-    for (const m of list) {
+  ${success(`\u2713 Discovered ${list2.length} model(s):`)}`, ""];
+    for (const m of list2) {
       const sizeGB = m.sizeBytes > 0 ? `${(m.sizeBytes / 1e9).toFixed(1)}GB` : "";
       const ctxK = m.contextWindow ? `${(m.contextWindow / 1e3).toFixed(0)}K ctx` : "";
       const meta = [m.parameterSize, sizeGB, ctxK].filter(Boolean).join(" \xB7 ");
@@ -39029,9 +40210,9 @@ async function backendList(globalOpts) {
     defaultModel: a.defaultModel
   }));
   output(data, (d) => {
-    const list = d;
+    const list2 = d;
     const lines = ["", divider("Backends"), ""];
-    for (const b of list) {
+    for (const b of list2) {
       const marker = b.active ? success("\u25CF ") : "  ";
       lines.push(`  ${marker}${b.displayName} (${b.id})${b.active ? success(" \u2190 active") : ""}`);
       lines.push(`     Default model: ${muted(b.defaultModel)}`);
@@ -39349,12 +40530,12 @@ async function cronList(globalOpts) {
   const jobs = readDb.prepare("SELECT * FROM jobs ORDER BY id").all();
   readDb.close();
   output(jobs, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted("No scheduled jobs.")}
 `;
-    const lines = ["", divider(`Scheduled Jobs (${list.length})`), ""];
-    for (const j of list) {
+    const lines = ["", divider(`Scheduled Jobs (${list2.length})`), ""];
+    for (const j of list2) {
       const status = !j.active ? "cancelled" : !j.enabled ? "paused" : "active";
       const schedule2 = j.cron ?? (j.at_time ? `at ${j.at_time}` : j.every_ms ? `every ${j.every_ms / 1e3}s` : "?");
       const tz = j.timezone !== "UTC" ? ` (${j.timezone})` : "";
@@ -39574,12 +40755,12 @@ async function cronRuns(globalOpts, jobId, opts) {
   const runs = readDb.prepare(query).all(...params);
   readDb.close();
   output(runs, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted(jobId ? `No runs for job #${jobId}.` : "No run history yet.")}
 `;
     const lines = ["", divider("Run History"), ""];
-    for (const r of list) {
+    for (const r of list2) {
       const duration = r.duration_ms ? ` (${(r.duration_ms / 1e3).toFixed(1)}s)` : "";
       lines.push(`  #${r.job_id} [${r.status}] ${formatLocalDateTime(r.started_at)}${duration}`);
       if (r.error) lines.push(`    Error: ${r.error.slice(0, 100)}`);
@@ -39622,12 +40803,12 @@ async function agentsList(globalOpts) {
   ).all();
   readDb.close();
   output(agents2, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted("No active agents.")}
 `;
-    const lines = ["", divider(`Active Agents (${list.length})`), ""];
-    for (const a of list) {
+    const lines = ["", divider(`Active Agents (${list2.length})`), ""];
+    for (const a of list2) {
       const shortId = a.id?.slice(0, 8) ?? "?";
       lines.push(`  ${statusDot(a.status)} ${shortId} (${a.runnerId}) \u2014 ${a.status}`);
       if (a.task) lines.push(`    Task: ${a.task.slice(0, 80)}${a.task.length > 80 ? "\u2026" : ""}`);
@@ -39653,12 +40834,12 @@ async function tasksList(globalOpts) {
   ).all();
   readDb.close();
   output(tasks, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted("No active tasks.")}
 `;
-    const lines = ["", divider(`Task Board (${list.length})`), ""];
-    for (const t of list) {
+    const lines = ["", divider(`Task Board (${list2.length})`), ""];
+    for (const t of list2) {
       const assignee = t.assignee ? ` (\u2192 ${t.assignee.slice(0, 8)})` : "";
       lines.push(`  ${statusDot(t.status === "completed" ? "ok" : t.status === "in_progress" ? "running" : "paused")} #${t.id}: ${t.subject}${assignee}`);
     }
@@ -39737,12 +40918,12 @@ async function runnersList(globalOpts) {
       displayName: r.displayName,
       specialties: r.capabilities.specialties ?? []
     })), (d) => {
-      const list = d;
-      if (list.length === 0) return `
+      const list2 = d;
+      if (list2.length === 0) return `
   ${muted("No runners registered.")}
 `;
-      const lines = ["", divider(`Registered Runners (${list.length})`), ""];
-      for (const r of list) {
+      const lines = ["", divider(`Registered Runners (${list2.length})`), ""];
+      for (const r of list2) {
         const specs = r.specialties.length > 0 ? ` \u2014 ${r.specialties.join(", ")}` : "";
         lines.push(`  \u2022 ${r.id} (${r.displayName})${specs}`);
       }
@@ -39965,9 +41146,9 @@ async function usageTokens(globalOpts) {
   });
   readDb.close();
   output(data, (d) => {
-    const list = d;
+    const list2 = d;
     const lines = ["", divider("Backend usage (last 24h)"), ""];
-    for (const u of list) {
+    for (const u of list2) {
       lines.push(`  ${u.displayName}: ${(u.input_tokens / 1e3).toFixed(1)}K in / ${(u.output_tokens / 1e3).toFixed(1)}K out (${u.request_count} requests)`);
     }
     lines.push("");
@@ -39981,13 +41162,13 @@ async function limitsList(globalOpts) {
   const limits2 = readDb.prepare("SELECT * FROM backend_limits").all();
   readDb.close();
   output(limits2, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted("No usage limits set.")}
   ${muted("Set with: cc-claw usage limits set <backend> <window> <tokens>")}
 `;
     const lines = ["", divider("Usage limits"), ""];
-    for (const l of list) {
+    for (const l of list2) {
       lines.push(`  ${l.backend} (${l.window}): ${l.max_input_tokens ? `${(l.max_input_tokens / 1e3).toFixed(0)}K input tokens` : "no limit"}`);
     }
     lines.push("");
@@ -40295,9 +41476,9 @@ async function toolsList(globalOpts) {
   const toolMap = new Map(rows.map((r) => [r.tool, !!r.enabled]));
   const tools2 = ALL_TOOLS4.map((t) => ({ name: t, enabled: toolMap.get(t) ?? true }));
   output(tools2, (d) => {
-    const list = d;
+    const list2 = d;
     const lines = ["", divider("Tools"), ""];
-    for (const t of list) {
+    for (const t of list2) {
       lines.push(`  ${checkMark(t.enabled)} ${t.name}`);
     }
     lines.push("");
@@ -40824,13 +42005,13 @@ async function chatsList(_globalOpts) {
   const aliases = readDb.prepare("SELECT alias, chat_id FROM chat_aliases ORDER BY alias").all();
   readDb.close();
   output(aliases, (d) => {
-    const list = d;
-    if (list.length === 0) return `
+    const list2 = d;
+    if (list2.length === 0) return `
   ${muted("No chat aliases configured yet.")}
   ${muted("Use: cc-claw chats alias <chat_id> <name>")}
 `;
     const lines = ["", divider("Chat Aliases"), ""];
-    for (const a of list) {
+    for (const a of list2) {
       lines.push(`  ${a.alias} \u2192 ${a.chat_id}`);
     }
     lines.push("");
@@ -40893,13 +42074,13 @@ async function skillsList(_globalOpts) {
       sources: s.sources,
       filePath: s.filePath
     })), (d) => {
-      const list = d;
-      if (list.length === 0) return `
+      const list2 = d;
+      if (list2.length === 0) return `
   ${muted("No skills found.")}
   ${muted("Install with: cc-claw skills install <github-url>")}
 `;
-      const lines = ["", divider(`Skills (${list.length})`), ""];
-      for (const s of list) {
+      const lines = ["", divider(`Skills (${list2.length})`), ""];
+      for (const s of list2) {
         const tags = s.sources.join(", ");
         const desc = s.description ? ` \u2014 ${s.description.slice(0, 60)}` : "";
         lines.push(`  \u2022 ${s.name} [${muted(tags)}]${desc}`);
@@ -40964,14 +42145,14 @@ async function mcpList(globalOpts) {
   const mcps = listMcpServers2(db3);
   db3.close();
   output(mcps, (d) => {
-    const list = d;
-    if (list.length === 0) {
+    const list2 = d;
+    if (list2.length === 0) {
       return `
   ${muted("No MCP servers registered. Use `cc-claw mcp add` or `cc-claw mcp import`.")}
 `;
     }
-    const lines = ["", divider(`MCP Servers (${list.length})`), ""];
-    for (const m of list) {
+    const lines = ["", divider(`MCP Servers (${list2.length})`), ""];
+    for (const m of list2) {
       const lock = SYSTEM_MCP_NAMES.has(m.name) ? " \u{1F512}" : "";
       const pin = m.enabledByDefault ? " \u{1F4CC}" : "";
       const desc = m.description ? ` \u2014 ${muted(m.description)}` : "";
@@ -41378,6 +42559,7 @@ async function tuiCommand(globalOpts, cmdOpts) {
     outputError("DAEMON_OFFLINE", "CC-Claw daemon is not running.\n\n  Start it with: cc-claw service start");
     process.exit(1);
   }
+  globalThis._cliStayAlive = true;
   const chatId = resolveChatId2(globalOpts);
   let theme = getTheme();
   const rl2 = createInterface10({
@@ -43387,6 +44569,7 @@ program.command("council").alias("debate").description("Multi-model council deba
   console.log("Select 2+ models, pose a question, and they debate anonymously for up to 3 rounds.");
 });
 program.command("start", { hidden: true }).description("Run the bot in the foreground (use 'service start' for background daemon)").action(async () => {
+  globalThis._cliStayAlive = true;
   await Promise.resolve().then(() => (init_index(), index_exports));
 });
 program.command("install", { hidden: true }).description("Install as background service \u2014 alias for service install").action(async () => {
@@ -43398,6 +44581,7 @@ program.command("uninstall", { hidden: true }).description("Remove background se
   uninstallService2();
 });
 program.command("setup").description("Interactive configuration wizard").option("--dry-run", "Run the wizard without saving anything (demo/test mode)").action(async (opts) => {
+  globalThis._cliStayAlive = true;
   if (opts.dryRun) process.env.CC_CLAW_SETUP_DRY_RUN = "1";
   await Promise.resolve().then(() => (init_setup(), setup_exports));
 });
@@ -43433,10 +44617,12 @@ Update available: v${latest} (current: v${VERSION})`);
     return;
   }
   await program.parseAsync(argv);
-  if (process.stdout.writableLength > 0) {
-    process.stdout.once("drain", () => process.exit(0));
-  } else {
-    setImmediate(() => process.exit(0));
+  if (!globalThis._cliStayAlive) {
+    if (process.stdout.writableLength > 0) {
+      process.stdout.once("drain", () => process.exit(0));
+    } else {
+      setTimeout(() => process.exit(0), 50);
+    }
   }
 }